mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-17 14:14:50 +00:00
Merge main into feat/recolor-add-remove-color-tools
This commit is contained in:
@@ -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
@@ -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
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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 =
|
||||
|
||||
@@ -511,6 +511,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();
|
||||
@@ -537,6 +539,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 {
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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
@@ -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>();
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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 }
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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:?}");
|
||||
}
|
||||
@@ -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());
|
||||
|
||||
@@ -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]);
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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(())
|
||||
})?;
|
||||
}
|
||||
|
||||
@@ -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])),
|
||||
|
||||
@@ -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
@@ -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.
|
||||
|
||||
@@ -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])], &[]);
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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
@@ -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)),
|
||||
@@ -584,6 +586,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())));
|
||||
@@ -1081,12 +1090,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",
|
||||
@@ -1095,6 +1104,8 @@ fn loadable(src: &Document, kind: Kind) -> (Vec<TextStyleDef>, Vec<String>) {
|
||||
"akiLeft",
|
||||
"akiRight",
|
||||
"tsume",
|
||||
"diacriticHorizontal",
|
||||
"diacriticVertical",
|
||||
"tcyUpDown",
|
||||
"tcyLeftRight",
|
||||
"warichuLines",
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -1921,6 +1921,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.
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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).
|
||||
|
||||
@@ -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"})),
|
||||
|
||||
@@ -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}]"),
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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
@@ -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 };
|
||||
}
|
||||
|
||||
@@ -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))))
|
||||
})
|
||||
}
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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")]
|
||||
|
||||
@@ -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}");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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"}}));
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
@@ -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 })),
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
@@ -1053,6 +1053,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,
|
||||
@@ -1127,7 +1131,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 {
|
||||
@@ -1186,6 +1191,8 @@ fn shapes_alike(a: &CharStyle, b: &CharStyle) -> bool {
|
||||
warichu_scale: _,
|
||||
warichu_align: _,
|
||||
digits,
|
||||
diacritic_horizontal: _,
|
||||
diacritic_vertical: _,
|
||||
font_height_reference,
|
||||
no_break,
|
||||
language,
|
||||
@@ -1464,11 +1471,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);
|
||||
@@ -1769,11 +1786,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);
|
||||
@@ -1828,8 +1855,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,
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -2769,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);
|
||||
|
||||
@@ -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];
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()),
|
||||
|
||||
@@ -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}");
|
||||
}
|
||||
@@ -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";
|
||||
|
||||
|
||||
@@ -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
@@ -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),
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -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()));
|
||||
|
||||
@@ -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
|
||||
@@ -58,7 +60,8 @@
|
||||
//! unset: `smooth`), `wheelTool` (`add`: the Add Color tool, `remove`: the Remove Color tool;
|
||||
//! unset: neither, a click on the wheel selects a marker), `themePicker` (the Color Theme Picker is on), `themePicks` (its picks, as
|
||||
//! `recolor.pickTheme`'s `picks`; a new list recolors the rows), `weights` (one per row, as
|
||||
//! `recolor.weigh`'s; a new list moves the rows' current colors toward them). 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};
|
||||
@@ -171,7 +174,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).
|
||||
@@ -225,6 +228,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);
|
||||
@@ -612,6 +617,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);
|
||||
@@ -672,7 +773,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);
|
||||
@@ -902,6 +1011,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);
|
||||
@@ -2273,6 +2386,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() {
|
||||
|
||||
@@ -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."));
|
||||
|
||||
@@ -1547,3 +1547,78 @@ fn an_artboard_name_stays_with_its_document() {
|
||||
assert_eq!(names(&app, 1), ["Artboard 1", "Artboard 2"]);
|
||||
assert!(log.borrow().is_empty(), "renaming must not export");
|
||||
}
|
||||
|
||||
/// Escape or Enter in the first frame that draws an artboard's name field closes the field, and
|
||||
/// the dialog stays open.
|
||||
#[test]
|
||||
fn a_key_in_the_first_frame_of_an_artboard_name_closes_it() {
|
||||
for view in ["grid", "list"] {
|
||||
for key in [egui::Key::Escape, egui::Key::Enter] {
|
||||
let (mut app, log) = app(2, true);
|
||||
open(&mut app);
|
||||
set(&mut app, "view", json!(view));
|
||||
let mut h = ScreensFrame::new();
|
||||
let out = h.settle(&mut app);
|
||||
let at = screen_text_at(&out, "1 Artboard 1");
|
||||
h.frame(&mut app, vec![egui::Event::PointerMoved(at)]);
|
||||
for pressed in [true, false, true, false] {
|
||||
h.frame(
|
||||
&mut app,
|
||||
vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }],
|
||||
);
|
||||
}
|
||||
// The double-click opened the field in the last frame; this frame draws it first.
|
||||
h.time += 0.1;
|
||||
let input = egui::RawInput {
|
||||
events: vec![egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }],
|
||||
time: Some(h.time),
|
||||
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1100.0, 900.0))),
|
||||
..Default::default()
|
||||
};
|
||||
let mut out = h.ctx.run_ui(input, |ui| {
|
||||
crate::shortcuts::handle(&mut app, ui.ctx());
|
||||
super::show(&mut app, ui.ctx());
|
||||
});
|
||||
out.textures_delta.clear();
|
||||
h.settle(&mut app);
|
||||
assert!(!h.ctx.egui_wants_keyboard_input(), "{view}, {key:?}: the field closes");
|
||||
assert_eq!(kind(&app), Some(export_for_screens::KIND), "{view}, {key:?}");
|
||||
assert_eq!(app.session.active().unwrap().doc.artboards[0].name, "Artboard 1", "{view}, {key:?}");
|
||||
assert!(log.borrow().is_empty(), "{view}, {key:?}: the key must not export");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A double-click on an earlier artboard's name, both clicks in one frame, renames the artboard
|
||||
/// whose name was being typed before it opens the new field.
|
||||
#[test]
|
||||
fn double_clicking_another_artboard_name_keeps_the_typed_name() {
|
||||
for view in ["grid", "list"] {
|
||||
let (mut app, log) = app(2, true);
|
||||
open(&mut app);
|
||||
set(&mut app, "view", json!(view));
|
||||
let mut h = ScreensFrame::new();
|
||||
let before = field(&app, "boards");
|
||||
let double_click = |h: &mut ScreensFrame, app: &mut VectorcraftApp, at: egui::Pos2| {
|
||||
h.frame(app, vec![egui::Event::PointerMoved(at)]);
|
||||
let events = [true, false, true, false]
|
||||
.into_iter()
|
||||
.map(|pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() })
|
||||
.collect();
|
||||
h.frame(app, events);
|
||||
h.settle(app);
|
||||
};
|
||||
let out = h.settle(&mut app);
|
||||
let first = screen_text_at(&out, "1 Artboard 1");
|
||||
double_click(&mut h, &mut app, screen_text_at(&out, "2 Artboard 2"));
|
||||
assert!(h.ctx.egui_wants_keyboard_input(), "{view}: the double-click opens the name");
|
||||
h.frame(&mut app, vec![egui::Event::Text("Typed".into())]);
|
||||
h.time += 1.0;
|
||||
double_click(&mut h, &mut app, first);
|
||||
let names: Vec<String> = app.session.active().unwrap().doc.artboards.iter().map(|a| a.name.clone()).collect();
|
||||
assert_eq!(names, ["Artboard 1", "Typed"], "{view}");
|
||||
assert!(h.ctx.egui_wants_keyboard_input(), "{view}: the second double-click opens its name");
|
||||
assert_eq!(field(&app, "boards"), before, "{view}");
|
||||
assert!(log.borrow().is_empty(), "{view}: renaming must not export");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -165,4 +165,25 @@ mod tests {
|
||||
assert_eq!(t.plain_text(), "one two\nthree", "one paragraph per block");
|
||||
assert_eq!(st.history.undo.len(), 1);
|
||||
}
|
||||
|
||||
/// A text file dropped on a canvas is placed by the dialog's OK in the document it was dropped
|
||||
/// on, even when another document became active meanwhile.
|
||||
#[test]
|
||||
fn a_dropped_text_files_ok_places_in_the_document_it_was_dropped_on() {
|
||||
use crate::place::{DropAt, DropTarget};
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
for _ in 0..2 {
|
||||
app.run("file.new", json!({"width": 300, "height": 200})).unwrap();
|
||||
}
|
||||
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(100.0, 100.0), embed: true });
|
||||
crate::place::drop_files(&mut app, vec![(target, ("notes.txt".into(), None, b"one".to_vec()))]);
|
||||
assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(KIND));
|
||||
app.session.set_active(1);
|
||||
super::super::confirm(&mut app).unwrap();
|
||||
let objects = |i: usize| app.session.documents()[i].doc.layers.iter().map(|l| l.children().map_or(0, Vec::len)).sum::<usize>();
|
||||
assert_eq!((objects(0), objects(1)), (1, 0), "placed in the document it was dropped on");
|
||||
assert_eq!(app.session.active_index(), Some(0));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -140,11 +140,18 @@ pub fn open(app: &mut VectorcraftApp, id: &str, preselect: Option<&str>) -> bool
|
||||
|
||||
/// Variable Options' Name and Kind fields for the variable `name`: its name, and its kind as
|
||||
/// `variable.rename` takes it (empty for a variable of unknown kind, which OK leaves as it is).
|
||||
/// [`FILLED`] records which variable they were filled for.
|
||||
/// [`FILLED`] records which variable they were filled for. Once they were, only a field that is
|
||||
/// still unset (null, as setting the Variable field leaves it) is filled.
|
||||
fn fill_variable_options(vars: &Variables, name: &str, fields: &mut serde_json::Map<String, Value>) {
|
||||
let kind = vars.variable(name).map(|v| v.kind).filter(|k| *k != VariableKind::Unknown).map(VariableKind::label).unwrap_or_default();
|
||||
fields.insert("newName".into(), json!(name));
|
||||
fields.insert("kind".into(), json!(kind));
|
||||
let refill = fields.get(FILLED).and_then(Value::as_str) != Some(name);
|
||||
let unset = |fields: &serde_json::Map<String, Value>, key: &str| matches!(fields.get(key), None | Some(Value::Null));
|
||||
if refill || unset(fields, "newName") {
|
||||
fields.insert("newName".into(), json!(name));
|
||||
}
|
||||
if refill || unset(fields, "kind") {
|
||||
let kind = vars.variable(name).map(|v| v.kind).filter(|k| *k != VariableKind::Unknown).map(VariableKind::label).unwrap_or_default();
|
||||
fields.insert("kind".into(), json!(kind));
|
||||
}
|
||||
fields.insert(FILLED.into(), json!(name));
|
||||
}
|
||||
|
||||
@@ -212,9 +219,7 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
|
||||
label(ui, tl!("Variable"));
|
||||
dropdown(ui, d, "variable", &variable_names, 220.0);
|
||||
let picked = d.str("variable");
|
||||
if picked != d.str(FILLED) {
|
||||
fill_variable_options(vars, &picked, &mut d.fields);
|
||||
}
|
||||
fill_variable_options(vars, &picked, &mut d.fields);
|
||||
ui.end_row();
|
||||
label(ui, tl!("Name"));
|
||||
text(ui, d, "newName", 220.0);
|
||||
@@ -305,7 +310,8 @@ fn set_text(d: &mut Dialog, key: &str, s: String) {
|
||||
///
|
||||
/// In Variable Options, setting the Variable field clears Name and Kind, which OK reads as the
|
||||
/// variable's own name and kind, until a frame fills them from it; setting Name or Kind ties them
|
||||
/// to the variable already named, so no frame fills them over.
|
||||
/// to the variable already named, so no frame fills them over, and a frame fills only the one
|
||||
/// still cleared.
|
||||
pub(super) fn note_set(d: &mut Dialog, field: &str) {
|
||||
d.fields.remove(&empty_marker(field));
|
||||
if d.str("__command") == "variable.rename" {
|
||||
@@ -669,4 +675,46 @@ mod tests {
|
||||
let d = app.ui.dialog.as_ref().unwrap();
|
||||
assert_eq!((d.str("newName"), d.str("kind")), ("Flag".to_string(), "visibility".to_string()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn variable_options_fills_the_field_left_unset_after_the_variable_changes() {
|
||||
let mut app = app_with_variables();
|
||||
let ctx = egui::Context::default();
|
||||
crate::theme::install_fonts(&ctx);
|
||||
let frame = |app: &mut VectorcraftApp| {
|
||||
let mut out = ctx.run_ui(egui::RawInput::default(), |ui| crate::dialogs::show(app, ui.ctx()));
|
||||
out.textures_delta.clear();
|
||||
};
|
||||
|
||||
// Kind alone: Name shows the newly picked variable's name.
|
||||
open(&mut app, "variable.rename", Some("Title"));
|
||||
{
|
||||
let d = app.ui.dialog.as_mut().unwrap();
|
||||
crate::dialogs::set_field(d, "variable".into(), json!("Badge"));
|
||||
crate::dialogs::set_field(d, "kind".into(), json!("text"));
|
||||
}
|
||||
frame(&mut app);
|
||||
{
|
||||
let d = app.ui.dialog.as_ref().unwrap();
|
||||
assert_eq!((d.str("newName"), d.str("kind")), ("Badge".to_string(), "text".to_string()));
|
||||
}
|
||||
|
||||
// Name alone: Kind shows the newly picked variable's kind.
|
||||
open(&mut app, "variable.rename", Some("Title"));
|
||||
{
|
||||
let d = app.ui.dialog.as_mut().unwrap();
|
||||
crate::dialogs::set_field(d, "variable".into(), json!("Badge"));
|
||||
crate::dialogs::set_field(d, "newName".into(), json!("Flag"));
|
||||
}
|
||||
frame(&mut app);
|
||||
{
|
||||
let d = app.ui.dialog.as_ref().unwrap();
|
||||
assert_eq!((d.str("newName"), d.str("kind")), ("Flag".to_string(), "visibility".to_string()));
|
||||
}
|
||||
|
||||
// OK still renames Badge and keeps its kind.
|
||||
crate::dialogs::confirm(&mut app).unwrap();
|
||||
let kind_of = |name: &str| app.session.active().and_then(|st| st.doc.variables.variable(name).map(|v| v.kind));
|
||||
assert_eq!((kind_of("Flag"), kind_of("Badge")), (Some(VariableKind::Visibility), None));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1496,6 +1496,7 @@ font-technology Variable Променливи
|
||||
Add Color Tool Инструмент „Добавяне на цвят“
|
||||
Remove Color Tool Инструмент „Премахване на цвят“
|
||||
Remove Color Премахване на цвят
|
||||
Find the selected colors in the artwork Намиране на избраните цветове в илюстрацията
|
||||
Harmony Sets Набори от хармонии
|
||||
Height Височина
|
||||
Height: Височина:
|
||||
@@ -2650,6 +2651,8 @@ font-technology Variable Променливи
|
||||
Insert Aki Left Вмъкване на аки отляво
|
||||
Insert Aki Right Вмъкване на аки отдясно
|
||||
Tsume Цуме
|
||||
Adjust Horizontal Diacritic Position Коригиране на хоризонталната позиция на диакритиците
|
||||
Adjust Vertical Diacritic Position Коригиране на вертикалната позиция на диакритиците
|
||||
Character Direction Посока на знаците
|
||||
Digits Цифри
|
||||
Arabic Арабски
|
||||
@@ -7000,4 +7003,21 @@ breakText Glyphs Глифи
|
||||
Nest Shapes… Подреждане на форми…
|
||||
Nest Shapes Подреждане на форми
|
||||
Roll Ролка
|
||||
Packaging Tools Инструменти за опаковки
|
||||
Fold Lines Линии на сгъване
|
||||
Make Cut Line Направи линия за рязане
|
||||
Make Crease Line Направи линия за биговане
|
||||
Make Partial Cut Line Направи линия за частично рязане
|
||||
Make Perforation Line Направи линия за перфорация
|
||||
Make Fold Line Направи линия на сгъване
|
||||
Role Swatches… Образци за видовете линии…
|
||||
Role Swatches Образци за видовете линии
|
||||
Role Вид линия
|
||||
Cut Line Линия за рязане
|
||||
Crease Line Линия за биговане
|
||||
Partial Cut Line Линия за частично рязане
|
||||
Perforation Line Линия за перфорация
|
||||
No objects are selected. Няма избрани обекти.
|
||||
Open a document to mark its fold lines. Отворете документ, за да отбележите линиите му на сгъване.
|
||||
Remove Fold Line Role Премахни вида на линията
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer трябва да е "singleLine", "everyLine", "standardSingleLine" или "standardEveryLine"
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1606,6 +1606,8 @@ lighting Light Svjetlo
|
||||
Insert Aki Left Umetni aki lijevo
|
||||
Insert Aki Right Umetni aki desno
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Podesi vodoravni položaj dijakritika
|
||||
Adjust Vertical Diacritic Position Podesi okomiti položaj dijakritika
|
||||
Character Direction Smjer znakova
|
||||
Digits Cifre
|
||||
Arabic Arapski
|
||||
@@ -2911,6 +2913,7 @@ digits Malayalam Malajalam
|
||||
Add Color Tool Alat za dodavanje boje
|
||||
Remove Color Tool Alat za uklanjanje boje
|
||||
Remove Color Ukloni boju
|
||||
Find the selected colors in the artwork Pronađi odabrane boje u crtežu
|
||||
Harmony Rules Pravila harmonije
|
||||
Keep this row's colors (exclude) Zadrži boje ovog reda (isključi)
|
||||
Limit to Library: Ograniči na biblioteku:
|
||||
@@ -7053,4 +7056,21 @@ shape Open Otvoren
|
||||
Nest Shapes… Slaganje oblika…
|
||||
Nest Shapes Slaganje oblika
|
||||
Roll Rolna
|
||||
Packaging Tools Alati za ambalažu
|
||||
Fold Lines Linije savijanja
|
||||
Make Cut Line Napravi liniju rezanja
|
||||
Make Crease Line Napravi liniju bigovanja
|
||||
Make Partial Cut Line Napravi liniju djelimičnog rezanja
|
||||
Make Perforation Line Napravi liniju perforacije
|
||||
Make Fold Line Napravi liniju savijanja
|
||||
Role Swatches… Uzorci boja za vrste linija…
|
||||
Role Swatches Uzorci boja za vrste linija
|
||||
Role Vrsta linije
|
||||
Cut Line Linija rezanja
|
||||
Crease Line Linija bigovanja
|
||||
Partial Cut Line Linija djelimičnog rezanja
|
||||
Perforation Line Linija perforacije
|
||||
No objects are selected. Nijedan objekat nije odabran.
|
||||
Open a document to mark its fold lines. Otvorite dokument da označite njegove linije savijanja.
|
||||
Remove Fold Line Role Ukloni vrstu linije
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer mora biti "singleLine", "everyLine", "standardSingleLine" ili "standardEveryLine"
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -2028,6 +2028,7 @@ digits Malayalam Malaiàlam
|
||||
Add Color Tool Eina Afegeix color
|
||||
Remove Color Tool Eina Elimina color
|
||||
Remove Color Elimina el color
|
||||
Find the selected colors in the artwork Troba els colors seleccionats a l’obra
|
||||
Harmony Sets Conjunts d’harmonia
|
||||
HDTV 1080p HDTV 1080p
|
||||
HDTV 720p HDTV 720p
|
||||
@@ -3433,6 +3434,8 @@ digits Malayalam Malaiàlam
|
||||
Insert Aki Left Insereix aki a l'esquerra
|
||||
Insert Aki Right Insereix aki a la dreta
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Ajusta la posició horitzontal dels diacrítics
|
||||
Adjust Vertical Diacritic Position Ajusta la posició vertical dels diacrítics
|
||||
Proportional Lining Xifres proporcionals alineades
|
||||
Position: Posició:
|
||||
Default Position Posició predeterminada
|
||||
@@ -7775,4 +7778,21 @@ breakText Glyphs Glifs
|
||||
@msg {width} × {height} pixels is too large for JPEG (at most 65535 pixels a side): lower the resolution {width} × {height} píxels és massa gran per a JPEG (com a màxim 65535 píxels per costat): reduïu la resolució
|
||||
@msg {width} × {height} pixels is too large for Targa (at most 65535 pixels a side): lower the resolution {width} × {height} píxels és massa gran per a Targa (com a màxim 65535 píxels per costat): reduïu la resolució
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} píxels és massa gran per a PSD (com a màxim {MAX_SIDE} píxels per costat): reduïu la resolució
|
||||
Packaging Tools Eines d’embalatge
|
||||
Fold Lines Línies de plegat
|
||||
Make Cut Line Converteix en línia de tall
|
||||
Make Crease Line Converteix en línia d’hendit
|
||||
Make Partial Cut Line Converteix en línia de tall parcial
|
||||
Make Perforation Line Converteix en línia de perforació
|
||||
Make Fold Line Converteix en línia de plegat
|
||||
Role Swatches… Mostres dels tipus de línia…
|
||||
Role Swatches Mostres dels tipus de línia
|
||||
Role Tipus de línia
|
||||
Cut Line Línia de tall
|
||||
Crease Line Línia d’hendit
|
||||
Partial Cut Line Línia de tall parcial
|
||||
Perforation Line Línia de perforació
|
||||
No objects are selected. No hi ha cap objecte seleccionat.
|
||||
Open a document to mark its fold lines. Obre un document per marcar-ne les línies de plegat.
|
||||
Remove Fold Line Role Elimina el tipus de línia
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer ha de ser "singleLine", "everyLine", "standardSingleLine" o "standardEveryLine"
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -1634,6 +1634,8 @@ lighting Light Světlo
|
||||
Insert Aki Left Vložit aki vlevo
|
||||
Insert Aki Right Vložit aki vpravo
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Upravit vodorovnou polohu diakritiky
|
||||
Adjust Vertical Diacritic Position Upravit svislou polohu diakritiky
|
||||
Character Direction Směr znaků
|
||||
Digits Číslice
|
||||
Arabic Arabské
|
||||
@@ -2989,6 +2991,7 @@ digits Malayalam Malajálamské
|
||||
Add Color Tool Nástroj Přidat barvu
|
||||
Remove Color Tool Nástroj Odstranit barvu
|
||||
Remove Color Odstranit barvu
|
||||
Find the selected colors in the artwork Najít vybrané barvy v kresbě
|
||||
Harmony Rules Pravidla harmonie
|
||||
Keep this row's colors (exclude) Ponechat barvy tohoto řádku (vyloučit)
|
||||
Limit to Library: Omezit na knihovnu:
|
||||
@@ -9596,3 +9599,20 @@ breakText Glyphs Glyfy
|
||||
@msg turn on at least one side zapněte alespoň jednu stranu
|
||||
@msg with no hem and no grommets there is nothing to mark bez lemu a bez průchodek není co označit
|
||||
@msg {saving} failed: {e} {saving} se nezdařilo: {e}
|
||||
Packaging Tools Nástroje pro obaly
|
||||
Fold Lines Linie skladu
|
||||
Make Cut Line Vytvořit linii řezu
|
||||
Make Crease Line Vytvořit linii bigu
|
||||
Make Partial Cut Line Vytvořit linii částečného řezu
|
||||
Make Perforation Line Vytvořit linii perforace
|
||||
Make Fold Line Vytvořit linii skladu
|
||||
Role Swatches… Vzorník typů linií…
|
||||
Role Swatches Vzorník typů linií
|
||||
Role Typ linie
|
||||
Cut Line Linie řezu
|
||||
Crease Line Linie bigu
|
||||
Partial Cut Line Linie částečného řezu
|
||||
Perforation Line Linie perforace
|
||||
No objects are selected. Nejsou vybrány žádné objekty.
|
||||
Open a document to mark its fold lines. Otevřete dokument, abyste označili jeho linie skladu.
|
||||
Remove Fold Line Role Odstranit typ linie
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -2158,6 +2158,8 @@ lighting Light Lys
|
||||
Insert Aki Left Indsæt aki til venstre
|
||||
Insert Aki Right Indsæt aki til højre
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Juster vandret placering af diakritiske tegn
|
||||
Adjust Vertical Diacritic Position Juster lodret placering af diakritiske tegn
|
||||
Character Direction Tegnretning
|
||||
Digits Cifre
|
||||
Arabic Arabisk
|
||||
@@ -3387,6 +3389,7 @@ digits Malayalam Malayalam
|
||||
Add Color Tool Værktøjet Tilføj farve
|
||||
Remove Color Tool Værktøjet Fjern farve
|
||||
Remove Color Fjern farve
|
||||
Find the selected colors in the artwork Find de valgte farver i grafikken
|
||||
Harmony Rules Harmoniregler
|
||||
Keep this row's colors (exclude) Behold farverne i denne række (ekskludér)
|
||||
Limit to Library: Begræns til bibliotek:
|
||||
@@ -7685,4 +7688,21 @@ breakText Glyphs Glyffer
|
||||
Nest Shapes… Pak figurer tæt…
|
||||
Nest Shapes Pak figurer tæt
|
||||
Roll Rulle
|
||||
Packaging Tools Emballageværktøjer
|
||||
Fold Lines Foldelinjer
|
||||
Make Cut Line Gør til skærelinje
|
||||
Make Crease Line Gør til rillelinje
|
||||
Make Partial Cut Line Gør til delvis skærelinje
|
||||
Make Perforation Line Gør til perforeringslinje
|
||||
Make Fold Line Gør til foldelinje
|
||||
Role Swatches… Farveprøver for linjetyper…
|
||||
Role Swatches Farveprøver for linjetyper
|
||||
Role Linjetype
|
||||
Cut Line Skærelinje
|
||||
Crease Line Rillelinje
|
||||
Partial Cut Line Delvis skærelinje
|
||||
Perforation Line Perforeringslinje
|
||||
No objects are selected. Ingen objekter er markeret.
|
||||
Open a document to mark its fold lines. Åbn et dokument for at markere dets foldelinjer.
|
||||
Remove Fold Line Role Fjern linjetype
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer skal være "singleLine", "everyLine", "standardSingleLine" eller "standardEveryLine"
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -1539,6 +1539,7 @@ file-filter Templates Vorlagen
|
||||
Add Color Tool Farbe-hinzufügen-Werkzeug
|
||||
Remove Color Tool Farbe-entfernen-Werkzeug
|
||||
Remove Color Farbe entfernen
|
||||
Find the selected colors in the artwork Ausgewählte Farben in der Grafik finden
|
||||
Harmony Sets Harmoniesätze
|
||||
Height Höhe
|
||||
Height: Höhe:
|
||||
@@ -2691,6 +2692,8 @@ mark-style Japanese Japanisch
|
||||
Insert Aki Left Aki links einfügen
|
||||
Insert Aki Right Aki rechts einfügen
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Horizontale Position diakritischer Zeichen anpassen
|
||||
Adjust Vertical Diacritic Position Vertikale Position diakritischer Zeichen anpassen
|
||||
Character Direction Zeichenrichtung
|
||||
Digits Ziffern
|
||||
Arabic Arabisch
|
||||
@@ -9194,3 +9197,20 @@ breakText Glyphs Glyphen
|
||||
Nest Shapes… Formen verschachteln…
|
||||
Nest Shapes Formen verschachteln
|
||||
Roll Rolle
|
||||
Packaging Tools Verpackungswerkzeuge
|
||||
Fold Lines Faltlinien
|
||||
Make Cut Line Als Schnittlinie festlegen
|
||||
Make Crease Line Als Rilllinie festlegen
|
||||
Make Partial Cut Line Als Teilschnittlinie festlegen
|
||||
Make Perforation Line Als Perforationslinie festlegen
|
||||
Make Fold Line Als Faltlinie festlegen
|
||||
Role Swatches… Farbfelder der Linienarten…
|
||||
Role Swatches Farbfelder der Linienarten
|
||||
Role Linienart
|
||||
Cut Line Schnittlinie
|
||||
Crease Line Rilllinie
|
||||
Partial Cut Line Teilschnittlinie
|
||||
Perforation Line Perforationslinie
|
||||
No objects are selected. Es sind keine Objekte ausgewählt.
|
||||
Open a document to mark its fold lines. Öffnen Sie ein Dokument, um seine Faltlinien festzulegen.
|
||||
Remove Fold Line Role Linienart entfernen
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1471,6 +1471,7 @@ font-technology Variable Μεταβλητές
|
||||
Add Color Tool Εργαλείο προσθήκης χρώματος
|
||||
Remove Color Tool Εργαλείο αφαίρεσης χρώματος
|
||||
Remove Color Αφαίρεση χρώματος
|
||||
Find the selected colors in the artwork Εύρεση των επιλεγμένων χρωμάτων στο σχέδιο
|
||||
Harmony Sets Σύνολα χρωματικής αρμονίας
|
||||
Height Ύψος
|
||||
Height: Ύψος:
|
||||
@@ -3503,6 +3504,8 @@ theme Appearance Εμφάνιση
|
||||
Insert Aki Left Εισαγωγή aki αριστερά
|
||||
Insert Aki Right Εισαγωγή aki δεξιά
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Προσαρμογή οριζόντιας θέσης διακριτικών
|
||||
Adjust Vertical Diacritic Position Προσαρμογή κατακόρυφης θέσης διακριτικών
|
||||
Arabic Αραβικά
|
||||
Hindi Χίντι
|
||||
Farsi Περσικά
|
||||
@@ -7749,4 +7752,21 @@ breakText Glyphs Γλύφοι
|
||||
@msg {width} × {height} pixels is too large for JPEG (at most 65535 pixels a side): lower the resolution τα {width} × {height} εικονοστοιχεία είναι υπερβολικό μέγεθος για JPEG (το πολύ 65535 εικονοστοιχεία ανά πλευρά): μειώστε την ανάλυση
|
||||
@msg {width} × {height} pixels is too large for Targa (at most 65535 pixels a side): lower the resolution τα {width} × {height} εικονοστοιχεία είναι υπερβολικό μέγεθος για Targa (το πολύ 65535 εικονοστοιχεία ανά πλευρά): μειώστε την ανάλυση
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution τα {w} × {h} εικονοστοιχεία είναι υπερβολικό μέγεθος για PSD (το πολύ {MAX_SIDE} εικονοστοιχεία ανά πλευρά): μειώστε την ανάλυση
|
||||
Packaging Tools Εργαλεία συσκευασίας
|
||||
Fold Lines Γραμμές δίπλωσης
|
||||
Make Cut Line Δημιουργία γραμμής κοπής
|
||||
Make Crease Line Δημιουργία γραμμής πτύχωσης
|
||||
Make Partial Cut Line Δημιουργία γραμμής μερικής κοπής
|
||||
Make Perforation Line Δημιουργία γραμμής διάτρησης
|
||||
Make Fold Line Δημιουργία γραμμής δίπλωσης
|
||||
Role Swatches… Δείγματα χρωμάτων τύπων γραμμής…
|
||||
Role Swatches Δείγματα χρωμάτων τύπων γραμμής
|
||||
Role Τύπος γραμμής
|
||||
Cut Line Γραμμή κοπής
|
||||
Crease Line Γραμμή πτύχωσης
|
||||
Partial Cut Line Γραμμή μερικής κοπής
|
||||
Perforation Line Γραμμή διάτρησης
|
||||
No objects are selected. Δεν έχουν επιλεγεί αντικείμενα.
|
||||
Open a document to mark its fold lines. Ανοίξτε ένα έγγραφο για να σημειώσετε τις γραμμές δίπλωσής του.
|
||||
Remove Fold Line Role Αφαίρεση τύπου γραμμής
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" το composer πρέπει να είναι "singleLine", "everyLine", "standardSingleLine" ή "standardEveryLine"
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -1550,6 +1550,7 @@ font-technology Variable Variables
|
||||
Add Color Tool Herramienta Añadir color
|
||||
Remove Color Tool Herramienta Eliminar color
|
||||
Remove Color Eliminar color
|
||||
Find the selected colors in the artwork Buscar los colores seleccionados en la ilustración
|
||||
Harmony Sets Conjuntos de armonía
|
||||
Height Altura
|
||||
Height: Altura:
|
||||
@@ -2728,6 +2729,8 @@ font-technology Variable Variables
|
||||
Insert Aki Left Insertar aki a la izquierda
|
||||
Insert Aki Right Insertar aki a la derecha
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Ajustar posición horizontal de los diacríticos
|
||||
Adjust Vertical Diacritic Position Ajustar posición vertical de los diacríticos
|
||||
Character Direction Dirección de caracteres
|
||||
Digits Dígitos
|
||||
Arabic Árabes
|
||||
@@ -7736,4 +7739,21 @@ breakText Glyphs Glifos
|
||||
Nest Shapes… Anidar formas…
|
||||
Nest Shapes Anidar formas
|
||||
Roll Rollo
|
||||
Packaging Tools Herramientas de embalaje
|
||||
Fold Lines Líneas de plegado
|
||||
Make Cut Line Convertir en línea de corte
|
||||
Make Crease Line Convertir en línea de hendido
|
||||
Make Partial Cut Line Convertir en línea de corte parcial
|
||||
Make Perforation Line Convertir en línea de perforación
|
||||
Make Fold Line Convertir en línea de plegado
|
||||
Role Swatches… Muestras de los tipos de línea…
|
||||
Role Swatches Muestras de los tipos de línea
|
||||
Role Tipo de línea
|
||||
Cut Line Línea de corte
|
||||
Crease Line Línea de hendido
|
||||
Partial Cut Line Línea de corte parcial
|
||||
Perforation Line Línea de perforación
|
||||
No objects are selected. No hay objetos seleccionados.
|
||||
Open a document to mark its fold lines. Abre un documento para marcar sus líneas de plegado.
|
||||
Remove Fold Line Role Quitar tipo de línea
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer debe ser "singleLine", "everyLine", "standardSingleLine" o "standardEveryLine"
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -1609,6 +1609,8 @@ lighting Light Valo
|
||||
Insert Aki Left Lisää aki vasemmalle
|
||||
Insert Aki Right Lisää aki oikealle
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Säädä tarkkeiden vaakasijaintia
|
||||
Adjust Vertical Diacritic Position Säädä tarkkeiden pystysijaintia
|
||||
Character Direction Merkkien suunta
|
||||
Digits Numerot
|
||||
Arabic Arabia
|
||||
@@ -2933,6 +2935,7 @@ digits Malayalam Malajalam
|
||||
Add Color Tool Lisää väri -työkalu
|
||||
Remove Color Tool Poista väri -työkalu
|
||||
Remove Color Poista väri
|
||||
Find the selected colors in the artwork Etsi valitut värit kuvituksesta
|
||||
Harmony Rules Harmoniasäännöt
|
||||
Keep this row's colors (exclude) Säilytä tämän rivin värit (jätä pois)
|
||||
Limit to Library: Rajoita kirjastoon:
|
||||
@@ -7832,4 +7835,21 @@ breakText Glyphs Merkit
|
||||
@msg {width} × {height} pixels is too large for JPEG (at most 65535 pixels a side): lower the resolution {width} × {height} pikseliä on liian suuri JPEG-kuvalle (enintään 65535 pikseliä sivua kohti): pienennä tarkkuutta
|
||||
@msg {width} × {height} pixels is too large for Targa (at most 65535 pixels a side): lower the resolution {width} × {height} pikseliä on liian suuri Targa-kuvalle (enintään 65535 pikseliä sivua kohti): pienennä tarkkuutta
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} pikseliä on liian suuri PSD-kuvalle (enintään {MAX_SIDE} pikseliä sivua kohti): pienennä tarkkuutta
|
||||
Packaging Tools Pakkaustyökalut
|
||||
Fold Lines Taittoviivat
|
||||
Make Cut Line Tee leikkausviiva
|
||||
Make Crease Line Tee nuuttausviiva
|
||||
Make Partial Cut Line Tee osittainen leikkausviiva
|
||||
Make Perforation Line Tee rei’itysviiva
|
||||
Make Fold Line Tee taittoviiva
|
||||
Role Swatches… Viivatyyppien värimallit…
|
||||
Role Swatches Viivatyyppien värimallit
|
||||
Role Viivatyyppi
|
||||
Cut Line Leikkausviiva
|
||||
Crease Line Nuuttausviiva
|
||||
Partial Cut Line Osittainen leikkausviiva
|
||||
Perforation Line Rei’itysviiva
|
||||
No objects are selected. Objekteja ei ole valittu.
|
||||
Open a document to mark its fold lines. Avaa asiakirja, niin voit merkitä sen taittoviivat.
|
||||
Remove Fold Line Role Poista viivatyyppi
|
||||
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer on oltava "singleLine", "everyLine", "standardSingleLine" tai "standardEveryLine"
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
@@ -1543,6 +1543,7 @@ font-technology Variable Variables
|
||||
Add Color Tool Outil Ajouter une couleur
|
||||
Remove Color Tool Outil Supprimer une couleur
|
||||
Remove Color Supprimer la couleur
|
||||
Find the selected colors in the artwork Rechercher les couleurs sélectionnées dans l’illustration
|
||||
Harmony Rules: Règles d’harmonie :
|
||||
Harmony Sets Ensembles d’harmonies
|
||||
Height Hauteur
|
||||
@@ -2720,6 +2721,8 @@ font-technology Variable Variables
|
||||
Insert Aki Left Insérer un aki à gauche
|
||||
Insert Aki Right Insérer un aki à droite
|
||||
Tsume Tsume
|
||||
Adjust Horizontal Diacritic Position Ajuster la position horizontale des signes diacritiques
|
||||
Adjust Vertical Diacritic Position Ajuster la position verticale des signes diacritiques
|
||||
Character Direction Direction des caractères
|
||||
Digits Chiffres
|
||||
Arabic Arabes
|
||||
@@ -9581,4 +9584,21 @@ breakText Glyphs Glyphes
|
||||
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} pixels, c’est trop grand pour le PSD ({MAX_SIDE} pixels par côté au plus) : réduisez la résolution
|
||||
@msg this is a DWG drawing, which can't be read: save it from the CAD app as a DXF and open that c’est un dessin DWG, qui ne peut pas être lu : enregistrez-le depuis l’application de CAO au format DXF et ouvrez ce fichier
|
||||
@msg this binary DXF file is damaged or cut short ce fichier DXF binaire est endommagé ou tronqué
|
||||
Packaging Tools Outils d’emballage
|
||||
Fold Lines Lignes de pliage
|
||||
Make Cut Line Convertir en ligne de découpe
|
||||
Make Crease Line Convertir en ligne de rainage
|
||||
Make Partial Cut Line Convertir en ligne de découpe partielle
|
||||
Make Perforation Line Convertir en ligne de perforation
|
||||
Make Fold Line Convertir en ligne de pliage
|
||||
Role Swatches… Nuances des types de ligne…
|
||||
Role Swatches Nuances des types de ligne
|
||||
Role Type de ligne
|
||||
Cut Line Ligne de découpe
|
||||
Crease Line Ligne de rainage
|
||||
Partial Cut Line Ligne de découpe partielle
|
||||
Perforation Line Ligne de perforation
|
||||
No objects are selected. Aucun objet n’est sélectionné.
|
||||
Open a document to mark its fold lines. Ouvrez un document pour marquer ses lignes de pliage.
|
||||
Remove Fold Line Role Supprimer le type de ligne
|
||||
@msg {_1} × {_2} pixels is too large for GIF (at most 65535 pixels a side): lower the resolution {_1} × {_2} pixels, c’est trop grand pour le GIF (65535 pixels par côté au plus) : réduisez la résolution
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -3566,6 +3566,7 @@
|
||||
Add Color Tool રંગ ઉમેરો સાધન
|
||||
Remove Color Tool રંગ દૂર કરો સાધન
|
||||
Remove Color રંગ દૂર કરો
|
||||
Find the selected colors in the artwork પસંદ કરેલા રંગો આર્ટવર્કમાં શોધો
|
||||
Show handles when multiple anchors are selected બહુવિધ એન્કર પસંદ હોય ત્યારે હૅન્ડલ બતાવો
|
||||
Show in Folder ફોલ્ડરમાં બતાવો
|
||||
Show its progress, see Cancel and write log lines તેની પ્રગતિ બતાવવી, રદ કરવાની વિનંતી જોવી અને લૉગ લાઇનો લખવી
|
||||
@@ -4446,6 +4447,8 @@ antiAlias Sharp શાર્પ
|
||||
Preview: પ્રીવ્યૂ:
|
||||
Insert Aki Left ડાબે અકી ઉમેરો
|
||||
Insert Aki Right જમણે અકી ઉમેરો
|
||||
Adjust Horizontal Diacritic Position ડાયાક્રિટિકની આડી સ્થિતિ ગોઠવો
|
||||
Adjust Vertical Diacritic Position ડાયાક્રિટિકની ઊભી સ્થિતિ ગોઠવો
|
||||
Conic Gradient કોનિક ગ્રેડિયન્ટ
|
||||
Diamond Gradient ડાયમંડ ગ્રેડિયન્ટ
|
||||
Include Placed Images પ્લેસ કરેલી ઇમેજો સામેલ કરો
|
||||
@@ -4776,6 +4779,23 @@ swatch [Registration] [રજિસ્ટ્રેશન]
|
||||
Repeat Objects પુનરાવર્તિત ઑબ્જેક્ટ્સ
|
||||
@msg `{path}` must be one of {_1}, not {got} `{path}` એ {_1}માંથી એક હોવું જોઈએ, {got} નહીં
|
||||
Path Length પાથની લંબાઈ
|
||||
Packaging Tools પેકેજિંગ ટૂલ્સ
|
||||
Fold Lines ફોલ્ડ લાઇન્સ
|
||||
Make Cut Line કટ લાઇન બનાવો
|
||||
Make Crease Line ક્રીઝ લાઇન બનાવો
|
||||
Make Partial Cut Line આંશિક કટ લાઇન બનાવો
|
||||
Make Perforation Line પર્ફોરેશન લાઇન બનાવો
|
||||
Make Fold Line ફોલ્ડ લાઇન બનાવો
|
||||
Role Swatches… લાઇન પ્રકારના સ્વેચ…
|
||||
Role Swatches લાઇન પ્રકારના સ્વેચ
|
||||
Role લાઇન પ્રકાર
|
||||
Cut Line કટ લાઇન
|
||||
Crease Line ક્રીઝ લાઇન
|
||||
Partial Cut Line આંશિક કટ લાઇન
|
||||
Perforation Line પર્ફોરેશન લાઇન
|
||||
No objects are selected. કોઈ ઑબ્જેક્ટ પસંદ કરેલ નથી.
|
||||
Open a document to mark its fold lines. તેની ફોલ્ડ લાઇન્સ ચિહ્નિત કરવા દસ્તાવેજ ખોલો.
|
||||
Remove Fold Line Role લાઇન પ્રકાર દૂર કરો
|
||||
Middle Eastern & South Asian Single-line Composer સિંગલ-લાઇન કમ્પોઝર (મધ્ય પૂર્વ અને દક્ષિણ એશિયા)
|
||||
Middle Eastern & South Asian Every-line Composer એવરી-લાઇન કમ્પોઝર (મધ્ય પૂર્વ અને દક્ષિણ એશિયા)
|
||||
Standard Single-line Composer સ્ટાન્ડર્ડ સિંગલ-લાઇન કમ્પોઝર
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 72 and column 5.
|
@@ -3773,6 +3773,8 @@ antiAlias Sharp शार्प
|
||||
Insert Aki Left बाईं ओर आकी जोड़ें
|
||||
Insert Aki Right दाईं ओर आकी जोड़ें
|
||||
Tsume त्सुमे
|
||||
Adjust Horizontal Diacritic Position डायक्रिटिक की क्षैतिज स्थिति समायोजित करें
|
||||
Adjust Vertical Diacritic Position डायक्रिटिक की लंबवत स्थिति समायोजित करें
|
||||
Proportional Oldstyle आनुपातिक ओल्डस्टाइल
|
||||
Protect Corners कॉर्नर को सुरक्षित रखें
|
||||
Proximity Guides निकटता गाइड
|
||||
@@ -4652,6 +4654,7 @@ antiAlias Sharp शार्प
|
||||
Add Color Tool रंग जोड़ें टूल
|
||||
Remove Color Tool रंग हटाएँ टूल
|
||||
Remove Color रंग हटाएँ
|
||||
Find the selected colors in the artwork चयनित रंगों को आर्टवर्क में खोजें
|
||||
Show Color Groups रंग समूह दिखाएँ
|
||||
Show Color Swatches रंग स्वॉचेस दिखाएँ
|
||||
Show Corner Widget शो कॉर्नर विजेट
|
||||
@@ -9188,3 +9191,20 @@ theme Appearance अपीयरेंस
|
||||
Nest Shapes… आकृतियाँ सटाकर रखें…
|
||||
Nest Shapes आकृतियाँ सटाकर रखें
|
||||
Roll रोल
|
||||
Packaging Tools पैकेजिंग टूल्स
|
||||
Fold Lines फ़ोल्ड लाइनें
|
||||
Make Cut Line कट लाइन बनाएँ
|
||||
Make Crease Line क्रीज़ लाइन बनाएँ
|
||||
Make Partial Cut Line आंशिक कट लाइन बनाएँ
|
||||
Make Perforation Line परफ़ोरेशन लाइन बनाएँ
|
||||
Make Fold Line फ़ोल्ड लाइन बनाएँ
|
||||
Role Swatches… लाइन प्रकार के स्वॉचेस…
|
||||
Role Swatches लाइन प्रकार के स्वॉचेस
|
||||
Role लाइन प्रकार
|
||||
Cut Line कट लाइन
|
||||
Crease Line क्रीज़ लाइन
|
||||
Partial Cut Line आंशिक कट लाइन
|
||||
Perforation Line परफ़ोरेशन लाइन
|
||||
No objects are selected. कोई ऑब्जेक्ट सिलेक्ट नहीं है।
|
||||
Open a document to mark its fold lines. फ़ोल्ड लाइनें मार्क करने के लिए कोई डॉक्यूमेंट ओपन करें।
|
||||
Remove Fold Line Role लाइन प्रकार हटाएँ
|
||||
|
||||
|
Can't render this file because it is too large.
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user