Merge main into fix/the-liquify-warning-s-tool-name-and-object-kinds

This commit is contained in:
dotCooCoo
2026-11-15 06:18:52 -08:00
93 changed files with 6533 additions and 316 deletions
Generated
+1
View File
@@ -6930,6 +6930,7 @@ name = "vectorcraft-ui-egui"
version = "0.24.1"
dependencies = [
"bytemuck",
"chrono",
"craft-keymap",
"craft-ui",
"craft-update",
+145 -11
View File
@@ -266,6 +266,7 @@ pub fn hit_test_visible_skipping(doc: &Document, p: Point, opt: HitOptions, skip
/// (`opt.scope`) or on a locked artboard. On a layer whose Preview is off it counts by its
/// outline, as a click there hits it.
pub fn selected_hidden_at(doc: &Document, p: Point, opt: HitOptions, selected: &[NodeId]) -> Option<NodeId> {
let _walk = ArtWalk::open();
let symbols = doc.symbol_boxes();
let locks = doc.locked_artboards();
selected.iter().rev().copied().find(|&id| {
@@ -322,6 +323,7 @@ fn path_options(nodes: &[&Node], chain: &[NodeId], opt: HitOptions) -> Option<Hi
/// The objects under `p` that [`Hit::top_object`] picks in `scope` (isolation mode), topmost
/// first: what clicks there select, one below the other (Cmd/Ctrl-click selects behind).
pub fn objects_at(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>) -> Vec<NodeId> {
let walk = ArtWalk::open();
let opt = HitOptions { scope: scope.or(opt.scope), ..opt };
// Normally one hit test per *object* suffices: layers and sublayers aren't selectable,
// while a group (including a clipping group) is selected as one object. Repeatedly
@@ -337,6 +339,7 @@ pub fn objects_at(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeI
for layer in doc.layers.iter().rev() {
// Malformed files may contain non-layer roots; let the general traversal handle them.
if !layer.is_layer() {
walk.restart();
return objects_at_repeated(doc, p, opt, scope);
}
if !layer.visible || layer.locked || layer.is_template() || doc.pattern_edit.as_ref().is_some_and(|e| e.layer != layer.id) {
@@ -344,7 +347,9 @@ pub fn objects_at(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeI
}
if !objects_at_layer(layer, p, opt, &symbols, &mut tops, &mut seen) {
// An envelope in Edit Contents may expose objects *within* a top-level group.
// The repeated traversal handles that mixed hierarchy precisely.
// The repeated traversal handles that mixed hierarchy precisely, with the whole
// limit of symbol art to walk.
walk.restart();
return objects_at_repeated(doc, p, opt, scope);
}
}
@@ -429,6 +434,7 @@ pub const MAX_LOCKED_AT: usize = 20;
/// out. While a pattern is edited only its tile layer is searched, and in isolation mode
/// (`opt.scope`) only what is inside the isolated group or object.
pub fn locked_objects_at(doc: &Document, p: Point, opt: HitOptions) -> Vec<NodeId> {
let _walk = ArtWalk::open();
let symbols = doc.symbol_boxes();
let mut out = Vec::new();
if let Some(scope) = opt.scope
@@ -506,6 +512,7 @@ fn object_hit(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes, editab
/// an isolated group on one ([`crate::LockedArtboards::holds`]). Symbol instances are measured by their art
/// ([`Node::geometric_bounds_with`]), and are also hit outside that box where their art paints.
fn hit_test_skipping(doc: &Document, p: Point, opt: HitOptions, skip: &dyn Fn(NodeId) -> bool, editable_only: bool) -> Option<Hit> {
let _walk = ArtWalk::open();
let finish = |mut h: Hit| {
h.contents_of = h.ancestry.iter().rev().copied().find(|a| doc.node(*a).is_some_and(edits_contents));
h.layers = h.ancestry.iter().take_while(|a| doc.node(**a).is_some_and(Node::is_layer)).count();
@@ -1059,9 +1066,10 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
n.geometric_bounds_with(symbols).filter(|b| b.inflate(opt.tol, opt.tol).contains(p)).map(|_| HitKind::Bounds)
}
// A symbol instance is hit within its bounds, and outside them where its art paints
// ([`instance_art_hit`]).
// ([`instance_art_hit`]). In the art of another instance walked outside that instance's
// bounds, it is hit only where its own art paints ([`ArtOnly`]).
NodeKind::SymbolInstance { .. } => {
if n.geometric_bounds_with(symbols).is_some_and(|b| b.inflate(opt.tol, opt.tol).contains(p)) {
if !ArtOnly::on() && n.geometric_bounds_with(symbols).is_some_and(|b| b.inflate(opt.tol, opt.tol).contains(p)) {
return Some(HitKind::Bounds);
}
instance_art_hit(n, p, opt, symbols)
@@ -1172,6 +1180,15 @@ impl<'a> InstanceArt<'a> {
whole.or_else(|| self.map.as_ref()?.one_cell_with(n, &self.boxes))
}
/// How many objects placing the whole art makes: the objects of the art with their opacity
/// masks' art ([`Node::count_with_masks`]), or, through the guides, the most that
/// [`crate::NineSliceMap::most_placed_with`] counts.
fn size(&self) -> u64 {
self.map
.as_ref()
.map_or_else(|| u64::try_from(self.art.count_with_masks()).unwrap_or(u64::MAX), |m| m.most_placed_with(&self.art, &self.boxes))
}
/// Object `n` of the art placed on the canvas as it is drawn, clip groups included: moved by
/// `whole` when an object around it is moved as one piece ([`Self::whole`]). `None` when
/// placing it through the guides could make more than [`crate::MAX_SYMBOL_NODES`] objects, as
@@ -1219,6 +1236,7 @@ fn moved(n: &Node, xf: vectorcraft_geom::Affine) -> Node {
/// layer, is tested in outline ([`HitOptions::outline`]), as the canvas draws it. `None` when `inst` is not a symbol instance or
/// no editable object of its art is under `p`.
pub fn symbol_part_at(doc: &Document, inst: &Node, p: Point, opt: HitOptions) -> Option<Vec<u32>> {
let _walk = ArtWalk::open();
let art = InstanceArt::of(doc, inst)?;
let symbols = doc.symbol_boxes();
let mut path = vec![];
@@ -1250,7 +1268,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) {
if !n.visible || !self.whole_instance && (n.locked || n.is_template()) || self.skips_guide(n) || !ArtWalk::take(1) {
return None;
}
let outline = outline || previews_off(n);
@@ -1298,17 +1316,120 @@ impl FindPart<'_> {
/// Outline, [`HitOptions::outline`]): its strokes, and the art that the live geometry effects of a
/// clipping path in it show past the art's box. `None` for an instance of a missing symbol, of a
/// symbol that holds an instance of itself or nests too deep ([`SymbolBoxes::art`]), and of art past
/// the 9-slice object limit ([`InstanceArt::of`]).
/// the 9-slice object limit ([`InstanceArt::of`]), when `p` is outside the instance's reach
/// ([`Node::reach_bounds_with`]), and once the click has visited as many objects of symbol art as
/// [`ArtWalk`] allows.
fn instance_art_hit(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Option<HitKind> {
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return None };
if opt.outline || symbols.art(symbol).is_none() {
if opt.outline || symbols.art(symbol).is_none() || !n.reach_bounds_with(symbols).is_some_and(|b| b.inflate(opt.tol, opt.tol).contains(p)) {
return None;
}
let _walk = ArtWalk::open();
if ArtWalk::used_up() {
return None;
}
let art = InstanceArt::of(symbols.document(), n)?;
#[cfg(test)]
ARTS_WALKED.with(|c| c.set(c.get() + 1));
let opt = HitOptions { clip_outlines: false, ..opt };
let _art_only = ArtOnly::set();
FindPart { art: &art, p, opt, symbols, whole_instance: true }.find(&art.art, &mut vec![], None, false)
}
thread_local! {
/// Whether a symbol instance's art is being walked outside the instance's box ([`ArtOnly`]).
static ART_ONLY: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
/// While a guard lives, a symbol instance is hit ([`hit_leaf`]) and touched by a marquee
/// ([`marquee_with`]) only where its own art is, by the same rule at every level, and not anywhere
/// in its box. [`instance_art_hit`] and the marquee's walk of an instance's art hold one: they walk
/// the art outside the instance's box, where the box of an instance nested in the art can reach
/// past it over empty space.
struct ArtOnly {
was: bool,
}
impl ArtOnly {
fn set() -> Self {
Self { was: ART_ONLY.replace(true) }
}
fn on() -> bool {
ART_ONLY.get()
}
}
impl Drop for ArtOnly {
fn drop(&mut self) {
ART_ONLY.set(self.was);
}
}
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) };
}
#[cfg(test)]
thread_local! {
/// The number of objects [`ArtWalk::open`] allows on this thread in place of
/// [`crate::MAX_SYMBOL_NODES`].
static ART_WALK_LIMIT: std::cell::Cell<Option<u64>> = const { std::cell::Cell::new(None) };
/// How many symbol instances' art clicks and marquees walked on this thread.
static ARTS_WALKED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// The objects of symbol art that one click or one marquee may visit: [`crate::MAX_SYMBOL_NODES`]
/// in all, the art of the instances nested in that art included, at every level. The first
/// [`ArtWalk::open`] of a click or a marquee sets the limit, and the walks opened while its guard
/// lives share it. Once the limit is used up, an instance is no longer hit or touched outside its
/// box; inside its box it still is.
struct ArtWalk {
outermost: bool,
}
impl ArtWalk {
fn open() -> Self {
let walk = Self { outermost: ART_WALK_LEFT.get().is_none() };
walk.restart();
walk
}
/// For the outermost guard, sets what is left back to the whole limit.
fn restart(&self) {
if self.outermost {
#[cfg(test)]
let limit = ART_WALK_LIMIT.get().unwrap_or(crate::MAX_SYMBOL_NODES);
#[cfg(not(test))]
let limit = crate::MAX_SYMBOL_NODES;
ART_WALK_LEFT.set(Some(limit));
}
}
/// Is nothing left?
fn used_up() -> bool {
ART_WALK_LEFT.get() == Some(0)
}
/// Takes `n` objects from what is left. `false` when fewer are left, and nothing is left after.
fn take(n: u64) -> bool {
let Some(left) = ART_WALK_LEFT.get() else { return true };
let rest = left.checked_sub(n);
ART_WALK_LEFT.set(Some(rest.unwrap_or(0)));
rest.is_some()
}
}
impl Drop for ArtWalk {
fn drop(&mut self) {
if self.outermost {
ART_WALK_LEFT.set(None);
}
}
}
/// 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.
@@ -1502,6 +1623,7 @@ fn previews_off(n: &Node) -> bool {
}
fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, whole_compounds: bool, outline: bool) -> Vec<NodeId> {
let _walk = ArtWalk::open();
let mut out = Vec::new();
// The objects the marquee may touch ([`Top`]).
let tops: Vec<Top> = match scope.and_then(|s| doc.node(s)) {
@@ -1613,8 +1735,9 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
NodeKind::Compound { children, .. } => children.iter().any(|c| c.visible && touches(c, s, r, scope, whole_compounds, outline)),
NodeKind::Repeat(spec) => spec.expand(Some(s.document())).iter().any(|copy| touches(copy, s, r, scope, whole_compounds, outline)),
// A symbol instance is touched by its box, and outside it where the live geometry
// effects of a clipping path in its art show the art.
NodeKind::SymbolInstance { .. } => box_touches(n, s, r) || !outline && instance_art_touches(n, s, r, whole_compounds),
// effects of a clipping path in its art show the art. In the art of another instance
// walked outside that instance's box, it is touched only by its own art ([`ArtOnly`]).
NodeKind::SymbolInstance { .. } => !ArtOnly::on() && box_touches(n, s, r) || !outline && instance_art_touches(n, s, r, whole_compounds),
_ => box_touches(n, s, r),
}
}
@@ -1628,15 +1751,26 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
}
/// Does the marquee `r` touch the art of symbol instance `n` placed as the canvas draws it, as
/// it touches a group of that art? Only for art whose clipping paths have live geometry effects
/// ([`SymbolBoxes::art`]), and only when `r` meets the instance's reach
/// ([`Node::reach_bounds_with`]): elsewhere the art lies within the instance's box.
/// ([`SymbolBoxes::art`]), or for any art while [`ArtOnly`] is on, and only when `r` meets the
/// instance's reach ([`Node::reach_bounds_with`]): elsewhere the art lies within the instance's
/// box. Not once the marquee has placed as many objects of symbol art as [`ArtWalk`] allows.
fn instance_art_touches(n: &Node, s: &SymbolBoxes, r: Rect, whole_compounds: bool) -> bool {
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return false };
let meets = |b: Rect| b.x0 <= r.x1 && r.x0 <= b.x1 && b.y0 <= r.y1 && r.y0 <= b.y1;
if s.art(symbol).is_none_or(|a| a.reshaped.is_none()) || !n.reach_bounds_with(s).is_some_and(meets) {
if s.art(symbol).is_none_or(|a| a.reshaped.is_none() && !ArtOnly::on()) || !n.reach_bounds_with(s).is_some_and(meets) {
return false;
}
let _walk = ArtWalk::open();
if ArtWalk::used_up() {
return false;
}
let Some(art) = InstanceArt::of(s.document(), n) else { return false };
if !ArtWalk::take(art.size()) {
return false;
}
#[cfg(test)]
ARTS_WALKED.with(|c| c.set(c.get() + 1));
let _art_only = ArtOnly::set();
art.place(&art.art, None).is_some_and(|placed| placed.visible && touches(&placed, s, r, None, whole_compounds, false))
}
fn collect_leaves(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, whole_compounds: bool, outline: bool, out: &mut Vec<NodeId>) {
+179
View File
@@ -1961,6 +1961,185 @@ fn a_symbol_instance_is_hit_on_the_stroke_of_its_art_past_its_box() {
assert_eq!(at(108.0, HitOptions { outline: true, ..HitOptions::default() }), None, "Outline view");
}
/// Outside a symbol instance's box, an instance nested in its art counts where its own art is, not
/// anywhere in its box: a click or a marquee on empty space in the nested box, where a moved
/// clipping path shows the art past the outer box, selects nothing, and on art drawn there it
/// selects the outer instance.
#[test]
fn a_nested_symbol_instances_box_past_the_outer_box_is_not_a_hit() {
set_clip_region(moved_clip_region);
// `Two` draws squares at the corners of 0..200 × 0..100, and with `middle` one at 140..160 ×
// 40..60. The outer symbol clips an instance of it to 0..100 × 0..100, which `test.move` moves
// to 100..200: the outer box is 0..100, the nested box 0..200.
let build = |middle: bool| {
let mut d = Document::new(600.0, 400.0);
let l = d.layers[0].id;
let square = |d: &mut Document, r: Rect| Arc::new(Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::default_art()));
let mut squares = vec![square(&mut d, Rect::new(0.0, 0.0, 10.0, 10.0)), square(&mut d, Rect::new(190.0, 90.0, 200.0, 100.0))];
if middle {
squares.push(square(&mut d, Rect::new(140.0, 40.0, 160.0, 60.0)));
}
group_symbol(&mut d, "Two", squares);
let (mut mask, _) = half_clipped(&mut d);
mask.appearance.effects.push(test_move());
let nested = instance_of(&mut d, "Two");
let mut clip = Node::group(d.alloc_id(), vec![Arc::new(mask), nested]);
clip.set_clips(true);
group_symbol(&mut d, "Outer", vec![Arc::new(clip)]);
let inst = d.alloc_id();
d.insert(Some(l), 0, Node::new(inst, NodeKind::SymbolInstance { symbol: "Outer".into(), xf: vectorcraft_geom::Affine::IDENTITY })).unwrap();
(d, inst)
};
let at = |d: &Document, x: f64, y: f64| hit_test(d, Point::new(x, y), HitOptions::default()).map(|h| h.leaf);
let inside = Rect::new(145.0, 45.0, 155.0, 55.0);
let (d, inst) = build(false);
assert_eq!(at(&d, 150.0, 50.0), None, "empty space in the nested box");
assert!(marquee(&d, inside, None, false).is_empty(), "marquee on empty space in the nested box");
assert_eq!(at(&d, 195.0, 95.0), Some(inst), "on the nested art past the outer box");
assert_eq!(at(&d, 50.0, 50.0), Some(inst), "in the outer box");
let (d, inst) = build(true);
assert_eq!(at(&d, 150.0, 50.0), Some(inst), "on the nested art");
// Across the middle square's left edge.
assert_eq!(marquee(&d, Rect::new(135.0, 45.0, 145.0, 55.0), None, false), [inst], "marquee on the nested art");
}
/// Adds the symbol `Clipped`: a clip group whose clipping path's region `test.move` moves to
/// 100..200 × 0..100, past the 0..100 box, over a 0..200 × 0..100 rectangle shown when `shown`.
/// A click at (150, 50) hits an instance of it on the rectangle, or, with the rectangle hidden,
/// walks its art and finds nothing.
fn clipped_symbol(d: &mut Document, shown: bool) {
set_clip_region(moved_clip_region);
let (mut mask, mut art) = half_clipped(d);
mask.appearance.effects.push(test_move());
art.visible = shown;
let mut clip = Node::group(d.alloc_id(), vec![Arc::new(mask), Arc::new(art)]);
clip.set_clips(true);
let root = Node::group(d.alloc_id(), vec![Arc::new(clip)]);
d.symbols.push(crate::Symbol { dynamic: false, name: "Clipped".into(), art: Arc::new(root) });
}
/// A symbol named `name` whose art is a group of `members`.
fn group_symbol(d: &mut Document, name: &str, members: Vec<Arc<Node>>) {
let root = Node::group(d.alloc_id(), members);
d.symbols.push(crate::Symbol { dynamic: false, name: name.into(), art: Arc::new(root) });
}
/// An instance of the symbol named `symbol`, not moved.
fn instance_of(d: &mut Document, symbol: &str) -> Arc<Node> {
Arc::new(Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: symbol.into(), xf: vectorcraft_geom::Affine::IDENTITY }))
}
/// 30 small squares at the origin, which a click at (150, 50) passes by.
fn far_squares(d: &mut Document) -> Vec<Arc<Node>> {
(0..30).map(|_| Arc::new(Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 1.0, 1.0)), Appearance::default_art()))).collect()
}
/// Runs `f` with [`ArtWalk`] allowing `limit` objects, and returns its result with how many
/// leaves [`hit_leaf`] tested and how many instances' art was walked meanwhile.
fn with_art_limit<R>(limit: u64, f: impl FnOnce() -> R) -> (R, usize, usize) {
ART_WALK_LIMIT.with(|c| c.set(Some(limit)));
LEAVES_TESTED.with(|c| c.set(0));
ARTS_WALKED.with(|c| c.set(0));
let r = f();
ART_WALK_LIMIT.with(|c| c.set(None));
(r, LEAVES_TESTED.with(std::cell::Cell::get), ARTS_WALKED.with(std::cell::Cell::get))
}
/// One click visits at most the art walk's limit of objects in a chain of nested symbol
/// instances, though each level's art alone is well within it. A click on the art of an
/// instance nested in another is still found.
#[test]
fn a_click_walks_a_chain_of_nested_symbol_instances_within_one_limit() {
// Level 0 is `Clipped`; each level above holds an instance of the level below and 30 squares:
// 32 objects to visit at each level.
let chain = |shown: bool| {
let mut d = Document::new(600.0, 400.0);
let l = d.layers[0].id;
clipped_symbol(&mut d, shown);
for level in 1..12 {
let below = if level == 1 { "Clipped".to_string() } else { format!("Level {}", level - 1) };
let mut members = vec![instance_of(&mut d, &below)];
members.extend(far_squares(&mut d));
group_symbol(&mut d, &format!("Level {level}"), members);
}
let inst = instance_of(&mut d, "Level 11");
let id = inst.id;
d.insert(Some(l), 0, Arc::unwrap_or_clone(inst)).unwrap();
(d, id)
};
let at = |d: &Document, x: f64| hit_test(d, Point::new(x, 50.0), HitOptions::default()).map(|h| h.leaf);
// Without one limit for the click, the miss walks the art of all 12 levels.
let (d, inst) = chain(false);
let (hit, _, arts) = with_art_limit(100, || at(&d, 150.0));
assert_eq!(hit, None);
assert!(arts <= 4, "{arts} levels walked");
assert_eq!(with_art_limit(100, || at(&d, 50.0)).0, Some(inst), "in the box");
// Past the limit, a click that the art would take finds only the box.
let (d, inst) = chain(true);
assert_eq!(with_art_limit(100, || at(&d, 150.0)).0, None, "past the limit");
assert_eq!(at(&d, 150.0), Some(inst), "within the limit");
// Two levels: a click on the inner instance's art is found within the limit.
let mut d = Document::new(600.0, 400.0);
let l = d.layers[0].id;
clipped_symbol(&mut d, true);
let inner = instance_of(&mut d, "Clipped");
group_symbol(&mut d, "Outer", vec![inner]);
let inst = instance_of(&mut d, "Outer");
let id = inst.id;
d.insert(Some(l), 0, Arc::unwrap_or_clone(inst)).unwrap();
assert_eq!(with_art_limit(100, || at(&d, 150.0)).0, Some(id), "nested");
}
/// One click, and one marquee, visit at most the art walk's limit of objects in art that repeats
/// one nested instance many times, though the art of each instance alone is well within it. A
/// click on one of the nested instances' art is still found.
#[test]
fn a_click_and_a_marquee_walk_repeated_nested_symbol_instances_within_one_limit() {
// 50 instances of `Clipped` in one symbol's art, its rectangle shown when `shown`.
let repeated = |shown: bool| {
let mut d = Document::new(600.0, 400.0);
let l = d.layers[0].id;
clipped_symbol(&mut d, shown);
let members = (0..50).map(|_| instance_of(&mut d, "Clipped")).collect();
group_symbol(&mut d, "Repeated", members);
let inst = instance_of(&mut d, "Repeated");
let id = inst.id;
d.insert(Some(l), 0, Arc::unwrap_or_clone(inst)).unwrap();
(d, id)
};
let (d, inst) = repeated(false);
// Without one limit for the click, the miss walks the art of all 51 instances. The outer art
// takes 1 object of the 100, and each nested instance with its art 4.
let (hit, _, arts) = with_art_limit(100, || hit_test(&d, Point::new(150.0, 50.0), HitOptions::default()).map(|h| h.leaf));
assert_eq!(hit, None);
assert!(arts <= 26, "{arts} instances' art walked");
// Select Behind over 60 instances of `Clipped` on the layer shares one limit too: each walk
// takes 3 objects of the 100.
let mut stack = Document::new(600.0, 400.0);
let l = stack.layers[0].id;
clipped_symbol(&mut stack, false);
for _ in 0..60 {
let inst = instance_of(&mut stack, "Clipped");
stack.insert(Some(l), 0, Arc::unwrap_or_clone(inst)).unwrap();
}
let (behind, _, arts) = with_art_limit(100, || objects_at(&stack, Point::new(150.0, 50.0), HitOptions::default(), None));
assert!(behind.is_empty());
assert!(arts <= 34, "Select Behind: {arts} instances' art walked");
// Without one limit for the marquee, it places the art of all 51 instances, inside the moved
// region (within each instance's reach and outside its box). Placing the outer art takes 51
// objects of the 100, and each nested art 4.
let inside = Rect::new(140.0, 40.0, 160.0, 60.0);
let (touched, _, arts) = with_art_limit(100, || marquee(&d, inside, None, false));
assert!(touched.is_empty());
assert!(arts <= 14, "{arts} instances' art placed");
assert_eq!(with_art_limit(100, || marquee(&d, Rect::new(40.0, 40.0, 60.0, 60.0), None, false)).0, [inst], "in the box");
// A click and a marquee on the nested instances' art are found within the limit.
let (d, inst) = repeated(true);
assert_eq!(with_art_limit(100, || hit_test(&d, Point::new(150.0, 50.0), HitOptions::default()).map(|h| h.leaf)).0, Some(inst), "click");
let edge = Rect::new(140.0, -5.0, 160.0, 5.0);
assert_eq!(with_art_limit(100, || marquee(&d, edge, None, false)).0, [inst], "marquee across the art's edge");
}
/// 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.
+34 -4
View File
@@ -17,22 +17,52 @@ pub enum Justify {
JustifyAll,
}
/// Paragraph composer (Paragraph panel menu): how lines are broken.
/// Paragraph composer (Paragraph panel menu): how lines are broken, and whether complex scripts
/// (Indic, Arabic, Hebrew) are shaped. `SingleLine` and `EveryLine` are the Middle Eastern & South
/// Asian composers: they shape complex scripts with the font's layout tables, as all type is set
/// here, and are what documents saved before the four composers existed use. The `Standard`
/// composers break lines the same way but set a complex script glyph by glyph as the font maps its
/// characters, with no conjuncts, marks placed or joining forms: what fonts that keep a script's
/// glyphs on Latin character codes (legacy ANSI Indic fonts) need.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Composer {
/// Break each line as soon as it is full.
/// Middle Eastern & South Asian Single-line Composer: break each line as soon as it is full.
SingleLine,
/// Total fit over the whole paragraph (Illustrator's default): justified lines get even word
/// spacing, ragged lines an even rag.
/// Middle Eastern & South Asian Every-line Composer: total fit over the whole paragraph
/// (Illustrator's default): justified lines get even word spacing, ragged lines an even rag.
#[default]
EveryLine,
/// Standard Single-line Composer: [`Composer::SingleLine`]'s breaks, complex scripts not shaped.
StandardSingleLine,
/// Standard Every-line Composer: [`Composer::EveryLine`]'s breaks, complex scripts not shaped.
StandardEveryLine,
}
impl Composer {
fn is_default(&self) -> bool {
*self == Self::default()
}
/// Does this composer break lines one at a time (as opposed to a total fit)?
pub fn is_single_line(self) -> bool {
matches!(self, Self::SingleLine | Self::StandardSingleLine)
}
/// Does this composer shape complex scripts ([`Composer::SingleLine`], [`Composer::EveryLine`])?
pub fn shapes_complex_scripts(self) -> bool {
matches!(self, Self::SingleLine | Self::EveryLine)
}
/// The same shaping with the other line breaking (`single_line`: one line at a time).
pub fn with_breaking(self, single_line: bool) -> Self {
match (single_line, self.shapes_complex_scripts()) {
(true, true) => Self::SingleLine,
(true, false) => Self::StandardSingleLine,
(false, true) => Self::EveryLine,
(false, false) => Self::StandardEveryLine,
}
}
}
/// A paragraph's hyphenation options (Paragraph panel menu › Hyphenation…): which words automatic
+56 -7
View File
@@ -171,7 +171,7 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value)
}
}
}
let casting = shapes.iter().filter(|s| surface_item(&s.items).is_some_and(|i| paint_of(i).1 * s.opacity > 0.0));
let casting = shapes.iter().filter(|s| surface_item(&s.items).is_some_and(|i| crate::solids::shadow::casts(paint_of(i).1 * s.opacity)));
return check_shadow(p, casting.map(|s| &s.path), b, options);
}
let (path, _) = object_profile(n, "Revolve")?;
@@ -350,8 +350,8 @@ fn geometry(path: &PathData, fx: &[Effect], ctx: &GeomContext) -> PathData {
/// The shadow of Revolve `fx` cast by the surface of `path` in `item`'s paint about the axis of
/// `b`, revolved with `options`, as dark as `item` is opaque and in its blending mode; `None` with
/// the shadow off, when `item` is fully transparent or when it casts nothing, and an error when
/// the surface it is cast from is past the limits.
/// the shadow off, when `item` is fully transparent or its opacity is not a finite number, or when
/// it casts nothing, and an error when the surface it is cast from is past the limits.
///
/// `kept` holds the faces the surface drawn kept for its shadow ([`surface`]); without them the
/// surface is swept again for its shadow alone.
@@ -366,7 +366,7 @@ fn shadow_of(
) -> Result<Option<Node>, String> {
let Some(settings) = crate::solids::shadow::options(&merged_params(&fx.id, &fx.params)) else { return Ok(None) };
let (_, opacity, blend) = paint_of(item);
if opacity <= 0.0 {
if !crate::solids::shadow::casts(opacity) {
return Ok(None);
}
let mut caster = vectorcraft_three_d::ShadowCaster::new();
@@ -377,7 +377,7 @@ fn shadow_of(
/// Does Revolve `fx` cast a shadow, so a surface in paint as opaque as `opacity` keeps the faces
/// its shadow is cast from ([`surface`])?
fn casts(fx: &Effect, opacity: f32) -> bool {
opacity > 0.0 && crate::solids::shadow::options(&merged_params(&fx.id, &fx.params)).is_some()
crate::solids::shadow::casts(opacity) && crate::solids::shadow::options(&merged_params(&fx.id, &fx.params)).is_some()
}
/// Add the surface of `path` about the axis of `b` to `caster`: the faces it kept when it was
@@ -420,9 +420,9 @@ fn group_shadow(
for s in shapes {
let kept = kept.next().flatten();
let Some((_, opacity, blend)) = surface_item(&s.items).map(paint_of) else { continue };
// A member whose surface is fully transparent casts nothing.
// A member whose surface is fully transparent, or whose opacity is not a finite number, casts nothing.
let ink = crate::solids::shadow::Ink { opacity: opacity * s.opacity, blend };
if ink.opacity <= 0.0 {
if !ink.casts() {
continue;
}
let faces = cast_surface(&mut caster, &s.path, b, options, kept)?;
@@ -1861,6 +1861,55 @@ mod tests {
}
}
}
/// A surface whose fill, or whose member, is at NaN or infinite opacity casts no shadow, as one
/// at 0 % does, whether the shadow is cast from the surface drawn or swept for it alone; the
/// member beside it still casts its part.
#[test]
fn a_surface_whose_opacity_is_not_a_finite_number_casts_no_shadow() {
let fx = crate::new_effect(REVOLVE, &json!({"shadow": true})).unwrap();
let group = |opacity: f32| {
let mut other = profile_node();
other.id = NodeId(2);
other.transform(Affine::translate((120.0, 0.0)), false);
other.opacity = opacity;
let mut g = Node::group(NodeId(9), vec![Arc::new(profile_node()), Arc::new(other)]);
g.appearance.effects.push(fx.clone());
g
};
let group_shadows = |g: &Node| {
let shapes = members(g, "").unwrap();
let b = union_bounds(&shapes).unwrap();
let options = shared_options(&shapes, fx_options(&fx)).unwrap();
let kept: Vec<Option<SolidFaces>> = shapes
.iter()
.map(|s| {
let (paint, opacity, blend) = paint_of(surface_item(&s.items).unwrap());
let cast = casts(&fx, opacity * s.opacity);
surface(None, g, &s.path, b, options, &fx, paint, opacity, blend, false, &mut Copies::default(), cast).unwrap().2
})
.collect();
[group_shadow(g.id, &fx, &shapes, b, options, kept).unwrap(), group_shadow(g.id, &fx, &shapes, b, options, vec![]).unwrap()]
.map(|art| format!("{art:?}"))
};
let expected = group_shadows(&group(0.0));
for bad in [f32::NAN, f32::INFINITY] {
let mut n = profile_node();
if let AppearanceItem::Fill(f) = &mut n.appearance.items[0] {
f.opacity = bad;
}
let (path, _) = profile(&n).unwrap();
let b = path.bounds().unwrap();
let item = surface_item(&n.appearance.items).unwrap();
assert!(!casts(&fx, bad), "{bad}: the surface keeps no faces for a shadow");
let (_, kept) = object_surface(None, &n, &path, &fx, item, false, &mut Copies::default()).unwrap();
assert_eq!(shadow_of(n.id, &fx, &path, item, b, fx_options(&fx), kept).unwrap(), None, "{bad} drawn");
assert_eq!(shadow_of(n.id, &fx, &path, item, b, fx_options(&fx), None).unwrap(), None, "{bad} alone");
let shadows = group_shadows(&group(bad));
assert!(!expected[0].is_empty() && expected[0] != "[]", "the opaque member casts");
assert_eq!(shadows, expected, "{bad}: only the opaque member casts");
}
}
}
#[cfg(test)]
+10 -10
View File
@@ -1474,8 +1474,8 @@ fn cast_shadow<'a>(id: &str, p: &Value, shapes: &'a [Profile]) -> Result<Option<
let view = view_options(p);
let mut caster = vectorcraft_three_d::ShadowCaster::new();
// The faces each solid of visible art added, with its member's scopes and its ink (opacity
// and blending mode), in order. A fully transparent fill or stroke (or member) casts nothing
// and does not place the plane.
// and blending mode), in order. A fill or stroke (or member) that is fully transparent, or whose
// opacity is not a finite number, casts nothing and does not place the plane ([`shadow::Ink::casts`]).
let mut cast: Vec<shadow::Cast> = vec![];
let ink = |item: &AppearanceItem, member: f32| {
let (_, opacity, blend) = paint_of(item, member);
@@ -1483,7 +1483,7 @@ fn cast_shadow<'a>(id: &str, p: &Value, shapes: &'a [Profile]) -> Result<Option<
};
if id == ROTATE {
for s in shapes {
for item in s.items.iter().filter(|i| ink(i, s.opacity).opacity > 0.0) {
for item in s.items.iter().filter(|i| ink(i, s.opacity).casts()) {
let (area, rule) = region(&s.path, s.rule, item);
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + 1));
@@ -1497,7 +1497,7 @@ fn cast_shadow<'a>(id: &str, p: &Value, shapes: &'a [Profile]) -> Result<Option<
// Inflate's eye is placed for every shape together, as the solids are.
let added: Vec<Result<std::ops::Range<usize>, String>> = if id == INFLATE {
let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, _, area, rule, _, _)| (area, *rule)).collect();
let casts: Vec<bool> = inks.iter().map(|i| i.opacity > 0.0).collect();
let casts: Vec<bool> = inks.iter().map(|i| i.casts()).collect();
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + shapes.len()));
caster.inflate(&shapes, &casts, bounds, inflate_options(p), view)
@@ -1505,13 +1505,13 @@ fn cast_shadow<'a>(id: &str, p: &Value, shapes: &'a [Profile]) -> Result<Option<
let mut added = vec![];
for ((_, _, area, rule, _, _), ink) in parts.iter().zip(&inks) {
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + usize::from(ink.opacity > 0.0)));
added.push(if ink.opacity > 0.0 { caster.extrude(area, *rule, bounds, extrude_options(p), view) } else { Ok(0..0) });
SOLIDS_BUILT.with(|n| n.set(n.get() + usize::from(ink.casts())));
added.push(if ink.casts() { caster.extrude(area, *rule, bounds, extrude_options(p), view) } else { Ok(0..0) });
}
added
};
for (((item, _, _, _, scopes, _), ink), faces) in parts.iter().zip(inks).zip(added) {
if ink.opacity <= 0.0 {
if !ink.casts() {
continue;
}
// A stroke whose own solid is past the limits is left out; past the shadow's limit for
@@ -1552,7 +1552,7 @@ fn cast_built<'a>(id: &str, p: &Value, shapes: &'a [Profile], built: Vec<Option<
}
for ((s, item), kept) in items.into_iter().zip(built) {
let ink = ink(item, s.opacity);
if ink.opacity <= 0.0 {
if !ink.casts() {
continue;
}
let faces = match kept {
@@ -1570,11 +1570,11 @@ fn cast_built<'a>(id: &str, p: &Value, shapes: &'a [Profile], built: Vec<Option<
}
let (parts, bounds) = solid_parts(shapes, b);
let inks: Vec<shadow::Ink> = parts.iter().map(|(item, member, ..)| ink(item, *member)).collect();
if parts.len() != built.len() || (id == INFLATE && inks.iter().zip(&built).any(|(ink, kept)| ink.opacity > 0.0 && kept.is_none())) {
if parts.len() != built.len() || (id == INFLATE && inks.iter().zip(&built).any(|(ink, kept)| ink.casts() && kept.is_none())) {
return cast_shadow(id, p, shapes);
}
for (((item, _, area, rule, scopes, _), ink), kept) in parts.iter().zip(inks).zip(built) {
if ink.opacity <= 0.0 {
if !ink.casts() {
continue;
}
let faces = match kept {
+13
View File
@@ -50,6 +50,19 @@ pub(crate) struct Ink {
pub(crate) blend: BlendMode,
}
impl Ink {
/// Whether art in this ink casts part of a shadow ([`casts`]).
pub(crate) fn casts(self) -> bool {
casts(self.opacity)
}
}
/// Whether art at `opacity` casts part of a shadow: its opacity is a finite number above zero.
/// Art at zero, negative, NaN or infinite opacity casts nothing.
pub(crate) fn casts(opacity: f32) -> bool {
opacity.is_finite() && opacity > 0.0
}
/// The shadow of the faces in `caster` as a path of object `id`, cast by art in `ink`: filled
/// black at [`SHADOW_OPACITY`] times its opacity, in its blending mode, with the nonzero rule;
/// `None` when it casts nothing.
+60
View File
@@ -312,3 +312,63 @@ fn the_shadow_cast_from_the_solids_drawn_is_the_shadow_of_solids_built_for_it()
}
}
}
/// The opacity of each part of the shadow of `n` (its 3D effect's shadow on) and the shadow's art,
/// as [`cast_shadow`] casts it from solids built for the shadow alone and as [`cast_built`] casts
/// it from the faces the solids drawn kept.
fn cast_parts(n: &Node) -> [(Vec<f32>, String); 2] {
let (_, fx) = solid(&n.appearance.effects).unwrap();
let shapes = if is_container(n) {
members(n, "").unwrap()
} else {
let (path, rule) = profile(n).unwrap();
vec![Profile { path, rule, items: solid_paint_sources(n).1, opacity: 1.0, scopes: vec![] }]
};
let p = crate::merged_params(&fx.id, &fx.params);
let (_, built) = surfaces_for(None, n, fx, &shapes, true).unwrap();
[cast_shadow(&fx.id, &p, &shapes), cast_built(&fx.id, &p, &shapes, built)].map(|c| {
let (caster, settings, cast) = c.unwrap().unwrap();
let inks = cast.iter().map(|(_, ink, _)| ink.opacity).collect();
(inks, format!("{:?}", shadow::scoped_art(n.id, &caster, settings, cast, has_masks(&shapes))))
})
}
/// A fill, a stroke or a member whose opacity is NaN or infinite casts no part of the shadow, as one
/// at 0 % does, whether the shadow is cast from solids built for it or from the solids drawn; the
/// art beside it still casts its part.
#[test]
fn art_whose_opacity_is_not_a_finite_number_casts_no_shadow() {
// The art with opacity `opacity` in one place: a square's stroke, the fill of a group's second
// member, and a group's second member.
let objects = |opacity: f32| {
let mut fill = square_node(2, 200.0);
for item in &mut fill.appearance.items {
if let AppearanceItem::Fill(f) = item {
f.opacity = opacity;
}
}
let mut member = square_node(2, 200.0);
member.opacity = opacity;
[
stroked_square(1, 0.0, opacity),
Node::group(NodeId(9), vec![Arc::new(square_node(1, 0.0)), Arc::new(fill)]),
Node::group(NodeId(9), vec![Arc::new(square_node(1, 0.0)), Arc::new(member)]),
]
};
for id in [EXTRUDE, INFLATE, ROTATE] {
for bad in [f32::NAN, f32::INFINITY] {
for (i, (mut n, mut clear)) in objects(bad).into_iter().zip(objects(0.0)).enumerate() {
n.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true})).unwrap());
clear.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true})).unwrap());
let expected = cast_parts(&clear);
for (k, (inks, shadow)) in cast_parts(&n).into_iter().enumerate() {
assert_eq!(inks, vec![1.0], "{id} {bad} object {i} cast {k}: only the opaque art casts");
assert_eq!(shadow, expected[k].1, "{id} {bad} object {i} cast {k}");
}
let mut opacities = vec![];
art(&n, id).unwrap().walk(&mut |c| opacities.extend(shadow_opacity(c)));
assert_eq!(opacities, vec![0.5], "{id} {bad} object {i}");
}
}
}
}
+6
View File
@@ -54,6 +54,7 @@ pub mod ppi;
pub mod progress;
mod psdlayers;
pub mod psdread;
mod psdslices;
mod pxrread;
mod save;
mod screens;
@@ -93,6 +94,9 @@ pub(crate) use native::preview_png;
pub use native::with_compression_pref;
pub(crate) use pdfimport::opened_page_document;
pub use pdfimport::{LoadOptions, page_document};
pub(crate) use psdlayers::import_active as psd_layers;
pub use psdlayers::{PsdInfo, info as psd_info};
pub(crate) use psdslices::over as psd_slices;
pub(crate) use save::job_for;
pub(crate) use save::save as save_document;
pub use save::{
@@ -240,6 +244,8 @@ mod tests_psd;
mod tests_psdlayers;
#[cfg(test)]
mod tests_psdread;
#[cfg(test)]
mod tests_psdslices;
#[cfg(test)]
mod tests_heifread;
File diff suppressed because one or more lines are too long
+17 -8
View File
@@ -528,17 +528,26 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result<Loaded>
}
// A PSD or PSB file's layers become layers (`layers`, default on); without layers, or with
// `layers: false`, its merged image opens. Layers that can't be read leave the merged image.
"psd" | "psb" if opts.layers => {
let cms = vectorcraft_color::cms::active();
match super::psdlayers::import(bytes, opts.hidden_layers, MAX_RASTER_ALLOC, |c| cms.cmyk_to_srgb(c, false)) {
Ok(Some((doc, warnings))) => (doc, warnings, false),
Ok(None) => (raster_doc(&title, bytes)?, vec![], false),
Err(e) => (raster_doc(&title, bytes)?, vec![format!("the layers can't be read ({e}): the file opened as its merged image")], false),
}
}
"psd" | "psb" if opts.layers => match super::psdlayers::import_active(bytes, opts.hidden_layers) {
Ok(Some((doc, warnings))) => (doc, warnings, false),
Ok(None) => (raster_doc(&title, bytes)?, vec![], false),
Err(e) => (raster_doc(&title, bytes)?, vec![format!("the layers can't be read ({e}): the file opened as its merged image")], false),
},
_ if format.raster => (raster_doc(&title, bytes)?, vec![], false),
_ => return Err(err(format!("{} files can't be opened yet", format.label))),
};
// A PSD or PSB file's slices become user slices over its canvas (`importSlices`, default on),
// whether its layers or its merged image came in.
if matches!(format.id, "psd" | "psb")
&& opts.import_slices
&& let Some(canvas) = doc.artboards.first().map(|a| a.rect)
{
let (slices, notes) = super::psd_slices(bytes, canvas);
for (rect, options) in slices {
crate::cmd::slices::add_slice(&mut doc, rect, options);
}
warnings.extend(notes);
}
// A PDF, `.ai` or `.ait` read from its pages or its editing copy, not restored from the document
// it carries, opens with the File Info it gives (a PostScript `.ai` gives none).
if matches!(format.id, "pdf" | "ai" | "ait")
+9 -1
View File
@@ -36,6 +36,8 @@ pub struct LoadOptions {
pub layers: bool,
/// A PSD or PSB file's hidden layers come in, hidden (`hiddenLayers`; else they are left out).
pub hidden_layers: bool,
/// A PSD or PSB file's slices become user slices (`importSlices`; else they are left out).
pub import_slices: bool,
/// How a DXF drawing comes in (the `dxf` param, see [`super::dxfimport`]).
pub dxf: vectorcraft_cad::ImportOptions,
/// An Illustrator EPS or `.ai` that carries the editing copy of its art opens from it (its
@@ -67,6 +69,7 @@ impl Default for LoadOptions {
text_as: TextAs::default(),
layers: true,
hidden_layers: false,
import_slices: true,
dxf: Default::default(),
editing_data: true,
trust_editing_data: false,
@@ -81,7 +84,7 @@ impl LoadOptions {
/// From command params: `pages` (`"2-3, 5"`, a page number or `"all"`), `page` (one page, when
/// `pages` isn't given), `cropTo` (or `crop`), `password`, `colorMode` (`rgb` | `cmyk`) with `grays`,
/// `textAs` (`text` | `outlines`), `layers` (true | false), `hiddenLayers` (true | false),
/// `editingData` (true | false | `always`),
/// `importSlices` (true | false), `editingData` (true | false | `always`),
/// `legacyNameEncoding` (one of [`vectorcraft_eps::NameEncoding::LABELS`]), `linkPages` (true |
/// false) and `dxf` (the DXF import options).
pub fn from_params(cmd: &str, p: &Value) -> Result<Self> {
@@ -111,6 +114,10 @@ impl LoadOptions {
None => false,
Some(v) => v.as_bool().ok_or_else(|| bad(cmd, "hiddenLayers must be true or false"))?,
};
let import_slices = match p.get("importSlices").filter(|v| !v.is_null()) {
None => true,
Some(v) => v.as_bool().ok_or_else(|| bad(cmd, "importSlices must be true or false"))?,
};
let (editing_data, trust_editing_data) = match p.get("editingData").filter(|v| !v.is_null()) {
None => (true, false),
Some(Value::String(s)) if s.eq_ignore_ascii_case("always") => (true, true),
@@ -137,6 +144,7 @@ impl LoadOptions {
text_as,
layers,
hidden_layers,
import_slices,
dxf,
editing_data,
trust_editing_data,
+64
View File
@@ -43,6 +43,7 @@ use std::cell::Cell;
use std::sync::Arc;
use image::RgbaImage;
use serde_json::{Value, json};
use vectorcraft_color::BlendMode;
use vectorcraft_color::blend::{blend_rgb, composite};
use vectorcraft_color::cms::{Lab, lab::lab_to_srgb};
@@ -51,6 +52,7 @@ use vectorcraft_geom::Affine;
use super::load::{RasterImage, as_png};
use super::psdread::{Header, Reader, byte, header, layer_channel, layer_info, long_key, row_bytes, sample, to_rgb};
use crate::cmd::Session;
use crate::cmd::place::text::mac_roman;
/// Most layer groups inside one another.
@@ -1527,3 +1529,65 @@ pub(super) fn import(
doc.limit_depth_noting(&mut warnings);
Ok(Some((doc, warnings)))
}
/// [`import`] within the memory allowed for one image, CMYK converted with the active color
/// settings: what `document.open` and `file.place` read a PSD or PSB file's layers with.
pub(crate) fn import_active(bytes: &[u8], hidden: bool) -> Result<Option<(Document, Vec<String>)>, String> {
let cms = vectorcraft_color::cms::active();
import(bytes, hidden, super::MAX_RASTER_ALLOC, |c| cms.cmyk_to_srgb(c, false))
}
/// What a PSD or PSB file holds (`document.psdInfo`, the PSD Import Options dialog).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PsdInfo {
/// The large document format.
pub psb: bool,
/// The canvas, in pixels.
pub width: u32,
pub height: u32,
/// The layers, group markers left out.
pub layers: usize,
/// The layers among them that are hidden.
pub hidden: usize,
/// The layer groups.
pub groups: usize,
/// The slices that come in with `importSlices` (those generated automatically, and those
/// outside the canvas, left out).
pub slices: usize,
}
/// What PSD or PSB file `bytes` holds, read from its header, its slices and its layer records
/// without decoding any pixels. A file without layer records, or whose layer records can't be read, has no layers: it
/// opens and places as its merged image.
pub fn info(bytes: &[u8]) -> Result<PsdInfo, String> {
let mut r = Reader::new(bytes);
let h = header(&mut r)?;
let records = layer_info(h.layers, h.psb).filter(|info| info.len() > 2).and_then(|info| records(info, h.psb).ok()).unwrap_or_default();
let layers = records.iter().filter(|r| r.divider == 0);
Ok(PsdInfo {
psb: h.psb,
width: h.width,
height: h.height,
layers: layers.clone().count(),
hidden: layers.filter(|r| r.hidden).count(),
groups: records.iter().filter(|r| matches!(r.divider, 1 | 2)).count(),
slices: super::psdslices::count(bytes),
})
}
const INFO: &str = "document.psdInfo";
/// `document.psdInfo`.
pub(super) fn psd_info(_: &mut Session, p: &Value) -> crate::cmd::Result<Value> {
let bytes = super::source(p, INFO)?.bytes;
let i = info(&bytes).map_err(super::load::err)?;
Ok(json!({
"format": if i.psb { "psb" } else { "psd" },
"width": i.width,
"height": i.height,
"layers": i.layers,
"hiddenLayers": i.hidden,
"groups": i.groups,
"slices": i.slices,
}))
}
+2 -2
View File
@@ -105,7 +105,7 @@ pub(super) struct Header<'a> {
/// Colour mode data: an indexed image's palette (256 reds, then greens, then blues).
palette: &'a [u8],
/// The image resources.
resources: &'a [u8],
pub(super) resources: &'a [u8],
/// The layer and mask information.
pub(super) layers: &'a [u8],
}
@@ -172,7 +172,7 @@ pub fn resolution(bytes: &[u8]) -> Option<(f64, f64)> {
/// The image resource blocks of `resources`, in file order: each one's id, name (the bytes of its
/// Pascal string) and data. Stops at the first block that is cut short. With `signed`, only the
/// blocks whose signature is `8BIM` are given.
fn resources(resources: &[u8], signed: bool) -> impl Iterator<Item = (u16, &[u8], &[u8])> {
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() {
+408
View File
@@ -0,0 +1,408 @@
//! The slices a Photoshop document (PSD or PSB) stores, for `document.open` and `file.place`
//! with `importSlices`: image resource 1050, read from the "Slices resource format" of Adobe's
//! public Photoshop File Formats Specification
//! (<https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/>). Version 6 stores the slices
//! as records; versions 7 and 8 store them in a descriptor. The descriptor's keys, and the meaning
//! of the origin, type and background values, are read as the MIT-licensed ag-psd reads them
//! (<https://github.com/Agamnentzar/ag-psd>, `src/imageResources.ts` and `src/descriptor.ts`),
//! which agrees with psd.rb (<https://github.com/layervault/psd.rb>,
//! `lib/psd/resources/slices.rb`) on the keys both read.
//!
//! A slice the file marks as generated automatically is left out: the document lays out its own
//! auto slices around the others. A slice that follows a layer comes in as a user slice over the
//! rectangle the file stores for it. Each slice keeps its name, its type (Image or No Image), its
//! link, target, message, alternative text, cell text and background color; text alignment isn't
//! read. The file is untrusted: every read is checked, and the slice count, the strings and the
//! descriptor's nesting and item count are capped.
use vectorcraft_doc::{SliceKind, SliceOptions};
use vectorcraft_geom::Rect;
use super::psdread::{Reader, TRUNCATED, header, resources};
/// The image resource that holds the slices.
const SLICES: u16 = 1050;
/// The most slices one file brings in.
const MAX_SLICES: usize = 10_000;
/// The deepest descriptor objects and lists nest.
const MAX_DEPTH: usize = 16;
/// The most values the descriptors of one slices resource hold together, nested ones included.
const MAX_VALUES: usize = 200_000;
/// The error of descriptors that hold more than [`MAX_VALUES`].
const TOO_MANY_VALUES: &str = "the slices' descriptor holds too many values";
/// One slice as the file stores it.
#[derive(Clone, Debug, PartialEq)]
struct PsdSlice {
/// Left, top, right and bottom, in the canvas's pixels.
rect: [i64; 4],
options: SliceOptions,
}
/// The slices a file stores, those generated automatically left out, and its canvas.
struct Stored {
slices: Vec<PsdSlice>,
/// The canvas's width and height, in pixels.
size: (u32, u32),
}
/// 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.
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) };
Ok(Some(Stored { slices: decode(data)?, size: (h.width, h.height) }))
}
/// The slices of resource 1050's `data`.
fn decode(data: &[u8]) -> Result<Vec<PsdSlice>, String> {
let mut r = Reader::new(data);
// The values every descriptor of the resource may hold together.
let mut budget = MAX_VALUES;
match r.u32()? {
6 => version_6(&mut r, &mut budget),
7 | 8 => {
if r.u32()? != 16 {
return Err("the slices' descriptor has a version other than 16".into());
}
let d = descriptor(&mut r, 0, &mut budget)?;
from_descriptor(&d)
}
v => Err(format!("the slices are stored in version {v}, which isn't read")),
}
}
/// Version 6: the bounds of all the slices, the group's name, the count, then each slice's record.
/// The descriptors that follow the records spend one `budget` of values between them.
fn version_6(r: &mut Reader<'_>, budget: &mut usize) -> Result<Vec<PsdSlice>, String> {
r.take(16)?;
unicode(r)?;
let count = r.u32()? as usize;
if count > MAX_SLICES {
return Err(format!("the file has {count} slices, more than the {MAX_SLICES} read"));
}
let mut out = vec![];
for _ in 0..count {
// The ID and group ID.
r.take(8)?;
let origin = r.u32()?;
// A slice that follows a layer gives the layer's ID.
if origin == 1 {
r.take(4)?;
}
let name = unicode(r)?;
let kind = if r.u32()? == 0 { SliceKind::NoImage } else { SliceKind::Image };
let mut rect = [0i64; 4];
for v in &mut rect {
*v = i64::from(r.u32()? as i32);
}
let (url, target, message, alt) = (unicode(r)?, unicode(r)?, unicode(r)?, unicode(r)?);
let html = r.u8()? != 0;
let cell = unicode(r)?;
// The horizontal and vertical alignment.
r.take(8)?;
let [a, red, green, blue] = r.array::<4>()?;
let background = if a == 0 && red == 0 && green == 0 && blue == 0 {
String::new()
} else if a == 0 {
"matte".into()
} else {
format!("#{red:02x}{green:02x}{blue:02x}")
};
// Photoshop 7 and later may follow a record with a descriptor (version 16); a record that
// doesn't start one is the next slice. A descriptor read that uses up the budget is an
// error.
if r.rest().starts_with(&16u32.to_be_bytes()) {
let mut ahead = Reader::new(r.rest());
ahead.u32()?;
match descriptor(&mut ahead, 0, budget) {
Ok(_) => {
let used = r.rest().len() - ahead.rest().len();
r.take(used)?;
}
Err(e) if e == TOO_MANY_VALUES => return Err(e),
Err(_) => {}
}
}
// Origin 0 is a slice generated automatically.
if origin != 0 {
let options = SliceOptions { kind, name, url, target, message, alt, text: cell_text(cell, html), background, ..Default::default() };
out.push(PsdSlice { rect, options: for_kind(options) });
}
}
Ok(out)
}
/// Versions 7 and 8: the descriptor's `slices` list, each slice an object.
fn from_descriptor(d: &[(String, Value)]) -> Result<Vec<PsdSlice>, String> {
let Some(Value::List(list)) = field(d, "slices") else { return Err("the slices' descriptor has no list of slices".into()) };
if list.len() > MAX_SLICES {
return Err(format!("the file has {} slices, more than the {MAX_SLICES} read", list.len()));
}
let mut out = vec![];
for s in list {
let Value::Object(s) = s else { return Err("the slices' descriptor lists something other than a slice".into()) };
if matches!(field(s, "origin"), Some(Value::Enum(_, v)) if v == "autoGenerated") {
continue;
}
let Some(Value::Object(b)) = field(s, "bounds") else { return Err("a slice in the slices' descriptor has no bounds".into()) };
let edge = |k: &str| number(field(b, k)).ok_or_else(|| "a slice's bounds in the slices' descriptor aren't numbers".to_string());
let rect = [edge("Left")?, edge("Top ")?, edge("Rght")?, edge("Btom")?];
let text = |k: &str| match field(s, k) {
Some(Value::Text(t)) => t.clone(),
_ => String::new(),
};
let kind = if matches!(field(s, "Type"), Some(Value::Enum(_, v)) if v == "noImage") { SliceKind::NoImage } else { SliceKind::Image };
let html = matches!(field(s, "cellTextIsHTML"), Some(Value::Bool(true)));
let background = match field(s, "bgColorType") {
Some(Value::Enum(_, v)) if v == "matte" => "matte".into(),
Some(Value::Enum(_, v)) if v == "Clr " => match field(s, "bgColor") {
Some(Value::Object(c)) => {
let channel = |k: &str| number(field(c, k)).map(|v| v.clamp(0, 255));
match (channel("Rd "), channel("Grn "), channel("Bl ")) {
(Some(r), Some(g), Some(b)) => format!("#{r:02x}{g:02x}{b:02x}"),
_ => String::new(),
}
}
_ => String::new(),
},
_ => String::new(),
};
let options = SliceOptions {
kind,
name: text("Nm "),
url: text("url"),
target: text("null"),
message: text("Msge"),
alt: text("altTag"),
text: cell_text(text("cellText"), html),
background,
..Default::default()
};
out.push(PsdSlice { rect, options: for_kind(options) });
}
Ok(out)
}
/// `o` with only the options of its slice type: an Image slice's cell text isn't shown, and a No
/// Image slice has no link, target, message or alternative text.
fn for_kind(mut o: SliceOptions) -> SliceOptions {
if o.kind == SliceKind::Image {
o.text.clear();
} else {
for s in [&mut o.url, &mut o.target, &mut o.message, &mut o.alt] {
s.clear();
}
}
o
}
/// A cell's text as the HTML a No Image slice shows: plain text has `&`, `<` and `>` escaped.
fn cell_text(text: String, html: bool) -> String {
if html { text } else { text.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;") }
}
/// The longest text one string, key or class ID holds (UTF-16 units or bytes).
const MAX_TEXT: usize = 65_536;
/// An error unless `n`, the length a string or ID declares, is at most [`MAX_TEXT`].
fn text_len(n: usize) -> Result<usize, String> {
if n > MAX_TEXT {
return Err(format!("a text in the slices has more than the {MAX_TEXT} characters read"));
}
Ok(n)
}
/// A Unicode string: a count of UTF-16 units, then the units; trailing NULs dropped.
fn unicode(r: &mut Reader<'_>) -> Result<String, String> {
let n = text_len(r.u32()? as usize)?;
let bytes = r.take(n.checked_mul(2).ok_or(TRUNCATED)?)?;
let units: Vec<u16> = bytes.as_chunks::<2>().0.iter().map(|u| u16::from_be_bytes(*u)).collect();
Ok(String::from_utf16_lossy(&units).trim_end_matches('\0').to_string())
}
/// A descriptor's value, as far as the slices need it.
#[derive(Clone, Debug, PartialEq)]
enum Value {
Long(i32),
Double(f64),
Bool(bool),
Text(String),
/// An enumeration's type and value.
Enum(String, String),
Object(Vec<(String, Value)>),
List(Vec<Value>),
/// A value of another type, read past.
Other,
}
/// The value with key `key`.
fn field<'a>(d: &'a [(String, Value)], key: &str) -> Option<&'a Value> {
d.iter().find(|(k, _)| k == key).map(|(_, v)| v)
}
/// A whole number: a long, or a finite double rounded.
fn number(v: Option<&Value>) -> Option<i64> {
match v? {
Value::Long(n) => Some(i64::from(*n)),
Value::Double(d) if d.is_finite() && d.abs() < 1e12 => Some(d.round() as i64),
_ => None,
}
}
/// A key or class ID: a length, then that many characters, or four when the length is 0.
fn id(r: &mut Reader<'_>) -> Result<String, String> {
let n = text_len(r.u32()? as usize)?;
let b = r.take(if n == 0 { 4 } else { n })?;
Ok(String::from_utf8_lossy(b).into_owned())
}
/// A class: its Unicode name, then its ID.
fn class(r: &mut Reader<'_>) -> Result<(), String> {
unicode(r)?;
id(r)?;
Ok(())
}
/// A descriptor: its class, the count of its items, then each item's key, type and value.
fn descriptor(r: &mut Reader<'_>, depth: usize, budget: &mut usize) -> Result<Vec<(String, Value)>, String> {
if depth > MAX_DEPTH {
return Err("the slices' descriptor nests too deep".into());
}
class(r)?;
let count = r.u32()? as usize;
let mut out = vec![];
for _ in 0..count {
let key = id(r)?;
let kind = r.array::<4>()?;
out.push((key, value(r, &kind, depth, budget)?));
}
Ok(out)
}
/// A value of type `kind`.
fn value(r: &mut Reader<'_>, kind: &[u8; 4], depth: usize, budget: &mut usize) -> Result<Value, String> {
*budget = budget.checked_sub(1).ok_or(TOO_MANY_VALUES)?;
Ok(match kind {
b"long" => Value::Long(r.u32()? as i32),
b"doub" => Value::Double(f64::from_be_bytes(r.array()?)),
b"UntF" => {
r.take(4)?;
Value::Double(f64::from_be_bytes(r.array()?))
}
b"UnFl" => {
r.take(4)?;
Value::Double(f64::from(f32::from_be_bytes(r.array()?)))
}
b"bool" => Value::Bool(r.u8()? != 0),
b"TEXT" => Value::Text(unicode(r)?),
b"enum" => Value::Enum(id(r)?, id(r)?),
b"Objc" | b"GlbO" => Value::Object(descriptor(r, depth + 1, budget)?),
b"VlLs" => {
if depth >= MAX_DEPTH {
return Err("the slices' descriptor nests too deep".into());
}
let count = r.u32()? as usize;
let mut items = vec![];
for _ in 0..count {
let kind = r.array::<4>()?;
items.push(value(r, &kind, depth + 1, budget)?);
}
Value::List(items)
}
b"comp" => {
r.take(8)?;
Value::Other
}
b"type" | b"GlbC" => {
class(r)?;
Value::Other
}
b"tdta" | b"alis" => {
let n = r.u32()? as usize;
r.take(n)?;
Value::Other
}
b"obj " => {
let count = r.u32()? as usize;
for _ in 0..count {
*budget = budget.checked_sub(1).ok_or(TOO_MANY_VALUES)?;
match &r.array::<4>()? {
b"prop" => {
class(r)?;
id(r)?;
}
b"Clss" => class(r)?,
b"Enmr" => {
class(r)?;
id(r)?;
id(r)?;
}
b"rele" => {
class(r)?;
r.take(4)?;
}
b"Idnt" | b"indx" => {
r.take(4)?;
}
b"name" => {
class(r)?;
unicode(r)?;
}
k => return Err(format!("the slices' descriptor has a reference of an unknown kind ({})", String::from_utf8_lossy(k))),
}
}
Value::Other
}
k => return Err(format!("the slices' descriptor has a value of an unknown type ({})", String::from_utf8_lossy(k))),
})
}
/// The slices of PSD or PSB file `bytes` laid over `canvas`, the box its canvas takes (points),
/// each clipped to the canvas, with warnings: for slices that lie wholly outside it or have no
/// size, and for slices that can't be read (the file comes in without them). Empty, without a
/// warning, when the file stores no slices.
pub(crate) fn over(bytes: &[u8], canvas: Rect) -> (Vec<(Rect, SliceOptions)>, Vec<String>) {
match read(bytes) {
Ok(None) => (vec![], vec![]),
Ok(Some(s)) => laid_over(&s.slices, s.size, canvas),
Err(e) => (vec![], vec![format!("the slices can't be read ({e}) and were left out")]),
}
}
/// `slices` of a canvas of `size` pixels laid over `canvas` (points).
fn laid_over(slices: &[PsdSlice], (w, h): (u32, u32), canvas: Rect) -> (Vec<(Rect, SliceOptions)>, Vec<String>) {
let (sx, sy) = (canvas.width() / f64::from(w.max(1)), canvas.height() / f64::from(h.max(1)));
let mut out = vec![];
for s in slices {
let [l, t, r, b] = s.rect;
let (l, r) = (l.clamp(0, i64::from(w)), r.clamp(0, i64::from(w)));
let (t, b) = (t.clamp(0, i64::from(h)), b.clamp(0, i64::from(h)));
if l < r && t < b {
let x = |v: i64| canvas.x0 + v as f64 * sx;
let y = |v: i64| canvas.y0 + v as f64 * sy;
out.push((Rect::new(x(l), y(t), x(r), y(b)), s.options.clone()));
}
}
let warnings = match slices.len() - out.len() {
0 => vec![],
1 => vec!["1 slice lies outside the canvas or has no size and was left out".to_string()],
n => vec![format!("{n} slices lie outside the canvas or have no size and were left out")],
};
(out, warnings)
}
/// How many slices of PSD or PSB file `bytes` come in (`document.psdInfo`): 0 when it stores none
/// or they can't be read.
pub(crate) fn count(bytes: &[u8]) -> usize {
match read(bytes) {
Ok(Some(Stored { slices, size: (w, h) })) => laid_over(&slices, (w, h), Rect::new(0.0, 0.0, f64::from(w), f64::from(h))).0.len(),
_ => 0,
}
}
+187 -1
View File
@@ -1,7 +1,8 @@
//! Opening PSD and PSB files with their layers as layers (`document.open`'s `layers` and
//! `hiddenLayers`): names, visibility, opacity, blend modes, groups, layer masks, clipped layers
//! and blend modes VectorCraft lacks merged, 16-bit and PSB files, VectorCraft's own PSD export
//! read back, and damaged files read without a panic.
//! read back, and damaged files read without a panic. Placing them with their layers as objects
//! (`file.place`'s `layers` and `hiddenLayers`), and `document.psdInfo`.
use serde_json::{Value, json};
use vectorcraft_color::BlendMode;
@@ -967,10 +968,12 @@ fn damaged_layers_never_panic() {
let mut f = good.clone();
f[i] = v;
let _ = psdlayers::import(&f, true, 1 << 30, cms);
let _ = psdlayers::info(&f);
}
}
for n in 0..good.len() {
let _ = psdlayers::import(&good[..n], true, 1 << 30, cms);
let _ = psdlayers::info(&good[..n]);
}
// A layer past the memory allowed is refused, not read.
assert!(psdlayers::import(&good, true, 64, cms).unwrap_err().contains("too large"));
@@ -1015,3 +1018,186 @@ fn merges_keep_pass_through_groups_blending_with_what_is_below() {
assert!(px.iter().zip([75, 150, 38, 255]).all(|(&a, b)| a.abs_diff(b) <= 1), "{px:?}");
}
}
/// `file.place` of `f` with `p` into a new 100 × 100 pt document, centred on (50, 50).
fn place(f: &[u8], p: Value) -> (Session, crate::cmd::Result<Value>) {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
let r = s.execute("file.place", &merge(json!({"name": "layers.psd", "dataBase64": vectorcraft_format::base64_encode(f), "at": [50, 50]}), p));
(s, r)
}
/// The one object `file.place` placed.
fn placed(s: &Session, r: &Value) -> Node {
let id = vectorcraft_doc::NodeId(r["ids"][0].as_u64().unwrap());
s.doc().unwrap().doc.node(id).unwrap().clone()
}
#[test]
fn placing_with_layers_embeds_the_layers_as_one_group() {
let f = file(8, 8, &stack(), 8, false, false);
let (mut s, r) = place(&f, json!({"layers": true}));
let r = r.unwrap();
assert_eq!((&r["format"], &r["linked"], &r["warnings"]), (&json!("psd"), &json!(false), &json!([HIDDEN_1])), "{r}");
let g = placed(&s, &r);
assert!(matches!(g.kind, NodeKind::Group { clip: false, .. }), "one group, unclipped: its layers lie on the canvas");
assert_eq!(name(&g), "layers.psd");
let kids = g.children().unwrap();
assert_eq!(kids.iter().map(|c| name(c)).collect::<Vec<_>>(), ["Bottom", "Folder", "Screens", "Faded"], "bottom first");
// A layer is its image, where the merged image would put it: the 8 pt canvas centred on (50, 50).
let ((x, y), px) = pixels_of(&s, &kids[0]);
assert_eq!(((x, y), px.dimensions(), px.get_pixel(3, 3).0), ((46.0, 46.0), (8, 8), [255, 0, 0, 255]));
// A group is a group of its layers; a pass-through group isn't isolated, another mode's is.
let folder = &kids[1];
assert!(matches!(folder.kind, NodeKind::Group { .. }) && !folder.isolate && folder.blend == BlendMode::Normal);
let inner = folder.children().unwrap();
assert_eq!(inner.iter().map(|c| name(c)).collect::<Vec<_>>(), ["Inner A"], "the hidden layer is left out");
assert!(matches!(inner[0].kind, NodeKind::Image(_)) && inner[0].blend == BlendMode::Multiply && (inner[0].opacity - 128.0 / 255.0).abs() < 1e-6);
let screens = &kids[2];
assert!(screens.isolate && screens.blend == BlendMode::Screen);
let ((x, y), px) = pixels_of(&s, &screens.children().unwrap()[0]);
assert_eq!(((x, y), px.get_pixel(0, 0).0), ((48.0, 48.0), [10, 20, 30, 128]));
assert!((kids[3].opacity - 102.0 / 255.0).abs() < 1e-6, "fill opacity: {}", kids[3].opacity);
// One undo step.
s.execute("edit.undo", &json!({})).unwrap();
assert!(s.doc().unwrap().doc.layers.iter().all(|l| l.children().is_none_or(Vec::is_empty)));
// Hidden layers come in hidden when asked for.
let (s, r) = place(&f, json!({"layers": true, "hiddenLayers": true}));
let r = r.unwrap();
assert_eq!(r["warnings"], json!([]), "{r}");
let g = placed(&s, &r);
let inner: Vec<(&str, bool)> = g.children().unwrap()[1].children().unwrap().iter().map(|c| (name(c), c.visible)).collect();
assert_eq!(inner, [("Inner A", true), ("Inner B", false)]);
// Without `layers`, the merged image, in the same box.
let (s, r) = place(&f, json!({}));
let r = r.unwrap();
let flat = placed(&s, &r);
let ((x, y), px) = pixels_of(&s, &flat);
assert_eq!(((x, y), px.dimensions(), px.get_pixel(0, 0).0), ((46.0, 46.0), (8, 8), [128, 128, 128, 255]), "{r}");
}
#[test]
fn placed_layers_keep_their_masks_and_are_clipped_to_the_canvas() {
let mut masked = layer("Masked", [0, 0, 8, 8], [255, 255, 255, 255]);
masked.mask = Some(([2, 2, 4, 4], 0, 0, vec![255, 128, 0, 255]));
let (s, r) = place(&file(8, 8, &[masked], 8, false, false), json!({"layers": true}));
let g = placed(&s, &r.unwrap());
let kids = g.children().unwrap();
assert!(matches!(kids[0].kind, NodeKind::Image(_)), "the layer is its image");
let m = kids[0].extras().mask.as_deref().expect("the layer mask as the image's opacity mask");
let ((x, y), px) = pixels_of(&s, &m.art);
assert_eq!(((x, y), px.dimensions(), m.clip), ((48.0, 48.0), (2, 2), true), "the mask moves with its layer");
// A layer that reaches past the canvas: the group is clipped to the canvas, as the merged
// image shows only the canvas.
let over = layer("Over", [-2, -2, 6, 6], [0, 255, 0, 255]);
let (s, r) = place(&file(8, 8, &[layer("Bottom", [0, 0, 8, 8], [255, 0, 0, 255]), over], 8, false, false), json!({"layers": true}));
let r = r.unwrap();
let g = placed(&s, &r);
assert!(matches!(g.kind, NodeKind::Group { clip: true, .. }), "{r}");
let kids = g.children().unwrap();
let b = kids[0].geometric_bounds_with(&s.doc().unwrap().doc.symbol_boxes()).unwrap();
assert!(matches!(kids[0].kind, NodeKind::Path { clipping: true, .. }));
assert_eq!((b.x0, b.y0, b.x1, b.y1), (46.0, 46.0, 54.0, 54.0), "the clipping path is the canvas");
assert_eq!(kids[1..].iter().map(|c| name(c)).collect::<Vec<_>>(), ["Bottom", "Over"]);
assert_eq!(pixels_of(&s, &kids[2]).0, (44.0, 44.0));
// A hidden layer that reaches past the canvas clips the group too, so showing it later draws
// only the canvas. Left out, it doesn't.
let mut hidden = layer("Hidden", [-2, -2, 6, 6], [0, 255, 0, 255]);
hidden.hidden = true;
let f = file(8, 8, &[layer("Bottom", [0, 0, 8, 8], [255, 0, 0, 255]), hidden], 8, false, false);
let (s, r) = place(&f, json!({"layers": true, "hiddenLayers": true}));
let r = r.unwrap();
let g = placed(&s, &r);
assert!(matches!(g.kind, NodeKind::Group { clip: true, .. }), "{r}");
assert_eq!(g.children().unwrap()[1..].iter().map(|c| (name(c), c.visible)).collect::<Vec<_>>(), [("Bottom", true), ("Hidden", false)]);
let (s, r) = place(&f, json!({"layers": true}));
assert!(matches!(placed(&s, &r.unwrap()).kind, NodeKind::Group { clip: false, .. }));
}
#[test]
fn placing_with_layers_never_links_and_refuses_values_it_cant_use() {
let f = file(8, 8, &stack(), 8, false, false);
let dir = std::env::temp_dir().join(format!("vc-psd-place-layers-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("layers.psd");
std::fs::write(&path, &f).unwrap();
let from_path = |p: Value| {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
let r = s.execute("file.place", &merge(json!({"path": path.to_str().unwrap()}), p));
(s, r)
};
// From a path, `layers` embeds: `link` is then false unless given, and `link: true` is refused.
let (s, r) = from_path(json!({"layers": true}));
let r = r.unwrap();
assert_eq!(r["linked"], json!(false), "{r}");
assert!(matches!(placed(&s, &r).kind, NodeKind::Group { .. }));
let (s, r) = from_path(json!({"layers": true, "link": true}));
assert!(r.unwrap_err().to_string().contains("a linked PSD file is placed as its flat image"));
assert!(s.doc().unwrap().doc.layers.iter().all(|l| l.children().is_none_or(Vec::is_empty)), "nothing is placed");
// Without `layers` the file is linked as before.
let (s, r) = from_path(json!({}));
let r = r.unwrap();
assert_eq!(r["linked"], json!(true), "{r}");
assert!(matches!(placed(&s, &r).kind, NodeKind::Image(_)));
// A file without layers is embedded as its merged image, without a warning.
let flat = {
let mut f = file(2, 2, &[layer("x", [0, 0, 2, 2], [9, 9, 9, 255])], 8, false, false);
let at = 26 + 8;
let len = u32::from_be_bytes(f[at..at + 4].try_into().unwrap()) as usize;
f.splice(at..at + 4 + len, 0u32.to_be_bytes());
f
};
std::fs::write(&path, &flat).unwrap();
let (s, r) = from_path(json!({"layers": true}));
let r = r.unwrap();
assert_eq!((&r["linked"], &r["warnings"]), (&json!(false), &json!([])), "{r}");
assert!(matches!(placed(&s, &r).kind, NodeKind::Image(_)));
// Layers that are all left out: the merged image, with the importer's warnings.
let mut gone = layer("Gone", [0, 0, 2, 2], [9, 9, 9, 255]);
gone.hidden = true;
let (s, r) = place(&file(2, 2, &[gone], 8, false, false), json!({"layers": true}));
let r = r.unwrap();
assert_eq!((&r["linked"], r["warnings"].as_array().map(Vec::len)), (&json!(false), Some(1)), "{r}");
assert!(matches!(placed(&s, &r).kind, NodeKind::Image(_)));
// Layers that can't be read: the merged image, with a warning.
let mut cut = file(4, 4, &[layer("x", [0, 0, 4, 4], [9, 9, 9, 255])], 8, false, false);
let at = cut.windows(4).position(|w| w == [0, 0, 0, 18]).unwrap();
cut[at..at + 4].copy_from_slice(&1000u32.to_be_bytes());
let (s, r) = place(&cut, json!({"layers": true}));
let r = r.unwrap();
assert!(r["warnings"][0].as_str().unwrap().starts_with("the layers can't be read"), "{r}");
assert!(matches!(placed(&s, &r).kind, NodeKind::Image(_)));
// Values the command can't use are errors, and nothing is placed.
for (p, why) in [
(json!({"hiddenLayers": true}), "hiddenLayers applies to a PSD file placed with layers: true"),
(json!({"layers": true, "link": true}), "a linked PSD file is placed as its flat image"),
(json!({"layers": "yes"}), "layers must be true or false"),
(json!({"layers": true, "hiddenLayers": 1}), "hiddenLayers must be true or false"),
] {
let (s, r) = place(&f, p.clone());
assert!(r.unwrap_err().to_string().contains(why), "{p}");
assert!(s.doc().unwrap().doc.layers.iter().all(|l| l.children().is_none_or(Vec::is_empty)), "{p}");
}
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
let q = s.execute("file.place.queue", &json!({"paths": [path.to_str().unwrap()], "layers": "yes"}));
assert!(q.unwrap_err().to_string().contains("`layers` must be true or false"));
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn psd_info_counts_the_layers_without_opening_the_file() {
let mut s = Session::new();
let info = |s: &mut Session, f: &[u8]| s.execute("document.psdInfo", &json!({"dataBase64": vectorcraft_format::base64_encode(f)}));
let r = info(&mut s, &file(8, 8, &stack(), 8, false, false)).unwrap();
assert_eq!(r, json!({"format": "psd", "width": 8, "height": 8, "layers": 5, "hiddenLayers": 1, "groups": 2, "slices": 0}));
let r = info(&mut s, &file(4, 2, &[layer("x", [0, 0, 2, 2], [9, 9, 9, 255])], 16, true, true)).unwrap();
assert_eq!((&r["format"], &r["width"], &r["height"], &r["layers"]), (&json!("psb"), &json!(4), &json!(2), &json!(1)), "{r}");
// Layer records that can't be read count as no layers: the file opens as its merged image.
let mut cut = file(4, 4, &[layer("x", [0, 0, 4, 4], [9, 9, 9, 255])], 8, false, false);
let at = cut.windows(4).position(|w| w == [0, 0, 0, 18]).unwrap();
cut[at..at + 4].copy_from_slice(&1000u32.to_be_bytes());
assert_eq!(info(&mut s, &cut).unwrap()["layers"], json!(0));
assert!(info(&mut s, b"not a psd").unwrap_err().to_string().contains("not a PSD file"));
}
@@ -0,0 +1,459 @@
//! A PSD or PSB file's slices (image resource 1050) opened and placed as user slices
//! (`document.open`'s and `file.place`'s `importSlices`): version 6 records and version 7 and 8
//! descriptors, built from the Photoshop File Formats Specification's "Slices resource format";
//! their options, slices outside the canvas, damaged or unknown slice data, placing scaled and
//! moved in one undo step, linked files, and `document.psdInfo`'s count.
use serde_json::{Value, json};
use vectorcraft_doc::{SliceKind, SliceOptions};
use vectorcraft_geom::Rect;
use crate::Session;
/// A Unicode string: a count of UTF-16 units, then the units.
fn ustr(s: &str) -> Vec<u8> {
let units: Vec<u16> = s.encode_utf16().collect();
let mut b = (units.len() as u32).to_be_bytes().to_vec();
b.extend(units.iter().flat_map(|u| u.to_be_bytes()));
b
}
/// One version 6 slice record.
#[derive(Clone)]
struct S {
/// 0: generated automatically, 1: follows a layer, 2: made by the user.
origin: u32,
name: &'static str,
/// 0: No Image, 1: Image.
kind: u32,
/// Left, top, right, bottom (px).
rect: [i32; 4],
url: &'static str,
target: &'static str,
message: &'static str,
alt: &'static str,
html: bool,
cell: &'static str,
/// Alpha, red, green, blue.
argb: [u8; 4],
}
fn user(name: &'static str, rect: [i32; 4]) -> S {
S { origin: 2, name, kind: 1, rect, url: "", target: "", message: "", alt: "", html: false, cell: "", argb: [0; 4] }
}
/// Resource 1050 in version 6, each record followed by `trailing` (a Photoshop 7 descriptor, or
/// nothing).
fn v6(slices: &[S], trailing: &[u8]) -> Vec<u8> {
let mut b = 6u32.to_be_bytes().to_vec();
b.extend([0u8; 16]);
b.extend(ustr("group"));
b.extend((slices.len() as u32).to_be_bytes());
for (i, s) in slices.iter().enumerate() {
b.extend((i as u32 + 1).to_be_bytes());
b.extend(0u32.to_be_bytes());
b.extend(s.origin.to_be_bytes());
if s.origin == 1 {
b.extend(7u32.to_be_bytes());
}
b.extend(ustr(s.name));
b.extend(s.kind.to_be_bytes());
for v in s.rect {
b.extend(v.to_be_bytes());
}
for t in [s.url, s.target, s.message, s.alt] {
b.extend(ustr(t));
}
b.push(u8::from(s.html));
b.extend(ustr(s.cell));
b.extend([0u8; 8]);
b.extend(s.argb);
b.extend(trailing);
}
b
}
/// A descriptor value.
enum D {
Long(i32),
Doub(f64),
Bool(bool),
Text(&'static str),
Enum(&'static str, &'static str),
Obj(Vec<(&'static str, D)>),
List(Vec<D>),
}
/// A key or class ID: a four-character one with length 0, else its length and characters.
fn key(k: &str) -> Vec<u8> {
let mut b = if k.len() == 4 { 0u32 } else { k.len() as u32 }.to_be_bytes().to_vec();
b.extend(k.as_bytes());
b
}
/// A descriptor: an empty class name, the class ID, the count, then each item.
fn descriptor(items: &[(&str, D)]) -> Vec<u8> {
let mut b = ustr("");
b.extend(key("null"));
b.extend((items.len() as u32).to_be_bytes());
for (k, v) in items {
b.extend(key(k));
b.extend(value(v));
}
b
}
/// A value's type, then the value.
fn value(v: &D) -> Vec<u8> {
let mut b = vec![];
match v {
D::Long(n) => {
b.extend(b"long");
b.extend(n.to_be_bytes());
}
D::Doub(d) => {
b.extend(b"doub");
b.extend(d.to_be_bytes());
}
D::Bool(on) => {
b.extend(b"bool");
b.push(u8::from(*on));
}
D::Text(t) => {
b.extend(b"TEXT");
b.extend(ustr(t));
}
D::Enum(t, e) => {
b.extend(b"enum");
b.extend(key(t));
b.extend(key(e));
}
D::Obj(items) => {
b.extend(b"Objc");
b.extend(descriptor(items));
}
D::List(items) => {
b.extend(b"VlLs");
b.extend((items.len() as u32).to_be_bytes());
for i in items {
b.extend(value(i));
}
}
}
b
}
/// A bounds object: top, left, bottom and right.
fn bounds(l: i32, t: i32, r: i32, b: i32) -> D {
D::Obj(vec![("Top ", D::Long(t)), ("Left", D::Long(l)), ("Btom", D::Long(b)), ("Rght", D::Long(r))])
}
/// Resource 1050 in `version` 7 or 8 holding `slices`.
fn v7(version: u32, slices: Vec<D>) -> Vec<u8> {
let mut b = version.to_be_bytes().to_vec();
b.extend(16u32.to_be_bytes());
b.extend(descriptor(&[("bounds", bounds(0, 0, 20, 20)), ("baseName", D::Text("poster")), ("slices", D::List(slices))]));
b
}
/// A 20 × 20 px PSD file written by `document.export`, with its layers (two) or flat.
fn psd(layers: bool) -> Vec<u8> {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 20, "height": 20})).unwrap();
s.execute("paint.setFill", &json!({ "color": "#ff0000" })).unwrap();
s.execute("shape.rectangle", &json!({"x": 2, "y": 2, "width": 10, "height": 10})).unwrap();
s.execute("layer.new", &json!({ "name": "Top" })).unwrap();
s.execute("shape.rectangle", &json!({"x": 8, "y": 8, "width": 10, "height": 10})).unwrap();
let r = s.execute("document.export", &json!({"format": "psd", "layers": layers})).unwrap();
vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
}
/// `psd` with image resource `id` holding `data` added to its image resources.
fn with_resource(psd: &[u8], id: u16, data: &[u8]) -> Vec<u8> {
let u32_at = |at: usize| u32::from_be_bytes(psd[at..at + 4].try_into().unwrap()) as usize;
let colors = 26 + 4 + u32_at(26);
let len = u32_at(colors);
let mut block = b"8BIM".to_vec();
block.extend(id.to_be_bytes());
block.extend([0, 0]);
block.extend((data.len() as u32).to_be_bytes());
block.extend(data);
block.resize(block.len().next_multiple_of(2), 0);
let mut out = psd[..colors].to_vec();
out.extend(((len + block.len()) as u32).to_be_bytes());
out.extend(&psd[colors + 4..colors + 4 + len]);
out.extend(block);
out.extend(&psd[colors + 4 + len..]);
out
}
fn b64(f: &[u8]) -> String {
vectorcraft_format::base64_encode(f)
}
fn open(f: &[u8], extra: Value) -> (Session, Value) {
let mut s = Session::new();
let mut p = json!({"name": "poster.psd", "dataBase64": b64(f)});
for (k, v) in extra.as_object().unwrap() {
p[k] = v.clone();
}
let r = s.execute("document.open", &p).unwrap();
(s, r)
}
/// The document's user slices: rectangle and options.
fn slices(s: &Session) -> Vec<(Rect, SliceOptions)> {
s.doc().unwrap().doc.slices.iter().map(|x| (x.rect, x.options.clone())).collect()
}
fn warnings(r: &Value) -> Vec<String> {
r["warnings"].as_array().map(|a| a.iter().filter_map(|w| w.as_str().map(str::to_string)).collect()).unwrap_or_default()
}
#[test]
fn version_6_slices_open_as_user_slices_with_their_options() {
let linked = S { origin: 1, url: "https://example.com/", target: "_blank", message: "Go", alt: "Logo", ..user("logo", [2, 4, 10, 8]) };
let plain = S { kind: 0, cell: "a < b & c", argb: [0, 0, 0, 0], ..user("note", [10, 10, 20, 20]) };
let html = S { kind: 0, html: true, cell: "<b>Hi</b>", argb: [255, 0x12, 0x34, 0x56], ..user("", [0, 12, 6, 18]) };
let matte = S { argb: [0, 1, 2, 3], cell: "ignored", ..user("matte", [12, 0, 18, 6]) };
let auto = S { origin: 0, ..user("auto", [0, 0, 20, 2]) };
let data = v6(&[linked, plain, html, matte, auto], &[]);
for layers in [true, false] {
let f = with_resource(&psd(layers), 1050, &data);
// Either conversion brings the slices in; the automatic one stays out.
for p in [json!({}), json!({"layers": false})] {
let (s, r) = open(&f, p);
assert!(warnings(&r).is_empty(), "{r}");
let got = slices(&s);
assert_eq!(got.len(), 4, "{got:?}");
assert_eq!(got[0].0, Rect::new(2.0, 4.0, 10.0, 8.0));
assert_eq!(
got[0].1,
SliceOptions {
kind: SliceKind::Image,
name: "logo".into(),
url: "https://example.com/".into(),
target: "_blank".into(),
message: "Go".into(),
alt: "Logo".into(),
..Default::default()
}
);
// Plain cell text is escaped as the HTML a No Image cell shows; HTML stays as it is.
assert_eq!((got[1].1.kind, got[1].1.text.as_str(), got[1].1.background.as_str()), (SliceKind::NoImage, "a &lt; b &amp; c", ""));
assert_eq!((got[2].1.text.as_str(), got[2].1.background.as_str(), got[2].1.name.as_str()), ("<b>Hi</b>", "#123456", ""));
// An Image slice's cell text isn't kept; a background with no alpha is the matte.
assert_eq!((got[3].1.text.as_str(), got[3].1.background.as_str()), ("", "matte"));
// Web output lays them out with auto slices around them.
let layout = s.doc().unwrap().doc.slice_layout();
assert_eq!(layout.iter().filter(|a| a.source == vectorcraft_doc::SliceSource::User).count(), 4);
assert!(layout.iter().any(|a| a.source == vectorcraft_doc::SliceSource::Auto));
}
}
}
#[test]
fn photoshop_7_descriptors_after_version_6_records_are_read_past() {
let trailing = [16u32.to_be_bytes().to_vec(), descriptor(&[("topOutset", D::Long(0))])].concat();
let f = with_resource(&psd(false), 1050, &v6(&[user("a", [0, 0, 5, 5]), user("b", [5, 5, 10, 10])], &trailing));
let (s, r) = open(&f, json!({}));
assert!(warnings(&r).is_empty(), "{r}");
let names: Vec<String> = slices(&s).into_iter().map(|(_, o)| o.name).collect();
assert_eq!(names, ["a", "b"]);
}
#[test]
fn version_6_descriptors_share_one_budget_of_values() {
// Each record's descriptor holds 2,501 values, well under the 200,000 one descriptor may hold;
// 100 of them hold 250,100 together.
let list = D::List((0..2_500).map(D::Long).collect());
let trailing = [16u32.to_be_bytes().to_vec(), descriptor(&[("many", list)])].concat();
let records: Vec<S> = (0..100).map(|_| user("a", [0, 0, 5, 5])).collect();
// Alone, one such descriptor is read past.
let (s, r) = open(&with_resource(&psd(false), 1050, &v6(&records[..1], &trailing)), json!({}));
assert!(warnings(&r).is_empty(), "{r}");
assert_eq!(slices(&s).len(), 1);
// Together they are refused, and the file opens without slices.
let (s, r) = open(&with_resource(&psd(false), 1050, &v6(&records, &trailing)), json!({}));
let w = warnings(&r);
assert!(w.iter().any(|w| w.starts_with("the slices can't be read (") && w.contains("too many values")), "{w:?}");
assert!(slices(&s).is_empty());
}
#[test]
fn version_7_and_8_descriptors_open_as_user_slices() {
let slice = |origin: &'static str, kind: &'static str, l: i32, t: i32, r: i32, b: i32| {
D::Obj(vec![
("sliceID", D::Long(1)),
("groupID", D::Long(0)),
("origin", D::Enum("ESliceOrigin", origin)),
("Type", D::Enum("ESliceType", kind)),
("bounds", bounds(l, t, r, b)),
("Nm ", D::Text("cell")),
("url", D::Text("https://example.com/")),
("null", D::Text("_top")),
("Msge", D::Text("msg")),
("altTag", D::Text("alt")),
("cellTextIsHTML", D::Bool(false)),
("cellText", D::Text("x>y")),
("bgColorType", D::Enum("ESliceBGColorType", "Clr ")),
("bgColor", D::Obj(vec![("Rd ", D::Doub(255.0)), ("Grn ", D::Doub(128.0)), ("Bl ", D::Long(0))])),
])
};
for version in [7, 8] {
let data = v7(
version,
vec![slice("userGenerated", "Img ", 1, 2, 9, 10), slice("autoGenerated", "Img ", 0, 0, 20, 1), slice("layer", "noImage", 10, 10, 15, 15)],
);
let (s, r) = open(&with_resource(&psd(true), 1050, &data), json!({}));
assert!(warnings(&r).is_empty(), "{r}");
let got = slices(&s);
assert_eq!(got.len(), 2, "{got:?}");
assert_eq!(got[0].0, Rect::new(1.0, 2.0, 9.0, 10.0));
assert_eq!(
got[0].1,
SliceOptions {
name: "cell".into(),
url: "https://example.com/".into(),
target: "_top".into(),
message: "msg".into(),
alt: "alt".into(),
background: "#ff8000".into(),
..Default::default()
}
);
assert_eq!((got[1].1.kind, got[1].1.text.as_str(), got[1].1.url.as_str()), (SliceKind::NoImage, "x&gt;y", ""));
}
}
#[test]
fn import_slices_false_leaves_them_out_and_must_be_a_switch() {
let f = with_resource(&psd(true), 1050, &v6(&[user("a", [0, 0, 5, 5])], &[]));
let (s, _) = open(&f, json!({"importSlices": false}));
assert!(slices(&s).is_empty());
let mut s = Session::new();
let e = s.execute("document.open", &json!({"name": "poster.psd", "dataBase64": b64(&f), "importSlices": "yes"})).unwrap_err();
assert!(e.to_string().contains("importSlices must be true or false"), "{e}");
}
#[test]
fn slices_that_cant_be_read_warn_and_the_file_still_opens() {
let good = v6(&[user("a", [0, 0, 5, 5])], &[]);
let mut bad_descriptor = v7(7, vec![]);
bad_descriptor[4..8].copy_from_slice(&15u32.to_be_bytes());
let cases: Vec<(Vec<u8>, &str)> = vec![
(good[..good.len() - 3].to_vec(), "cut short"),
([9u32.to_be_bytes().to_vec(), good[4..].to_vec()].concat(), "version 9"),
(bad_descriptor, "version other than 16"),
// The count follows the version, the bounds and the group's name.
([&good[..34], &u32::MAX.to_be_bytes()[..], &good[38..]].concat(), "more than the 10000 read"),
(v7(8, vec![D::Long(3)]), "other than a slice"),
// A whole record whose name is longer than a slice's text may be.
(v6(&[user("a".repeat(65_537).leak(), [0, 0, 5, 5])], &[]), "more than the 65536 characters read"),
];
for (data, why) in cases {
for layers in [true, false] {
let (s, r) = open(&with_resource(&psd(layers), 1050, &data), json!({}));
let w = warnings(&r);
assert!(w.iter().any(|w| w.starts_with("the slices can't be read (") && w.contains(why)), "{why}: {w:?}");
assert!(slices(&s).is_empty());
// The art still came in.
assert!(s.doc().unwrap().doc.art_bounds().is_some(), "{why}");
}
}
// A name of the longest length read comes in.
let longest = v6(&[user("a".repeat(65_536).leak(), [0, 0, 5, 5])], &[]);
let (s, r) = open(&with_resource(&psd(false), 1050, &longest), json!({}));
assert!(warnings(&r).is_empty(), "{r}");
assert_eq!(slices(&s).first().map(|(_, o)| o.name.len()), Some(65_536));
// A file without slices opens without a word about them.
let (s, r) = open(&psd(true), 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])], &[]);
let (s, r) = open(&with_resource(&psd(false), 1050, &data), json!({}));
assert_eq!(warnings(&r), ["2 slices lie outside the canvas or have no size and were left out"]);
let got: Vec<(Rect, String)> = slices(&s).into_iter().map(|(r, o)| (r, o.name)).collect();
assert_eq!(got, [(Rect::new(0.0, 0.0, 5.0, 20.0), "over".to_string()), (Rect::new(1.0, 1.0, 2.0, 2.0), "in".to_string())]);
}
#[test]
fn placed_embedded_files_bring_their_slices_with_the_art_in_one_undo_step() {
let data = v6(&[user("a", [0, 0, 10, 10]), user("b", [10, 10, 20, 20])], &[]);
for layers in [false, true] {
let f = with_resource(&psd(layers), 1050, &data);
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
// Fitted into a 40 pt square at (100, 60): twice the size.
let r = s.execute("file.place", &json!({"name": "poster.psd", "dataBase64": b64(&f), "rect": [100, 60, 40, 40], "layers": layers})).unwrap();
assert_eq!(r["slices"].as_array().map(Vec::len), Some(2), "{r}");
let got: Vec<Rect> = slices(&s).into_iter().map(|(r, _)| r).collect();
assert_eq!(got, [Rect::new(100.0, 60.0, 120.0, 80.0), Rect::new(120.0, 80.0, 140.0, 100.0)]);
// The placed art stays selected, and one undo takes the art and the slices away.
assert_eq!(s.doc().unwrap().selection.objects.len(), 1);
s.execute("edit.undo", &json!({})).unwrap();
assert!(slices(&s).is_empty());
assert!(s.doc().unwrap().doc.art_bounds().is_none());
// Centered on `at` at 100%.
s.execute("file.place", &json!({"name": "poster.psd", "dataBase64": b64(&f), "at": [100, 100], "layers": layers})).unwrap();
assert_eq!(slices(&s)[0].0, Rect::new(90.0, 90.0, 100.0, 100.0));
// `importSlices: false` places the art alone.
let r = s.execute("file.place", &json!({"name": "poster.psd", "dataBase64": b64(&f), "importSlices": false, "layers": layers})).unwrap();
assert!(r.get("slices").is_none());
assert_eq!(slices(&s).len(), 2);
}
}
#[test]
fn linked_files_are_placed_without_their_slices() {
let dir = std::env::temp_dir().join(format!("vc-psd-slices-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("poster.psd");
std::fs::write(&path, with_resource(&psd(false), 1050, &v6(&[user("a", [0, 0, 5, 5])], &[]))).unwrap();
let path = path.to_string_lossy().into_owned();
let mut s = Session::new();
s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
let r = s.execute("file.place", &json!({ "path": path })).unwrap();
assert_eq!((&r["linked"], r.get("slices")), (&json!(true), None));
assert!(slices(&s).is_empty());
let e = s.execute("file.place", &json!({ "path": path, "importSlices": true })).unwrap_err();
assert!(e.to_string().contains("importSlices: a linked PSD file is placed as its flat image"), "{e}");
// Embedded from its path, they come in.
let r = s.execute("file.place", &json!({ "path": path, "link": false })).unwrap();
assert_eq!((&r["linked"], r["slices"].as_array().map(Vec::len)), (&json!(false), Some(1)));
// file.place.info counts what a place would bring in.
let info = s.execute("file.place.info", &json!({ "path": path, "link": false })).unwrap();
assert_eq!(info["slices"], json!(1));
let info = s.execute("file.place.info", &json!({ "path": path })).unwrap();
assert_eq!(info["slices"], json!(0));
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn psd_info_counts_the_slices_that_come_in() {
let mut s = Session::new();
let info = |s: &mut Session, f: &[u8]| s.execute("document.psdInfo", &json!({"dataBase64": b64(f)})).unwrap();
let data = v6(&[user("a", [0, 0, 5, 5]), S { origin: 0, ..user("auto", [5, 5, 20, 20]) }, user("out", [30, 30, 40, 40])], &[]);
assert_eq!(info(&mut s, &with_resource(&psd(false), 1050, &data))["slices"], json!(1));
assert_eq!(info(&mut s, &with_resource(&psd(true), 1050, &data[..data.len() - 4]))["slices"], json!(0));
assert_eq!(info(&mut s, &psd(true))["slices"], json!(0));
}
#[test]
fn damaged_slices_never_panic() {
let data = v7(8, vec![D::Obj(vec![("origin", D::Enum("ESliceOrigin", "userGenerated")), ("bounds", bounds(0, 0, 5, 5))])]);
let base = with_resource(&psd(false), 1050, &data);
let start = base.windows(data.len()).position(|w| w == data).unwrap();
for at in (start - 12..start + data.len()).step_by(3) {
for v in [0u8, 0x7f, 0xff] {
let mut f = base.clone();
f[at] = v;
let mut s = Session::new();
let _ = s.execute("document.open", &json!({"name": "poster.psd", "dataBase64": b64(&f)}));
let _ = s.execute("document.psdInfo", &json!({"dataBase64": b64(&f)}));
}
}
}
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+24
View File
@@ -1652,6 +1652,30 @@ fn paragraph_style_options_edit_applies_to_users_and_is_one_saved_undo_step() {
}
}
/// A paragraph style can hold a Standard composer: it applies to its paragraphs, redefining and
/// resetting treat it like any attribute, and the style and the paragraphs keep it through a save.
#[test]
fn paragraph_styles_keep_a_standard_composer_through_a_save() {
use vectorcraft_doc::Composer;
let (mut s, id) = session_with_text("One\nTwo");
s.execute("paraStyle.new", &json!({"name": "Legacy", "attrs": {"composer": "standardSingleLine"}})).unwrap();
s.execute("paraStyle.apply", &json!({"name": "Legacy", "id": id, "start": 0, "end": 0})).unwrap();
assert_eq!(paras(&s, id).iter().map(|p| p.composer).collect::<Vec<_>>(), [Composer::StandardSingleLine, Composer::EveryLine]);
let doc = s.doc().unwrap().doc.clone();
let saved = vectorcraft_format::load(&vectorcraft_format::save(&doc, false)).unwrap();
let style = saved.para_styles.iter().find(|d| d.name == "Legacy").unwrap();
assert_eq!(style.attrs["composer"], json!("standardSingleLine"));
let mut composers = vec![];
saved.walk(|n| {
if let vectorcraft_doc::NodeKind::Text(t) = &n.kind {
composers.extend(t.paragraph_styles().iter().map(|p| p.composer));
}
});
assert_eq!(composers, [Composer::StandardSingleLine, Composer::EveryLine]);
s.execute("paraStyle.setAttrs", &json!({"name": "Legacy", "attrs": {"composer": "standardEveryLine"}})).unwrap();
assert_eq!(paras(&s, id)[0].composer, Composer::StandardEveryLine, "an edited style reaches its paragraphs");
}
/// A changed paragraph attribute outside the range `text.setFormat` keeps it to is an error for
/// `paraStyle.edit`, `paraStyle.setAttrs` and `paraStyle.new`, with no change to the document; the
/// ends of each range are accepted, and an out-of-range value the style already has can be kept.
+17 -2
View File
@@ -59,8 +59,23 @@ fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {
/// margin passes without being measured: its curves stay inside their control points. Any other
/// object, and a path with a point outside that margin, is measured.
pub(crate) fn objects_in_range(d: &Document, ids: &[NodeId]) -> bool {
let paths = d.index_paths(ids.iter().copied());
ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).is_none_or(|n| points_in_range(n) || n.geometric_bounds().is_none_or(rect_in_range)))
if ids.is_empty() {
return true;
}
let node_ok = |n: &vectorcraft_doc::Node| points_in_range(n) || n.geometric_bounds().is_none_or(rect_in_range);
// A cached document or a few ids: look each one up. Otherwise one walk of the tree, with no
// path vectors allocated.
if d.has_lookup_cache() || ids.len() <= 16 {
return ids.iter().all(|id| d.node(*id).is_none_or(node_ok));
}
let want: std::collections::HashSet<NodeId> = ids.iter().copied().collect();
let mut ok = true;
d.walk(|n| {
if ok && want.contains(&n.id) && !node_ok(n) {
ok = false;
}
});
ok
}
/// Coordinates at most this far from 0 keep a curve's measured bounds within [`MAX_COORD`]
+29
View File
@@ -1722,6 +1722,35 @@ fn text_set_format() {
assert_eq!(t.para.composer, vectorcraft_doc::Composer::EveryLine);
}
/// `text.setFormat {composer}` takes the two Middle Eastern & South Asian and the two Standard
/// composers, each per paragraph and one undo step; any other value is refused and names them all.
#[test]
fn text_set_format_takes_the_four_composers() {
use vectorcraft_doc::Composer;
let mut s = session();
let r = s.execute("text.create", &json!({"x": 10, "y": 100, "text": "One\nTwo"})).unwrap();
let id = NodeId(r["id"].as_u64().unwrap());
let composers = |s: &Session| {
let NodeKind::Text(t) = node(s, id).kind else { panic!() };
[t.para_at(0).composer, t.para_at(1).composer]
};
assert_eq!(composers(&s), [Composer::EveryLine; 2], "new type is ME&SA Every-line");
for (value, want) in [
("singleLine", Composer::SingleLine),
("standardSingleLine", Composer::StandardSingleLine),
("standardEveryLine", Composer::StandardEveryLine),
("everyLine", Composer::EveryLine),
] {
s.execute("text.setFormat", &json!({"ids": [id.0], "composer": value, "start": 4, "end": 4})).unwrap();
assert_eq!(composers(&s), [Composer::EveryLine, want], "{value}: only the second paragraph");
}
s.execute("text.setFormat", &json!({"ids": [id.0], "composer": "standardEveryLine"})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(composers(&s), [Composer::EveryLine; 2], "one undo step");
let e = s.execute("text.setFormat", &json!({"ids": [id.0], "composer": "standard"})).unwrap_err().to_string();
assert!(e.contains("standardSingleLine") && e.contains("standardEveryLine"), "{e}");
}
#[test]
fn stroke_advanced_scale_swap_flip() {
let mut s = session();
+5
View File
@@ -1841,6 +1841,7 @@ proptest! {
/// Mutated copies of the PSD and PSB samples never crash opening them with their layers, hidden
/// ones too: the PSD's layer records, channel lengths and data, and the PSB's layer count.
/// (Masks, clipping and groups are covered by `tests_psdlayers::damaged_layers_never_panic`.)
/// Neither does `document.psdInfo`, nor placing them with their layers as objects.
#[test]
fn mutated_layered_psds_open_without_panics(which in 6usize..8, cut in 0usize..1_000_000, edits in prop::collection::vec((0usize..1_000_000, any::<u8>()), 0..12)) {
let (name, mut bytes) = raster_samples().swap_remove(which);
@@ -1855,6 +1856,10 @@ proptest! {
let mut s = vectorcraft_engine::Session::new();
let p = json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(&bytes), "hiddenLayers": true});
let _ = no_panic(s.execute("document.open", &p));
let _ = no_panic(s.execute("document.psdInfo", &p));
let _ = no_panic(s.execute("file.new", &json!({})));
let p = json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(&bytes), "layers": true, "hiddenLayers": true});
let _ = no_panic(s.execute("file.place", &p));
});
prop_assert!(r.is_ok(), "{name}: panicked: {:?}", r.err());
}
+327 -1
View File
@@ -1038,7 +1038,8 @@ fn nested_symbol_instances_stop_at_the_symbol_art_limit() {
/// The documents [`the_writer_counts_objects_as_the_reader_reads_them`] writes: groups, compound
/// paths, guides, sublayers, clipping groups and layers, painted clipping paths, opacity masks,
/// gradients, pattern definitions and tiles, images, type, symbol definitions and instances,
/// objects with art styles, objects bound to variables and live envelopes.
/// objects with art styles, objects bound to variables, live envelopes, and the rectangles of the
/// bounds of wrapped objects written as their art.
fn counted() -> Vec<(&'static str, Document)> {
vec![
("sample", sample()),
@@ -1054,9 +1055,28 @@ fn counted() -> Vec<(&'static str, Document)> {
("blend", blend_doc()),
("brushes", brushes_document()),
("envelopes", envelopes_document()),
("wrap bounds", wrap_bounds_doc()),
]
}
/// Area type below a wrapped symbol instance written as its art and wrapped type written as its
/// outlines, each with the rectangle of its bounds.
fn wrap_bounds_doc() -> Document {
let mut doc = over_area_type(|doc| {
two_leaves(doc);
let mut n = instance(doc, "Leaf", Affine::new([3.0, 0.0, 0.0, 3.0, 150.0, 100.0]));
n.isolate = true;
wrapped(n, 4.5, false)
});
let mut label = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::ZERO, "Ill", style(60.0, Color::BLACK));
// Mirrored, so written as its outlines.
label.xf = Affine::new([-1.0, 0.0, 0.0, 1.0, 150.0, 120.0]);
let label = wrapped(text_node(&mut doc, label), -2.0, true);
let layer = doc.layers[0].id;
doc.insert(Some(layer), usize::MAX, label).unwrap();
doc
}
/// A blend of two squares 20 pt apart with a step every 10 pt, written as its steps.
fn blend_doc() -> Document {
let mut doc = Document::new(200.0, 100.0);
@@ -11374,6 +11394,42 @@ fn text_wrap_options_of_type_and_envelopes_are_read_back() {
same_wraps(&wraps(top), &[(Some("Bent".into()), 2.5, true)]);
}
/// The wrap shapes that `doc`'s first area type on its first layer takes from the objects above it,
/// in the type's own space: the bounds of each one's subpaths, and its options.
fn area_wrap_region(doc: &Document) -> Vec<(Vec<[f64; 4]>, f64, bool)> {
use vectorcraft_doc::TextKind;
let mut doc = doc.clone();
vectorcraft_doc::text::resolve_wrap(None, &mut doc);
let top = doc.layers[0].children().unwrap();
let Some(NodeKind::Text(t)) = top.iter().map(|n| &n.kind).find(|k| matches!(k, NodeKind::Text(t) if matches!(t.kind, TextKind::Area { .. })))
else {
panic!("no area type");
};
t.wrap
.iter()
.map(|s| {
let parts = s
.path
.subpaths
.iter()
.map(|sp| {
let b = PathData::new(vec![sp.clone()]).bounds().unwrap_or_default();
[b.x0, b.y0, b.x1, b.y1]
})
.collect();
(parts, s.wrap.offset, s.wrap.invert)
})
.collect()
}
/// `before` and `after` hold as many wrap shapes, each with as many subpaths, with bounds within
/// `1e-3`, and the same options.
fn same_region(before: &[(Vec<[f64; 4]>, f64, bool)], after: &[(Vec<[f64; 4]>, f64, bool)]) -> bool {
let close =
|b: &[[f64; 4]], a: &[[f64; 4]]| b.len() == a.len() && b.iter().zip(a).all(|(b, a)| b.iter().zip(a).all(|(x, y)| (x - y).abs() < 1e-3));
before.len() == after.len() && before.iter().zip(after).all(|(b, a)| close(&b.0, &a.0) && (b.1 - a.1).abs() < 1e-6 && b.2 == a.2)
}
/// Type written as its outlines wraps area type below it by its bounds, as it did before saving,
/// not by its glyphs: its text wrap options go on an unpainted rectangle of its bounds, the last
/// member of the outlines' group, which keeps the type's name and has no options of its own.
@@ -11464,6 +11520,276 @@ fn type_written_as_outlines_keeps_wrapping_by_its_bounds() {
assert_eq!(top[1].name.as_deref(), Some("Label"), "{text_out}");
}
/// A 300 × 200 document of area type "Body" filling the page, with `top` above it.
fn over_area_type(make: impl FnOnce(&mut Document) -> Node) -> Document {
use vectorcraft_doc::{TextKind, TextObject, TextRun};
let mut doc = Document::new(300.0, 200.0);
let layer = doc.layers[0].id;
let mut body = TextObject::point(vectorcraft_geom::Point::ZERO, "", style(10.0, Color::BLACK));
body.runs = vec![TextRun::new("one two three four five six seven eight nine ten eleven twelve", style(10.0, Color::BLACK))];
body.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 290.0, 190.0)) };
body.xf = Affine::IDENTITY;
let body = named(text_node(&mut doc, body), "Body");
let top = make(&mut doc);
for n in [body, top] {
doc.insert(Some(layer), usize::MAX, n).unwrap();
}
doc
}
/// Symbol "Leaf": two squares in opposite corners of the 20 × 20 square around the origin, apart.
fn two_leaves(doc: &mut Document) {
let a = square(doc, Rect::new(-10.0, -10.0, -6.0, -6.0), LEAF);
let b = square(doc, Rect::new(6.0, 6.0, 10.0, 10.0), LEAF);
let art = group(doc, vec![a, b], false);
doc.symbols.push(Symbol { dynamic: false, name: "Leaf".into(), art: Arc::new(art) });
}
/// A symbol instance written as its art (its isolation is a group's), a blend and an intertwine,
/// each written as a group of its art, wrap area type below them by their bounds after reopening,
/// as they did before saving, not by the members of that art: the text wrap options go on an
/// unpainted rectangle of the bounds, the group's first member, and the group, which keeps the
/// object's name, isolation, lock and visibility, has none. A positive offset, a negative offset
/// with Invert Wrap, and hidden and locked.
#[test]
fn live_art_written_as_a_group_keeps_wrapping_by_its_bounds() {
let instance_of = |offset: f64, invert: bool, visible: bool, locked: bool| {
move |doc: &mut Document| {
two_leaves(doc);
let mut n = instance(doc, "Leaf", Affine::new([3.0, 0.0, 0.0, 3.0, 150.0, 100.0]));
n.isolate = true;
(n.visible, n.locked) = (visible, locked);
wrapped(named(n, "Thing"), offset, invert)
}
};
let blend = |doc: &mut Document| {
let keys = vec![
Arc::new(square(doc, Rect::new(60.0, 80.0, 70.0, 90.0), Color::gray(0.5))),
Arc::new(square(doc, Rect::new(220.0, 110.0, 230.0, 120.0), Color::gray(0.5))),
];
let spec = vectorcraft_doc::BlendSpec { spacing: vectorcraft_doc::BlendSpacing::Distance(60.0), ..Default::default() };
wrapped(named(Node::new(doc.alloc_id(), NodeKind::Blend { children: keys, spec: Box::new(spec) }), "Thing"), 4.5, false)
};
let intertwine = |doc: &mut Document| {
let a = Arc::new(square(doc, Rect::new(60.0, 60.0, 80.0, 80.0), Color::gray(0.5)));
let b = Arc::new(square(doc, Rect::new(200.0, 120.0, 220.0, 140.0), Color::gray(0.5)));
wrapped(named(Node::new(doc.alloc_id(), NodeKind::Intertwine { children: vec![a, b] }), "Thing"), 2.0, true)
};
let repeat = |doc: &mut Document| {
let a = Arc::new(square(doc, Rect::new(100.0, 80.0, 110.0, 90.0), Color::gray(0.5)));
let spec = vectorcraft_doc::RepeatSpec::grid(vec![a], 8.0, 12.0);
wrapped(named(Node::new(doc.alloc_id(), NodeKind::Repeat(spec)), "Thing"), 1.5, false)
};
// A Fidelity that isn't a whole number: written as its distorted art.
let envelope = |doc: &mut Document| {
use vectorcraft_doc::live::{EnvelopeKind, EnvelopeOptions};
let kind = EnvelopeKind::Mesh { rows: 2, cols: 3, points: envelope_points(2, 3), handles: vec![] };
wrapped(named(envelope_node(doc, kind, 50.5, false, EnvelopeOptions::NEW), "Thing"), -3.0, true)
};
let docs = [
("instance", over_area_type(instance_of(4.5, false, true, false)), 4.5, false, true, false),
("instance, inverted", over_area_type(instance_of(-2.0, true, true, false)), -2.0, true, true, false),
("instance, hidden and locked", over_area_type(instance_of(3.0, false, false, true)), 3.0, false, false, true),
("blend", over_area_type(blend), 4.5, false, true, false),
("intertwine", over_area_type(intertwine), 2.0, true, true, false),
("repeat", over_area_type(repeat), 1.5, false, true, false),
("envelope", over_area_type(envelope), -3.0, true, true, false),
];
for (name, doc, offset, invert, visible, locked) in docs {
let thing = &doc.layers[0].children().unwrap()[1];
let want = thing.geometric_bounds().unwrap();
let text_out = program(&doc);
let back = read_back(&doc);
let (before, after) = (area_wrap_region(&doc), area_wrap_region(&back));
assert_eq!(before.len(), usize::from(visible), "{name}");
assert!(same_region(&before, &after), "{name}\n{before:?}\n{after:?}\n{text_out}");
assert_eq!(text_out.matches("(AI11TextWrapOffset)").count(), 1, "{name}: {text_out}");
let top = back.layers[0].children().unwrap();
same_wraps(&wraps(top), &[(None, offset, invert)]);
let g = &top[1];
assert!(matches!(g.kind, NodeKind::Group { clip: false, .. }), "{name}: {text_out}");
assert_eq!(
(g.name.as_deref(), g.extras().wrap, g.visible, g.locked, g.isolate),
(Some("Thing"), None, visible, locked, thing.isolate),
"{name}"
);
let first = &g.children().unwrap()[0];
assert!(matches!(first.kind, NodeKind::Path { guide: false, .. }) && first.appearance.items.is_empty(), "{name}: {text_out}");
assert_eq!((first.visible, first.locked), (visible, locked), "{name}");
let b = first.geometric_bounds().unwrap();
assert!([b.x0 - want.x0, b.y0 - want.y0, b.x1 - want.x1, b.y1 - want.y1].iter().all(|d| d.abs() < 1e-3), "{name}: {b:?} {want:?}");
}
// An envelope written live opens live and wraps by its bounds, its options its own.
let live = |doc: &mut Document| {
use vectorcraft_doc::live::{EnvelopeKind, EnvelopeOptions};
let kind = EnvelopeKind::Mesh { rows: 2, cols: 3, points: envelope_points(2, 3), handles: vec![] };
wrapped(named(envelope_node(doc, kind, 50.0, false, EnvelopeOptions::NEW), "Thing"), -3.0, true)
};
let doc = over_area_type(live);
let text_out = program(&doc);
let back = read_back(&doc);
let (before, after) = (area_wrap_region(&doc), area_wrap_region(&back));
assert_eq!(before.len(), 1);
assert!(same_region(&before, &after), "{before:?}\n{after:?}\n{text_out}");
let top = back.layers[0].children().unwrap();
assert!(matches!(top[1].kind, NodeKind::Envelope { .. }), "{text_out}");
same_wraps(&wraps(top), &[(Some("Thing".into()), -3.0, true)]);
}
/// The rectangle that keeps a blend written as its art wrapping by its bounds counts toward the
/// object limit, ahead of the art: one object short, the last step is left out with the limit's
/// warning; without room for the rectangle, the options are left out with the warning, and the
/// group does not take them. In an instance whose art holds area type, shown, hidden, in a hidden
/// group or written as its outlines, the rectangle is the group's first member, below that type:
/// area type below the instance wraps by its bounds after reopening, and the type in its art is not
/// wrapped by them.
#[test]
fn wrap_bounds_of_live_art_fit_the_object_limit_and_leave_area_type_in_the_art_unwrapped() {
use vectorcraft_doc::{TextKind, TextObject, TextRun};
// A blend alone, without a symbol definition, so the objects are the group, the rectangle and
// the steps.
let mut doc = Document::new(300.0, 200.0);
let keys = vec![
Arc::new(square(&mut doc, Rect::new(60.0, 80.0, 70.0, 90.0), Color::gray(0.5))),
Arc::new(square(&mut doc, Rect::new(220.0, 110.0, 230.0, 120.0), Color::gray(0.5))),
];
let spec = vectorcraft_doc::BlendSpec { spacing: vectorcraft_doc::BlendSpacing::Distance(60.0), ..Default::default() };
let thing = wrapped(named(Node::new(doc.alloc_id(), NodeKind::Blend { children: keys, spec: Box::new(spec) }), "Thing"), 4.5, false);
let layer = doc.layers[0].id;
doc.insert(Some(layer), usize::MAX, thing).unwrap();
let steps = export_ai_editing(&doc, &opts()).unwrap();
let steps = crate::ai_alone(&steps.program).unwrap().0.layers[0].children().unwrap()[0].children().unwrap().len() - 1;
let read = crate::import::objects_read(&export_ai_editing(&doc, &opts()).unwrap().program).unwrap();
let all = export_within(&doc, &opts(), read).unwrap();
assert!(!all.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{:?}", all.warnings);
let out = export_within(&doc, &opts(), read - 1).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{:?}", out.warnings);
let text_out = String::from_utf8_lossy(&out.program).replace("\r\n", "\n");
assert_eq!(text_out.matches("(AI11TextWrapOffset)").count(), 1, "{text_out}");
let (back, _) = crate::ai_alone(&out.program).unwrap();
let top = back.layers[0].children().unwrap();
same_wraps(&wraps(top), &[(None, 4.5, false)]);
assert_eq!((top[0].name.as_deref(), top[0].extras().wrap), (Some("Thing"), None), "{text_out}");
let members = top[0].children().unwrap();
assert_eq!(members.len(), steps, "the rectangle and all but the last step: {text_out}");
assert!(matches!(members[0].kind, NodeKind::Path { guide: false, .. }) && members[0].appearance.items.is_empty(), "{text_out}");
let out = export_within(&doc, &opts(), read - steps - 1).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{:?}", out.warnings);
let text_out = String::from_utf8_lossy(&out.program).replace("\r\n", "\n");
assert!(!text_out.contains("(AI11TextWrapOffset)"), "{text_out}");
let (back, _) = crate::ai_alone(&out.program).unwrap();
assert!(wraps(back.layers[0].children().unwrap()).is_empty(), "{text_out}");
// Area type in the symbol's art, shown or hidden, of `words`, in a hidden group with `in_hidden`.
let make = |shown: bool, words: &'static str, in_hidden: bool| {
move |doc: &mut Document| {
let mut t = TextObject::point(vectorcraft_geom::Point::ZERO, "", style(2.0, Color::BLACK));
t.runs = vec![TextRun::new(words, style(2.0, Color::BLACK))];
t.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(-10.0, -10.0, -6.0, -6.0)) };
t.xf = Affine::IDENTITY;
let mut t = text_node(doc, t);
t.visible = shown;
if in_hidden {
t = group(doc, vec![t], false);
t.visible = false;
}
let s = square(doc, Rect::new(6.0, 6.0, 10.0, 10.0), LEAF);
let art = group(doc, vec![t, s], false);
doc.symbols.push(Symbol { dynamic: false, name: "Leaf".into(), art: Arc::new(art) });
let mut n = instance(doc, "Leaf", Affine::new([3.0, 0.0, 0.0, 3.0, 150.0, 100.0]));
n.isolate = true;
wrapped(named(n, "Thing"), 4.5, false)
}
};
// Type of spaces alone is written as its outlines, which are not type.
for (what, shown, words, in_hidden) in
[("shown", true, "leaf", false), ("hidden", false, "leaf", false), ("in a hidden group", true, "leaf", true), ("spaces", true, " ", false)]
{
let doc = over_area_type(make(shown, words, in_hidden));
let text_out = program(&doc);
assert_eq!(text_out.matches("(AI11TextWrapOffset)").count(), 1, "{what}: {text_out}");
let back = read_back(&doc);
let (before, after) = (area_wrap_region(&doc), area_wrap_region(&back));
assert_eq!(before.len(), 1, "{what}");
assert!(same_region(&before, &after), "{what}\n{before:?}\n{after:?}\n{text_out}");
let g = &back.layers[0].children().unwrap()[1];
assert!(matches!(g.kind, NodeKind::Group { clip: false, .. }), "{what}: {text_out}");
assert_eq!(g.extras().wrap, None, "{what}: {text_out}");
let first = &g.children().unwrap()[0];
assert!(matches!(first.kind, NodeKind::Path { guide: false, .. }) && first.appearance.items.is_empty(), "{what}: {text_out}");
let mut resolved = back.clone();
vectorcraft_doc::text::resolve_wrap(None, &mut resolved);
let mut inner = vec![];
resolved.layers[0].children().unwrap()[1].walk(&mut |m| {
if let NodeKind::Text(t) = &m.kind {
inner.push((matches!(t.kind, TextKind::Area { .. }), m.visible, t.wrap.len()));
}
});
let want: &[(bool, bool, usize)] = match what {
"shown" | "in a hidden group" => &[(true, true, 0)],
"hidden" => &[(true, false, 0)],
_ => &[],
};
assert_eq!(inner, want, "{what}: {text_out}");
}
}
/// A blend with no keys, written as an empty group, has no bounds for a rectangle: its group keeps
/// the text wrap options, and they read back.
#[test]
fn live_art_without_bounds_keeps_its_text_wrap_on_the_group() {
let mut doc = Document::new(300.0, 200.0);
let spec = vectorcraft_doc::BlendSpec::default();
let thing = wrapped(named(Node::new(doc.alloc_id(), NodeKind::Blend { children: vec![], spec: Box::new(spec) }), "Thing"), 4.5, true);
assert_eq!(thing.geometric_bounds(), None);
let layer = doc.layers[0].id;
doc.insert(Some(layer), usize::MAX, thing).unwrap();
let text_out = program(&doc);
assert_eq!(text_out.matches("(AI11TextWrapOffset)").count(), 1, "{text_out}");
let back = read_back(&doc);
same_wraps(&wraps(back.layers[0].children().unwrap()), &[(Some("Thing".into()), 4.5, true)]);
}
/// A symbol instance written as its art, whose art holds an envelope of area type beside a square,
/// wraps area type below it by its bounds after reopening. The envelope there is written as its art,
/// after the type written for it as a live envelope is taken back: the group has no text wrap
/// options, and its first member is the rectangle of the bounds.
#[test]
fn an_envelope_of_area_type_in_written_art_leaves_the_wrap_on_the_bounds() {
use vectorcraft_doc::live::{EnvelopeKind, EnvelopeOptions};
use vectorcraft_doc::{TextKind, TextObject, TextRun};
let doc = over_area_type(|doc| {
let kind = EnvelopeKind::Mesh { rows: 2, cols: 3, points: envelope_points(2, 3), handles: vec![] };
let mut envelope = envelope_node(doc, kind, 50.0, false, EnvelopeOptions::NEW);
let mut t = TextObject::point(vectorcraft_geom::Point::ZERO, "", style(10.0, Color::BLACK));
t.runs = vec![TextRun::new("bent", style(10.0, Color::BLACK))];
t.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(60.0, 30.0, 140.0, 70.0)) };
t.xf = Affine::IDENTITY;
let t = text_node(doc, t);
let NodeKind::Envelope { content, .. } = &mut envelope.kind else { unreachable_envelope() };
content.push(Arc::new(t));
let s = square(doc, Rect::new(250.0, 150.0, 260.0, 160.0), LEAF);
let art = group(doc, vec![envelope, s], false);
doc.symbols.push(Symbol { dynamic: false, name: "Bent".into(), art: Arc::new(art) });
let mut n = instance(doc, "Bent", Affine::IDENTITY);
n.isolate = true;
wrapped(named(n, "Thing"), 4.5, false)
});
let text_out = program(&doc);
let back = read_back(&doc);
let (before, after) = (area_wrap_region(&doc), area_wrap_region(&back));
assert_eq!(before.len(), 1);
assert!(same_region(&before, &after), "{before:?}\n{after:?}\n{text_out}");
let g = &back.layers[0].children().unwrap()[1];
assert_eq!(g.extras().wrap, None, "{text_out}");
let mut live = 0;
g.walk(&mut |m| live += usize::from(matches!(m.kind, NodeKind::Envelope { .. })));
assert_eq!(live, 0, "{text_out}");
let first = &g.children().unwrap()[0];
assert!(matches!(first.kind, NodeKind::Path { guide: false, .. }) && first.appearance.items.is_empty(), "{text_out}");
}
/// A clipping path inside art cut to a clipping object is written as its fills and its strokes,
/// two objects: its text wrap options are written once, whether it has both or only strokes, and
/// with its strokes when the region outside leaves nothing of its fills.
+43 -13
View File
@@ -289,7 +289,8 @@ pub(super) struct Writer<'a> {
/// brushed stroke's pieces) the art being written is in. Text wrap options are written only
/// outside them, since only the document's own objects wrap type.
drawn: u32,
/// The type just written as outlines has its text wrap options on the rectangle of its bounds
/// The type just written as outlines, or the symbol instance or live object just written as a
/// group of its art, has its text wrap options on the rectangle of its bounds
/// ([`Self::wrap_bounds`]), not in the group's dictionary.
wrap_moved: bool,
/// The brushes written ([`brushes`]).
@@ -773,6 +774,8 @@ impl<'a> Writer<'a> {
if !self.open_group("u") {
return;
}
let state = self.state;
let moved = self.wrap_on_bounds(n, state);
// The canvas places an instance inside a symbol's art where the outer instance puts
// it (9-slice guides, stains and patterns included), and this art doesn't move with it.
self.wrote_fixed |= self.in_symbol;
@@ -817,12 +820,13 @@ impl<'a> Writer<'a> {
self.warn(SYMBOL_LIMIT);
}
}
self.wrap_moved = moved;
self.end_group("U", xy);
}
NodeKind::Envelope { .. } if self.envelope(n, xy) => {}
NodeKind::Envelope { .. } => self.drawn_art(n, xy, Some(envelopes::ENVELOPES)),
NodeKind::Envelope { .. } => self.drawn_art(n, xy, Some(envelopes::ENVELOPES), true),
NodeKind::Blend { .. } | NodeKind::Mesh(_) | NodeKind::Repeat(_) | NodeKind::PlacedDocument(_) | NodeKind::Intertwine { .. } => {
self.drawn_art(n, xy, Some(LIVE));
self.drawn_art(n, xy, Some(LIVE), true);
}
// Ruler guides are kept in the document's native copy only.
NodeKind::RulerGuide { .. } => {}
@@ -889,13 +893,17 @@ impl<'a> Writer<'a> {
}
/// Live object `n`, of transparency `xy`, as a group of its art, with `warning` when it is given.
fn drawn_art(&mut self, n: &Node, xy: Xy, warning: Option<&str>) {
/// With `bounds`, `n`'s text wrap options go on the rectangle of its bounds, the group's first
/// member ([`Self::wrap_on_bounds`]); without it, in the group's dictionary.
fn drawn_art(&mut self, n: &Node, xy: Xy, warning: Option<&str>, bounds: bool) {
if !self.open_group("u") {
return;
}
let state = self.state;
if let Some(w) = warning {
self.warn(w);
}
let moved = bounds && self.wrap_on_bounds(n, state);
if self.nest < MAX_NEST {
let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);
self.nest += 1;
@@ -906,9 +914,29 @@ impl<'a> Writer<'a> {
self.drawn -= 1;
self.nest -= 1;
}
self.wrap_moved = moved;
self.end_group("U", xy);
}
/// In the group that object `n` is written as, when the group's dictionary would hold `n`'s text
/// wrap options: the rectangle of `n`'s bounds with them ([`Self::wrap_bounds`]), then lock and
/// hidden state `state` again. True when the group's dictionary is to leave the options out
/// ([`Self::wrap_moved`]), so the group wraps type by `n`'s bounds, as `n` does
/// ([`vectorcraft_doc::text::resolve_wrap`]), not by its members. Written before the group's
/// members, the rectangle is below any area type among them and does not wrap it. False,
/// writing nothing, when `n` has no finite bounds, and the group's dictionary keeps the options.
fn wrap_on_bounds(&mut self, n: &Node, state: Option<(bool, bool)>) -> bool {
let Some(w) = n.extras().wrap.filter(|_| self.drawn == 0 && !self.in_look) else { return false };
if finite_bounds(n).is_none() {
return false;
}
self.wrap_bounds(n, w);
if let Some((locked, hidden)) = state {
self.state(locked, hidden);
}
true
}
/// `n`'s `/ArtDictionary`, after it, when it has a name (`AI10_ArtUID`, see [`Self::take_id`]),
/// is bound to variables ([`Self::bound_variables`]; without a name, it gets an XML id and an
/// empty `AIArtName`), has text wrap options ([`Self::text_wrap`]), has an opacity mask
@@ -1555,23 +1583,20 @@ impl<'a> Writer<'a> {
for c in over {
self.node(c);
}
// Type wraps by its bounds: its text wrap options go on a rectangle of its bounds, the
// group's last member, and the group's dictionary leaves them out.
if let Some(w) = n.extras().wrap.filter(|_| self.drawn == 0 && !self.in_look) {
self.wrap_bounds(n, w);
self.wrap_moved = true;
}
// Type wraps by its bounds.
self.wrap_moved = self.wrap_on_bounds(n, state);
if let Some((locked, hidden)) = state {
self.state(locked, hidden);
}
self.end_group("U", xy);
}
/// An unpainted closed rectangle at the geometric bounds of type `n`, the region its text wraps
/// around, with `n`'s lock and hidden state and text wrap options `w` in its dictionary. Nothing
/// An unpainted closed rectangle at the geometric bounds of type, a symbol instance or a live
/// object `n`, the region its text wraps around ([`vectorcraft_doc::text::resolve_wrap`]), with
/// `n`'s lock and hidden state and text wrap options `w` in its dictionary. Nothing
/// when `n` has no finite bounds, or without room for it ([`Self::take_objects`]).
fn wrap_bounds(&mut self, n: &Node, w: TextWrap) {
let Some(b) = n.geometric_bounds().filter(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite())) else { return };
let Some(b) = finite_bounds(n) else { return };
self.state(n.locked, !n.visible);
let objects = self.objects;
self.plain_object(&shapes::rectangle(b), FillRule::NonZero, None, None, Xy::PLAIN);
@@ -1760,6 +1785,11 @@ impl<'a> Writer<'a> {
}
}
/// `n`'s geometric bounds, when they are finite.
fn finite_bounds(n: &Node) -> Option<vectorcraft_geom::Rect> {
n.geometric_bounds().filter(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()))
}
/// The gradient of paint `p`, when it has one.
fn gradient(p: Option<&Paint>) -> Option<&vectorcraft_color::GradientPaint> {
match p {
@@ -411,9 +411,10 @@ impl Writer<'_> {
self.hidden -= 1;
self.nest -= 1;
// The distorted art, which takes the envelope's lock, visibility, transparency, name and
// opacity mask.
// opacity mask. The reader opens the envelope live, wrapping type by its bounds, so its text
// wrap options stay in the art's dictionary.
self.state(n.locked, !n.visible);
self.drawn_art(n, xy, None);
self.drawn_art(n, xy, None, false);
if !opened || outlines || self.left_out_since(charges) {
let lines = self.body.split_off(start);
self.give_back(charges, &lines);
+38
View File
@@ -212,6 +212,44 @@ fn text_composer_round_trips() {
assert!(!String::from_utf8_lossy(&save(&d2, false)).contains("composer"));
}
/// Every composer reads back as it was saved (the two Standard ones as their own values), and the
/// ME&SA names are the ones files have always used: `everyLine` stays the unwritten default and
/// `singleLine` keeps its spelling, so a document that never picks a Standard composer is unchanged.
#[test]
fn all_four_composers_round_trip() {
use vectorcraft_doc::{TextKind, TextObject};
let one = |c: Composer| {
let mut d = Document::new(200.0, 200.0);
let mut t = TextObject::point(vectorcraft_geom::Point::ZERO, "ક\u{ACD}ક", Default::default());
t.para.composer = c;
t.kind = TextKind::Point;
let id = d.alloc_id();
d.insert(None, usize::MAX, Node::new(id, NodeKind::Text(Box::new(t)))).unwrap();
d
};
for (c, written) in [
(Composer::SingleLine, Some("singleLine")),
(Composer::EveryLine, None),
(Composer::StandardSingleLine, Some("standardSingleLine")),
(Composer::StandardEveryLine, Some("standardEveryLine")),
] {
let bytes = save(&one(c), false);
let text = String::from_utf8_lossy(&bytes);
match written {
Some(w) => assert!(text.contains(&format!("\"composer\":\"{w}\"")), "{c:?}"),
None => assert!(!text.contains("\"composer\""), "{c:?}"),
}
let back = load(&bytes).unwrap();
let mut got = None;
back.walk(|n| {
if let NodeKind::Text(t) = &n.kind {
got = Some(t.para.composer);
}
});
assert_eq!(got, Some(c));
}
}
/// A document as the first version wrote it (format name `drawcraft`, anchors as maps).
const V1_FILE: &str = r#"{"format":"drawcraft","version":1,"generator":"DrawCraft 0.1.0","document":{"version":1,"title":"Old","artboards":[{"id":1,"name":"Artboard 1","rect":{"x0":0.0,"y0":0.0,"x1":100.0,"y1":80.0}}],
"layers":[{"id":1,"name":"Layer 1","visible":true,"locked":false,"opacity":1.0,"kind":{"type":"layer","children":[
+7 -1
View File
@@ -392,7 +392,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"type.lineComposer",
"Toggle Line Composer",
"Cmd+Alt+Shift+C",
"{} the selected type's paragraphs (or those the Type tool's selection touches) use the Single-line Composer when they all use the Every-line Composer, else the Every-line Composer (text.setFormat {composer}) → \"singleLine\" | \"everyLine\"",
"{} the selected type's paragraphs (or those the Type tool's selection touches) use the Single-line Composer when they all use the Every-line Composer, else the Every-line Composer; paragraphs that all use a Standard composer keep it, any other mix takes the Middle Eastern & South Asian one (text.setFormat {composer}) → \"singleLine\" | \"everyLine\" | \"standardSingleLine\" | \"standardEveryLine\"",
),
(
"type.hyphenate",
@@ -432,6 +432,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
),
("view.nextArtboard", "Next Artboard", "", "{} the navigator's Next Artboard button: view.goToArtboard {index: \"next\"} → {index}"),
("view.lastArtboard", "Last Artboard", "", "{} the navigator's Last Artboard button: view.goToArtboard {index: \"last\"} → {index}"),
(
"view.statusBarShow",
"Status Bar Show",
"",
"{show: \"artboardName\" | \"currentTool\" | \"dateTime\" | \"undos\" | \"colorProfile\"} the status bar's Show menu (a click on its info field): the field shows the name of the artboard the navigator shows, the tool in use (the default), the date and time (local on the desktop, UTC on the web), the active document's undo and redo step counts, or the profile its colors use (the one assigned for its color mode, else, or when that one is not available, that mode's working space); kept with the UI state; any other value is an error → show",
),
("view.edges", "Hide Edges", "Cmd+H", "{}"),
("view.artboards", "Hide Artboards", "Cmd+Shift+H", "{}"),
(
+5 -1
View File
@@ -859,7 +859,9 @@ impl Exporter<'_> {
/// Opens the blend mode and the transparency group `n` is drawn with (`container` when it is a
/// group or layer whose children `knockout` each other). Returns how many were opened, and
/// whether the children are to be drawn in an isolated group of their own: the knockout group of
/// an unclipped group's elements is its isolated group too.
/// an unclipped group's elements is its isolated group too. An opaque knockout group in Normal
/// mode that does not isolate opens no group: its elements are drawn on the art below it, in a
/// knockout group without `/I` when there are several.
fn transparency(s: &mut Surface, n: &Node, page: Rect, container: bool, knockout: bool) -> (usize, bool) {
let mut pushes = 0;
if n.blend != BlendMode::Normal {
@@ -876,6 +878,8 @@ fn transparency(s: &mut Surface, n: &Node, page: Rect, container: bool, knockout
} else if n.opacity < 1.0 {
s.push_opacity(norm(n.opacity));
pushes += 1;
} else if knockout && !n.isolate && n.blend == BlendMode::Normal {
// A knockout group that does not isolate: its elements start from the art below it.
} else if knockout && matches!(n.kind, NodeKind::Layer { clip: false, .. } | NodeKind::Group { clip: false, .. }) {
isolated_children = true;
} else {
+71
View File
@@ -151,6 +151,77 @@ fn a_knockout_group_is_written_as_one_pdf_knockout_group() {
}
}
/// A knockout group with nothing blending inside is drawn in an isolated group (`/I true`) only
/// when the group isolates, clipped or not, with opaque or translucent elements, and reads back
/// knocking out.
#[test]
fn a_knockout_group_without_blending_inside_is_isolated_only_when_it_isolates() {
for clip in [false, true] {
for opacity in [0.5, 1.0] {
for isolate in [false, true] {
let mut d = knockout_squares(3, false, isolate);
let g = d.layers[0].children().unwrap()[1].id;
let mut squares: Vec<_> = d.node(g).unwrap().children().unwrap().to_vec();
for s in &mut squares {
std::sync::Arc::make_mut(s).opacity = opacity;
}
if clip {
let c = Node::path(
d.alloc_id(),
shapes::rectangle(Rect::new(10.0, 10.0, 190.0, 190.0)),
Appearance::basic(Paint::None, Paint::None, 0.0),
);
squares.insert(0, std::sync::Arc::new(c));
}
d.node_mut(g).unwrap().kind = vectorcraft_doc::NodeKind::Group { children: squares, clip };
let case = format!("clip {clip}, opacity {opacity}, isolate {isolate}");
let t = text(&d);
assert_eq!(t.matches("/Ktrue").count(), 1, "{case}");
// Each translucent element is an isolated form with its opacity.
let elements = if opacity < 1.0 { 3 } else { 0 };
assert_eq!(t.matches("/Itrue").count(), elements + usize::from(isolate), "{case}");
let back = import(&export(&d, &PdfOptions::default()).unwrap()).unwrap_or_else(|e| panic!("{case}: {e}"));
let mut found = vec![];
back.walk(|n| {
if n.knockout == vectorcraft_doc::Knockout::On {
found.push(n.isolate);
}
});
assert_eq!(found, [false], "{case}");
}
}
}
}
/// 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`.
#[test]
fn an_overprinting_element_of_a_knockout_group_that_does_not_isolate_overprints_the_art_below() {
for isolate in [false, true] {
let mut d = knockout_squares(3, false, isolate);
let g = d.layers[0].children().unwrap()[1].id;
let squares: Vec<_> = d.node(g).unwrap().children().unwrap().iter().map(|s| s.id).collect();
for s in &squares {
d.node_mut(*s).unwrap().opacity = 1.0;
}
d.node_mut(squares[2]).unwrap().appearance.fill_mut().unwrap().overprint = true;
let t = text(&d);
assert_eq!(t.matches("/Ktrue").count(), 1, "isolate {isolate}");
assert_eq!(t.matches("/Itrue").count(), usize::from(isolate), "isolate {isolate}");
assert!(t.contains("/OPtrue/optrue/OPM1"), "isolate {isolate}");
let back = import(&export(&d, &PdfOptions::default()).unwrap()).unwrap_or_else(|e| panic!("isolate {isolate}: {e}"));
let mut overprints = vec![];
back.walk(|n| {
if let Some(f) = n.appearance.fill() {
overprints.push(f.overprint);
}
});
assert_eq!(overprints, [false, false, false, true], "isolate {isolate}");
assert_eq!(knockout_groups(&back), [3], "isolate {isolate}");
}
}
/// The knockout group of an isolated group is isolated too (`/I true` beside `/K true`), and the
/// group reads back as isolated and knocking out. (Each translucent element is a group of its own.)
#[test]
+6
View File
@@ -52,6 +52,10 @@ pub struct OtFeatures {
pub extra_values: [u16; EXTRA_FEATURES.len()],
/// The value `swsh=N` gives swashes ([`Self::swash`]), as [`Self::extra_values`] for `salt`.
pub swash_value: u16,
/// Set a complex script (Indic, Arabic, Hebrew) glyph by glyph as the font maps its
/// characters, with none of its layout tables: the Standard composers. Set per paragraph by
/// layout from the paragraph's composer, not by a style.
pub unshaped_complex: bool,
}
/// The largest value a `tag=N` feature takes: a font's glyph ids are 16 bits, so is an alternate's
@@ -94,6 +98,7 @@ impl Default for OtFeatures {
extra: 0,
extra_values: [0; EXTRA_FEATURES.len()],
swash_value: 0,
unshaped_complex: false,
}
}
}
@@ -167,6 +172,7 @@ impl OtFeatures {
extra: u32::MAX >> (32 - EXTRA_FEATURES.len()),
extra_values: [0; EXTRA_FEATURES.len()],
swash_value: 0,
unshaped_complex: false,
};
change(&mut off);
change(&mut on);
+4 -3
View File
@@ -78,10 +78,11 @@ fn joining(c: char) -> Joining {
}
/// Is the cluster of glyph `a` joined to the cluster of glyph `b` that follows it in `text`: both
/// right to left in one face, `a`'s last character other than a mark joining the letter after it,
/// and `b` starting with a letter that joins the one before it?
/// right to left in one face and set as joining letters (not by a Standard composer), `a`'s last
/// character other than a mark joining the letter after it, and `b` starting with a letter that
/// joins the one before it?
fn joined(text: &str, a: &SGlyph, b: &SGlyph) -> bool {
if a.face.id() != b.face.id() || a.level != b.level || !a.level.is_rtl() || a.byte + a.len != b.byte {
if a.face.id() != b.face.id() || a.level != b.level || !a.level.is_rtl() || a.byte + a.len != b.byte || !(a.cursive && b.cursive) {
return false;
}
let last = text.get(a.byte..a.byte + a.len).and_then(|s| s.chars().rev().find(|&c| joining(c) != Joining::Transparent));
+9 -5
View File
@@ -22,7 +22,7 @@ use crate::shape::{
Punct, SGlyph, Tcy, cap_x_heights, hyphen_glyph, is_cjk, mark_word_ends, no_line_end, no_line_start, punct, run_face, shape_range, shape_runs,
soft_line_start, style_metrics,
};
use crate::{Composer, FirstBaseline, InlineGlyph, LayoutOptions, LineInfo, ListMarker, OtFeatures, PositionedGlyph, TextLayout, VerticalAlign};
use crate::{FirstBaseline, InlineGlyph, LayoutOptions, LineInfo, ListMarker, OtFeatures, PositionedGlyph, TextLayout, VerticalAlign};
mod bidi;
mod breaking;
@@ -229,11 +229,14 @@ impl Ctx<'_> {
out
}
/// Shape paragraph `r` (its bidi resolution `bidi`).
fn shape_para(&self, r: Range<usize>, bidi: Option<&BidiInfo<'_>>) -> Vec<SGlyph> {
/// Shape paragraph `r` (its bidi resolution `bidi`, its attributes `para`). A Standard composer
/// sets a complex script glyph by glyph ([`OtFeatures::unshaped_complex`]).
fn shape_para(&self, r: Range<usize>, bidi: Option<&BidiInfo<'_>>, para: &ParaStyle) -> Vec<SGlyph> {
let mut v = Vec::with_capacity(r.len());
let levels = bidi.map_or(&[][..], |b| &b.levels);
shape_runs(self.db, self.text, r, &self.runs, &self.inlines, &self.faces, &self.opts.features, levels, &mut v);
let standard = !self.opts.composer.unwrap_or(para.composer).shapes_complex_scripts();
let feats = OtFeatures { unshaped_complex: standard, ..self.opts.features };
shape_runs(self.db, self.text, r, &self.runs, &self.inlines, &self.faces, &feats, levels, &mut v);
self.finish_shaping(&mut v, |g| self.style_at(g.byte));
v
}
@@ -373,7 +376,8 @@ impl Ctx<'_> {
// Only the glyph right after an upright glyph can continue its cluster.
let cluster = self.upright_cluster.take();
// Control characters (tabs) and soft hyphens draw nothing (fonts map them to .notdef).
let blank = g.is_soft_hyphen() || g.ch.is_control() || g.ch == '\u{2028}';
// Joiners and direction marks are format controls: no ink either, whatever glyph the font maps.
let blank = g.is_soft_hyphen() || g.ch.is_control() || g.ch == '\u{2028}' || crate::justify::is_format_control(g.ch);
// A colour glyph draws its art (COLR layers, an SVG document) or its image (a bitmap, or
// COLR paints documents have no form for), not its outline; COLR, then SVG, then bitmaps.
// Art in the text's colours takes the run's fill (black when it isn't a colour) and
+6 -6
View File
@@ -8,9 +8,9 @@ use super::vertical::{
EM_CENTER, MojikumiRules, align_shift, compress_punctuation, dot_quarter, glyph_em, halve_punctuation, punct_half, space_japanese_and_latin,
};
use super::{
Affine, BidiInfo, Burasagari, CharStyle, Composer, Ctx, EPS, Flex, Justify, Kinsoku, KinsokuShoriType, LeadingModel, LineFit, LineInfo,
ListMarker, ParaStyle, Params, Point, Punct, Range, SGlyph, SingleWordJustify, TextObject, apply_desired, cap_x_heights, compose, fit_line,
hyphen_glyph, is_cjk, is_word_space, kashida, mark_word_ends, no_line_end, no_line_start, style_metrics,
Affine, BidiInfo, Burasagari, CharStyle, Ctx, EPS, Flex, Justify, Kinsoku, KinsokuShoriType, LeadingModel, LineFit, LineInfo, ListMarker,
ParaStyle, Params, Point, Punct, Range, SGlyph, SingleWordJustify, TextObject, apply_desired, cap_x_heights, compose, fit_line, hyphen_glyph,
is_cjk, is_word_space, kashida, mark_word_ends, no_line_end, no_line_start, style_metrics,
};
use crate::justify::is_format_control;
use crate::shape::{keep_inseparable_pairs, keep_korean_words};
@@ -62,7 +62,7 @@ fn compose_para(
// The tab of a list marker is on the first line, with the marker, and has a fixed width.
let has_tab = sg.iter().any(|g| g.ch == '\t' && g.len > 0);
let has_soft_break = sg.iter().any(|g| g.ch == '\u{2028}');
if composer != Composer::EveryLine
if composer.is_single_line()
|| pen.regions.is_none()
|| sg.len() < 2
|| sg.len() > MAX_COMPOSE_GLYPHS
@@ -247,7 +247,7 @@ fn prepare_paragraph<'a, 'text>(
let text = cx.text;
let bidi = para_bidi_with(text.get(pr.clone()).unwrap_or_default(), para.direction, &cx.char_directions(&pr));
let rtl = is_rtl(bidi.as_ref());
let mut sg = cx.shape_para(pr.clone(), bidi.as_ref());
let mut sg = cx.shape_para(pr.clone(), bidi.as_ref(), para);
// Thai, Lao, Khmer and Myanmar break lines between words, not at spaces.
mark_word_ends(text.get(pr.clone()).unwrap_or_default(), pr.start, &mut sg);
// Korean breaks between words, unless Korean Line Break Anywhere lets it break between syllables.
@@ -321,7 +321,7 @@ fn prepare_paragraph<'a, 'text>(
let composed = compose_para(cx, &sg, &flex, &line_end, para, pen, rtl, continued);
// Hyphenation options: the Hyphenation Zone applies with the Single-line Composer, and the
// Hyphen Limit counts the lines in a row that end with a hyphen.
let zone = if cx.opts.composer.unwrap_or(para.composer) == Composer::SingleLine { para.hyphenation.zone } else { 0.0 };
let zone = if cx.opts.composer.unwrap_or(para.composer).is_single_line() { para.hyphenation.zone } else { 0.0 };
let hyphen_limit = usize::try_from(para.hyphenation.hyphen_limit).unwrap_or(usize::MAX);
let mirror = mirrors_indents(para, rtl, cx.vertical);
ParagraphData {
+1 -1
View File
@@ -422,7 +422,7 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
let text = cx.text;
let bidi = para_bidi_with(text.get(pr.clone()).unwrap_or_default(), para.direction, &cx.char_directions(pr));
rtl.get_or_insert(is_rtl(bidi.as_ref()) && !cx.vertical);
let mut glyphs = cx.shape_para(pr.clone(), bidi.as_ref());
let mut glyphs = cx.shape_para(pr.clone(), bidi.as_ref(), t.para_at(pi));
// Bullets and numbers: a list paragraph's text starts after its marker here too, unless
// the paragraph continues from the frame before in its thread.
if pi > 0 || !t.first_para_continues {
+39 -5
View File
@@ -128,6 +128,27 @@ pub(crate) fn joins(script: Script) -> bool {
)
}
/// Is `script` one a Standard composer leaves unshaped: Indic (conjuncts, half forms, marks placed
/// by the font's layout tables), the joining scripts ([`joins`]: Arabic, Syriac, N'Ko, Mongolian…)
/// and Hebrew?
fn is_complex_script(script: Script) -> bool {
joins(script)
|| matches!(
script,
Script::Hebrew
| Script::Devanagari
| Script::Bengali
| Script::Gurmukhi
| Script::Gujarati
| Script::Oriya
| Script::Tamil
| Script::Telugu
| Script::Kannada
| Script::Malayalam
| Script::Sinhala
)
}
/// How `vpal` and the vertical kerning with it move an upright glyph in vertical type and change
/// its length down the column, in points: `advance` down the column, `dx` and `dy` in glyph space
/// (y down; `dy` is down the column once the glyph stands upright). `proportional`: `vpal` itself
@@ -1394,7 +1415,13 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
let source_runs = &(source_runs.start + first..source_runs.start + last);
let text_seg = &text[range.clone()];
// The segment's script: that of its first character of a script of its own.
let cursive = text_seg.chars().map(|c| c.script()).find(|s| !matches!(s, Script::Common | Script::Inherited)).is_some_and(joins);
let first_script = text_seg.chars().map(|c| c.script()).find(|s| !matches!(s, Script::Common | Script::Inherited));
// A Standard composer sets a complex script glyph by glyph (no layout tables, nominal glyphs).
// shortcut: decided for the whole segment by its first strong script, as `cursive` is; segments
// already split where the script changes.
let unshaped = feats.unshaped_complex && first_script.is_some_and(is_complex_script);
// Unshaped letters don't join, so they are not bent along a path as joined ones are.
let cursive = first_script.is_some_and(joins) && !unshaped;
let full = st.size.max(0.0);
// Superscript/subscript and small capitals shrink the glyphs; line metrics keep the full size.
let (_, pos_shift) = st.position.scale_shift(full);
@@ -1475,7 +1502,7 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
.and_then(|l| l.parse::<harfrust::Language>().ok());
let mut shaped = Shaped::default();
let Shaped { raw, proportional, vpal, chars, unkerned } = &mut shaped;
let hb_shaped = face.hb().map(|hb| {
let hb_shaped = face.hb().filter(|_| !unshaped).map(|hb| {
let shaper = face.shaper.shaper(&hb).instance(face.instance.as_ref()).build();
// The baseline and character-level pass use exactly the same resolved features.
// Alternate positioning passes still resolve their own features, with `more` last.
@@ -1591,7 +1618,8 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
}
});
if hb_shaped.is_none() {
// Fallback: nominal glyphs and hmtx advances, no shaping.
// Fallback: nominal glyphs and hmtx advances, no shaping (also a complex script under a
// Standard composer).
if let Some(f) = face.skrifa() {
let cmap = f.charmap();
let gm = f.glyph_metrics(Size::unscaled(), face.location());
@@ -1600,8 +1628,14 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
let c = st.digits.map(c);
let chars: Vec<char> = if upper { c.to_uppercase().collect() } else { vec![c] };
for u in chars {
let g = cmap.map(u).unwrap_or_default();
let adv = gm.advance_width(g).unwrap_or(face.upem as f32 * 0.5);
// Format characters (joiners, direction marks) have no glyph of their own in most
// fonts, and the shaper hides them: draw the space's glyph with no advance.
let (g, adv) = if crate::justify::is_format_control(u) {
(cmap.map(' ').unwrap_or_default(), 0.0)
} else {
let g = cmap.map(u).unwrap_or_default();
(g, gm.advance_width(g).unwrap_or(face.upem as f32 * 0.5))
};
raw.push((g.to_u32(), cl, adv.round() as i32, 0, 0));
}
}
+5 -3
View File
@@ -534,7 +534,8 @@ pub fn half_form_font(half: bool) -> Option<Vec<u8>> {
pub const CONJUNCT_FAMILY: &str = "Conjuncttest Sans";
/// A test-only cmap over bundled Source Sans 3: Devanagari Ka uses K, the halant uses a period and
/// the vowel sign I (drawn before its syllable) uses i. The `GSUB` table's `dev2` script has an
/// the vowel sign I (drawn before its syllable) uses i; Gujarati Ka, virama and vowel sign I use the
/// same glyphs. The `GSUB` table's `dev2` and `gjr2` scripts have an
/// `aalt` single substitution of K by k and a `salt` one of K by i, which list k and the vowel
/// sign's glyph as alternates of Ka, and a `half` ligature of K and the period into k (Ka's half
/// form). Family [`CONJUNCT_FAMILY`]. `None` when it can't be built.
@@ -549,7 +550,7 @@ pub fn conjunct_font() -> Option<Vec<u8>> {
const BASE: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");
let font = skrifa::FontRef::new(BASE).ok()?;
let charmap = font.charmap();
let mapping = [('क', 'K'), ('\u{094D}', '.'), ('\u{093F}', 'i')];
let mapping = [('क', 'K'), ('\u{094D}', '.'), ('\u{093F}', 'i'), ('ક', 'K'), ('\u{0ACD}', '.'), ('\u{0ABF}', 'i')];
let mappings = mapping.into_iter().map(|(c, source)| Some((c, write_fonts::types::GlyphId::new(charmap.map(source)?.to_u32()))));
let cmap = Cmap::from_mappings(mappings.collect::<Option<Vec<_>>>()?).ok()?;
let family = CONJUNCT_FAMILY;
@@ -574,7 +575,8 @@ pub fn conjunct_font() -> Option<Vec<u8>> {
SubstitutionLookup::Ligature(Lookup::new(Default::default(), vec![half])),
SubstitutionLookup::Single(Lookup::new(Default::default(), vec![salt.into()])),
]);
let scripts = ScriptList::new(vec![ScriptRecord::new(Tag::new(b"dev2"), Script::new(Some(LangSys::new(vec![0, 1, 2])), vec![]))]);
let langsys = || Script::new(Some(LangSys::new(vec![0, 1, 2])), vec![]);
let scripts = ScriptList::new(vec![ScriptRecord::new(Tag::new(b"dev2"), langsys()), ScriptRecord::new(Tag::new(b"gjr2"), langsys())]);
builder.add_table(&Gsub::new(scripts, features, lookups)).ok()?;
for r in font.table_directory.table_records() {
let tag = Tag::new(&r.tag().to_be_bytes());
+1
View File
@@ -10,6 +10,7 @@ mod bidi;
mod bitmaps;
mod colr;
mod combos;
mod composers;
mod composite;
mod devanagari;
mod embed;
+113
View File
@@ -0,0 +1,113 @@
//! The four composers: the Middle Eastern & South Asian ones shape complex scripts with the font's
//! layout tables, the Standard ones set them glyph by glyph as the font maps their characters.
//! Uses a font built in code ([`conjunct_font`]): Ka K, halant a period and vowel sign I i, in
//! Devanagari and Gujarati, with a `half` ligature of K and the period into k.
use crate::test_fonts::{CONJUNCT_FAMILY, conjunct_font, source_sans_gid};
use crate::*;
use kurbo::Point;
use vectorcraft_doc::{CharStyle, Composer, TextObject};
/// Ka, halant, Ka, vowel sign I in Devanagari, then in Gujarati.
const DEVANAGARI: &str = "क\u{94D}क\u{93F}";
const GUJARATI: &str = "ક\u{ACD}ક\u{ABF}";
fn db() -> FontDb {
let db = FontDb::with_font_dirs(vec![]);
db.add_font(conjunct_font().expect("the test font builds"));
db
}
fn object(text: &str, composer: Composer) -> TextObject {
let st = CharStyle { font_family: CONJUNCT_FAMILY.into(), font_style: "Regular".into(), size: 20.0, ..CharStyle::default() };
let mut t = TextObject::point(Point::ZERO, text, st);
t.para.composer = composer;
t
}
/// The glyph ids drawn for `text` with `composer`, and each glyph's source cluster length.
fn drawn(db: &FontDb, text: &str, composer: Composer) -> Vec<(u32, usize)> {
layout(db, &object(text, composer)).glyphs.iter().map(|g| (g.gid, g.len)).collect()
}
fn g(c: char) -> u32 {
u32::from(source_sans_gid(c).expect("a Source Sans glyph"))
}
/// Under the ME&SA composers the conjunct forms (the vowel sign I drawn before its syllable and Ka's
/// half form, in Devanagari and in Gujarati); under the Standard ones each character
/// has its own glyph, in text order, as the font maps it.
#[test]
fn standard_composers_set_indic_text_glyph_by_glyph() {
let db = db();
let ids = |v: Vec<(u32, usize)>| v.into_iter().map(|(gid, _)| gid).collect::<Vec<_>>();
for composer in [Composer::SingleLine, Composer::EveryLine] {
assert_eq!(ids(drawn(&db, DEVANAGARI, composer)), [g('i'), g('k'), g('K')], "{composer:?} Devanagari");
assert_eq!(ids(drawn(&db, GUJARATI, composer)), [g('i'), g('k'), g('K')], "{composer:?} Gujarati");
}
for composer in [Composer::StandardSingleLine, Composer::StandardEveryLine] {
let plain = [g('K'), g('.'), g('K'), g('i')];
let devanagari = drawn(&db, DEVANAGARI, composer);
assert_eq!(ids(devanagari.clone()), plain, "{composer:?} Devanagari");
assert_eq!(ids(drawn(&db, GUJARATI, composer)), plain, "{composer:?} Gujarati");
assert!(devanagari.iter().all(|&(_, len)| len == 3), "each glyph is one character's own cluster: {devanagari:?}");
}
}
/// The composer is per paragraph: of two paragraphs of the same text, each is shaped by its own.
#[test]
fn each_paragraph_follows_its_own_composer() {
let db = db();
let mut t = object(&format!("{DEVANAGARI}\n{DEVANAGARI}"), Composer::EveryLine);
let standard = vectorcraft_doc::ParaStyle { composer: Composer::StandardEveryLine, ..t.para.clone() };
t.set_paragraph_styles(vec![t.para.clone(), standard]);
let l = layout(&db, &t);
let second = DEVANAGARI.len() + 1;
let of = |from: usize, to: usize| l.glyphs.iter().filter(|g| (from..to).contains(&g.byte) && g.len > 0).map(|g| g.gid).collect::<Vec<_>>();
assert_eq!(of(0, second), [g('i'), g('k'), g('K')], "ME&SA paragraph");
assert_eq!(of(second, second + DEVANAGARI.len()), [g('K'), g('.'), g('K'), g('i')], "Standard paragraph");
}
/// Layout's composer override ([`LayoutOptions::composer`]) decides the shaping too.
#[test]
fn the_layout_composer_override_decides_the_shaping() {
let db = db();
let t = object(DEVANAGARI, Composer::EveryLine);
let with = |c| layout_with(&db, &t, &LayoutOptions { composer: Some(c), ..Default::default() }).glyphs.len();
assert_eq!((with(Composer::SingleLine), with(Composer::StandardSingleLine)), (3, 4));
}
/// Standard composers break lines as the ME&SA ones do (`is_single_line`), and old files' composers
/// keep their meaning.
#[test]
fn composers_split_into_breaking_and_shaping() {
use Composer::*;
for (c, single, shapes) in
[(SingleLine, true, true), (EveryLine, false, true), (StandardSingleLine, true, false), (StandardEveryLine, false, false)]
{
assert_eq!((c.is_single_line(), c.shapes_complex_scripts()), (single, shapes), "{c:?}");
assert_eq!(c.with_breaking(single), c, "{c:?}");
assert_eq!(
(c.with_breaking(!single).is_single_line(), c.with_breaking(!single).shapes_complex_scripts()),
(!single, shapes),
"{c:?} toggled"
);
}
assert_eq!(Composer::default(), EveryLine, "new type and old documents are ME&SA Every-line");
}
/// A joiner or non-joiner has no glyph in most fonts and the shaper hides it; a Standard composer
/// draws it as no width at all, not as a missing-glyph box.
#[test]
fn standard_composers_give_format_characters_no_width() {
let db = db();
let text = "क\u{200C}क";
for composer in [Composer::StandardSingleLine, Composer::StandardEveryLine] {
let l = layout(&db, &object(text, composer));
let widths: Vec<f64> = l.glyphs.iter().map(|g| g.advance).collect();
assert_eq!(widths.len(), 3, "{composer:?}: {widths:?}");
assert_eq!(widths[1], 0.0, "{composer:?}: the non-joiner takes no room: {widths:?}");
assert!(widths[0] > 0.0 && widths[2] > 0.0, "{composer:?}: {widths:?}");
// The test font maps no space: the control must still draw nothing (not glyph 0's outline).
assert!(l.glyphs[1].outline.elements().is_empty(), "{composer:?}: the non-joiner has no ink");
}
}
+1 -1
View File
@@ -84,7 +84,7 @@ fn fills(paths: &[TracedPath]) -> Vec<TracedPath> {
continue;
}
if sp.closed && marks.iter().all(|&m| m) {
runs.push(SubPath::new(sp.anchors.clone(), true));
runs.push(sp.clone());
continue;
}
// Start after an unmarked segment, so that a run across the subpath's first anchor
+3
View File
@@ -54,6 +54,9 @@ log = { workspace = true }
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
craft-ui = { workspace = true, features = ["native-windows"] }
craft-update = { workspace = true }
# The local date and time the status bar's Date and Time readout shows (`chrono::Local`). Already in
# Cargo.lock with the time-zone crates `clock` uses.
chrono = { workspace = true, features = ["clock"] }
[target.'cfg(target_arch = "wasm32")'.dependencies]
# `now_ms` (src/lib.rs) reads the page's `performance.now()` with this crate in the web build. It is
+2 -2
View File
@@ -28,9 +28,9 @@ pub(crate) use control_bar::{Fit, group_separator, left_out, link_reserve};
#[cfg(test)]
use hints::hint_segments;
pub use hints::{hint_bar, hint_strings};
pub use status_bar::status_bar;
pub use status_bar::{StatusBarShow, deserialize_status_bar_show, set_status_bar_show, status_bar};
#[cfg(test)]
use status_bar::{StatusReadoutWidths, status_readouts};
use status_bar::{StatusReadoutWidths, color_profile_name, date_time_label, status_readouts};
#[cfg(test)]
use tabs::{CLOSE_BEFORE_TITLE, first_tab_shown, tab_drop, tab_groups, tab_title};
pub use tabs::{doc_tabs, isolation_bar, step_document};
+175 -11
View File
@@ -73,19 +73,37 @@ pub fn status_bar(app: &mut VectorcraftApp, ui: &mut Ui) {
app.status(e);
}
ui.separator();
let tool = vectorcraft_tools::tool_info(app.session.tool_id())
.map(|t| {
// The catalog keys carry the full label ("Selection Tool"); only English drops the suffix.
let shown = tl!(t.label);
if crate::i18n::current() == crate::i18n::Lang::EN { shown.trim_end_matches(" Tool") } else { shown }
})
.unwrap_or("");
// The tool name leaves the status message its least width and ends in an ellipsis first.
let (info, next) = info_text(app);
if let Some(secs) = next {
ui.ctx().request_repaint_after(std::time::Duration::from_secs(secs));
}
// The info field leaves the status message its least width and ends in an ellipsis first.
// An empty readout shows a dash, so the field can still be clicked.
let room = (ui.available_width() - MESSAGE_MIN - ui.spacing().item_spacing.x).max(0.0);
ui.scope(|ui| {
ui.set_max_width(room);
clipped_label(ui, egui::RichText::new(tool).size(11.5).color(t.text_dim));
let shown = if info.is_empty() { "–" } else { info.as_str() };
let field = ui
.scope(|ui| {
ui.set_max_width(room);
clipped_label(ui, egui::RichText::new(shown).size(11.5).color(t.text_dim))
})
.inner
.interact(Sense::click());
let mut pick = None;
egui::Popup::menu(&field).show(|ui| {
ui.menu_button(tl!("Show"), |ui| {
for show in StatusBarShow::ALL {
if widgets::menu_item_name(ui, show.label(), true, app.ui.status_bar_show == show) {
pick = Some(show);
ui.close();
}
}
});
});
if let Some(show) = pick
&& let Err(e) = app.run("view.statusBarShow", json!({ "show": show.param() }))
{
app.status(e);
}
status_readouts(app, ui, &t);
});
});
@@ -95,6 +113,152 @@ pub fn status_bar(app: &mut VectorcraftApp, ui: &mut Ui) {
/// The least width the status message keeps when the window is narrow.
const MESSAGE_MIN: f32 = 180.0;
/// What the status bar's info field shows, chosen from the Show menu that a click on the field
/// opens (`view.statusBarShow`). Kept with the UI state ([`crate::UiState::status_bar_show`]).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub enum StatusBarShow {
/// The name of the artboard the navigator shows.
ArtboardName,
/// The name of the tool in use.
#[default]
CurrentTool,
/// The date and time.
DateTime,
/// How many steps the active document can undo and redo.
Undos,
/// The profile the active document's colors use.
ColorProfile,
}
impl StatusBarShow {
/// Every choice, in the Show menu's order.
pub const ALL: [StatusBarShow; 5] =
[StatusBarShow::ArtboardName, StatusBarShow::CurrentTool, StatusBarShow::DateTime, StatusBarShow::Undos, StatusBarShow::ColorProfile];
/// The `show` param of `view.statusBarShow`.
pub fn param(self) -> &'static str {
match self {
StatusBarShow::ArtboardName => "artboardName",
StatusBarShow::CurrentTool => "currentTool",
StatusBarShow::DateTime => "dateTime",
StatusBarShow::Undos => "undos",
StatusBarShow::ColorProfile => "colorProfile",
}
}
/// The choice whose param is `param`.
pub fn from_param(param: &str) -> Option<StatusBarShow> {
StatusBarShow::ALL.into_iter().find(|s| s.param() == param)
}
/// The Show menu's label, in the interface language.
pub fn label(self) -> &'static str {
match self {
StatusBarShow::ArtboardName => tl!("Artboard Name"),
StatusBarShow::CurrentTool => tl!("Current Tool"),
StatusBarShow::DateTime => tl!("Date and Time"),
StatusBarShow::Undos => tl!("Number of Undos"),
StatusBarShow::ColorProfile => tl!("Document Color Profile"),
}
}
}
/// Serde reader for the saved choice ([`crate::UiState::status_bar_show`]): a value this version
/// does not know reads as Current Tool.
pub fn deserialize_status_bar_show<'de, D: serde::Deserializer<'de>>(d: D) -> Result<StatusBarShow, D::Error> {
let v = <serde_json::Value as serde::Deserialize>::deserialize(d)?;
Ok(v.as_str().and_then(StatusBarShow::from_param).unwrap_or_default())
}
/// `view.statusBarShow {show}`: the info field shows that readout from now on → the choice.
pub fn set_status_bar_show(app: &mut VectorcraftApp, p: &serde_json::Value) -> Result<serde_json::Value, String> {
let key = "show";
let Some(show) = p.get(key).and_then(serde_json::Value::as_str).and_then(StatusBarShow::from_param) else {
let all: Vec<&str> = StatusBarShow::ALL.iter().map(|s| s.param()).collect();
return Err(format!("`{key}` must be one of {}", all.join(", ")));
};
app.ui.status_bar_show = show;
Ok(json!(show.param()))
}
/// The info field's text for the choice in the Show menu, and for Date and Time the seconds until
/// the minute it shows ends (when the bar draws again).
pub(super) fn info_text(app: &VectorcraftApp) -> (String, Option<u64>) {
let st = app.session.active();
match app.ui.status_bar_show {
StatusBarShow::CurrentTool => {
let tool = vectorcraft_tools::tool_info(app.session.tool_id())
.map(|t| {
// The catalog keys carry the full label ("Selection Tool"); only English drops the suffix.
let shown = tl!(t.label);
if crate::i18n::current() == crate::i18n::Lang::EN { shown.trim_end_matches(" Tool") } else { shown }
})
.unwrap_or("");
(tool.to_string(), None)
}
StatusBarShow::ArtboardName => {
let name = st.and_then(|d| {
let n = d.doc.artboards.len();
d.doc.artboards.get(crate::panels::artboards::selected(app, n)).map(|a| a.name.clone())
});
(name.unwrap_or_default(), None)
}
StatusBarShow::DateTime => {
let (text, next) = date_time_now();
(text, Some(next))
}
StatusBarShow::Undos => {
let text = st.map(|d| format!("{}: {} {}: {}", tl!("Undos"), d.history.undo.len(), tl!("Redos"), d.history.redo.len()));
(text.unwrap_or_default(), None)
}
StatusBarShow::ColorProfile => (st.map(|d| color_profile_name(&d.doc)).unwrap_or_default(), None),
}
}
/// The profile `doc`'s colors use for its color mode, as the context it draws through has it
/// ([`vectorcraft_engine::cmd::colormgmt::doc_cms`]): the one assigned (Edit › Assign Profile), else
/// the working space of that mode (Edit › Color Settings), also when the assigned one is not
/// available.
pub(super) fn color_profile_name(doc: &vectorcraft_doc::Document) -> String {
let cms = vectorcraft_engine::cmd::colormgmt::doc_cms(doc);
let settings = cms.settings();
let name = match doc.color_mode {
vectorcraft_doc::ColorMode::Rgb => &settings.rgb,
vectorcraft_doc::ColorMode::Cmyk => &settings.cmyk,
};
vectorcraft_color::cms::canonical_name(name).to_string()
}
/// `[year, month, day, hour, minute, second]` as the info field shows it: `2026-11-15 14:03`.
pub(super) fn date_time_label([y, mo, d, h, mi, _]: [i64; 6]) -> String {
format!("{y:04}-{mo:02}-{d:02} {h:02}:{mi:02}")
}
/// The local date and time ([`date_time_label`]) and the seconds until the minute ends.
#[cfg(not(target_arch = "wasm32"))]
fn date_time_now() -> (String, u64) {
use chrono::{Datelike, Timelike};
let now = chrono::Local::now();
let parts = [
i64::from(now.year()),
i64::from(now.month()),
i64::from(now.day()),
i64::from(now.hour()),
i64::from(now.minute()),
i64::from(now.second()),
];
(date_time_label(parts), 60 - u64::from(now.second().min(59)))
}
/// The web build reads no time zone, so it shows the date and time in UTC.
#[cfg(target_arch = "wasm32")]
fn date_time_now() -> (String, u64) {
let secs = web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map_or(0, |d| d.as_secs());
let parts = vectorcraft_doc::metadata::civil(i64::try_from(secs).unwrap_or(i64::MAX));
(format!("{} UTC", date_time_label(parts)), 60 - u64::try_from(parts[5].clamp(0, 59)).unwrap_or(0))
}
/// A label that ends in an ellipsis when it is wider than the room left in `ui`. Only a cut label
/// shows its full text in a tooltip; screen readers always receive the full text.
pub(super) fn clipped_label(ui: &mut Ui, text: impl Into<egui::WidgetText>) -> egui::Response {
+149
View File
@@ -576,6 +576,155 @@ fn a_clipped_tool_name_shows_in_full_on_hover() {
}
}
/// The texts of one status bar frame after `events`, `dt` seconds after the last one.
fn status_after(app: &mut crate::VectorcraftApp, ctx: &egui::Context, dt: f64, events: Vec<egui::Event>) -> Vec<StatusText> {
let t = ctx.input(|i| i.time) + dt;
bar_frame(app, ctx, 1400.0, Some(t), events, super::status_bar).0
}
/// A press and release of the primary button at `pos`.
fn click_at(pos: egui::Pos2) -> Vec<egui::Event> {
let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
vec![egui::Event::PointerMoved(pos), button(true), button(false)]
}
/// The center of the first text that is `text`.
fn text_center(texts: &[StatusText], text: &str) -> egui::Pos2 {
let at = texts.iter().find(|t| t.text == text).unwrap_or_else(|| panic!("no {text:?} in {texts:?}"));
at.clip.intersect(at.bounds).center()
}
/// The status bar's info field shows the readout `view.statusBarShow` chooses: the navigator's
/// artboard name, the tool in use, the date and time, the undo and redo counts, or the document's
/// color profile.
#[test]
fn the_status_bar_info_field_shows_the_chosen_readout() {
let (mut app, ctx) = status_readout_app();
let texts = status_after(&mut app, &ctx, 0.1, vec![]);
assert!(texts.iter().any(|t| t.text == "Selection"), "Current Tool by default: {texts:?}");
app.run("artboard.new", json!({"x": 200, "y": 0, "width": 100, "height": 100, "name": "Back Cover"})).unwrap();
app.run("view.statusBarShow", json!({"show": "artboardName"})).unwrap();
let first = app.session.active().unwrap().doc.artboards[0].name.clone();
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == first), "the first artboard's name");
app.run("view.goToArtboard", json!({"index": 1})).unwrap();
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == "Back Cover"), "the navigator's artboard");
app.run("view.statusBarShow", json!({"show": "undos"})).unwrap();
let counts = |app: &crate::VectorcraftApp| {
let h = &app.session.active().unwrap().history;
format!("Undos: {} Redos: {}", h.undo.len(), h.redo.len())
};
let before = app.session.active().unwrap().history.undo.len();
app.session.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
assert_eq!(counts(&app), format!("Undos: {} Redos: 0", before + 1));
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == counts(&app)));
app.run("edit.undo", json!({})).unwrap();
assert_eq!(counts(&app), format!("Undos: {before} Redos: 1"));
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == counts(&app)), "the redo step counts");
app.run("view.statusBarShow", json!({"show": "colorProfile"})).unwrap();
let working = vectorcraft_color::cms::working_settings();
let mode_working = |app: &crate::VectorcraftApp| match app.session.active().unwrap().doc.color_mode {
vectorcraft_doc::ColorMode::Rgb => working.rgb.clone(),
vectorcraft_doc::ColorMode::Cmyk => working.cmyk.clone(),
};
let untagged = vectorcraft_color::cms::canonical_name(&mode_working(&app)).to_string();
assert_eq!(super::color_profile_name(&app.session.active().unwrap().doc), untagged, "untagged: the working space");
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == untagged));
// A profile assigned for the document's color mode shows; one that is not available shows the
// working space the document draws through.
let (key, assigned) = match app.session.active().unwrap().doc.color_mode {
vectorcraft_doc::ColorMode::Rgb => ("rgb", vectorcraft_color::cms::PROPHOTO_RGB),
vectorcraft_doc::ColorMode::Cmyk => ("cmyk", vectorcraft_color::cms::DEVICE_CMYK),
};
app.run("edit.assignProfile", json!({ key: assigned })).unwrap();
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == assigned), "the assigned profile");
let st = app.session.active_mut().unwrap();
std::sync::Arc::make_mut(&mut st.doc).color_profiles =
vectorcraft_doc::ColorProfiles { rgb: Some("Not Installed".into()), cmyk: Some("Not Installed".into()) };
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == untagged), "an unavailable profile: the working space");
app.run("view.statusBarShow", json!({"show": "dateTime"})).unwrap();
let texts = status_after(&mut app, &ctx, 0.1, vec![]);
let is_date = |s: &str| {
let b = s.as_bytes();
b.len() == 16
&& b.iter().enumerate().all(|(i, c)| match i {
4 | 7 => *c == b'-',
10 => *c == b' ',
13 => *c == b':',
_ => c.is_ascii_digit(),
})
};
assert!(texts.iter().any(|t| is_date(&t.text)), "a date and time: {texts:?}");
assert_eq!(super::date_time_label([2026, 3, 7, 9, 5, 59]), "2026-03-07 09:05");
// Without a document the field shows a dash, which can still be clicked.
app.run("view.statusBarShow", json!({"show": "undos"})).unwrap();
while app.session.active().is_some() {
app.session.execute("file.close", &json!({})).unwrap();
}
assert!(status_after(&mut app, &ctx, 0.1, vec![]).iter().any(|t| t.text == "–"));
}
/// A click on the info field opens its Show menu, which checks the readout shown and changes it.
#[test]
fn a_click_on_the_info_field_opens_the_show_menu() {
let (mut app, ctx) = status_readout_app();
status_after(&mut app, &ctx, 1.0, vec![egui::Event::PointerGone]);
let texts = status_after(&mut app, &ctx, 0.1, vec![]);
let field = text_center(&texts, "Selection");
status_after(&mut app, &ctx, 0.1, click_at(field));
let texts = status_after(&mut app, &ctx, 0.1, vec![]);
let show = text_center(&texts, "Show");
status_after(&mut app, &ctx, 0.1, vec![egui::Event::PointerMoved(show)]);
status_after(&mut app, &ctx, 0.5, vec![]);
let texts = status_after(&mut app, &ctx, 0.5, vec![]);
for label in [" Artboard Name", "✓ Current Tool", " Date and Time", " Number of Undos", " Document Color Profile"] {
assert!(texts.iter().any(|t| t.text == label), "no {label:?} in {texts:?}");
}
let undos = text_center(&texts, " Number of Undos");
status_after(&mut app, &ctx, 0.1, vec![egui::Event::PointerMoved(egui::pos2(undos.x, show.y)), egui::Event::PointerMoved(undos)]);
status_after(&mut app, &ctx, 0.1, click_at(undos));
assert_eq!(app.ui.status_bar_show, super::StatusBarShow::Undos);
assert_eq!(crate::menus::checked(&app, "view.statusBarShow", &json!({"show": "undos"})), Some(true));
assert_eq!(crate::menus::checked(&app, "view.statusBarShow", &json!({"show": "currentTool"})), Some(false));
}
/// `view.statusBarShow` takes only the five readouts, leaving the choice as it was otherwise, and the
/// choice is saved with the UI state, which reads a value it does not know as Current Tool.
#[test]
fn the_status_bar_show_choice_is_checked_and_saved() {
let (mut app, _ctx) = status_readout_app();
assert_eq!(app.run("view.statusBarShow", json!({"show": "dateTime"})).unwrap(), json!("dateTime"));
for bad in [json!({}), json!({"show": "zoom"}), json!({"show": 2}), json!({"show": null}), json!({"show": "DateTime"})] {
let err = app.run("view.statusBarShow", bad.clone()).unwrap_err();
assert!(err.contains("`show` must be one of artboardName, currentTool, dateTime, undos, colorProfile"), "{bad}: {err}");
assert_eq!(app.ui.status_bar_show, super::StatusBarShow::DateTime, "{bad} leaves the choice");
}
let saved = serde_json::to_value(&app.ui).unwrap();
assert_eq!(saved["status_bar_show"], json!("dateTime"));
let read: crate::state::UiState = serde_json::from_value(saved.clone()).unwrap();
assert_eq!(read.status_bar_show, super::StatusBarShow::DateTime);
for (stored, shown) in [
(json!("colorProfile"), super::StatusBarShow::ColorProfile),
(json!("zoom"), super::StatusBarShow::CurrentTool),
(json!(7), super::StatusBarShow::CurrentTool),
] {
let mut v = saved.clone();
v["status_bar_show"] = stored;
assert_eq!(serde_json::from_value::<crate::state::UiState>(v).unwrap().status_bar_show, shown);
}
let mut v = saved;
v.as_object_mut().unwrap().remove("status_bar_show");
assert_eq!(
serde_json::from_value::<crate::state::UiState>(v).unwrap().status_bar_show,
super::StatusBarShow::CurrentTool,
"state saved before it"
);
}
/// Busy-job transitions preserve message placement, labels and accessibility.
#[test]
fn background_activity_keeps_the_status_message_origin() {
+2
View File
@@ -97,6 +97,7 @@ pub mod plugin;
mod png_options;
pub mod print;
pub mod print_presets;
pub mod psd_import;
mod psd_options;
pub mod raster_effects;
pub mod rearrange_artboards;
@@ -417,6 +418,7 @@ registry! {
PluginStopped: [safe_mode::STOPPED] => safe_mode::STOPPED_SPEC,
SafeMode: [safe_mode::KIND] => safe_mode::SPEC,
DxfImport: [dxf_import::KIND] => dxf_import::SPEC,
PsdImport: [psd_import::KIND] => psd_import::SPEC,
RasterFormatOptions: ["tiffOptions", "bmpOptions", "tgaOptions"] => png_options::SPEC,
SaveForWeb: [save_for_web::KIND] => save_for_web::SPEC,
PsdOptions: ["psdOptions"] => png_options::SPEC,
@@ -361,7 +361,12 @@ pub(crate) fn edited_attrs(d: &Dialog) -> Result<Map<String, Value>, String> {
}
let same = unchanged("composer", "__resetComposition");
keep_or(&mut attrs, "composer", same, choice("composer").filter(|v| matches!(v.as_str(), Some("singleLine" | "everyLine"))));
keep_or(
&mut attrs,
"composer",
same,
choice("composer").filter(|v| matches!(v.as_str(), Some("singleLine" | "everyLine" | "standardSingleLine" | "standardEveryLine"))),
);
let same = unchanged("roman_hanging", "__resetComposition");
keep_or(&mut attrs, "roman_hanging", same, switch("roman_hanging"));
@@ -637,7 +642,9 @@ fn choice(ui: &mut egui::Ui, d: &mut Dialog, key: &str, options: &[(&str, &str)]
let shown = options.iter().find(|(value, _)| *value == selected).map_or("", |(_, label)| *label);
let labels: Vec<&str> = std::iter::once(" ").chain(options.iter().map(|(_, label)| *label)).collect();
ui.add_enabled_ui(enabled, |ui| {
if let Some(i) = crate::widgets::dropdown(ui, (KIND, key), shown, &labels, 190.0) {
// shortcut: 7 pt per character approximates the widest label; measure the text when a label wraps.
let width = (labels.iter().map(|l| l.chars().count()).max().unwrap_or(0) as f32 * 7.0).max(190.0);
if let Some(i) = crate::widgets::dropdown(ui, (KIND, key), shown, &labels, width) {
d.fields.insert(key.into(), if i == 0 { Value::Null } else { options.get(i - 1).map_or(Value::Null, |(value, _)| json!(value)) });
}
});
@@ -842,11 +849,16 @@ pub(crate) fn clear_tabs(d: &mut Dialog) {
d.fields.remove("__tabEdited");
}
/// Composition: the Single-line or Every-line Composer, and Roman Hanging Punctuation.
/// Composition: the Middle Eastern & South Asian or Standard, Single-line or Every-line Composer, and Roman Hanging Punctuation.
pub(crate) fn composition_body(ui: &mut egui::Ui, d: &mut Dialog) {
egui::Grid::new("paragraph-style-composition").num_columns(2).spacing([18.0, 8.0]).show(ui, |ui| {
let row = ui.label(tl!("Composition"));
let composers = [("singleLine", tl!("Single-line Composer")), ("everyLine", tl!("Every-line Composer"))];
let composers = [
("singleLine", tl!("Middle Eastern & South Asian Single-line Composer")),
("everyLine", tl!("Middle Eastern & South Asian Every-line Composer")),
("standardSingleLine", tl!("Standard Single-line Composer")),
("standardEveryLine", tl!("Standard Every-line Composer")),
];
ui.label_inputs_by(row.id, |ui| choice(ui, d, "composer", &composers, true));
ui.end_row();
switch(ui, d, "roman_hanging", tl!("Roman Hanging Punctuation"), true);
@@ -857,7 +869,7 @@ pub(crate) fn composition_body(ui: &mut egui::Ui, d: &mut Dialog) {
/// unset; Hyphenation Zone is also inactive with the Every-line Composer, which does not use it.
pub(crate) fn hyphenation_body(ui: &mut egui::Ui, d: &mut Dialog) {
let on = d.fields.get("hyphenate").and_then(Value::as_bool) == Some(true);
let single_line = d.fields.get("composer").and_then(Value::as_str) == Some("singleLine");
let single_line = matches!(d.fields.get("composer").and_then(Value::as_str), Some("singleLine" | "standardSingleLine"));
egui::Grid::new("paragraph-style-hyphenation").num_columns(2).spacing([18.0, 8.0]).show(ui, |ui| {
switch(ui, d, "hyphenate", tl!("Hyphenation"), true);
for (key, suffix) in [
+585
View File
@@ -0,0 +1,585 @@
//! PSD Import Options: opening a PSD or PSB file with two or more layers or with slices, or
//! placing one without Link, asks whether its layers become objects or one flat image, whether
//! hidden layers come in, and whether its slices come in (Import Slices, offered only for a file
//! with slices)
//! (<https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html>).
//! A linked file shows its flat image, so placing with Link doesn't ask. The two-layer threshold,
//! the starting choices, Import Slices applying to both conversions and remembering the choices
//! are VectorCraft's own.
//!
//! Fields: `mode` (`open` | `place`), `name`, `path?`, `width`, `height` (the canvas, px),
//! `layers`, `hidden` and `slices` (counts, from `document.psdInfo`), `convert` (`objects` |
//! `flatten`), `hiddenLayers` and `importSlices`. `__place` keeps the other `file.place` params.
//! The file's bytes stay in [`crate::state::UiState::dialog_file`]. OK opens or places the file
//! with `layers`, `hiddenLayers` and (for a file with slices) `importSlices`, and remembers the
//! choices for the next file; errors keep the dialog open.
use serde_json::{Value, json};
use vectorcraft_engine::cmd::fileio;
use super::DialogSpec;
use super::import_pdf::{DialogFile, other_place_params, place_source, with_file};
use crate::state::Dialog;
use crate::{VectorcraftApp, io, widgets};
pub const KIND: &str = "psdImport";
pub(super) const SPEC: DialogSpec = DialogSpec {
heading: |d| if d.str("mode") == "place" { tl!("Place PSD") } else { tl!("PSD Import Options") }.into(),
body,
confirm,
min_width: 380.0,
..DialogSpec::FORM
};
/// The fewest layers a file has for the dialog to ask.
const MIN_LAYERS: usize = 2;
/// Open `bytes` (or place them with the `file.place` params `place`) through the dialog when they
/// are a PSD or PSB file with [`MIN_LAYERS`] layers or more, or with slices; false when they aren't
/// (the loader then opens or places the file, or says why it can't).
pub fn offer(app: &mut VectorcraftApp, name: &str, bytes: &[u8], path: Option<String>, place: Option<&Value>) -> bool {
let Ok(info) = fileio::psd_info(bytes) else { return false };
if info.layers < MIN_LAYERS && info.slices == 0 {
return false;
}
app.ui.dialog_file = Some(DialogFile::new(bytes.to_vec()));
let (layers, hidden, slices) = last_choices(app);
let mut fields = json!({
"mode": if place.is_some() { "place" } else { "open" },
"name": name,
"width": info.width,
"height": info.height,
"layers": info.layers,
"hidden": info.hidden,
"slices": info.slices,
"convert": if layers { "objects" } else { "flatten" },
"hiddenLayers": hidden,
"importSlices": slices,
});
if let Some(p) = path {
fields["path"] = json!(p);
}
if let Some(p) = place {
fields["__place"] = other_place_params(p, &["layers", "hiddenLayers", "importSlices"]);
}
app.ui.dialog = Some(Dialog::new(KIND, fields));
true
}
/// `file.place` with params `p` asks first (true) when they embed a PSD or PSB file (`link: false`,
/// or the file's bytes) and give no `layers`.
pub fn offer_place(app: &mut VectorcraftApp, p: &Value) -> bool {
let embedded = p.get("path").is_none() || p.get("link").and_then(Value::as_bool) == Some(false);
if !embedded || p.get("layers").is_some() {
return false;
}
let Some((name, bytes, path)) = place_source(app, p, |ext| matches!(ext, "psd" | "pdd" | "psb")) else { return false };
offer(app, &name, &bytes, path, Some(p))
}
/// The PSD Import Options chosen last (layers, hidden layers, slices), at first Convert Layers to
/// Objects without hidden layers, with Import Slices.
fn last_choices(app: &VectorcraftApp) -> (bool, bool, bool) {
let last = |k: &str, default: bool| app.ui.psd_import.get(k).and_then(Value::as_bool).unwrap_or(default);
(last("layers", true), last("hiddenLayers", false), last("importSlices", true))
}
/// Several files placed without Link load the place cursor without asking: the `file.place.queue`
/// params `q` take the PSD Import Options chosen last, which apply to each PSD or PSB file among them.
pub fn queue_options(app: &VectorcraftApp, q: &mut Value) {
let (layers, hidden, slices) = last_choices(app);
q["layers"] = json!(layers);
if layers && hidden {
q["hiddenLayers"] = json!(true);
}
q["importSlices"] = json!(slices);
}
/// `file.place` params `p` placed without asking (Show Import Options off) that embed a PSD or PSB
/// file and give no `layers` take the PSD Import Options chosen last; `hiddenLayers` and
/// `importSlices` that the params give are kept.
pub fn last_options(app: &VectorcraftApp, p: &mut Value) {
let embedded = p.get("path").is_none() || p.get("link").and_then(Value::as_bool) == Some(false);
let name = p.get("path").or_else(|| p.get("name")).and_then(Value::as_str).unwrap_or_default();
if embedded && p.get("layers").is_none() && matches!(fileio::extension(name).as_str(), "psd" | "pdd" | "psb") {
let (layers, hidden, slices) = last_choices(app);
p["layers"] = json!(layers);
if layers && hidden && p.get("hiddenLayers").is_none() {
p["hiddenLayers"] = json!(true);
}
if p.get("importSlices").is_none() {
p["importSlices"] = json!(slices);
}
if p.get("path").is_none() {
// A file from bytes has no file to link to; it may carry the Place dialog's Link.
p["link"] = json!(false);
}
}
}
/// OK: open or place the file with the choices.
fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
let file = app.ui.dialog_file.clone().ok_or("the file is no longer loaded")?;
let layers = d.str("convert") != "flatten";
let hidden = layers && d.bool("hiddenLayers");
// Import Slices is a choice only for a file with slices; otherwise the one made last stays.
let has_slices = d.fields.get("slices").and_then(Value::as_u64).unwrap_or(0) > 0;
let slices = if has_slices { d.bool("importSlices") } else { last_choices(app).2 };
app.ui.psd_import = json!({ "layers": layers, "hiddenLayers": d.bool("hiddenLayers"), "importSlices": slices });
let r = if d.str("mode") == "place" {
let mut p = with_file(d.fields.get("__place"), d, &file);
p["layers"] = json!(layers);
if layers || has_slices {
// Layers and slices are always embedded; a file from bytes may carry the Place dialog's
// Link.
p["link"] = json!(false);
}
if hidden {
p["hiddenLayers"] = json!(true);
}
if has_slices {
p["importSlices"] = json!(slices);
}
crate::place::run_for_user(app, &p).map(|_| ())
} else {
let path = d.fields.get("path").and_then(Value::as_str).map(str::to_string);
let mut p = json!({ "layers": layers, "hiddenLayers": hidden });
if has_slices {
p["importSlices"] = json!(slices);
}
io::open_document(app, &d.str("name"), &file.bytes, path, &p).map(|_| ())
};
match r {
Ok(()) => {
// Placing may have opened another dialog; only this one closes.
if app.ui.dialog.as_ref().is_some_and(|x| x.kind == KIND) {
app.ui.dialog = None;
}
Ok(Value::Null)
}
Err(e) => {
app.ui.dialog = Some(d.clone());
Err(e)
}
}
}
fn body(_: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
let count = |k: &str| d.fields.get(k).and_then(Value::as_u64).unwrap_or(0);
widgets::dim_label(ui, &format!("{} × {} px · {}: {}", count("width"), count("height"), tl!("Layers"), count("layers")));
// Offered only for a file with slices, with either conversion.
let sliced = count("slices") > 0;
ui.add_space(8.0);
let convert = d.str("convert") != "flatten";
if widgets::radio(ui, tl!("Convert Layers to Objects"), convert, true) {
d.fields.insert("convert".into(), json!("objects"));
}
ui.horizontal(|ui| {
ui.add_space(22.0);
let on = d.bool("hiddenLayers");
if widgets::check(ui, tl!("Import Hidden Layers"), on && convert, convert) {
d.fields.insert("hiddenLayers".into(), json!(!on));
}
});
if widgets::radio(ui, tl!("Flatten Layers to a Single Image"), !convert, true) {
d.fields.insert("convert".into(), json!("flatten"));
}
ui.add_space(8.0);
let on = d.bool("importSlices");
if widgets::check(ui, tl!("Import Slices"), on && sliced, sliced) {
d.fields.insert("importSlices".into(), json!(!on));
}
false
}
#[cfg(test)]
mod tests {
use vectorcraft_engine::Session;
use vectorcraft_engine::doc::NodeKind;
use super::*;
/// A PSD file of three layers, the middle one hidden, written by `document.export`.
fn layered() -> Vec<u8> {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 20, "height": 20})).unwrap();
let back = s.doc().unwrap().doc.layers[0].id.0;
s.execute("layer.setProps", &json!({"id": back, "name": "Back"})).unwrap();
for (name, color) in [("Back", "#ff0000"), ("Middle", "#00ff00"), ("Front", "#0000ff")] {
if name != "Back" {
s.execute("layer.new", &json!({ "name": name })).unwrap();
}
s.execute("paint.setFill", &json!({ "color": color })).unwrap();
s.execute("shape.rectangle", &json!({"x": 2, "y": 2, "width": 10, "height": 10})).unwrap();
}
let middle = s.doc().unwrap().doc.layers[1].id.0;
s.execute("layer.setProps", &json!({"id": middle, "visible": false})).unwrap();
let r = s.execute("document.export", &json!({"format": "psd", "hiddenLayers": true})).unwrap();
vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
}
fn app() -> VectorcraftApp {
VectorcraftApp::new(Session::new(), Default::default())
}
fn frame(app: &mut VectorcraftApp) -> String {
crate::tests_labels::painted_text(app, |app, ui| super::super::show(app, ui.ctx()))
}
fn set(app: &mut VectorcraftApp, k: &str, v: Value) {
app.ui.dialog.as_mut().unwrap().fields.insert(k.into(), v);
}
fn layer_names(app: &VectorcraftApp) -> Vec<(String, bool)> {
app.session.doc().unwrap().doc.layers.iter().map(|l| (l.name.clone().unwrap_or_default(), l.visible)).collect()
}
#[test]
fn opening_a_layered_file_asks_for_the_import_options() {
let psd = layered();
let mut app = app();
io::open_bytes(&mut app, "poster.psd", &psd, None).unwrap();
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), d.str("mode"), d.str("convert"), d.bool("hiddenLayers")), (KIND, "open".into(), "objects".into(), false));
assert_eq!((&d.fields["layers"], &d.fields["hidden"], &d.fields["width"]), (&json!(3), &json!(1), &json!(20)));
assert!(app.session.active().is_none(), "nothing opens before OK");
let text = frame(&mut app);
for label in [
"PSD Import Options",
"20 × 20 px",
"Layers: 3",
"Convert Layers to Objects",
"Import Hidden Layers",
"Flatten Layers to a Single Image",
"OK",
] {
assert!(text.contains(label), "{label} in {text}");
}
// Layers as objects, hidden ones left out.
super::super::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
assert_eq!(layer_names(&app), [("Back".to_string(), true), ("Front".to_string(), true)]);
// With Import Hidden Layers the hidden layer comes in hidden.
io::open_bytes(&mut app, "poster.psd", &psd, None).unwrap();
set(&mut app, "hiddenLayers", json!(true));
frame(&mut app);
super::super::confirm(&mut app).unwrap();
assert_eq!(layer_names(&app), [("Back".to_string(), true), ("Middle".to_string(), false), ("Front".to_string(), true)]);
// Flatten opens one image, and the next file starts from the choices made last.
io::open_bytes(&mut app, "poster.psd", &psd, None).unwrap();
assert!(app.ui.dialog.as_ref().unwrap().bool("hiddenLayers"), "remembered");
set(&mut app, "convert", json!("flatten"));
frame(&mut app);
super::super::confirm(&mut app).unwrap();
let st = app.session.doc().unwrap();
assert_eq!(st.doc.layers.len(), 1);
assert!(matches!(st.doc.layers[0].children().map(Vec::as_slice), Some([one]) if matches!(one.kind, NodeKind::Image(_))));
io::open_bytes(&mut app, "poster.psd", &psd, None).unwrap();
assert_eq!(app.ui.dialog.as_ref().unwrap().str("convert"), "flatten");
}
#[test]
fn files_with_fewer_than_two_layers_open_without_asking() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 20, "height": 20})).unwrap();
s.execute("shape.rectangle", &json!({"x": 2, "y": 2, "width": 10, "height": 10})).unwrap();
let one = s.execute("document.export", &json!({"format": "psd"})).unwrap();
let flat = s.execute("document.export", &json!({"format": "psd", "layers": false})).unwrap();
for r in [one, flat] {
let bytes = vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap();
let mut app = app();
io::open_bytes(&mut app, "one.psd", &bytes, None).unwrap();
assert!(app.ui.dialog.is_none());
assert!(app.session.active().is_some());
}
}
#[test]
fn placing_without_link_asks_and_places_the_layers_as_a_group() {
let b64 = vectorcraft_format::base64_encode(&layered());
let mut app = app();
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
let r = crate::place::run_for_user(&mut app, &json!({"name": "poster.psd", "dataBase64": b64, "at": [50, 50]})).unwrap();
assert_eq!(r["dialog"], KIND);
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.str("mode"), &d.fields["__place"]), ("place".into(), &json!({"at": [50, 50]})));
assert!(frame(&mut app).contains("Place PSD"));
super::super::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
let st = app.session.doc().unwrap();
let [id] = st.selection.objects[..] else { panic!("one object is selected") };
let g = st.doc.node(id).unwrap();
assert!(matches!(g.kind, NodeKind::Group { .. }));
let names: Vec<&str> = g.children().unwrap().iter().filter_map(|c| c.name.as_deref()).collect();
assert_eq!(names, ["Back", "Front"]);
// Flatten places the merged image.
crate::place::run_for_user(&mut app, &json!({"name": "poster.psd", "dataBase64": b64})).unwrap();
set(&mut app, "convert", json!("flatten"));
super::super::confirm(&mut app).unwrap();
let st = app.session.doc().unwrap();
let [id] = st.selection.objects[..] else { panic!("one object is selected") };
assert!(matches!(st.doc.node(id).unwrap().kind, NodeKind::Image(_)));
}
#[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()));
std::fs::create_dir_all(&dir).unwrap();
let paths: Vec<String> = ["a.psd", "b.psd"]
.iter()
.map(|n| {
let p = dir.join(n);
std::fs::write(&p, layered()).unwrap();
p.to_string_lossy().into_owned()
})
.collect();
// Place both through the Place dialog, then click the cursor once for each: what was placed.
let place_two = |app: &mut VectorcraftApp, link: bool| -> Vec<vectorcraft_engine::doc::Node> {
let files: Vec<Value> = paths.iter().map(|p| json!({ "path": p })).collect();
let d = Dialog::new(crate::dialogs::place::KIND, json!({"files": files, "link": link, "template": false}));
crate::place::confirm(app, &d).unwrap();
assert!(app.ui.dialog.is_none(), "the cursor loads without asking");
let view = vectorcraft_engine::ViewInfo::default();
(0..2)
.map(|_| {
for kind in [vectorcraft_tools::PointerKind::Down, vectorcraft_tools::PointerKind::Up] {
for r in app.session.pointer(&vectorcraft_tools::PointerEvent::new(kind, 10.0, 10.0), view).unwrap() {
if let vectorcraft_engine::UiRequest::Place(p) = r {
crate::place::place_from_cursor(app, &p);
}
}
}
let st = app.session.doc().unwrap();
let [id] = st.selection.objects[..] else { panic!("one object is placed") };
st.doc.node(id).unwrap().clone()
})
.collect()
};
let visible = |n: &vectorcraft_engine::doc::Node| -> Vec<bool> { n.children().unwrap().iter().map(|c| c.visible).collect() };
let mut app = app();
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
// At first, Convert Layers to Objects without hidden layers.
for n in place_two(&mut app, false) {
assert!(matches!(n.kind, NodeKind::Group { .. }));
assert_eq!(visible(&n), [true, true]);
}
// Then the choices made last.
app.ui.psd_import = json!({"layers": true, "hiddenLayers": true});
for n in place_two(&mut app, false) {
assert_eq!(visible(&n), [true, false, true]);
}
app.ui.psd_import = json!({"layers": false, "hiddenLayers": true});
assert!(place_two(&mut app, false).iter().all(|n| matches!(n.kind, NodeKind::Image(_))));
// Placed with Link, the files keep their flat images.
app.ui.psd_import = json!({"layers": true, "hiddenLayers": false});
assert!(place_two(&mut app, true).iter().all(|n| matches!(n.kind, NodeKind::Image(_))));
std::fs::remove_dir_all(&dir).ok();
}
/// `psd` with a slices resource (1050, version 6) holding one user slice over its top-left
/// 10 × 10 px, named "cell".
fn sliced(psd: &[u8]) -> Vec<u8> {
let ustr = |s: &str| -> Vec<u8> {
let units: Vec<u16> = s.encode_utf16().collect();
let mut b = (units.len() as u32).to_be_bytes().to_vec();
b.extend(units.iter().flat_map(|u| u.to_be_bytes()));
b
};
let mut data = 6u32.to_be_bytes().to_vec();
data.extend([0u8; 16]);
data.extend(ustr(""));
data.extend(1u32.to_be_bytes());
// ID, group ID, origin (made by the user), name, type (Image), left, top, right, bottom.
data.extend([1u32, 0, 2].iter().flat_map(|v| v.to_be_bytes()));
data.extend(ustr("cell"));
data.extend([1u32, 0, 0, 10, 10].iter().flat_map(|v| v.to_be_bytes()));
// URL, target, message, alt text, cell text is HTML, cell text, alignments, color.
for _ in 0..4 {
data.extend(ustr(""));
}
data.push(0);
data.extend(ustr(""));
data.extend([0u8; 12]);
let u32_at = |at: usize| u32::from_be_bytes(psd[at..at + 4].try_into().unwrap()) as usize;
let colors = 26 + 4 + u32_at(26);
let len = u32_at(colors);
let mut block = b"8BIM".to_vec();
block.extend(1050u16.to_be_bytes());
block.extend([0, 0]);
block.extend((data.len() as u32).to_be_bytes());
block.extend(&data);
block.resize(block.len().next_multiple_of(2), 0);
let mut out = psd[..colors].to_vec();
out.extend(((len + block.len()) as u32).to_be_bytes());
out.extend(&psd[colors + 4..colors + 4 + len]);
out.extend(block);
out.extend(&psd[colors + 4 + len..]);
out
}
fn slice_names(app: &VectorcraftApp) -> Vec<String> {
app.session.doc().unwrap().doc.slices.iter().map(|s| s.options.name.clone()).collect()
}
#[test]
fn a_file_with_slices_asks_with_import_slices_on_either_conversion() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 20, "height": 20})).unwrap();
s.execute("shape.rectangle", &json!({"x": 2, "y": 2, "width": 10, "height": 10})).unwrap();
let r = s.execute("document.export", &json!({"format": "psd"})).unwrap();
// One layer: without slices it opens at once, with them it asks.
let psd = sliced(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
let mut app = app();
io::open_bytes(&mut app, "one.psd", &psd, None).unwrap();
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), &d.fields["slices"], d.bool("importSlices")), (KIND, &json!(1), true));
assert!(frame(&mut app).contains("Import Slices"));
// Flatten keeps Import Slices: the merged image opens with the slice.
set(&mut app, "convert", json!("flatten"));
super::super::confirm(&mut app).unwrap();
assert_eq!(slice_names(&app), ["cell"]);
// Left off, the slice stays out, and the next file starts from that choice.
io::open_bytes(&mut app, "one.psd", &psd, None).unwrap();
set(&mut app, "importSlices", json!(false));
super::super::confirm(&mut app).unwrap();
assert!(slice_names(&app).is_empty());
io::open_bytes(&mut app, "one.psd", &psd, None).unwrap();
assert!(!app.ui.dialog.as_ref().unwrap().bool("importSlices"), "remembered");
// A layered file without slices keeps the choice made last for the next sliced one.
app.ui.dialog = None;
io::open_bytes(&mut app, "poster.psd", &layered(), None).unwrap();
assert_eq!(app.ui.dialog.as_ref().unwrap().fields["slices"], json!(0));
set(&mut app, "importSlices", json!(true));
super::super::confirm(&mut app).unwrap();
assert_eq!(app.ui.psd_import["importSlices"], json!(false));
}
#[test]
fn placing_a_sliced_file_without_link_brings_its_slices_with_the_art() {
let b64 = vectorcraft_format::base64_encode(&sliced(&layered()));
let mut app = app();
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
crate::place::run_for_user(&mut app, &json!({"name": "poster.psd", "dataBase64": b64, "at": [50, 50]})).unwrap();
assert!(app.ui.dialog.as_ref().unwrap().bool("importSlices"));
super::super::confirm(&mut app).unwrap();
let st = app.session.doc().unwrap();
assert_eq!(st.doc.slices.len(), 1);
assert_eq!(st.doc.slices[0].rect, vectorcraft_geom::Rect::new(40.0, 40.0, 50.0, 50.0));
// Several files placed together take the choice made last.
let mut q = json!({});
app.ui.psd_import = json!({"layers": true, "importSlices": false});
queue_options(&app, &mut q);
assert_eq!(q["importSlices"], json!(false));
}
#[test]
fn placing_with_show_import_options_off_takes_the_last_choices() {
let b64 = vectorcraft_format::base64_encode(&sliced(&layered()));
let mut app = app();
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
// The file's bytes carry the Place dialog's Link, which they have no file for.
let place = |app: &mut VectorcraftApp, slices: Option<bool>| {
let mut p = json!({"name": "poster.psd", "dataBase64": b64, "link": true, "showImportOptions": false});
if let Some(s) = slices {
p["importSlices"] = json!(s);
}
crate::place::run_for_user(app, &p).unwrap();
assert!(app.ui.dialog.is_none(), "placed without asking");
let st = app.session.doc().unwrap();
let [id] = st.selection.objects[..] else { panic!("one object is selected") };
(st.doc.node(id).unwrap().kind.clone(), st.doc.slices.len())
};
// At first, Convert Layers to Objects with Import Slices.
let (kind, slices) = place(&mut app, None);
assert!(matches!(kind, NodeKind::Group { .. }));
assert_eq!(slices, 1);
// An `importSlices` the params give is kept.
let (kind, slices) = place(&mut app, Some(false));
assert!(matches!(kind, NodeKind::Group { .. }));
assert_eq!(slices, 1, "no new slice");
// Then the choices made last.
app.ui.psd_import = json!({"layers": false, "importSlices": false});
let (kind, slices) = place(&mut app, None);
assert!(matches!(kind, NodeKind::Image(_)));
assert_eq!(slices, 1, "no new slice");
let (_, slices) = place(&mut app, Some(true));
assert_eq!(slices, 2, "the given importSlices brings the slice in");
}
#[test]
fn files_from_bytes_placed_with_link_take_the_last_choices() {
let files: Vec<Value> = ["a.psd", "b.psd"].iter().map(|n| json!({ "name": n })).collect();
let mut app = app();
for n in ["a.psd", "b.psd"] {
app.place.picked.push((n.to_string(), sliced(&layered())));
}
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
// The dialog's Link is on, but files from bytes have no file to link to.
let d = Dialog::new(crate::dialogs::place::KIND, json!({"files": files, "link": true, "template": false, "showImportOptions": false}));
crate::place::confirm(&mut app, &d).unwrap();
assert!(app.ui.dialog.is_none(), "the cursor loads without asking");
let view = vectorcraft_engine::ViewInfo::default();
for kind in [vectorcraft_tools::PointerKind::Down, vectorcraft_tools::PointerKind::Up] {
for r in app.session.pointer(&vectorcraft_tools::PointerEvent::new(kind, 10.0, 10.0), view).unwrap() {
if let vectorcraft_engine::UiRequest::Place(p) = r {
crate::place::place_from_cursor(&mut app, &p);
}
}
}
let st = app.session.doc().unwrap();
let [id] = st.selection.objects[..] else { panic!("one object is placed") };
// At first, Convert Layers to Objects with Import Slices.
assert!(matches!(st.doc.node(id).unwrap().kind, NodeKind::Group { .. }));
assert_eq!(st.doc.slices.len(), 1);
}
#[test]
fn a_cursor_loaded_with_show_import_options_on_asks_for_each_psd_file() {
let dir = std::env::temp_dir().join(format!("vc-psd-import-asks-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let paths: Vec<String> = ["a.psd", "b.psd"]
.iter()
.map(|n| {
let p = dir.join(n);
std::fs::write(&p, layered()).unwrap();
p.to_string_lossy().into_owned()
})
.collect();
let files: Vec<Value> = paths.iter().map(|p| json!({ "path": p })).collect();
let services = crate::Services { read: Some(Box::new(|p: &str| std::fs::read(p).map_err(|e| e.to_string()))), ..Default::default() };
let mut app = VectorcraftApp::new(Session::new(), services);
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
// The choices made last would place the layers without asking with Show Import Options off.
app.ui.psd_import = json!({"layers": true, "importSlices": true});
let d = Dialog::new(crate::dialogs::place::KIND, json!({"files": files, "link": false, "template": false, "showImportOptions": true}));
crate::place::confirm(&mut app, &d).unwrap();
assert!(app.ui.dialog.is_none(), "the cursor loads without asking");
assert_eq!(app.session.tool_options()["count"], 2);
// A click on the canvas: the file the cursor's request names asks.
let view = vectorcraft_engine::ViewInfo::default();
for kind in [vectorcraft_tools::PointerKind::Down, vectorcraft_tools::PointerKind::Up] {
for r in app.session.pointer(&vectorcraft_tools::PointerEvent::new(kind, 10.0, 10.0), view).unwrap() {
if let vectorcraft_engine::UiRequest::Place(p) = r {
crate::place::place_from_cursor(&mut app, &p);
}
}
}
assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(KIND), "the clicked file asks");
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn scripted_places_and_places_that_give_layers_dont_ask() {
let b64 = vectorcraft_format::base64_encode(&layered());
let mut app = app();
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
// `file.place` run as a command places at once, as before.
let r = crate::place::run(&mut app, &json!({"name": "poster.psd", "dataBase64": b64})).unwrap();
assert!(app.ui.dialog.is_none());
assert_eq!(r["format"], "psd");
// The user's place with `layers` given doesn't ask either.
crate::place::run_for_user(&mut app, &json!({"name": "poster.psd", "dataBase64": b64, "layers": false})).unwrap();
assert!(app.ui.dialog.is_none());
}
}
+14 -4
View File
@@ -682,14 +682,22 @@ const MESSAGE_DEPTH: usize = 5;
/// Translate a status or error message for display (see the module docs). Unknown messages, and
/// parts of them (file names, numbers, a reason with no entry, a JSON object or array such as
/// `{"objects": [...]}`, a value the message quotes in `"…"`, `“…”` or backticks, such as a
/// symbol's name), stay as they are. A part that starts with `{` or `[` is translated only
/// when it is a whole message with an exact entry, such as `[x, y] (two numbers)`.
/// symbol's name), stay as they are. A part that starts with `{` is translated only when it is a
/// whole message with an exact entry. A part that starts with `[` is translated when it has an
/// exact entry, such as `[x, y] (two numbers)`, or when it fits a template that starts with `[`
/// and an index of digits, such as an effect's refusal ``[0] `id`: {why}``.
pub fn message(lang: Lang, s: &str) -> String {
message_at(lang, s, MESSAGE_DEPTH)
}
fn message_at(lang: Lang, s: &str, depth: usize) -> String {
let Some((forms, caps)) = lang.catalog().message_forms(s) else { return s.to_string() };
fill_message(lang, s, lang.catalog().message_forms(s), depth)
}
/// `s` shown through the catalog entry `found` matched for it, its placeholder values translated
/// in turn while `depth` lasts.
fn fill_message(lang: Lang, s: &str, found: Option<(&[String], catalog::Captures<'_, '_>)>, depth: usize) -> String {
let Some((forms, caps)) = found else { return s.to_string() };
let count = caps.iter().find(|(k, _)| *k == "n").and_then(|(_, v)| v.parse::<u64>().ok());
let form = count.map_or(forms.len().saturating_sub(1), |n| (lang.0.plural)(n).min(forms.len().saturating_sub(1)));
let Some(template) = forms.get(form) else { return s.to_string() };
@@ -697,8 +705,10 @@ fn message_at(lang: Lang, s: &str, depth: usize) -> String {
let nested = |v: &str| {
if depth <= 1 || quoted(v) {
v.to_string()
} else if v.starts_with(['{', '[']) {
} else if v.starts_with('{') {
exact_translation(lang.catalog(), v).unwrap_or_else(|| v.to_string())
} else if v.starts_with('[') {
fill_message(lang, v, lang.catalog().indexed_message_forms(v), depth - 1)
} else {
message_at(lang, v, depth - 1)
}
+13 -2
View File
@@ -1054,7 +1054,10 @@ font-technology Variable Променливи
Every (minutes) На всеки (минути)
Every option is at its default. Всички опции са в състояние по подразбиране.
Every option matches {base}. Всички опции съответстват на {base}.
Every-line Composer Композитор за всеки ред
Middle Eastern & South Asian Single-line Composer Ред по ред композитор (Близък изток и Южна Азия)
Middle Eastern & South Asian Every-line Composer Композитор за всеки ред (Близък изток и Южна Азия)
Standard Single-line Composer Стандартен ред по ред композитор
Standard Every-line Composer Стандартен композитор за всеки ред
Exact dash lengths Точни дължини на тиретата
Exceptions (comma separated) Изключения (разделени със запетаи)
Exclude Изключване
@@ -1348,6 +1351,14 @@ font-technology Variable Променливи
Previous Artboard Предишна работна област
Next Artboard Следваща работна област
Last Artboard Последна работна област
Status Bar Show Показване в лентата на състоянието
Artboard Name Име на работната област
Current Tool Текущ инструмент
Date and Time Дата и час
Number of Undos Брой отмени
Document Color Profile Цветови профил на документа
Undos Отмени
Redos Повторения
Go To Link Към връзката
GPL palettes keep solid colours only, as RGB. Палитрите GPL запазват само плътни цветове като RGB.
GPU Performance Производителност на графичния процесор
@@ -3360,7 +3371,6 @@ digits Malayalam Малаялам
Single Left Quotation Mark Лява единична кавичка
Single Quotes: Единични кавички:
Single Right Quotation Mark Дясна единична кавичка
Single-line Composer Ред по ред композитор
Toggle Line Composer Превключване на композитора на редове
Sixth Space Шесто разстояние
Size Размер
@@ -6985,3 +6995,4 @@ breakText Glyphs Глифи
Nest Shapes… Подреждане на форми…
Nest Shapes Подреждане на форми
Roll Ролка
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer трябва да е "singleLine", "everyLine", "standardSingleLine" или "standardEveryLine"
Can't render this file because it is too large.
+13 -2
View File
@@ -1085,6 +1085,14 @@ lighting Light Svjetlo
Previous Artboard Prethodna radna ploča
Next Artboard Sljedeća radna ploča
Last Artboard Posljednja radna ploča
Status Bar Show Prikaz u traci stanja
Artboard Name Naziv radne ploče
Current Tool Trenutni alat
Date and Time Datum i vrijeme
Number of Undos Broj poništavanja
Document Color Profile Profil boja dokumenta
Undos Poništavanja
Redos Ponavljanja
Graphic Style Options… Opcije grafičkog stila…
Symbol Options Opcije simbola
Symbol Options… Opcije simbola…
@@ -2028,7 +2036,10 @@ digits Malayalam Malajalam
Tabular Lining Tabelarne brojke
Tabular Oldstyle Tabelarne stare brojke
Titling Alternates Alternative za naslove
Every-line Composer Slagač svih redova
Middle Eastern & South Asian Single-line Composer Slagač jednog reda (Bliski istok i Južna Azija)
Middle Eastern & South Asian Every-line Composer Slagač svih redova (Bliski istok i Južna Azija)
Standard Single-line Composer Standardni slagač jednog reda
Standard Every-line Composer Standardni slagač svih redova
First-line Left Indent Lijeva uvlaka prvog reda
Hyphenation… Rastavljanje riječi…
Words Longer Than: Riječi duže od:
@@ -2068,7 +2079,6 @@ digits Malayalam Malajalam
East Asian Composition Settings Postavke istočnoazijske kompozicije
Korean Composition Settings Postavke korejske kompozicije
Select a text object to edit its paragraph attributes. Odaberite tekstualni objekat da uredite njegove atribute pasusa.
Single-line Composer Slagač jednog reda
Toggle Line Composer Uključi/isključi Line Composer
Space After Paragraph Razmak nakon pasusa
Space Before Paragraph Razmak prije pasusa
@@ -7038,3 +7048,4 @@ shape Open Otvoren
Nest Shapes… Slaganje oblika…
Nest Shapes Slaganje oblika
Roll Rolna
@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.
+13 -2
View File
@@ -1537,7 +1537,10 @@ antiAlias Sharp Nítid
Every (minutes) Cada (minuts)
Every option is at its default. Totes les opcions són al valor predeterminat.
Every option matches {base}. Totes les opcions coincideixen amb {base}.
Every-line Composer Composició línia per línia
Middle Eastern & South Asian Single-line Composer Compositor d’una línia (Orient Pròxim i Àsia Meridional)
Middle Eastern & South Asian Every-line Composer Composició línia per línia (Orient Pròxim i Àsia Meridional)
Standard Single-line Composer Compositor estàndard d’una línia
Standard Every-line Composer Composició estàndard línia per línia
Exact Exacte
Exact dash lengths Longituds de guió exactes
Example: {name} Exemple: {name}
@@ -2325,6 +2328,14 @@ digits Malayalam Malaiàlam
Enclosing Lasso Llaç envoltant
Last Últim
Last Artboard Últim tauler
Status Bar Show Mostra a la barra d'estat
Artboard Name Nom del tauler
Current Tool Eina actual
Date and Time Data i hora
Number of Undos Nombre de desfets
Document Color Profile Perfil de color del document
Undos Desfets
Redos Refets
Last commit Últim commit
Last Effect: {name} Últim efecte: {name}
Last Effect: {} Últim efecte: {}
@@ -4395,7 +4406,6 @@ digits Malayalam Malaiàlam
Single Quotes: Cometes simples:
Single Right Quotation Mark Cometa simple dreta
Single Word Justification: Justificació d’una sola paraula:
Single-line Composer Compositor d’una línia
Sixth Space Espai de sisena part
Size Mida
Size Tile to Art Ajusta la mida del mosaic a l’art
@@ -7781,3 +7791,4 @@ 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ó
@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.
+22
View File
@@ -262,6 +262,28 @@ impl Catalog {
self.templates.iter().find_map(|t| t.captures(s).map(|caps| (t.forms.as_slice(), caps)))
}
/// [`Catalog::message_forms`] for a part of a message that starts with `[`, which may be a JSON
/// array: an exact `@msg` entry, else only a template that starts with a literal `[` and a
/// placeholder whose value is an index of ASCII digits, such as ``[{j}] `{_1}`: {why}``. An
/// array such as ``["] `x`: b"]`` fits that template's text, but not its index.
pub fn indexed_message_forms<'a>(&self, s: &'a str) -> Option<(&[String], Captures<'_, 'a>)> {
if let Some(tr) = self.messages.get(s) {
return Some((std::slice::from_ref(tr), Vec::new()));
}
if s.len() > MAX_MESSAGE_LEN {
return None;
}
self.templates.iter().find_map(|t| {
let [Piece::Text(open), Piece::Hole(index), ..] = t.pieces.as_slice() else { return None };
if open != "[" {
return None;
}
let caps = t.captures(s)?;
let digits = caps.iter().any(|(k, v)| k == index && v.bytes().all(|b| b.is_ascii_digit()));
digits.then_some((t.forms.as_slice(), caps))
})
}
/// The translation of a status or error message that has an exact `@msg` entry, as written in
/// the catalog (`{{` and `}}` for literal braces); templates are not tried.
pub fn exact_message(&self, s: &str) -> Option<&str> {
+13 -3
View File
@@ -1109,6 +1109,14 @@ lighting Light Světlo
Previous Artboard Předchozí pracovní plocha
Next Artboard Další pracovní plocha
Last Artboard Poslední pracovní plocha
Status Bar Show Zobrazit ve stavovém řádku
Artboard Name Název pracovní plochy
Current Tool Aktuální nástroj
Date and Time Datum a čas
Number of Undos Počet kroků zpět
Document Color Profile Barevný profil dokumentu
Undos Zpět
Redos Znovu
Graphic Style Options… Možnosti grafického stylu…
Symbol Options Možnosti symbolu
Symbol Options… Možnosti symbolu…
@@ -2101,7 +2109,8 @@ digits Malayalam Malajálamské
Tabular Lining Tabulkové verzálkové
Tabular Oldstyle Tabulkové minuskové
Titling Alternates Titulkové alternativy
Every-line Composer Sazba všech řádků
Middle Eastern & South Asian Every-line Composer Sazba všech řádků (Blízký východ a Jižní Asie)
Standard Every-line Composer Standardní sazba všech řádků
First-line Left Indent Odsazení prvního řádku zleva
Hyphenation… Dělení slov…
Words Longer Than: Slova delší než:
@@ -2141,7 +2150,8 @@ digits Malayalam Malajálamské
East Asian Composition Settings Nastavení východoasijské sazby
Korean Composition Settings Nastavení korejské sazby
Select a text object to edit its paragraph attributes. Vyberte textový objekt, abyste mohli upravit atributy jeho odstavce.
Single-line Composer Sazba jednoho řádku
Middle Eastern & South Asian Single-line Composer Sazba jednoho řádku (Blízký východ a Jižní Asie)
Standard Single-line Composer Standardní sazba jednoho řádku
Toggle Line Composer Přepnout sazbu řádků
Space After Paragraph Mezera za odstavcem
Space Before Paragraph Mezera před odstavcem
@@ -8406,7 +8416,7 @@ breakText Glyphs Glyfy
@msg column: true floats the whole column and takes no onto, above or below column: true uvolní celý sloupec jako plovoucí a nepřijímá onto, above ani below
@msg command must be a shape.* command command musí být příkaz shape.*
@msg commands[{i}]: missing `command` commands[{i}]: chybí `command`
@msg composer must be "singleLine" or "everyLine" composer musí být "singleLine" nebo "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer musí být "singleLine", "everyLine", "standardSingleLine" nebo "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes složené tvary přijímají cesty, složené cesty, skupiny, složené tvary, text, prolnutí a obálky
@msg compound {_1} must contain exactly one open path to join složený objekt {_1} musí ke spojení obsahovat právě jednu otevřenou cestu
@msg connect needs a path other than the one extended connect vyžaduje jinou cestu než tu prodlužovanou
Can't render this file because it is too large.
+14 -2
View File
@@ -2554,7 +2554,10 @@ digits Malayalam Malayalam
Tabular Lining Tabulære versalcifre
Tabular Oldstyle Tabulære mediævalcifre
Titling Alternates Titelalternativer
Every-line Composer Hverlinjesætter
Middle Eastern & South Asian Single-line Composer Enlinjesætter (Mellemøsten og Sydasien)
Middle Eastern & South Asian Every-line Composer Hverlinjesætter (Mellemøsten og Sydasien)
Standard Single-line Composer Standard-enlinjesætter
Standard Every-line Composer Standard-hverlinjesætter
First-line Left Indent Venstre indrykning af første linje
Hyphenation… Orddeling…
Justification… Justering…
@@ -2586,7 +2589,6 @@ digits Malayalam Malayalam
East Asian Composition Settings Indstillinger for østasiatisk komposition
Korean Composition Settings Indstillinger for koreansk komposition
Select a text object to edit its paragraph attributes. Markér et tekstobjekt for at redigere dets afsnitsattributter.
Single-line Composer Enlinjesætter
Toggle Line Composer Skift linjesætter
Space After Paragraph Mellemrum efter afsnit
Space Before Paragraph Mellemrum før afsnit
@@ -5433,6 +5435,7 @@ imageTrace Outline Kontur
@msg plug-in failed: {0} plug-in fejlede: {0}
@msg plug-in manifest: {0} plug-in-manifest: {0}
@msg plug-in output: {0} plug-in-output: {0}
@msg [{j}] `{_1}`: {why} [{j}] `{_1}`: {why}
@msg plug-in parameters: {0} plug-in-parametre: {0}
@msg plug-in trapped: {0} plug-in'et blev fanget: {0}
@msg print settings are not an object printindstillingerne er ikke et objekt
@@ -6548,6 +6551,14 @@ swatch Bright Violet Kraftig violet
Color wheel Farvehjul
First Artboard Første kunstplade
Last Artboard Sidste kunstplade
Status Bar Show Vis i statuslinjen
Artboard Name Kunstpladens navn
Current Tool Aktuelt værktøj
Date and Time Dato og klokkeslæt
Number of Undos Antal fortrydelser
Document Color Profile Dokumentets farveprofil
Undos Fortrydelser
Redos Gentagelser
Next Artboard Næste kunstplade
Previous Artboard Forrige kunstplade
Step up or down Trinvis op eller ned
@@ -7690,3 +7701,4 @@ breakText Glyphs Glyffer
Nest Shapes… Pak figurer tæt…
Nest Shapes Pak figurer tæt
Roll Rulle
@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.
+13 -3
View File
@@ -1056,7 +1056,8 @@ font-technology Variable Variabel
Every (minutes) Alle (Minuten)
Every option is at its default. Alle Optionen haben ihren Standardwert.
Every option matches {base}. Alle Optionen entsprechen {base}.
Every-line Composer Alle-Zeilen-Setzer
Middle Eastern & South Asian Every-line Composer Alle-Zeilen-Setzer (Naher Osten und Südasien)
Standard Every-line Composer Standard-Alle-Zeilen-Setzer
Exact dash lengths Exakte Strichlängen
Exceptions (comma separated) Ausnahmen (durch Kommas getrennt)
Exclude Schnittmenge entfernen
@@ -1393,6 +1394,14 @@ file-filter Templates Vorlagen
Previous Artboard Vorherige Zeichenfläche
Next Artboard Nächste Zeichenfläche
Last Artboard Letzte Zeichenfläche
Status Bar Show In Statusleiste anzeigen
Artboard Name Name der Zeichenfläche
Current Tool Aktuelles Werkzeug
Date and Time Datum und Uhrzeit
Number of Undos Anzahl der Rückgängig-Schritte
Document Color Profile Farbprofil des Dokuments
Undos Rückgängig
Redos Wiederholen
Go To Link Gehe zu Verknüpfung
GPL palettes keep solid colours only, as RGB. GPL-Paletten enthalten nur einfarbige Farben, als RGB.
GPU Performance GPU-Leistung
@@ -3421,7 +3430,8 @@ digits Malayalam Malayalam
Single Left Quotation Mark Einfaches öffnendes Anführungszeichen
Single Quotes: Einfache Anführungszeichen:
Single Right Quotation Mark Einfaches schließendes Anführungszeichen
Single-line Composer Einzeilen-Setzer
Middle Eastern & South Asian Single-line Composer Einzeilen-Setzer (Naher Osten und Südasien)
Standard Single-line Composer Standard-Einzeilen-Setzer
Toggle Line Composer Zeilensetzer umschalten
Sixth Space Sechstelgeviert-Leerzeichen
Size Größe
@@ -8087,7 +8097,7 @@ breakText Glyphs Glyphen
@msg column: true floats the whole column and takes no onto, above or below column: true macht die ganze Spalte schwebend und nimmt kein onto, above oder below
@msg command must be a shape.* command command muss ein shape.*-Befehl sein
@msg commands[{i}]: missing `command` commands[{i}]: `command` fehlt
@msg composer must be "singleLine" or "everyLine" composer muss „singleLine“ oder „everyLine“ sein
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer muss „singleLine“, „everyLine“, „standardSingleLine“ oder „standardEveryLine“ sein
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes zusammengesetzte Formen nehmen Pfade, zusammengesetzte Pfade, Gruppen, zusammengesetzte Formen, Text, Angleichungen und Verzerrungshüllen
@msg compound {_1} must contain exactly one open path to join zusammengesetzter Pfad {_1} muss genau einen offenen Pfad zum Zusammenfügen enthalten
@msg connect end must be "start" or "end" connect end muss „start“ oder „end“ sein
Can't render this file because it is too large.
+13 -2
View File
@@ -1021,7 +1021,10 @@ font-technology Variable Μεταβλητές
Every (minutes) Κάθε (λεπτά)
Every option is at its default. Όλες οι επιλογές έχουν τις προεπιλεγμένες τιμές τους.
Every option matches {base}. Όλες οι επιλογές ταιριάζουν με το {base}.
Every-line Composer Σύνθεση όλων των γραμμών
Middle Eastern & South Asian Single-line Composer Σύνθεση μονής γραμμής (Μέση Ανατολή και Νότια Ασία)
Middle Eastern & South Asian Every-line Composer Σύνθεση όλων των γραμμών (Μέση Ανατολή και Νότια Ασία)
Standard Single-line Composer Τυπική σύνθεση μονής γραμμής
Standard Every-line Composer Τυπική σύνθεση όλων των γραμμών
Exact dash lengths Ακριβή μήκη παυλών
Exceptions (comma separated) Εξαιρέσεις (χωρισμένες με κόμμα)
Exclude Εξαίρεση
@@ -1323,6 +1326,14 @@ font-technology Variable Μεταβλητές
Previous Artboard Προηγούμενος πίνακας σχεδίασης
Next Artboard Επόμενος πίνακας σχεδίασης
Last Artboard Τελευταίος πίνακας σχεδίασης
Status Bar Show Εμφάνιση στη γραμμή κατάστασης
Artboard Name Όνομα πίνακα σχεδίασης
Current Tool Τρέχον εργαλείο
Date and Time Ημερομηνία και ώρα
Number of Undos Αριθμός αναιρέσεων
Document Color Profile Χρωματικό προφίλ εγγράφου
Undos Αναιρέσεις
Redos Επαναλήψεις
Go To Link Μετάβαση στη σύνδεση
GPL palettes keep solid colours only, as RGB. Οι παλέτες GPL διατηρούν μόνο συμπαγή χρώματα σε RGB.
GPU Performance Απόδοση GPU
@@ -4039,7 +4050,6 @@ digits Malayalam Μαλαγιάλαμ
Single Left Quotation Mark Μονό αριστερό εισαγωγικό
Single Quotes: Μονά εισαγωγικά:
Single Right Quotation Mark Μονό δεξί εισαγωγικό
Single-line Composer Σύνθεση μονής γραμμής
Toggle Line Composer Εναλλαγή σύνθεσης γραμμών
Sixth Space Διάστημα ενός έκτου
Size Tile to Art Προσαρμογή μεγέθους πλακιδίου στο σχέδιο
@@ -7755,3 +7765,4 @@ 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} εικονοστοιχεία ανά πλευρά): μειώστε την ανάλυση
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" το composer πρέπει να είναι "singleLine", "everyLine", "standardSingleLine" ή "standardEveryLine"
Can't render this file because it is too large.
+13 -2
View File
@@ -1077,7 +1077,10 @@ font-technology Variable Variables
Every (minutes) Cada (minutos)
Every option is at its default. Todas las opciones tienen su valor predeterminado.
Every option matches {base}. Todas las opciones coinciden con {base}.
Every-line Composer Composición de todas las líneas
Middle Eastern & South Asian Single-line Composer Composición de una línea (Oriente Medio y Sur de Asia)
Middle Eastern & South Asian Every-line Composer Composición de todas las líneas (Oriente Medio y Sur de Asia)
Standard Single-line Composer Composición estándar de una línea
Standard Every-line Composer Composición estándar de todas las líneas
Exact dash lengths Longitudes exactas de guion
Exceptions (comma separated) Excepciones (separadas por comas)
Exclude Excluir
@@ -1402,6 +1405,14 @@ font-technology Variable Variables
Previous Artboard Mesa de trabajo anterior
Next Artboard Mesa de trabajo siguiente
Last Artboard Última mesa de trabajo
Status Bar Show Mostrar en la barra de estado
Artboard Name Nombre de la mesa de trabajo
Current Tool Herramienta actual
Date and Time Fecha y hora
Number of Undos Número de deshacer
Document Color Profile Perfil de color del documento
Undos Deshacer
Redos Rehacer
Go To Link Ir al vínculo
GPL palettes keep solid colours only, as RGB. Las paletas GPL solo conservan colores sólidos, en RGB.
GPU Performance Rendimiento de GPU
@@ -3453,7 +3464,6 @@ digits Malayalam Malayálam
Single Left Quotation Mark Comilla simple de apertura
Single Quotes: Comillas simples:
Single Right Quotation Mark Comilla simple de cierre
Single-line Composer Composición de una línea
Toggle Line Composer Alternar composición de líneas
Sixth Space Sexto de espacio
Size Tamaño
@@ -7742,3 +7752,4 @@ breakText Glyphs Glifos
Nest Shapes… Anidar formas…
Nest Shapes Anidar formas
Roll Rollo
@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.
+13 -2
View File
@@ -1088,6 +1088,14 @@ lighting Light Valo
Previous Artboard Edellinen piirtoalusta
Next Artboard Seuraava piirtoalusta
Last Artboard Viimeinen piirtoalusta
Status Bar Show Näytä tilarivillä
Artboard Name Piirtoalustan nimi
Current Tool Nykyinen työkalu
Date and Time Päivämäärä ja aika
Number of Undos Kumousten määrä
Document Color Profile Asiakirjan väriprofiili
Undos Kumoukset
Redos Uudelleentekot
Graphic Style Options… Grafiikkatyylin asetukset…
Symbol Options Symbolin asetukset
Symbol Options… Symbolin asetukset…
@@ -2062,7 +2070,10 @@ digits Malayalam Malajalam
Tabular Lining Taulukkonumerot
Tabular Oldstyle Vanhanaikaiset taulukkonumerot
Titling Alternates Otsikkovaihtoehdot
Every-line Composer Kaikkien rivien asettelu
Middle Eastern & South Asian Single-line Composer Yhden rivin asettelu (Lähi-itä ja Etelä-Aasia)
Middle Eastern & South Asian Every-line Composer Kaikkien rivien asettelu (Lähi-itä ja Etelä-Aasia)
Standard Single-line Composer Tavallinen yhden rivin asettelu
Standard Every-line Composer Tavallinen kaikkien rivien asettelu
First-line Left Indent Ensimmäisen rivin vasen sisennys
Hyphenation… Tavutus…
Words Longer Than: Sanat, jotka ovat pidempiä kuin:
@@ -2102,7 +2113,6 @@ digits Malayalam Malajalam
East Asian Composition Settings Itäaasialaisen ladonnan asetukset
Korean Composition Settings Korean ladonnan asetukset
Select a text object to edit its paragraph attributes. Valitse tekstiobjekti, jonka kappalemääritteitä haluat muokata.
Single-line Composer Yhden rivin asettelu
Toggle Line Composer Vaihda rivien asettelu
Space After Paragraph Väli kappaleen jälkeen
Space Before Paragraph Väli ennen kappaletta
@@ -7838,3 +7848,4 @@ 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
@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.
+13 -3
View File
@@ -1072,7 +1072,10 @@ font-technology Variable Variables
Every (minutes) Toutes les (minutes)
Every option is at its default. Toutes les options ont leur valeur par défaut.
Every option matches {base}. Toutes les options correspondent à {base}.
Every-line Composer Compositeur multiligne
Middle Eastern & South Asian Single-line Composer Compositeur ligne par ligne (Moyen-Orient et Asie du Sud)
Middle Eastern & South Asian Every-line Composer Compositeur multiligne (Moyen-Orient et Asie du Sud)
Standard Single-line Composer Compositeur standard ligne par ligne
Standard Every-line Composer Compositeur standard multiligne
Exact dash lengths Longueurs de tirets exactes
Exceptions (comma separated) Exceptions (séparées par des virgules)
Exclude Exclusion
@@ -1396,6 +1399,14 @@ font-technology Variable Variables
Previous Artboard Plan de travail précédent
Next Artboard Plan de travail suivant
Last Artboard Dernier plan de travail
Status Bar Show Afficher dans la barre d'état
Artboard Name Nom du plan de travail
Current Tool Outil actif
Date and Time Date et heure
Number of Undos Nombre d'annulations
Document Color Profile Profil colorimétrique du document
Undos Annulations
Redos Rétablissements
Go To Link Atteindre le lien
GPL palettes keep solid colours only, as RGB. Les palettes GPL ne conservent que les couleurs unies, en RVB.
GPU Performance Performances GPU
@@ -3445,7 +3456,6 @@ digits Malayalam Malayalam
Single Left Quotation Mark Guillemet simple ouvrant
Single Quotes: Guillemets simples :
Single Right Quotation Mark Guillemet simple fermant
Single-line Composer Compositeur ligne par ligne
Toggle Line Composer Basculer le compositeur de lignes
Sixth Space Espace d’un sixième
Size Taille
@@ -8267,7 +8277,7 @@ breakText Glyphs Glyphes
@msg column: true floats the whole column and takes no onto, above or below column: true rend flottante toute la colonne et n’accepte ni onto, ni above, ni below
@msg command must be a shape.* command command doit être une commande shape.*
@msg commands[{i}]: missing `command` commands[{i}] : `command` manquant
@msg composer must be "singleLine" or "everyLine" composer doit valoir "singleLine" ou "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer doit être "singleLine", "everyLine", "standardSingleLine" ou "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes les formes composées acceptent les tracés, tracés transparents, groupes, formes composées, textes, dégradés de formes et enveloppes
@msg compound {_1} must contain exactly one open path to join le tracé transparent {_1} doit contenir exactement un tracé ouvert à joindre
@msg connect end must be "start" or "end" l’extrémité de connect doit valoir "start" ou "end"
Can't render this file because it is too large.
+13 -2
View File
@@ -1241,7 +1241,6 @@
Every (minutes) દર (મિનિટ)
Every option is at its default. દરેક વિકલ્પ ડિફૉલ્ટ પર છે.
Every option matches {base}. દરેક વિકલ્પ {base} સાથે મેળ ખાય છે.
Every-line Composer એવરી-લાઇન કમ્પોઝર
Exact dash lengths ચોક્કસ ડેશ લંબાઈ
Exceptions (comma separated) અપવાદો (અલ્પવિરામથી અલગ)
Exclude બાકાત રાખો
@@ -1908,6 +1907,14 @@
Lasso Tool લાસો ટૂલ
Last છેલ્લું
Last Artboard છેલ્લું આર્ટબોર્ડ
Status Bar Show સ્ટેટસ બારમાં બતાવો
Artboard Name આર્ટબોર્ડનું નામ
Current Tool વર્તમાન ટૂલ
Date and Time તારીખ અને સમય
Number of Undos પૂર્વવત્ કરવાની સંખ્યા
Document Color Profile દસ્તાવેજની રંગ પ્રોફાઇલ
Undos પૂર્વવત્
Redos ફરીથી કરો
Last Effect: {name} છેલ્લી ઇફેક્ટ: {name}
Last Effect… છેલ્લી ઇફેક્ટ…
Last Page છેલ્લું પેજ
@@ -3582,7 +3589,6 @@
Single Quotes: એકલ અવતરણ ચિહ્નો:
Single Right Quotation Mark જમણું એકલ અવતરણ ચિહ્ન
Single Word Justification: એક શબ્દ જસ્ટિફિકેશન:
Single-line Composer સિંગલ-લાઇન કમ્પોઝર
Sixth Space છઠ્ઠી જગ્યા
Size કદ
Size Tile to Art ટાઇલનું કદ આર્ટ પ્રમાણે કરો
@@ -4765,3 +4771,8 @@ swatch [Registration] [રજિસ્ટ્રેશન]
Repeat Objects પુનરાવર્તિત ઑબ્જેક્ટ્સ
@msg `{path}` must be one of {_1}, not {got} `{path}` એ {_1}માંથી એક હોવું જોઈએ, {got} નહીં
Path Length પાથની લંબાઈ
Middle Eastern & South Asian Single-line Composer સિંગલ-લાઇન કમ્પોઝર (મધ્ય પૂર્વ અને દક્ષિણ એશિયા)
Middle Eastern & South Asian Every-line Composer એવરી-લાઇન કમ્પોઝર (મધ્ય પૂર્વ અને દક્ષિણ એશિયા)
Standard Single-line Composer સ્ટાન્ડર્ડ સિંગલ-લાઇન કમ્પોઝર
Standard Every-line Composer સ્ટાન્ડર્ડ એવરી-લાઇન કમ્પોઝર
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer આમાંથી એક હોવું જોઈએ: "singleLine", "everyLine", "standardSingleLine" અથવા "standardEveryLine"
Can't render this file because it contains an unexpected character in line 72 and column 5.
+13 -3
View File
@@ -1718,7 +1718,8 @@ antiAlias Sharp शार्प
Every (minutes) हर (मिनट)
Every option is at its default. प्रत्येक ऑप्शन इसके डिफ़ॉल्ट रूप से होता है।
Every option matches {base}. प्रत्येक ऑप्शन {base} से मेल खाता है।
Every-line Composer हर लाइन संगीतकार
Middle Eastern & South Asian Every-line Composer हर लाइन संगीतकार (मध्य पूर्व और दक्षिण एशिया)
Standard Every-line Composer मानक हर लाइन संगीतकार
Exact सटीक
Exact dash lengths सटीक डैश लंबाई
Example: {name} उदाहरण: {name}
@@ -2570,6 +2571,14 @@ antiAlias Sharp शार्प
Lasso Tool लैस्सो टूल
Last अंतिम
Last Artboard अंतिम आर्टबोर्ड
Status Bar Show स्टेटस बार में दिखाएँ
Artboard Name आर्टबोर्ड का नाम
Current Tool मौजूदा टूल
Date and Time तारीख और समय
Number of Undos पूर्ववत करने की संख्या
Document Color Profile दस्तावेज़ की रंग प्रोफ़ाइल
Undos पूर्ववत
Redos फिर से करें
Last commit अंतिम कमिट
Last Effect: {} अंतिम इफ़ेक्ट: {}
Last Effect: {name} अंतिम इफ़ेक्ट: {name}
@@ -4740,7 +4749,8 @@ antiAlias Sharp शार्प
Single Quotes: एकल उद्धरण:
Single Right Quotation Mark सिंगल राइट कोटेशन मार्क
Single Word Justification: एकल शब्द जस्टिफ़िकेशन:
Single-line Composer एकल लाइन संगीतकार
Middle Eastern & South Asian Single-line Composer एकल लाइन संगीतकार (मध्य पूर्व और दक्षिण एशिया)
Standard Single-line Composer मानक एकल लाइन संगीतकार
Sixth Space छठे हिस्से जितना स्पेस
Size आकार
Size Tile to Art आकार टाइल कला के लिए
@@ -6704,7 +6714,7 @@ antiAlias Sharp शार्प
@msg command `{id}` is not available right now आदेश `{id}` अभी उपलब्ध नहीं है
@msg command must be a shape.* command command कोई shape.* कमांड होना चाहिए
@msg commands[{i}]: missing `command` आदेश [{i}]: लापता `command`
@msg composer must be "singleLine" or "everyLine" composer "singleLine" या "everyLine" होना चाहिए
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer "singleLine", "everyLine", "standardSingleLine" या "standardEveryLine" होना चाहिए
@msg compound {_1} must contain exactly one open path to join जोड़ने के लिए कंपाउंड {_1} में ठीक एक खुला पाथ होना चाहिए
@msg compound paths can only contain paths यौगिक पाथ में केवल पाथ हो सकते हैं
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes कंपाउंड शेप पाथ, कंपाउंड पाथ, समूह, कंपाउंड शेप, टाइप, ब्लेंड और एन्वेलप लेते हैं
Can't render this file because it is too large.
+13 -3
View File
@@ -1368,7 +1368,10 @@ font-technology Variable Változó
Every (minutes) Gyakoriság (perc)
Every option is at its default. Minden beállítás az alapértéken áll.
Every option matches {base}. Minden beállítás egyezik: {base}.
Every-line Composer Többsoros tördelő
Middle Eastern & South Asian Single-line Composer Egysoros tördelő (Közel-Kelet és Dél-Ázsia)
Middle Eastern & South Asian Every-line Composer Többsoros tördelő (Közel-Kelet és Dél-Ázsia)
Standard Single-line Composer Normál egysoros tördelő
Standard Every-line Composer Normál többsoros tördelő
Exact Pontos
Exact dash lengths Pontos vonalhosszak
Exceptions (comma separated) Kivételek (vesszővel elválasztva)
@@ -1744,6 +1747,14 @@ file-filter Templates Sablonok
Previous Artboard Előző rajztábla
Next Artboard Következő rajztábla
Last Artboard Utolsó rajztábla
Status Bar Show Megjelenítés az állapotsorban
Artboard Name Rajztábla neve
Current Tool Aktuális eszköz
Date and Time Dátum és idő
Number of Undos Visszavonások száma
Document Color Profile Dokumentum színprofilja
Undos Visszavonások
Redos Újra
Go to Conflict Ugrás az ütközésre
Go To Link Ugrás a csatoláshoz
Good Jó
@@ -4107,7 +4118,6 @@ mark-style Japanese Japán
Single Left Quotation Mark Bal oldali szimpla idézőjel
Single Quotes: Szimpla idézőjelek:
Single Right Quotation Mark Jobb oldali szimpla idézőjel
Single-line Composer Egysoros tördelő
Toggle Line Composer Sortördelő váltása
Sixth Space Hatodkvirt-szóköz
Size Méret
@@ -8277,7 +8287,7 @@ breakText Glyphs Glifák
@msg column: true floats the whole column and takes no onto, above or below column: true az egész oszlopot lebegővé teszi, és nem adható meg mellette onto, above vagy below
@msg command must be a shape.* command command: shape.* parancs kell
@msg commands[{i}]: missing `command` commands[{i}]: hiányzik: `command`
@msg composer must be "singleLine" or "everyLine" composer: "singleLine" vagy "everyLine" kell
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer értéke "singleLine", "everyLine", "standardSingleLine" vagy "standardEveryLine" lehet
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes összetett alakzatba útvonalak, összetett útvonalak, csoportok, összetett alakzatok, szöveg, összemosások és burkolók kerülhetnek
@msg compound {_1} must contain exactly one open path to join az összetett objektumnak ({_1}) pontosan egy összekapcsolható nyitott útvonalat kell tartalmaznia
@msg connect needs a path other than the one extended connect: a meghosszabbított útvonaltól különböző útvonal kell
Can't render this file because it is too large.
+13 -2
View File
@@ -1867,7 +1867,10 @@ digits Malayalam Malayalam
Tabular Lining Lining tabular
Tabular Oldstyle Oldstyle tabular
Titling Alternates Alternatif judul
Every-line Composer Komposer tiap baris
Middle Eastern & South Asian Single-line Composer Komposer satu baris (Timur Tengah dan Asia Selatan)
Middle Eastern & South Asian Every-line Composer Komposer tiap baris (Timur Tengah dan Asia Selatan)
Standard Single-line Composer Komposer standar satu baris
Standard Every-line Composer Komposer standar tiap baris
First-line Left Indent Indentasi kiri baris pertama
Hyphenation… Pemenggalan kata…
Justification… Justifikasi…
@@ -1899,7 +1902,6 @@ digits Malayalam Malayalam
East Asian Composition Settings Pengaturan komposisi Asia Timur
Korean Composition Settings Pengaturan komposisi Korea
Select a text object to edit its paragraph attributes. Pilih objek teks untuk mengedit atribut paragrafnya.
Single-line Composer Komposer satu baris
Toggle Line Composer Alihkan komposer baris
Space After Paragraph Spasi setelah paragraf
Space Before Paragraph Spasi sebelum paragraf
@@ -5858,6 +5860,14 @@ swatch Bright Violet Violet cerah
Color wheel Roda warna
First Artboard Artboard pertama
Last Artboard Artboard terakhir
Status Bar Show Tampilkan di bilah status
Artboard Name Nama artboard
Current Tool Alat saat ini
Date and Time Tanggal dan waktu
Number of Undos Jumlah urungkan
Document Color Profile Profil warna dokumen
Undos Urungkan
Redos Ulangi
Next Artboard Artboard berikutnya
Previous Artboard Artboard sebelumnya
Step up or down Naikkan atau turunkan bertahap
@@ -7000,3 +7010,4 @@ breakText Glyphs Glif
Nest Shapes… Susun Bentuk…
Nest Shapes Susun Bentuk
Roll Gulungan
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer harus "singleLine", "everyLine", "standardSingleLine", atau "standardEveryLine"
Can't render this file because it contains an unexpected character in line 2469 and column 5.
+13 -3
View File
@@ -1086,7 +1086,8 @@ font-technology Variable Variabili
Every (minutes) Ogni (minuti)
Every option is at its default. Tutte le opzioni hanno il valore predefinito.
Every option matches {base}. Tutte le opzioni corrispondono a {base}.
Every-line Composer Composizione su tutte le righe
Middle Eastern & South Asian Every-line Composer Composizione su tutte le righe (Medio Oriente e Asia meridionale)
Standard Every-line Composer Composizione standard su tutte le righe
Exact dash lengths Lunghezze esatte dei trattini
Exceptions (comma separated) Eccezioni (separate da virgole)
Exclude Escludi
@@ -1423,6 +1424,14 @@ file-filter Templates Modelli
Previous Artboard Tavola da disegno precedente
Next Artboard Tavola da disegno successiva
Last Artboard Ultima tavola da disegno
Status Bar Show Mostra nella barra di stato
Artboard Name Nome tavola da disegno
Current Tool Strumento attivo
Date and Time Data e ora
Number of Undos Numero di annullamenti
Document Color Profile Profilo colore del documento
Undos Annullamenti
Redos Ripristini
Go To Link Vai al collegamento
GPL palettes keep solid colours only, as RGB. Le palette GPL conservano solo i colori pieni, in RGB.
GPU Performance Prestazioni GPU
@@ -3498,7 +3507,8 @@ digits Malayalam Malayalam
Single Left Quotation Mark Virgoletta singola di apertura
Single Quotes: Virgolette singole:
Single Right Quotation Mark Virgoletta singola di chiusura
Single-line Composer Composizione su riga singola
Middle Eastern & South Asian Single-line Composer Composizione su riga singola (Medio Oriente e Asia meridionale)
Standard Single-line Composer Composizione standard su riga singola
Toggle Line Composer Alterna composizione delle righe
Sixth Space Spazio di un sesto
Size Dimensione
@@ -8137,7 +8147,7 @@ breakText Glyphs Glifi
@msg column: true floats the whole column and takes no onto, above or below column: true rende mobile l'intera colonna e non accetta onto, above o below
@msg command must be a shape.* command command deve essere un comando shape.*
@msg commands[{i}]: missing `command` commands[{i}]: `command` mancante
@msg composer must be "singleLine" or "everyLine" composer deve essere "singleLine" o "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer deve essere "singleLine", "everyLine", "standardSingleLine" o "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes le forme composte accettano tracciati, tracciati composti, gruppi, forme composte, testo, fusioni e involucri
@msg compound {_1} must contain exactly one open path to join il composto {_1} deve contenere esattamente un tracciato aperto da unire
@msg connect end must be "start" or "end" end di connect deve essere "start" o "end"
Can't render this file because it is too large.
+13 -3
View File
@@ -1688,7 +1688,10 @@ antiAlias Sharp シャープ
Every (minutes) 間隔 (分)
Every option is at its default. すべてのオプションが初期値です。
Every option matches {base}. すべてのオプションが {base} と同じです。
Every-line Composer すべての行を一括処理
Middle Eastern & South Asian Single-line Composer 1 行ずつ組む (中東・南アジア)
Middle Eastern & South Asian Every-line Composer すべての行を一括処理 (中東・南アジア)
Standard Single-line Composer 1 行ずつ組む (標準)
Standard Every-line Composer すべての行を一括処理 (標準)
Exact dash lengths 破線の長さを正確に保つ
Exceptions (comma separated) 例外 (カンマ区切り)
Exclusion 除外
@@ -1885,6 +1888,14 @@ antiAlias Sharp シャープ
Previous Artboard 前のアートボード
Next Artboard 次のアートボード
Last Artboard 最後のアートボード
Status Bar Show ステータスバーの表示
Artboard Name アートボード名
Current Tool 現在のツール
Date and Time 日付と時刻
Number of Undos 取り消し回数
Document Color Profile ドキュメントのカラープロファイル
Undos 取り消し
Redos やり直し
Gradient Fill: click to apply, drag onto art グラデーションの塗り: クリックで適用、アートにドラッグ
Gradient Mesh グラデーションメッシュ
Gradient Tool グラデーションツール
@@ -3282,7 +3293,6 @@ mark-style Japanese 日本式
Simulate Colored Paper 色紙をシミュレート
Simulate Paper 紙色をシミュレート
Single Quotes: 一重引用符:
Single-line Composer 1 行ずつ組む
Toggle Line Composer 行の組版方式を切り替え
Size Tile to Art タイルをアートワークのサイズに合わせる
Move Tile with Art タイルをアートワークと一緒に移動
@@ -7338,7 +7348,7 @@ axis Y Axis Y 軸
@msg column: true floats the whole column and takes no onto, above or below column: true は列全体をフローティングにするため、onto、above、below は指定できません
@msg command must be a shape.* command command には shape.* コマンドを指定してください
@msg commands[{i}]: missing `command` commands[{i}]: `command` がありません
@msg composer must be "singleLine" or "everyLine" composer には "singleLine" または "everyLine" を指定してください
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer は "singleLine"、"everyLine"、"standardSingleLine"、"standardEveryLine" のいずれかにしてください
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes 複合シェイプに含められるのは、パス、複合パス、グループ、複合シェイプ、文字、ブレンド、エンベロープです
@msg compound {_1} must contain exactly one open path to join 連結するには、複合パス {_1} にオープンパスがちょうど 1 つ含まれている必要があります
@msg connect end must be "start" or "end" connect の end には "start" または "end" を指定してください
Can't render this file because it is too large.
File diff suppressed because it is too large Load Diff
+13 -3
View File
@@ -1678,7 +1678,10 @@ antiAlias Sharp 날카롭게
Every (minutes) 간격 (분)
Every option is at its default. 모든 옵션이 기본값입니다.
Every option matches {base}. 모든 옵션이 {base}와(과) 같습니다.
Every-line Composer 전체 줄 컴포저
Middle Eastern & South Asian Single-line Composer 한 줄 조판 (중동·남아시아)
Middle Eastern & South Asian Every-line Composer 전체 줄 컴포저 (중동·남아시아)
Standard Single-line Composer 표준 한 줄 조판
Standard Every-line Composer 표준 전체 줄 컴포저
Exact dash lengths 정확한 대시 길이
Exceptions (comma separated) 예외 (쉼표로 구분)
Exclusion 제외
@@ -1875,6 +1878,14 @@ antiAlias Sharp 날카롭게
Previous Artboard 이전 아트보드
Next Artboard 다음 아트보드
Last Artboard 마지막 아트보드
Status Bar Show 상태 표시줄 표시
Artboard Name 아트보드 이름
Current Tool 현재 도구
Date and Time 날짜 및 시간
Number of Undos 실행 취소 횟수
Document Color Profile 문서 색상 프로파일
Undos 실행 취소
Redos 다시 실행
Gradient Fill: click to apply, drag onto art 그레이디언트 칠: 클릭하여 적용, 아트웍에 끌어 놓기
Gradient Mesh 그레이디언트 메시
Gradient Tool 그레이디언트 도구
@@ -3271,7 +3282,6 @@ mark-style Japanese 일본식
Simulate Colored Paper 색 용지 시뮬레이션
Simulate Paper 용지 시뮬레이션
Single Quotes: 작은따옴표:
Single-line Composer 한 줄 조판
Toggle Line Composer 줄 조판 방식 전환
Size Tile to Art 타일을 아트웍 크기에 맞춤
Move Tile with Art 아트웍과 함께 타일 이동
@@ -8002,7 +8012,7 @@ breakText Glyphs 글리프
@msg column: true floats the whole column and takes no onto, above or below column: true는 열 전체를 띄우며 onto, above, below와 함께 쓸 수 없습니다
@msg command must be a shape.* command command는 shape.* 명령이어야 합니다
@msg commands[{i}]: missing `command` commands[{i}]: `command`가 없습니다
@msg composer must be "singleLine" or "everyLine" composer는 "singleLine" 또는 "everyLine"이어야 합니다
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer는 "singleLine", "everyLine", "standardSingleLine" 또는 "standardEveryLine"이어야 합니다
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes 컴파운드 모양에는 패스, 컴파운드 패스, 그룹, 컴파운드 모양, 문자, 블렌드, 엔벨로프를 넣을 수 있습니다
@msg compound {_1} must contain exactly one open path to join 컴파운드 {_1}에는 연결할 열린 패스가 정확히 하나 있어야 합니다
@msg connect needs a path other than the one extended connect에는 연장한 패스가 아닌 다른 패스가 필요합니다
Can't render this file because it is too large.
+13 -3
View File
@@ -2450,7 +2450,10 @@ digits Malayalam Malayalam
Tabular Lining Tabulaire lining
Tabular Oldstyle Tabulaire oldstyle
Titling Alternates Titelalternatieven
Every-line Composer Compositie per alinea
Middle Eastern & South Asian Single-line Composer Compositie per regel (Midden-Oosten en Zuid-Azië)
Middle Eastern & South Asian Every-line Composer Compositie per alinea (Midden-Oosten en Zuid-Azië)
Standard Single-line Composer Standaardcompositie per regel
Standard Every-line Composer Standaardcompositie per alinea
First-line Left Indent Eerste regel links inspringen
Hyphenation… Afbreken…
Justification… Uitvullen…
@@ -2482,7 +2485,6 @@ digits Malayalam Malayalam
East Asian Composition Settings Instellingen voor Oost-Aziatische zetting
Korean Composition Settings Instellingen voor Koreaanse zetting
Select a text object to edit its paragraph attributes. Selecteer een tekstobject om de alineakenmerken ervan te bewerken.
Single-line Composer Compositie per regel
Toggle Line Composer Compositiemethode wisselen
Space After Paragraph Ruimte na alinea
Space Before Paragraph Ruimte voor alinea
@@ -6332,7 +6334,7 @@ imageTrace Outline Contour
@msg column: true floats the whole column and takes no onto, above or below column: true laat de hele kolom zweven en accepteert geen onto, above of below
@msg command must be a shape.* command command moet een shape.*-opdracht zijn
@msg commands[{i}]: missing `command` commands[{i}]: `command` ontbreekt
@msg composer must be "singleLine" or "everyLine" composer moet "singleLine" of "everyLine" zijn
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer moet "singleLine", "everyLine", "standardSingleLine" of "standardEveryLine" zijn
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes samengestelde vormen accepteren paden, samengestelde paden, groepen, samengestelde vormen, tekst, mengsels en omvormingen
@msg compound {_1} must contain exactly one open path to join samengesteld object {_1} moet precies één open pad bevatten om te verbinden
@msg connect needs a path other than the one extended connect heeft een ander pad nodig dan het pad dat wordt verlengd
@@ -8328,6 +8330,14 @@ swatch Bright Violet Felviolet
Color wheel Kleurenwiel
First Artboard Eerste tekenbord
Last Artboard Laatste tekenbord
Status Bar Show Weergeven in statusbalk
Artboard Name Naam van tekenbord
Current Tool Huidig gereedschap
Date and Time Datum en tijd
Number of Undos Aantal ongedaan gemaakte stappen
Document Color Profile Kleurprofiel van document
Undos Ongedaan maken
Redos Opnieuw uitvoeren
Next Artboard Volgende tekenbord
Previous Artboard Vorige tekenbord
Step up or down Stapsgewijs verhogen of verlagen
Can't render this file because it is too large.
+13 -3
View File
@@ -1045,6 +1045,14 @@ lighting Light Światło
Previous Artboard Poprzedni obszar kompozycji
Next Artboard Następny obszar kompozycji
Last Artboard Ostatni obszar kompozycji
Status Bar Show Pokaż na pasku stanu
Artboard Name Nazwa obszaru kompozycji
Current Tool Bieżące narzędzie
Date and Time Data i godzina
Number of Undos Liczba cofnięć
Document Color Profile Profil kolorów dokumentu
Undos Cofnięcia
Redos Ponowienia
Graphic Style Options… Opcje stylu graficznego…
Symbol Options Opcje symbolu
Symbol Options… Opcje symbolu…
@@ -2019,7 +2027,8 @@ digits Malayalam Malajalam
Tabular Lining Tabelaryczne nowoczesne
Tabular Oldstyle Tabelaryczne nautyczne
Titling Alternates Alternatywy tytułowe
Every-line Composer Kompozytor wielowierszowy
Middle Eastern & South Asian Every-line Composer Kompozytor wielowierszowy (Bliski Wschód i Azja Południowa)
Standard Every-line Composer Standardowy kompozytor wielowierszowy
First-line Left Indent Wcięcie pierwszego wiersza
Hyphenation… Dzielenie wyrazów…
Words Longer Than: Wyrazy dłuższe niż:
@@ -2059,7 +2068,8 @@ digits Malayalam Malajalam
East Asian Composition Settings Ustawienia składu wschodnioazjatyckiego
Korean Composition Settings Ustawienia składu koreańskiego
Select a text object to edit its paragraph attributes. Zaznacz obiekt tekstowy, aby edytować atrybuty akapitu.
Single-line Composer Kompozytor jednowierszowy
Middle Eastern & South Asian Single-line Composer Kompozytor jednowierszowy (Bliski Wschód i Azja Południowa)
Standard Single-line Composer Standardowy kompozytor jednowierszowy
Toggle Line Composer Przełącz kompozytor wierszy
Space After Paragraph Odstęp po akapicie
Space Before Paragraph Odstęp przed akapitem
@@ -8378,7 +8388,7 @@ breakText Glyphs Glify
@msg column: true floats the whole column and takes no onto, above or below column: true odłącza całą kolumnę i nie przyjmuje onto, above ani below
@msg command must be a shape.* command command musi być poleceniem shape.*
@msg commands[{i}]: missing `command` commands[{i}]: brak `command`
@msg composer must be "singleLine" or "everyLine" composer musi mieć wartość "singleLine" lub "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer musi mieć wartość "singleLine", "everyLine", "standardSingleLine" lub "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes kształty złożone przyjmują ścieżki, ścieżki złożone, grupy, kształty złożone, tekst, przejścia i koperty
@msg compound {_1} must contain exactly one open path to join obiekt złożony {_1} musi zawierać dokładnie jedną otwartą ścieżkę do połączenia
@msg connect needs a path other than the one extended connect wymaga ścieżki innej niż przedłużana
Can't render this file because it is too large.
+13 -3
View File
@@ -966,7 +966,8 @@ antiAlias Sharp Nítido
Every (minutes) A cada (minutos)
Every option is at its default. Todas as opções estão no padrão.
Every option matches {base}. Todas as opções correspondem a {base}.
Every-line Composer Compositor de Todas as Linhas
Middle Eastern & South Asian Every-line Composer Compositor de Todas as Linhas (Oriente Médio e Sul da Ásia)
Standard Every-line Composer Compositor Padrão de Todas as Linhas
Exact dash lengths Comprimentos de tracejado exatos
Exceptions (comma separated) Exceções (separadas por vírgula)
Exclude Excluir
@@ -1258,6 +1259,14 @@ antiAlias Sharp Nítido
Previous Artboard Mesa de trabalho anterior
Next Artboard Próxima mesa de trabalho
Last Artboard Última mesa de trabalho
Status Bar Show Mostrar na barra de status
Artboard Name Nome da prancheta
Current Tool Ferramenta atual
Date and Time Data e hora
Number of Undos Número de ações desfeitas
Document Color Profile Perfil de cor do documento
Undos Desfazer
Redos Refazer
Gradient Gradiente
Gradient Fill: click to apply, drag onto art Preenchimento de Gradiente: clique para aplicar, arraste sobre a arte
Gradient Finishes Finalizações de Gradiente
@@ -2890,7 +2899,8 @@ digits Malayalam Malaiala
Single Left Quotation Mark Aspa Esquerda Única
Single Quotes: Aspas Simples:
Single Right Quotation Mark Aspa Direita Única
Single-line Composer Compositor de Linha Única
Middle Eastern & South Asian Single-line Composer Compositor de Linha Única (Oriente Médio e Sul da Ásia)
Standard Single-line Composer Compositor Padrão de Linha Única
Toggle Line Composer Alternar Compositor de Linhas
Sixth Space Espaço de Sexto
Size Tamanho
@@ -8468,7 +8478,7 @@ swatch Yellow Green Verde-amarelado
@msg column: true floats the whole column and takes no onto, above or below column: true torna flutuante a coluna inteira e não aceita onto, above nem below
@msg command must be a shape.* command command deve ser um comando shape.*
@msg commands[{i}]: missing `command` commands[{i}]: falta `command`
@msg composer must be "singleLine" or "everyLine" composer deve ser "singleLine" ou "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer deve ser "singleLine", "everyLine", "standardSingleLine" ou "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes formas compostas aceitam caminhos, caminhos compostos, grupos, formas compostas, texto, mesclagens e envelopes
@msg compound {_1} must contain exactly one open path to join o composto {_1} deve conter exatamente um caminho aberto para unir
@msg connect needs a path other than the one extended connect precisa de um caminho diferente do que foi estendido
Can't render this file because it is too large.
+13 -12
View File
@@ -1075,7 +1075,10 @@ font-technology Variable Вариативные
Every (minutes) Каждые (минут)
Every option is at its default. Все параметры имеют значения по умолчанию.
Every option matches {base}. Все параметры совпадают с {base}.
Every-line Composer Компоновщик всех строк
Middle Eastern & South Asian Single-line Composer Однострочный компоновщик (Ближний Восток и Южная Азия)
Middle Eastern & South Asian Every-line Composer Компоновщик всех строк (Ближний Восток и Южная Азия)
Standard Single-line Composer Стандартный однострочный компоновщик
Standard Every-line Composer Стандартный компоновщик всех строк
Exact dash lengths Точная длина штрихов
Exceptions (comma separated) Исключения (через запятую)
Exclude Исключить
@@ -1412,6 +1415,14 @@ file-filter Templates Шаблоны
Previous Artboard Предыдущая монтажная область
Next Artboard Следующая монтажная область
Last Artboard Последняя монтажная область
Status Bar Show Показ в строке состояния
Artboard Name Имя монтажной области
Current Tool Текущий инструмент
Date and Time Дата и время
Number of Undos Число отмен
Document Color Profile Цветовой профиль документа
Undos Отмены
Redos Повторы
Go To Link Перейти по ссылке
GPL palettes keep solid colours only, as RGB. Палитры GPL сохраняют только сплошные цвета в RGB.
GPU Performance Производительность GPU
@@ -3485,7 +3496,6 @@ digits Malayalam Малаялам
Single Left Quotation Mark Одинарная открывающая кавычка
Single Quotes: Одинарные кавычки:
Single Right Quotation Mark Одинарная закрывающая кавычка
Single-line Composer Однострочный компоновщик
Toggle Line Composer Переключить компоновщик строк
Sixth Space Шестая шпация
Size Размер
@@ -7861,9 +7871,6 @@ shape Open Открытый
@msg `anchors` must list anchor indices (0, 1, 2…), not {k} `anchors` должно содержать индексы опорных точек (0, 1, 2…), а не {k}
@msg `anchors` must list anchor indices (0, 1, 2…), not {v} `anchors` должно содержать индексы опорных точек (0, 1, 2…), а не {v}
@msg `answer` for this {kind} dialog must be one of: {_1} `answer` для этого диалогового окна {kind} должно быть одним из: {_1}
@msg `answers` has more than {MAX_ANSWERS} answers в `answers` больше {MAX_ANSWERS} ответов
@msg `answers` is larger than 1 MiB `answers` больше 1 MiB
@msg `answers` must be a list of answers `answers` должно быть списком ответов
@msg `artboard` must be the index of an artboard of the document `artboard` должно быть индексом монтажной области документа
@msg `artboardsAt` must be [x, y] `artboardsAt` должно быть [x, y]
@msg `artboards` must be a list of artboard indices `artboards` должно быть списком индексов монтажных областей
@@ -8607,10 +8614,6 @@ shape Open Открытый
@msg invalid t недопустимое t
@msg invalid time value недопустимое значение времени
@msg invalid tolerance недопустимый допуск
@msg is a confirm's answer, whose `value` must be true or false является ответом для confirm, `value` которого должно быть true или false
@msg is a prompt's answer, whose `value` must be a string or null является ответом для prompt, `value` которого должно быть строкой или null
@msg is an alert's answer, whose `value` must be "ok" является ответом для alert, `value` которого должно быть "ok"
@msg is longer than 16 KiB длиннее 16 KiB
@msg it draws its image through a clipping path он рисует своё изображение через контур обрезки
@msg it draws no image он не рисует изображения
@msg it is larger than {MAX_DICTIONARY_FILE_BYTES} bytes он больше {MAX_DICTIONARY_FILE_BYTES} байт
@@ -8738,9 +8741,6 @@ shape Open Открытый
@msg more than {MAX_FILES} images больше {MAX_FILES} изображений
@msg more than {MAX_IMPORT} presets больше {MAX_IMPORT} наборов
@msg moved must be [[x,y]…] moved должно быть [[x,y]…]
@msg must be an object with `kind` and `value` должен быть объектом с `kind` и `value`
@msg must have `kind` alert, confirm or prompt должен иметь `kind` alert, confirm или prompt
@msg must have exactly `kind` and `value` должен содержать только `kind` и `value`
# Messages that begin with a lowercase word, n to s.
@msg name (a toolbar's name) is required требуется name (имя панели инструментов)
@msg name (a toolbar's name) must be a string name (имя панели инструментов) должно быть строкой
@@ -9707,3 +9707,4 @@ shape Open Открытый
@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} пикселей по стороне): уменьшите разрешение
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer должен быть "singleLine", "everyLine", "standardSingleLine" или "standardEveryLine"
Can't render this file because it is too large.
+13 -3
View File
@@ -1056,7 +1056,8 @@ font-technology Variable Variabla
Every (minutes) Intervall (minuter)
Every option is at its default. Alla alternativ har standardvärden.
Every option matches {base}. Alla alternativ matchar {base}.
Every-line Composer Flerradssättning
Middle Eastern & South Asian Every-line Composer Flerradssättning (Mellanöstern och Sydasien)
Standard Every-line Composer Standard-flerradssättning
Exact dash lengths Exakta strecklängder
Exceptions (comma separated) Undantag (kommaavgränsade)
Exclude Uteslut
@@ -1361,6 +1362,14 @@ font-technology Variable Variabla
Previous Artboard Föregående rityta
Next Artboard Nästa rityta
Last Artboard Sista ritytan
Status Bar Show Visa i statusfältet
Artboard Name Ritytans namn
Current Tool Aktuellt verktyg
Date and Time Datum och tid
Number of Undos Antal ångringar
Document Color Profile Dokumentets färgprofil
Undos Ångringar
Redos Gör om
Go To Link Gå till länk
GPL palettes keep solid colours only, as RGB. GPL-paletter sparar bara enfärgade färger, som RGB.
GPU Performance GPU-prestanda
@@ -3375,7 +3384,8 @@ digits Malayalam Malayalam
Single Left Quotation Mark Enkelt vänster citattecken
Single Quotes: Enkla citattecken:
Single Right Quotation Mark Enkelt höger citattecken
Single-line Composer Enradssättare
Middle Eastern & South Asian Single-line Composer Enradssättare (Mellanöstern och Sydasien)
Standard Single-line Composer Standard-enradssättare
Toggle Line Composer Växla radsättare
Sixth Space Sjättedelsblanksteg
Size Storlek
@@ -8045,7 +8055,7 @@ digits Hindi Hindi
@msg column: true floats the whole column and takes no onto, above or below column: true gör hela kolumnen flytande och tar inte onto, above eller below
@msg command must be a shape.* command command måste vara ett shape.*-kommando
@msg commands[{i}]: missing `command` commands[{i}]: `command` saknas
@msg composer must be "singleLine" or "everyLine" composer måste vara "singleLine" eller "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer måste vara "singleLine", "everyLine", "standardSingleLine" eller "standardEveryLine"
@msg compound {_1} must contain exactly one open path to join sammansatt {_1} måste innehålla exakt en öppen bana att foga samman
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes sammansatta former tar banor, sammansatta banor, grupper, sammansatta former, text, övergångar och kuvert
@msg connect end must be "start" or "end" connect end måste vara "start" eller "end"
Can't render this file because it is too large.
+228 -17
View File
@@ -3331,6 +3331,72 @@ fn f(text: &str, n: usize) -> Result<u32, String> {
assert!(message_literals_in(&["effects"]).contains("the SVG filter isn't valid XML: {e}"));
}
/// The scan reads the message a `.map_err` closure gives with `return`, also from inside an `if`
/// branch or a `let` statement but not from a closure inside it, the last expression after a block
/// statement with no `;`, and the values a `let` statement gives a local that the closure returns,
/// and not those of a local the closure only passes elsewhere or writes into a format string, by
/// name or as a `format!` argument.
#[test]
fn message_scan_reads_returns_and_tails_and_skips_locals() {
let code = r#"
fn f(text: &str) -> Result<u32, String> {
let a = read(text).map_err(|_| {
return "the file cannot be read".to_string();
})?;
let b = read(text).map_err(|e| {
if e.is_io() {
return format!("the disk failed: {e}");
}
e.to_string()
})?;
let c = read(text).map_err(|e| {
if e.is_io() { cleanup(); }
format!("the file is cut short: {e}")
})?;
let d = read(text).map_err(|e| {
if e.is_io() { cleanup(); }
let level = if e.is_io() { "warning" } else { "error" };
log_failure(level, &e);
format!("the file is not a library: {e}")
})?;
let g = read(text).map_err(|e| {
let kind = match e.kind() {
Kind::Gone => return GONE.into(),
_ => { "some other kind" }
};
format!("the {kind} file is wrong")
})?;
let h = read(text).map_err(|e| {
let name = e.name().unwrap_or_else(|| return "unnamed source");
let note = e.note().map(move |n| { return "noted source" });
format!("the source {name} is gone")
})?;
let k = read(text).map_err(|e| {
let why = if e.is_deep() { format!("its objects are nested too deep ({e})") } else { e.to_string() };
FormatError::NotVectorcraft(why)
})?;
let m = read(text).map_err(|e| {
let level = if e.is_io() { "warning" } else { "error" };
format!("the file failed with a {}", level)
})?;
Ok(a)
}
"#;
let consts = [("GONE", "the file is gone")].map(|(k, v)| (k.to_string(), vec![v.to_string()])).into();
let want = [
"the file cannot be read",
"the disk failed: {e}",
"the file is cut short: {e}",
"the file is not a library: {e}",
"the file is gone",
"the {kind} file is wrong",
"the source {name} is gone",
"its objects are nested too deep ({e})",
"the file failed with a {_1}",
];
assert_eq!(source_messages(code, &[], &consts), want);
}
/// The scan reads the messages of an error handler that a `.map_err(name)` names: a closure bound
/// to that name, up to its `;`, and a function of that name, each of its statements.
#[test]
@@ -4141,7 +4207,8 @@ fn bracketed_message_parts_translate_only_as_exact_messages() {
let point = message(lang, "[x, y] (two numbers)");
assert_ne!(point, "[x, y] (two numbers)", "{code}");
assert!(point.contains("[x, y]"), "{code}: {point}");
for got in ["[1]", "[1, 2, 3]", r#"{"objects": [1]}"#, r#"[{"a": 1}, "b: c", …"#] {
// ``["] `x`: b"]`` fits the text of the effect refusal ``[{j}] `{_1}`: {why}`` but not its index.
for got in ["[1]", "[1, 2, 3]", r#"{"objects": [1]}"#, r#"[{"a": 1}, "b: c", …"#, r#"["] `x`: b"]"#] {
let shown = message(lang, &format!("`center` must be [x, y] (two numbers), not {got}"));
assert!(shown.contains(&point) && shown.contains(got), "{code}: {shown}");
let shown = message(lang, &format!("`p` must be an object, not {got}"));
@@ -4150,6 +4217,42 @@ fn bracketed_message_parts_translate_only_as_exact_messages() {
}
}
/// An effect refusal inside another message (`plug-in output: …`, and an importer's `can't open …`)
/// is translated through its template with its reason, keeping the index and the effect id.
#[test]
fn nested_effect_refusals_translate_with_their_reason() {
for code in COMPLETE_MESSAGES {
let lang = Lang::from_code(code).expect("registered");
let refusal = "[0] `fx`: nothing selected";
let output = format!("plug-in output: objects[0].effects: {refusal}");
for shown in [message(lang, refusal), message(lang, &output), message(lang, &format!("can't open `a.svg`: {output}"))] {
assert!(!shown.contains("nothing selected") && shown.contains("[0] `fx`"), "{code}: {shown}");
}
}
let de = de();
let refusal = "[0] `fx`: `radius` must be a number";
assert_eq!(message(de, refusal), "[0] `fx`: `radius` muss eine Zahl sein");
let output = format!("plug-in output: objects[0].effects: {refusal}");
assert_eq!(message(de, &output), "Plug-in-Ausgabe: objects[0].effects: [0] `fx`: `radius` muss eine Zahl sein");
assert_eq!(
message(de, &format!("can't open `a.svg`: {output}")),
"`a.svg` kann nicht geöffnet werden: Plug-in-Ausgabe: objects[0].effects: [0] `fx`: `radius` muss eine Zahl sein"
);
assert_eq!(
message(de, "plug-in output: objects[12].effects: [3] `fx`: no row for this reason"),
"Plug-in-Ausgabe: objects[12].effects: [3] `fx`: no row for this reason"
);
let selected = "[1] `fx`: nothing selected";
assert_eq!(
message(de, &format!("plug-in output: objects[0].effects: {selected}")),
"Plug-in-Ausgabe: objects[0].effects: [1] `fx`: nichts ausgewählt"
);
// Past the depth limit the refusal stays as it is.
let deep = format!("plug-in output: plug-in output: plug-in output: plug-in output: objects[0].effects: {selected}");
let shown = message(de, &deep);
assert!(shown.ends_with(selected), "{shown}");
}
/// The warning for a PDF/X file that leaves out the document's bleed is translated in every catalog,
/// alone and in the status bar's note.
#[test]
@@ -5137,27 +5240,72 @@ fn statement(code: &str) -> &str {
/// Where each value a closure can return starts, `body` being the text after its parameters: the
/// body itself, each block or `if`/`else` branch in it (`{ ACB_CUT_SHORT.into() }`, not the
/// `{` of a `json!({…})` value), each `match` arm (`=>`) and each statement after a `;` (the
/// last expression of a block or a function body), up to the bracket that closes the call the
/// closure is given to or the function.
/// `{` of a `json!({…})` value), each `match` arm (`=>`), each statement after a `;` or after a
/// block statement's `}` (the last expression of a block or a function body) and the value of
/// each `return`, up to the bracket that closes the call the closure is given to or the function.
/// The blocks, arms and statements inside a `let` statement give a local its value, so they count
/// only when the local's name is used, outside a string literal and a `format!`, in a value the closure returns
/// (`let why = if … { format!("…") } else { … }; Error(why)`), and not when the local only goes
/// elsewhere (`let level = if … { "warning" } else { "error" }; log(level);`). A `return` counts
/// wherever it is, except inside a closure the body holds (`unwrap_or_else(|| return …)`).
fn closure_returns(body: &str) -> Vec<&str> {
let mut out = vec![body];
let (mut depth, mut chars) = (0usize, body.char_indices());
let ident = |c: char| c.is_alphanumeric() || c == '_';
// The name a `let` statement starting at `at` binds (empty for a pattern), if it is one.
let let_at = |at: usize| {
let rest = body[at..].trim_start().strip_prefix("let").filter(|r| r.starts_with(char::is_whitespace))?.trim_start();
let rest = rest.strip_prefix("mut ").map_or(rest, str::trim_start);
Some(&rest[..rest.find(|c: char| !ident(c)).unwrap_or(rest.len())])
};
// Each place a value starts, with the `let` whose local it gives a value to, if any, and
// whether a `return` gives it.
let mut found: Vec<(&str, Option<&str>, bool)> = vec![(body, None, false)];
// For each open bracket, the `quiet` and `in_let` of the text around it: `quiet` names the
// `let` that a value inside the bracket belongs to, `in_let` the `let` the statement is.
let mut outer = vec![];
let (mut quiet, mut in_let, mut chars) = (None, let_at(0), body.char_indices());
// Where the innermost closure in the body that a `return` would leave ends.
let mut inner_closure_end = 0;
while let Some((at, c)) = chars.next() {
match c {
'(' | '[' => depth += 1,
'{' => {
depth += 1;
if !body[..at].trim_end().ends_with('(') {
out.push(&body[at + 1..]);
'|' if at >= inner_closure_end => {
let before = body[..at].trim_end();
let after_operator = before.ends_with(['(', ',', '=']) && !["==", "!=", "<=", ">="].iter().any(|op| before.ends_with(op));
let opens = after_operator || (before.ends_with("move") && !before[..before.len() - 4].ends_with(ident));
let params_end = if body[at + 1..].starts_with('|') { Some(at + 1) } else { body[at + 1..].find('|').map(|end| at + 1 + end) };
if let Some(params_end) = params_end.filter(|_| opens) {
inner_closure_end = params_end + 1 + statement(&body[params_end + 1..]).len();
}
}
')' | ']' | '}' => match depth.checked_sub(1) {
Some(d) => depth = d,
None => break,
},
';' => out.push(&body[at + 1..]),
'=' if body[at + 1..].starts_with('>') => out.push(&body[at + 2..]),
'(' | '[' | '{' => {
outer.push((quiet, in_let));
if c == '{' && !body[..at].trim_end().ends_with('(') {
found.push((&body[at + 1..], quiet.or(in_let), false));
}
quiet = quiet.or(in_let);
in_let = if c == '{' { let_at(at + 1) } else { None };
}
')' | ']' | '}' => {
let Some(around) = outer.pop() else { break };
(quiet, in_let) = around;
if c == '}' {
found.push((&body[at + 1..], quiet.or(in_let), false));
if in_let.is_none() {
in_let = let_at(at + 1);
}
}
}
';' => {
found.push((&body[at + 1..], quiet, false));
in_let = let_at(at + 1);
}
'=' if body[at + 1..].starts_with('>') => found.push((&body[at + 2..], quiet.or(in_let), false)),
'r' if at >= inner_closure_end
&& body[at..].starts_with("return")
&& !body[..at].ends_with(ident)
&& !body[at + "return".len()..].starts_with(ident) =>
{
found.push((&body[at + "return".len()..], None, true));
}
'"' => loop {
match chars.next() {
Some((_, '\\')) => {
@@ -5170,6 +5318,69 @@ fn closure_returns(body: &str) -> Vec<&str> {
_ => {}
}
}
// The values the closure returns: each `return`, and each expression that ends its block
// rather than a `;` (a block's start, which spans the whole block, aside).
let returned: Vec<String> = found
.iter()
.filter(|&&(start, held, by_return)| {
let tail = !start.trim_start().starts_with('{') && !start[statement(start).len()..].starts_with(';');
held.is_none() && (by_return || tail)
})
.map(|(start, ..)| without_format_args(&without_strings(statement(start))))
.collect();
let used = |name: &str| !name.is_empty() && returned.iter().any(|value| holds_ascii_word(value, name));
found.into_iter().filter(|&(_, held, _)| held.is_none_or(used)).map(|(start, ..)| start).collect()
}
/// `code`, its string literals already emptied, with the arguments of each `format!(…)` removed:
/// a value written into a format string is part of a message, not one of its own.
fn without_format_args(code: &str) -> String {
let (mut out, mut rest) = (String::new(), code);
while let Some(at) = rest.find("format!(") {
out.push_str(&rest[..at + "format!(".len()]);
rest = &rest[at + "format!(".len()..];
let mut depth = 0usize;
let end = rest.char_indices().find_map(|(i, c)| match c {
'(' | '[' | '{' => {
depth += 1;
None
}
')' | ']' | '}' => match depth.checked_sub(1) {
Some(d) => {
depth = d;
None
}
None => Some(i),
},
_ => None,
});
rest = &rest[end.unwrap_or(rest.len())..];
}
out.push_str(rest);
out
}
/// `code` with the text of its string literals removed, the quotes kept.
fn without_strings(code: &str) -> String {
let (mut out, mut chars) = (String::new(), code.chars());
while let Some(c) = chars.next() {
out.push(c);
if c == '"' {
loop {
match chars.next() {
Some('\\') => {
chars.next();
}
Some('"') => {
out.push('"');
break;
}
Some(_) => {}
None => break,
}
}
}
}
out
}
+13 -3
View File
@@ -1048,7 +1048,10 @@ font-technology Variable Değişken
Every (minutes) Her (dakika)
Every option is at its default. Her seçenek varsayılan değerdedir.
Every option matches {base}. Her seçenek {base} ile eşleşir.
Every-line Composer Her Satır Bestecisi
Middle Eastern & South Asian Single-line Composer Tek Satır Oluşturucu (Orta Doğu ve Güney Asya)
Middle Eastern & South Asian Every-line Composer Her Satır Bestecisi (Orta Doğu ve Güney Asya)
Standard Single-line Composer Standart Tek Satır Oluşturucu
Standard Every-line Composer Standart Her Satır Bestecisi
Exact dash lengths Tam çizgi uzunlukları
Exceptions (comma separated) İstisnalar (virgülle ayrılmış)
Exclude Hariç tut
@@ -3251,7 +3254,6 @@ digits Malayalam Malayalam
Single Left Quotation Mark Tek Sol Tırnak İşareti
Single Quotes: Tek Alıntılar:
Single Right Quotation Mark Tek Sağ Tırnak İşareti
Single-line Composer Tek Satır Oluşturucu
Toggle Line Composer Satır Oluşturucuyu Değiştir
Sixth Space Altıncı Uzay
Size Boyut
@@ -6156,6 +6158,14 @@ theme Appearance Görünüm
JavaScript: JavaScript:
Large Gaps Büyük Boşluklar
Last Artboard Son Çalışma Yüzeyi
Status Bar Show Durum Çubuğunda Göster
Artboard Name Çalışma Yüzeyi Adı
Current Tool Geçerli Araç
Date and Time Tarih ve Saat
Number of Undos Geri Alma Sayısı
Document Color Profile Belge Renk Profili
Undos Geri Al
Redos Yinele
Levels Düzeyler
Library Panel Options Kütüphane Paneli Seçenekleri
Link JavaScript Files… JavaScript Dosyalarını Bağla…
@@ -7721,7 +7731,7 @@ axis Y Axis Y ekseni
@msg column: true floats the whole column and takes no onto, above or below column: true tüm sütunu yüzdürür ve onto, above veya below almaz
@msg command must be a shape.* command command bir shape.* komutu olmalıdır
@msg commands[{i}]: missing `command` commands[{i}]: `command` eksik
@msg composer must be "singleLine" or "everyLine" composer "singleLine" veya "everyLine" olmalıdır
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer "singleLine", "everyLine", "standardSingleLine" veya "standardEveryLine" olmalıdır
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes bileşik şekiller yolları, bileşik yolları, grupları, bileşik şekilleri, metni, karışımları ve zarfları alır
@msg compound {_1} must contain exactly one open path to join bileşik {_1}, birleştirilecek tam olarak bir açık yol içermelidir
@msg connect needs a path other than the one extended connect için uzatılan yoldan başka bir yol gerekir
Can't render this file because it is too large.
+13 -3
View File
@@ -1080,7 +1080,8 @@ font-technology Variable Варіативні
Every (minutes) Кожен (хвилин)
Every option is at its default. Усі параметри мають значення за промовчанням.
Every option matches {base}. Усі параметри збігаються з {base}.
Every-line Composer Компонувальник всіх рядків
Middle Eastern & South Asian Every-line Composer Компонувальник всіх рядків (Близький Схід і Південна Азія)
Standard Every-line Composer Стандартний компонувальник всіх рядків
Exact dash lengths Точна довжина штрихів
Exceptions (comma separated) Винятки (через кому)
Exclude Виключити
@@ -1417,6 +1418,14 @@ file-filter Templates Шаблони
Previous Artboard Попередня монтажна область
Next Artboard Наступна монтажна область
Last Artboard Остання монтажна область
Status Bar Show Показ у рядку стану
Artboard Name Назва монтажної області
Current Tool Поточний інструмент
Date and Time Дата й час
Number of Undos Кількість скасувань
Document Color Profile Колірний профіль документа
Undos Скасування
Redos Повтори
Go To Link Перейти за посиланням
GPL palettes keep solid colours only, as RGB. Палітри GPL зберігають лише суцільні кольори RGB.
GPU Performance Продуктивність GPU
@@ -3490,7 +3499,8 @@ digits Malayalam Малаялам
Single Left Quotation Mark Одинарна лапка, що відкриває
Single Quotes: Одинарні лапки:
Single Right Quotation Mark Одинарна лапка, що закриває
Single-line Composer Однорядковий компонувальник
Middle Eastern & South Asian Single-line Composer Однорядковий компонувальник (Близький Схід і Південна Азія)
Standard Single-line Composer Стандартний однорядковий компонувальник
Toggle Line Composer Переключити компонувальник рядків
Sixth Space Шоста шпація
Size Розмір
@@ -8004,7 +8014,7 @@ breakText Glyphs Гліфи
@msg column: true floats the whole column and takes no onto, above or below column: true робить плаваючим увесь стовпець і не приймає onto, above або below
@msg command must be a shape.* command command має бути командою shape.*
@msg commands[{i}]: missing `command` commands[{i}]: відсутній `command`
@msg composer must be "singleLine" or "everyLine" composer має бути "singleLine" або "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer має бути "singleLine", "everyLine", "standardSingleLine" або "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes складені фігури приймають контури, складені контури, групи, складені фігури, текст, переходи й оболонки
@msg compound {_1} must contain exactly one open path to join складений об’єкт {_1} має містити рівно один відкритий контур для з’єднання
@msg connect needs a path other than the one extended для connect потрібен контур, відмінний від того, що продовжується
Can't render this file because it is too large.
+13 -2
View File
@@ -1257,7 +1257,10 @@ font-technology Variable Biến thiên
Every (minutes) Mỗi (phút)
Every option is at its default. Mọi tùy chọn đang ở mặc định.
Every option matches {base}. Mọi tùy chọn khớp với {base}.
Every-line Composer Soạn theo từng dòng
Middle Eastern & South Asian Single-line Composer Soạn thảo một dòng (Trung Đông và Nam Á)
Middle Eastern & South Asian Every-line Composer Soạn theo từng dòng (Trung Đông và Nam Á)
Standard Single-line Composer Soạn thảo một dòng tiêu chuẩn
Standard Every-line Composer Soạn theo từng dòng tiêu chuẩn
Exact dash lengths Độ dài nét đứt chính xác
Exceptions (comma separated) Ngoại lệ (phân cách bằng dấu phẩy)
Exclude Loại trừ
@@ -1653,6 +1656,14 @@ file-filter Templates Mẫu
Previous Artboard Bảng vẽ trước
Next Artboard Bảng vẽ tiếp theo
Last Artboard Bảng vẽ cuối cùng
Status Bar Show Hiển thị trên thanh trạng thái
Artboard Name Tên bảng vẽ
Current Tool Công cụ hiện tại
Date and Time Ngày và giờ
Number of Undos Số lần hoàn tác
Document Color Profile Hồ sơ màu của tài liệu
Undos Hoàn tác
Redos Làm lại
Go To Link Đến liên kết
Good Tốt
GPL palettes keep solid colours only, as RGB. Bảng màu GPL chỉ lưu màu đặc theo RGB.
@@ -3850,7 +3861,6 @@ mark-style Japanese Kiểu Nhật
Single Left Quotation Mark Dấu nháy đơn mở
Single Quotes: Dấu nháy đơn:
Single Right Quotation Mark Dấu nháy đơn đóng
Single-line Composer Soạn thảo một dòng
Toggle Line Composer Chuyển đổi cách soạn dòng
Sixth Space Dấu cách 1/6
Size Kích thước
@@ -7412,3 +7422,4 @@ breakText Glyphs Glyph
@msg {width} × {height} pixels is too large for JPEG (at most 65535 pixels a side): lower the resolution {width} × {height} điểm ảnh quá lớn cho JPEG (tối đa 65535 điểm ảnh mỗi cạnh): hãy giảm độ phân giải
@msg {width} × {height} pixels is too large for Targa (at most 65535 pixels a side): lower the resolution {width} × {height} điểm ảnh quá lớn cho Targa (tối đa 65535 điểm ảnh mỗi cạnh): hãy giảm độ phân giải
@msg {w} × {h} pixels is too large for PSD (at most {MAX_SIDE} pixels a side): lower the resolution {w} × {h} điểm ảnh quá lớn cho PSD (tối đa {MAX_SIDE} điểm ảnh mỗi cạnh): hãy giảm độ phân giải
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer phải là "singleLine", "everyLine", "standardSingleLine" hoặc "standardEveryLine"
Can't render this file because it contains an unexpected character in line 205 and column 5.
+13 -3
View File
@@ -1019,7 +1019,8 @@ antiAlias Sharp 锐利
Every (minutes) 每隔 (分钟)
Every option is at its default. 所有选项皆为默认值。
Every option matches {base}. 所有选项皆与{base}相同。
Every-line Composer 逐行排版器
Middle Eastern & South Asian Every-line Composer 逐行排版器(中东和南亚)
Standard Every-line Composer 标准逐行排版器
Exact dash lengths 精确虚线长度
Exceptions (comma separated) 例外词 (逗号分隔)
Exclude 差集
@@ -1352,6 +1353,14 @@ file-filter Templates 模板
Previous Artboard 上一个画板
Next Artboard 下一个画板
Last Artboard 最后一个画板
Status Bar Show 状态栏显示
Artboard Name 画板名称
Current Tool 当前工具
Date and Time 日期和时间
Number of Undos 撤销次数
Document Color Profile 文档颜色配置文件
Undos 撤销
Redos 重做
Go To Link 转到链接
GPL palettes keep solid colours only, as RGB. GPL 调板仅保留为 RGB 的纯色。
GPU Performance GPU 性能
@@ -3312,7 +3321,8 @@ digits Malayalam 马拉雅拉姆数字
Single Left Quotation Mark 左单引号
Single Quotes: 单引号:
Single Right Quotation Mark 右单引号
Single-line Composer 单行排版器
Middle Eastern & South Asian Single-line Composer 单行排版器(中东和南亚)
Standard Single-line Composer 标准单行排版器
Toggle Line Composer 切换行排版器
Sixth Space 六分之一空格
Size 大小
@@ -8364,7 +8374,7 @@ breakText Glyphs 字形
@msg column: true floats the whole column and takes no onto, above or below column: true 会使整列浮动,不能再给出 onto、above 或 below
@msg command must be a shape.* command command 必须是 shape.* 命令
@msg commands[{i}]: missing `command` commands[{i}]:缺少 `command`
@msg composer must be "singleLine" or "everyLine" composer 必须是 "singleLine" 或 "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer 必须是 "singleLine"、"everyLine"、"standardSingleLine" 或 "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes 复合形状接受路径、复合路径、编组、复合形状、文字、混合和封套
@msg compound {_1} must contain exactly one open path to join 复合对象 {_1} 必须恰好包含一条要连接的开放路径
@msg connect needs a path other than the one extended connect 需要一条不同于被延伸路径的路径
Can't render this file because it is too large.
+13 -3
View File
@@ -1050,7 +1050,8 @@ font-technology Variable 可變
Every (minutes) 每隔 (分鐘)
Every option is at its default. 所有選項皆為預設值。
Every option matches {base}. 所有選項皆與{base}相同。
Every-line Composer 逐行排版程式
Middle Eastern & South Asian Every-line Composer 逐行排版程式(中東與南亞)
Standard Every-line Composer 標準逐行排版程式
Exact dash lengths 精確虛線長度
Exceptions (comma separated) 例外 (以逗號分隔)
Exclude 差集
@@ -1387,6 +1388,14 @@ file-filter Templates 範本
Previous Artboard 上一個工作區域
Next Artboard 下一個工作區域
Last Artboard 最後一個工作區域
Status Bar Show 狀態列顯示
Artboard Name 工作區域名稱
Current Tool 目前工具
Date and Time 日期和時間
Number of Undos 復原次數
Document Color Profile 文件色彩描述檔
Undos 復原
Redos 重做
Go To Link 前往連結
GPL palettes keep solid colours only, as RGB. GPL 調色盤僅保留純色,並以 RGB 儲存。
GPU Performance GPU 效能
@@ -4595,7 +4604,8 @@ digits Malayalam 馬來亞拉姆數字
Single Left Quotation Mark 左單引號
Single Quotes: 單引號:
Single Right Quotation Mark 右單引號
Single-line Composer 單行排版程式
Middle Eastern & South Asian Single-line Composer 單行排版程式(中東與南亞)
Standard Single-line Composer 標準單行排版程式
Toggle Line Composer 切換行排版程式
Sixth Space 六分之一空格
Size 大小
@@ -8292,7 +8302,7 @@ breakText Glyphs 字符
@msg column: true floats the whole column and takes no onto, above or below column: true 會讓整欄浮動,不接受 onto、above 或 below
@msg command must be a shape.* command command 必須是 shape.* 指令
@msg commands[{i}]: missing `command` commands[{i}]:未提供 `command`
@msg composer must be "singleLine" or "everyLine" composer 必須是 "singleLine" 或 "everyLine"
@msg composer must be "singleLine", "everyLine", "standardSingleLine" or "standardEveryLine" composer 必須是 "singleLine"、"everyLine"、"standardSingleLine" 或 "standardEveryLine"
@msg compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes 複合形狀接受路徑、複合路徑、群組、複合形狀、文字、漸變物件和封套
@msg compound {_1} must contain exactly one open path to join 複合路徑 {_1} 必須剛好包含一條可連接的開放路徑
@msg connect needs a path other than the one extended connect 需要延伸路徑以外的另一條路徑
Can't render this file because it is too large.
+7 -3
View File
@@ -52,10 +52,12 @@ fn open_bytes_with(app: &mut VectorcraftApp, name: &str, bytes: &[u8], path: Opt
let load = if swatches { crate::panels::swatches::load_library } else { crate::panels::graphic_styles::load_library };
return load(app, p).map(|_| Value::Null);
}
// A PDF with several pages or a password asks first (the Import PDF dialog), and so does a
// DXF drawing (DXF Import Options).
// A PDF with several pages or a password asks first (the Import PDF dialog), and so do a DXF
// drawing (DXF Import Options) and a PSD file with several layers or with slices (PSD Import
// Options), unless `p` says how its layers come in.
if crate::dialogs::import_pdf::offer(app, name, bytes, path.clone(), None)
|| crate::dialogs::dxf_import::offer(app, name, bytes, path.clone(), None)
|| (p.get("layers").is_none() && crate::dialogs::psd_import::offer(app, name, bytes, path.clone(), None))
{
return Ok(Value::Null);
}
@@ -552,9 +554,11 @@ fn open_file_with(app: &mut VectorcraftApp, path: &str, background: bool, p: &Va
check_import_size(path, false)?;
let mut bytes = read(app, path)?;
if background && opens_as(path).is_none() {
// A PDF with several pages or a password, or a DXF drawing, asks first, as at once.
// A PDF with several pages or a password, a DXF drawing, or a PSD file with several layers
// or with slices asks first, as at once.
if crate::dialogs::import_pdf::offer(app, path, &bytes, Some(path.to_string()), None)
|| crate::dialogs::dxf_import::offer(app, path, &bytes, Some(path.to_string()), None)
|| (p.get("layers").is_none() && crate::dialogs::psd_import::offer(app, path, &bytes, Some(path.to_string()), None))
{
note_recent(app, path);
return Ok(Value::Null);
+1
View File
@@ -455,6 +455,7 @@ fn run_ui_part5(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<
Ok(Value::Null)
}
"view.goToArtboard" => go_to_artboard(app, p),
"view.statusBarShow" => crate::chrome::set_status_bar_show(app, p),
// The navigator's four buttons as commands of their own, so Edit › Keyboard Shortcuts lists
// them (view.goToArtboard needs an index, so a key alone can't run it).
"view.firstArtboard" => go_to_artboard(app, &json!({ "index": "first" })),
+1
View File
@@ -63,6 +63,7 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option<bool> {
"view.rotate" => app.view().zip(p.get("angle").and_then(Value::as_f64)).is_some_and(|(view, a)| (view.rotation - a).abs() < 1e-9),
"window.control" => app.ui.control_bar,
"window.helpBar" => app.ui.help_bar,
"view.statusBarShow" => p.get("show").and_then(Value::as_str) == Some(app.ui.status_bar_show.param()),
"window.control.dock" => p.get("edge").and_then(Value::as_str) == Some(crate::chrome::control_bar_placement(&app.ui)),
"window.control.options" => p
.get("group")
+7 -1
View File
@@ -393,7 +393,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"type.lineComposer",
"Toggle Line Composer",
"Cmd+Alt+Shift+C",
"{} the selected type's paragraphs (or those the Type tool's selection touches) use the Single-line Composer when they all use the Every-line Composer, else the Every-line Composer (text.setFormat {composer}) → \"singleLine\" | \"everyLine\"",
"{} the selected type's paragraphs (or those the Type tool's selection touches) use the Single-line Composer when they all use the Every-line Composer, else the Every-line Composer; paragraphs that all use a Standard composer keep it, any other mix takes the Middle Eastern & South Asian one (text.setFormat {composer}) → \"singleLine\" | \"everyLine\" | \"standardSingleLine\" | \"standardEveryLine\"",
),
(
"type.hyphenate",
@@ -433,6 +433,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
),
("view.nextArtboard", "Next Artboard", "", "{} the navigator's Next Artboard button: view.goToArtboard {index: \"next\"} → {index}"),
("view.lastArtboard", "Last Artboard", "", "{} the navigator's Last Artboard button: view.goToArtboard {index: \"last\"} → {index}"),
(
"view.statusBarShow",
"Status Bar Show",
"",
"{show: \"artboardName\" | \"currentTool\" | \"dateTime\" | \"undos\" | \"colorProfile\"} the status bar's Show menu (a click on its info field): the field shows the name of the artboard the navigator shows, the tool in use (the default), the date and time (local on the desktop, UTC on the web), the active document's undo and redo step counts, or the profile its colors use (the one assigned for its color mode, else, or when that one is not available, that mode's working space); kept with the UI state; any other value is an error → show",
),
("view.edges", "Hide Edges", "Cmd+H", "{}"),
("view.artboards", "Hide Artboards", "Cmd+Shift+H", "{}"),
(
+24 -7
View File
@@ -54,15 +54,29 @@ pub(crate) fn align(app: &mut VectorcraftApp, justify: &str) -> Result<Value, St
}
/// `type.lineComposer` (Cmd+Alt+Shift+C): the Single-line Composer for the paragraphs the panel
/// acts on when they all use the Every-line Composer, else the Every-line Composer. Returns the
/// composer set.
/// acts on when they all break their lines every-line (either shaping), else the Every-line
/// Composer. Paragraphs that all use a Standard composer keep it; any other mix takes the Middle
/// Eastern & South Asian one. Returns the composer set.
pub(crate) fn toggle_composer(app: &mut VectorcraftApp) -> Result<Value, String> {
text_style(app).ok_or("select some type first")?;
let id = if shared_composer(app) == Some(Composer::EveryLine) { "singleLine" } else { "everyLine" };
let to_single = shared_para(app, |p| p.composer.is_single_line()) == Some(false);
let standard = shared_para(app, |p| p.composer.shapes_complex_scripts()) == Some(false);
let base = if standard { Composer::StandardEveryLine } else { Composer::EveryLine };
let id = composer_id(base.with_breaking(to_single));
format(app, json!({ "composer": id }));
Ok(json!(id))
}
/// The `text.setFormat` value of `composer`.
fn composer_id(composer: Composer) -> &'static str {
match composer {
Composer::SingleLine => "singleLine",
Composer::EveryLine => "everyLine",
Composer::StandardSingleLine => "standardSingleLine",
Composer::StandardEveryLine => "standardEveryLine",
}
}
/// `type.hyphenate` (Cmd+Alt+Shift+H): what the Hyphenate checkbox does, on the paragraphs the
/// panel acts on. Returns whether they now hyphenate.
pub(crate) fn toggle_hyphenate(app: &mut VectorcraftApp) -> Result<Value, String> {
@@ -874,11 +888,14 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
}
ui.separator();
let composer = shared_composer(app);
for (c, label, id) in
[(Composer::SingleLine, tl!("Single-line Composer"), "singleLine"), (Composer::EveryLine, tl!("Every-line Composer"), "everyLine")]
{
for (c, label) in [
(Composer::SingleLine, tl!("Middle Eastern & South Asian Single-line Composer")),
(Composer::EveryLine, tl!("Middle Eastern & South Asian Every-line Composer")),
(Composer::StandardSingleLine, tl!("Standard Single-line Composer")),
(Composer::StandardEveryLine, tl!("Standard Every-line Composer")),
] {
if menu_item(ui, label, has, composer == Some(c)) {
format(app, json!({ "composer": id }));
format(app, json!({ "composer": composer_id(c) }));
}
}
ui.separator();
@@ -82,6 +82,83 @@ fn paragraph_mixed_composer_checks_neither_menu_item() {
assert_eq!(shared_composer(&app), Some(Composer::EveryLine));
}
/// Cmd+Alt+Shift+C switches between Single-line and Every-line and keeps what each paragraph's
/// composer does with complex scripts: a Standard composer toggles to the other Standard one.
#[test]
fn toggling_the_line_composer_keeps_the_shaping() {
let (mut app, id) = editing_text("A\nB\n");
for (from, first, second) in [
("standardEveryLine", "standardSingleLine", "standardEveryLine"),
("everyLine", "singleLine", "everyLine"),
("standardSingleLine", "standardEveryLine", "standardSingleLine"),
] {
app.run("text.setFormat", json!({"id": id, "composer": from})).unwrap();
app.session.set_tool_option("selectAll", &json!(true));
assert_eq!(toggle_composer(&mut app).unwrap(), json!(first), "{from}");
assert_eq!(toggle_composer(&mut app).unwrap(), json!(second), "{from} again");
}
// Paragraphs that break differently take Every-line, as before the Standard composers existed.
app.run("text.setFormat", json!({"id": id, "composer": "standardSingleLine"})).unwrap();
app.run("text.setFormat", json!({"id": id, "start": 2, "end": 3, "composer": "singleLine"})).unwrap();
app.session.set_tool_option("selectAll", &json!(true));
assert_eq!(toggle_composer(&mut app).unwrap(), json!("everyLine"));
// Paragraphs that both break every-line but differ in shaping: Single-line, Middle Eastern & South Asian.
app.run("text.setFormat", json!({"id": id, "composer": "everyLine"})).unwrap();
app.run("text.setFormat", json!({"id": id, "start": 2, "end": 3, "composer": "standardEveryLine"})).unwrap();
app.session.set_tool_option("selectAll", &json!(true));
assert_eq!(toggle_composer(&mut app).unwrap(), json!("singleLine"));
}
/// The Paragraph panel menu lists the four composers, and ticks the one every selected paragraph has.
#[test]
fn the_paragraph_menu_sets_each_of_the_four_composers() {
let (mut app, id) = editing_text("A\nB\n");
app.session.set_tool_option("selectAll", &json!(true));
let ctx = egui::Context::default();
let items = |app: &mut VectorcraftApp| {
let mut seen = vec![];
let mut out = ctx.run_ui(egui::RawInput::default(), |ui| menu(app, ui));
out.textures_delta.clear();
for shape in out.shapes {
collect_texts(&shape.shape, &mut seen);
}
seen
};
fn collect_texts(shape: &egui::Shape, out: &mut Vec<String>) {
match shape {
egui::Shape::Vec(v) => v.iter().for_each(|s| collect_texts(s, out)),
egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
_ => {}
}
}
let labels = [
("singleLine", "Middle Eastern & South Asian Single-line Composer"),
("everyLine", "Middle Eastern & South Asian Every-line Composer"),
("standardSingleLine", "Standard Single-line Composer"),
("standardEveryLine", "Standard Every-line Composer"),
];
// The menu lists all four, each row ticked (and only that one) when every selected paragraph has it.
for (value, _) in labels {
app.run("text.setFormat", json!({"id": id, "composer": value})).unwrap();
app.session.set_tool_option("selectAll", &json!(true));
let texts = items(&mut app);
for (v, label) in labels {
let row = if v == value { format!("✓ {label}") } else { format!(" {label}") };
assert!(texts.contains(&row), "{value}: {row:?} in {texts:?}");
}
}
// Choosing a row sets its composer: the row is a `text.setFormat {composer}` with the row's id.
for (value, want) in [
("standardEveryLine", Composer::StandardEveryLine),
("singleLine", Composer::SingleLine),
("standardSingleLine", Composer::StandardSingleLine),
] {
app.run("text.setFormat", json!({"id": id, "composer": value})).unwrap();
assert_eq!(shared_composer(&app), Some(want), "{value}");
assert_eq!(composer_id(want), value);
}
}
#[test]
fn paragraph_mixed_hyphenate_checks_off() {
let (mut app, id) = editing_text("A\nB\n");
+20 -6
View File
@@ -61,7 +61,7 @@ pub fn is_document(name: &str) -> bool {
#[derive(Default)]
pub struct PlaceState {
/// Web: the bytes of the files picked for the Place dialog, by name.
picked: Vec<(String, Vec<u8>)>,
pub(crate) picked: Vec<(String, Vec<u8>)>,
/// The loaded cursor's thumbnails by file name.
thumbs: Vec<(String, Thumb)>,
/// The Control bar's `image.info`, for (document uid, revision, image id).
@@ -125,10 +125,11 @@ fn engine(app: &mut VectorcraftApp, id: &str, p: &Value) -> Result<Value, String
/// File → Place… (`file.place`): with a file (`path` or `name` + `dataBase64`), place it, centred
/// in the view unless `at`, `rect` or `replace` say otherwise (a text file without `text` options,
/// a DXF drawing without `dxf` options and a PDF with several pages or a password and no `page`
/// ask for them first, unless `showImportOptions: false` places them with the options confirmed
/// last); with `paths`, the Place dialog for them; with neither, pick the files first. The file is
/// read and placed at once (MCP, scripts).
/// a DXF drawing without `dxf` options, a PSD file embedded without `layers` (when the user places
/// it) and a PDF with several pages or a password and no `page` ask for them first, unless
/// `showImportOptions: false` places them with the options confirmed last); with `paths`, the
/// Place dialog for them; with neither, pick the files first. The file is read and placed at once
/// (MCP, scripts).
pub fn run(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
place_file(app, p, Read::AtOnce)
}
@@ -181,6 +182,7 @@ fn place_file_in(app: &mut VectorcraftApp, p: &Value, read: Read) -> Result<Valu
if let Some(dxf) = crate::dialogs::dxf_import::last_options(app, &p) {
p["dxf"] = dxf;
}
crate::dialogs::psd_import::last_options(app, &mut p);
}
if p.get("text").is_none() && crate::dialogs::text_import::is_text(&p) {
return Ok(crate::dialogs::text_import::open(app, &p));
@@ -209,6 +211,12 @@ fn place_file_in(app: &mut VectorcraftApp, p: &Value, read: Read) -> Result<Valu
if ask && crate::dialogs::dxf_import::offer_place(app, &p) {
return Ok(json!({ "dialog": crate::dialogs::dxf_import::KIND }));
}
// A PSD file with several layers or with slices that the user embeds asks for its import
// options. A place run as a command (MCP, scripts) places at once and takes `layers` and
// `importSlices` itself.
if ask && matches!(read, Read::ForUser { .. }) && crate::dialogs::psd_import::offer_place(app, &p) {
return Ok(json!({ "dialog": crate::dialogs::psd_import::KIND }));
}
if ["at", "rect", "replace"].iter().all(|k| p.get(k).is_none())
&& let Some(v) = app.view()
{
@@ -409,9 +417,15 @@ pub fn confirm(app: &mut VectorcraftApp, d: &crate::state::Dialog) -> Result<Val
let files: Vec<&Value> = many.iter().filter(|s| s.get("path").is_none()).collect();
let mut q = json!({ "paths": paths, "files": files, "link": link, "template": template });
if !ask {
// Each text file and DXF drawing in the cursor takes the options confirmed last.
// Each text file, DXF drawing and embedded PSD file in the cursor takes the options
// confirmed last.
q["text"] = crate::dialogs::text_import::last_options(app);
q["dxf"] = crate::dialogs::dxf_import::remembered(app);
if !link || paths.is_empty() {
// Files from bytes have no file to link to; they may carry the dialog's Link.
q["link"] = json!(false);
crate::dialogs::psd_import::queue_options(app, &mut q);
}
}
queue_files(app, &q, Read::ForUser { dropped: false }, ask)
}
+9
View File
@@ -550,6 +550,10 @@ pub struct UiState {
#[serde(default)]
pub toolbar_right: bool,
pub status_bar: bool,
/// What the status bar's info field shows (its Show menu, `view.statusBarShow`): Current Tool by
/// default and in state saved without it ([`crate::chrome::deserialize_status_bar_show`]).
#[serde(default, deserialize_with = "crate::chrome::deserialize_status_bar_show")]
pub status_bar_show: crate::chrome::StatusBarShow,
pub help_bar: bool,
pub dock: bool,
/// The bars that Tab (`window.dock`) hid, which the next Tab shows again; none when Tab has not
@@ -827,6 +831,9 @@ pub struct UiState {
/// never used).
#[serde(default)]
pub dxf_import: Value,
/// The PSD Import Options chosen last (layers, hiddenLayers, importSlices; null: never used).
#[serde(default)]
pub psd_import: Value,
/// The Home screen is shown over the open documents (`app.home`): the active document's uid
/// and the document count when it opened. Choosing a tab, or a document opening, closing or
/// becoming active, leaves it.
@@ -1177,6 +1184,7 @@ impl Default for UiState {
tools_beside_canvas: false,
toolbar_right: false,
status_bar: true,
status_bar_show: crate::chrome::StatusBarShow::CurrentTool,
help_bar: true,
dock: true,
tab_hid: None,
@@ -1255,6 +1263,7 @@ impl Default for UiState {
transform_each: Value::Null,
rearrange_artboards_spacing: Value::Null,
dxf_import: Value::Null,
psd_import: Value::Null,
home: None,
trace_hold_source: None,
layers_panel: Default::default(),
+4 -1
View File
@@ -294,7 +294,10 @@ other `sv-*` locale resolve to it), Georgian (`ka`, complete; `ka-GE` and `ka_GE
control channel, MCP and tests read them) and are translated only where the status bar draws them
(`i18n::msg`). `@msg` catalog rows hold a whole message or a template such as
`Couldn't open {name}: {e}`; `{_1}`, `{_2}` … stand for the format string's `{}`, and the values in the
placeholders are translated in turn (the reason after `: {e}` is often a message too). A literal brace in a
placeholders are translated in turn (the reason after `: {e}` is often a message too). A value that starts with
`{` is translated only when it has an exact row, so a JSON object stays as it is; a value that starts with `[` is
also matched against a template that starts with `[` and an index of digits, such as an effect's refusal
``[{j}] `{_1}`: {why}``, so its reason is translated while a JSON array stays as it is. A literal brace in a
row is written `{{` or `}}`, in the English and in the translation: a message made with `format!` keeps the
doubled braces of its format string, and a plain string literal has each of its braces doubled, so the row for
`"expected {\"objects\": [...]}"` is `expected {{"objects": [...]}}`. Czech, German, Greek, Spanish, French, Georgian, Hindi, Hungarian, Italian, Japanese, Korean, Polish, Brazilian Portuguese, Russian, Simplified Chinese, Traditional Chinese, Swedish, Ukrainian, Vietnamese, Finnish, Turkish, Catalan, Dutch and Danish
+1 -1
View File
@@ -294,7 +294,7 @@ Names in the editing data that aren't UTF-8 (layers, objects, artboards, colors,
| HP-GL/2 `.plt`, `.hpgl`, `.hgl`, `.hpg` | — | yes (pen moves, pens and widths, line types and attributes, circles, arcs, wedges and Bézier curves, filled and edged rectangles, wedges and polygons, encoded polylines, scaling and rotation; labels, symbol mode, raster images and hatching aren't drawn) | yes (`.plt`: each visible path once along its line, a pen per color or a pen table, type as outlines, clipping applied, HP-GL or HP-GL/2 with pen colors and encoded polylines) | recognized by its first instructions after any printer escapes, under its own extensions or one no other format reads; `crates/cad/src/hpgl/tests.rs`, `crates/cad/src/hpgl/write/tests.rs` (plots read back by the reader), `tests_hpgl.rs`, `import_fuzz.rs` |
| DWG | open, export | no | no | no open spec; DXF instead |
| EMF / WMF | open, export | yes | yes | an oversized embedded PNG or JPEG is refused from its header, before any pixels are decoded (#1776) |
| PSD | open, place, export | yes (open: layers as layers, or the merged image with `layers: false`; place: merged image; the merged image comes in clipped by the file's clipping path; every mode and depth; `.psd` and `.pdd`) | yes (layered, max editability) | placing as layers and a PSD import options dialog missing; the embedded ICC profile's tags are 4-byte aligned (#1584) |
| PSD | open, place, export | yes (open: layers as layers, or the merged image with `layers: false`; place: merged image, or the layers embedded as a group of objects with `layers: true`; the merged image comes in clipped by the file's clipping path; every mode and depth; `.psd` and `.pdd`) | yes (layered, max editability) | PSD Import Options on File › Open and on File › Place without Link (Convert Layers to Objects, Flatten Layers to a Single Image, Import Hidden Layers, Import Slices; `tests_psdlayers.rs`, `dialogs/psd_import.rs`); slices (image resource 1050, version 6 and the version 7 and 8 descriptor) open and embed as user slices with `importSlices` (`tests_psdslices.rs`); layer comps aren't read; the embedded ICC profile's tags are 4-byte aligned (#1584) |
| PSB | open | yes (layers as layers, or the merged image; the merged image comes in clipped by the file's clipping path) | no | |
| PNG / JPEG / GIF / BMP / TIFF / Targa | open, place, export | yes (PNG: `.png` and `.pns`; BMP: `.bmp`, `.dib` and `.rle`; Targa: `.tga`, `.vda`, `.icb` and `.vst`, raw or run-length encoded, with a 16-bit file's one-bit alpha) | yes; TIFF is also selectable in Export for Screens and Asset Export with its existing options | Targa: `tests_tiffbmp.rs`, `tests/links.rs`; TIFF: grayscale with an alpha channel or other extra channels reads (#1466 in part), and so do files that store each channel as its own plane (PlanarConfiguration 2), CMYK ones with their ink amounts, and 1-bit files compressed with CCITT Group 3 (Compression 2 and 3, one- and two-dimensional rows); the ICC profiles embedded in JPEG and TIFF have 4-byte aligned tags (#1584); PNG export marks its colours as sRGB (`embedIcc`, an `sRGB` chunk; no ICC profile is embedded, #2221) |
| WebP | export (Export for Screens) | yes | yes (lossless only; lossy written lossless with a warning) | |
+3 -2
View File
File diff suppressed because one or more lines are too long
+99 -13
View File
@@ -1,6 +1,6 @@
# VectorCraft MCP server
> **Last updated:** 2026-11-14 · **Change:** Pencil ignores Smart Guides and Snap to Point and shows no Smart Guides, #7252; no response-shape change. Previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; no response-shape change. Previously: Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; no response-shape change. Previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097); existing response shapes retained.
> **Last updated:** 2026-11-14 · **Change:** `text.setFormat {composer}` and paragraph styles also take `standardSingleLine` and `standardEveryLine` (#4935); existing values and responses unchanged. Previously: Pencil ignores Smart Guides and Snap to Point and shows no Smart Guides, #7252; no response-shape change. Previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; no response-shape change. Previously: Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; no response-shape change. Previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097); existing response shapes retained.
>
> Tech Circuit update (2026-11-14): three original procedural brushes; ten built-in brush libraries (G5).
@@ -6623,6 +6623,22 @@ Reset Rotate View is the command `view.rotateReset`:
the angle the selected objects share (`selectionRotation` in `document.inspect`, 0 when their angles differ), so their
bounding box is square to the window. It returns `{angle}`, and with nothing selected it returns "nothing selected".
`view.statusBarShow` (desktop app, the Show menu that a click on the status bar's info field opens) chooses what that
field shows, with `show` set to one of these values:
- `artboardName`: the name of the artboard the status bar's navigator shows.
- `currentTool`: the name of the tool in use. This is the default.
- `dateTime`: the date and time, as `2026-11-15 14:03`. The desktop app shows local time, and the web build shows UTC
with ` UTC` after it.
- `undos`: the active document's undo and redo step counts, as `Undos: 3 Redos: 1`.
- `colorProfile`: the profile the active document's colors use. That is the profile assigned for its color mode
(Edit › Assign Profile), or that mode's working space (Edit › Color Settings) when none is assigned or the
assigned one is not available.
It returns the value set. The choice is kept with the UI state. A missing or other `show` fails with
``` `show` must be one of artboardName, currentTool, dateTime, undos, colorProfile ``` and leaves the choice as it was.
Without a document, the readouts that need one show a dash.
The Smart Guides preferences (Preferences › Smart Guides) apply to `pointer_gesture` with Smart Guides on (the
default view) and to the mouse; they change what the tools show and how far a target pulls, and only Construction
Guides change where a snapped point lands:
@@ -7172,10 +7188,12 @@ with `pointer_gesture` (a click places at 100% with the top-left corner there, a
number, naming the key, and place nothing; null is the same as leaving the key out.
In the app, `file.place` asks for a file's import options before placing it: a text file without `text` (Text Import
Options), a DXF drawing without `dxf` (DXF Import Options), and a PDF, `.ai` or `.ait` file with several pages or a
password and no `page` (Place PDF). `showImportOptions: false` places such a file without asking, with the options
last confirmed in its dialog: the text options, and the DXF fit, lineweight, centering and layer choices with the
drawing at 1:1 in its own unit. A PDF is placed on page 1 (or `page`) and its crop box, and an encrypted PDF given no
Options), a DXF drawing without `dxf` (DXF Import Options), a PDF, `.ai` or `.ait` file with several pages or a
password and no `page` (Place PDF), and a PSD or PSB file embedded without `layers` that has two layers or more or
slices (Place PSD). `showImportOptions: false` places such a file without asking, with the options last confirmed in
its dialog: the text options, the DXF fit, lineweight, centering and layer choices with the drawing at 1:1 in its own
unit, and the PSD conversion, hidden-layer and Import Slices choices. A PDF is placed on page 1 (or `page`) and its
crop box, and an encrypted PDF given no
`password` still asks for the password. A `showImportOptions` that is not true or false is refused, and nothing is placed. The
Place dialog (File › Place, or `file.place {paths}`) has a Show Import Options checkbox after Link, Template and
Replace ([Place multiple files in a document](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/place-multiple-files-in-a-document.html)).
@@ -8604,6 +8622,65 @@ flattened picture every PSD file carries: Bitmap, Grayscale, Duotone, Indexed, R
A document with transparency keeps it. `file.place {path}` links the file like any image (`links.update` reads it
again when it changes); Multichannel files are refused.
`file.place` with `layers: true` embeds a PSD or PSB file's layers as objects instead, and `hiddenLayers: true`
brings the hidden layers in, hidden. The
[PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html)
offer the conversion and the hidden layers only for a file that is opened or embedded, and a linked file shows its
flat image. The rest are VectorCraft's own rules:
- The layers are read as `document.open` reads them (below) and placed as one group named after the file. A layer
becomes an image and a layer group becomes a group, each with the layer's name, visibility, opacity, blend mode
and opacity mask. A Pass Through group is not isolated; a group in any other mode is.
- The group takes the place the merged image would take: `at` centers the file's canvas and `rect` fits it. When
layers reach past the canvas, hidden layers included, the group is a clip group whose clipping path is the canvas.
- The layers are never linked. With `layers: true`, `link` is false unless it is given, and `link: true` is an
error.
- `hiddenLayers: true` without `layers: true` is an error.
- A file without layers is embedded as its merged image, and so is a file whose layers are all left out, with the
import's warnings. A file whose layers can't be read is embedded as its merged image with a warning.
- `file.place.queue` and `file.place.info` take `layers` and `hiddenLayers` too.
`document.psdInfo` reads a PSD or PSB file without opening it: its `format` (`psd` or `psb`), the canvas `width`
and `height` in pixels, and the counts `layers` (group markers left out), `hiddenLayers`, `groups` and `slices`
(the slices `importSlices` brings in). A file without layer records, or whose layer records can't be read, has
`layers: 0`; a file without slices, or whose slices can't be read, has `slices: 0`. A file that is not a PSD or PSB
file is an error.
`importSlices` brings a PSD or PSB file's slices in as user slices (Object › Slice), which Save for Web exports.
The [PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html)
keep the slices a file holds, and offer it only for a file that is opened or embedded. The slices are read from
image resource 1050 as the
[Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/) describes it,
in version 6 and in the descriptor of versions 7 and 8. The rest are VectorCraft's own rules:
- `document.open` takes `importSlices`, default true, with the layers as objects and with `layers: false` alike.
The slices lie over the canvas, each clipped to it.
- `file.place` takes `importSlices`, default true when the file is embedded and false when it is linked;
`importSlices: true` with a linked file is an error. The slices move and scale with the placed art, in the same
undo step, and the reply lists their ids in `slices`. `file.place.info` counts them in `slices`, and
`file.place.queue` takes `importSlices` too.
- Each slice keeps its name, its type (Image or No Image), its link, target, message, alternative text and
background color, and a No Image slice keeps its cell text (plain text escaped as HTML). Text alignment isn't
read. A slice that follows a layer comes in as a user slice over the rectangle the file stores for it.
- Slices the file generated automatically are left out: the document lays out its own auto slices around the
others. A slice wholly outside the canvas, or without a size, is left out with a warning, and so are slices that
can't be read; the file's art comes in either way. A file without slices brings no warning.
In the app, File › Open of a PSD or PSB file with two or more layers, or with slices, shows PSD Import Options:
Convert Layers to Objects (with Import Hidden Layers) or Flatten Layers to a Single Image, and Import Slices, which
is offered only for a file with slices and applies to either choice. File › Place shows the same dialog for such a
file placed without Link, and so does a file dropped on the canvas with Shift held. The dialog starts from the
choices made last, at first Convert Layers to Objects without hidden layers, with Import Slices. A file with fewer
than two layers and no slices, a file placed with Link, and `document.open` and `file.place` run as commands don't
show it. Several files placed together without Link load the place cursor without asking, and each PSD or PSB file
among them comes in with the choices made last.
```json
{"name":"run_command","arguments":{"command":"file.place","params":{"path":"/tmp/poster.psd","layers":true,"hiddenLayers":true}}}
{"name":"run_command","arguments":{"command":"document.psdInfo","params":{"path":"/tmp/poster.psd"}}}
{"name":"run_command","arguments":{"command":"document.open","params":{"path":"/tmp/poster.psd","importSlices":false}}}
```
A PSD or PSB file that names a clipping path (the saved path its clipping path resource names, in the
[published PSD file format specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/)) places, and
opens as its merged image (`layers: false`, a file with no layers, or a file whose layers can't be read), inside a clip group whose clipping
@@ -8663,8 +8740,7 @@ Each layer's pixels must fit the memory allowed for one image, and the pixels of
canvases the merges make, must together fit eight times that; a file past either limit opens as its merged image,
with a warning. The canvases one step of a merge holds at once must also fit the memory allowed for one image; when
they don't, the layer that needed the merge comes in alone, with a warning: in the Normal mode, or as a layer of its
own instead of clipped. File › Open in the app has no PSD import options dialog: it converts the layers and leaves
hidden layers out.
own instead of clipped.
```json
{"name":"run_command","arguments":{"command":"document.open","params":{"path":"/tmp/poster.psd","hiddenLayers":true}}}
@@ -10366,7 +10442,7 @@ The `paraStyleOptions` dialog exposes `name`, `section` (`general`, `basic`, `ta
100000 pt); it is disabled at 256 stops or when a stop is already at that position. Delete Tab removes the selected
stop, and Clear All Tabs leaves the style with no stops, which it then sets. OK sorts the stops by
position; of two stops at one position it keeps the one edited last.
- Composition: `composer` (`singleLine` or `everyLine`) and the `roman_hanging` checkbox.
- Composition: `composer` (`singleLine`, `everyLine`, `standardSingleLine` or `standardEveryLine`) and the `roman_hanging` checkbox.
- Hyphenation: the `hyphenate` checkbox, `words_longer_than`, `after_first`, `before_last`, `hyphen_limit`,
`hyphenation_zone` and the `hyphenate_capitalized` checkbox. The options are inactive while Hyphenation is off, and
Hyphenation Zone is inactive with the Every-line Composer.
@@ -11349,9 +11425,17 @@ of the group in the Layers panel (`layer.move`).
## Paragraph composer
`text.setFormat {ids?, composer: "singleLine"|"everyLine"}` sets how a text object's lines are broken (the Paragraph
panel menu's Single-line and Every-line Composer; stored in the paragraph attributes as `para.composer`, saved only
when it is Single-line). Every-line, the default, picks the breaks of the whole paragraph together in area type:
`text.setFormat {ids?, composer: "singleLine"|"everyLine"|"standardSingleLine"|"standardEveryLine"}` sets how a text
object's lines are broken and whether complex scripts are shaped (the Paragraph panel menu's four composers: Middle
Eastern & South Asian Single-line and Every-line, and Standard Single-line and Every-line; stored in the paragraph
attributes as `para.composer`, saved only when it is not Every-line, which is the default and what all type used before the
Standard composers existed). `singleLine` and `everyLine` shape Indic, Arabic and Hebrew type with the font's layout
tables, as all type is set; `standardSingleLine` and `standardEveryLine` break lines the same way but set such type
glyph by glyph as the font maps its characters (no conjuncts, reordering, mark placement or joining forms), for legacy
fonts that keep a script on Latin character codes. The scripts a Standard composer leaves unshaped are Indic, Arabic and the
other joining scripts (Syriac, N'Ko, Mongolian, Adlam…) and Hebrew; Latin, Greek, Cyrillic, CJK, Thai and the rest keep their
kerning and ligatures under every composer. Letters left unshaped do not join, so Insert Kashidas adds no tatweel between them. An older VectorCraft cannot open a file that uses a Standard composer. `.ai`, EPS and PDF files carry no composer.
Every-line, the default, picks the breaks of the whole paragraph together in area type:
justified text gets even word spacing, ragged text (left, centre or right aligned) an even rag, so it may move a word
that fits to the next line to avoid a lone short word on the last line or a full line next to a short one.
Single-line fills each line as far as it goes. Point type and type on a path have no line width, so both composers
@@ -11371,8 +11455,10 @@ new height and broken again in the room there. When that leaves the taller chara
set at its own height where the room there is no narrower, with the words before that character that fit there, and
otherwise stays where it was placed.
The UI command `type.lineComposer` (Cmd+Alt+Shift+C, in remote mode `press_key {key: "C", mods: {cmd: true, alt: true,
shift: true}}` or `invoke_menu`) sets `singleLine` when every paragraph of the selected type (or every paragraph the
Type tool's selection touches) uses Every-line, else `everyLine`, and returns the composer it set.
shift: true}}` or `invoke_menu`) sets the Single-line form when every paragraph of the selected type (or every paragraph the
Type tool's selection touches) uses an Every-line one, else the Every-line form. Paragraphs that all use a Standard composer
keep it (`standardSingleLine` or `standardEveryLine`); any other mix takes the Middle Eastern & South Asian one (`singleLine`
or `everyLine`). It returns the composer it set.
```json
{"name":"run_command","arguments":{"command":"text.setFormat","params":{"ids":[7],"composer":"singleLine"}}}
File diff suppressed because one or more lines are too long
+5 -3
View File
@@ -1,6 +1,6 @@
# Type parity
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-11 · **Change:** minor (kerning at the Type tool's caret at the start of a line sets the space before the character after it, #5111; previously minor: type's strokes in an envelope paint along its bent glyph outlines at their own weight, Distort Appearance on or off, as users' `.ai` files draw them, #6644; previously minor: a centred or right-aligned line of tracked type is aligned without the tracking after its last character, as the page of users' `.ai` files aligns it, #6610; previously minor: tracking and manual kerning in horizontally scaled type are thousandths of the em as the Horizontal Scale draws it, as the page of users' `.ai` files spaces such type; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: Direct Selection shows and drags the direction handles of type on a path's path, #3565; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; paint-only Arabic harakat keep joining with GDEF-mark ownership and Insert Kashidas base-letter paint; scores and estimates unchanged; custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: right-aligned area type sets the text after a line's last tab against the right edge; a soft return in justified type no longer keeps its line from being justified; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen) · **Target:** Adobe Illustrator 2026 (30.x)
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-14 · **Change:** minor (Paragraph composers (#4935): the Paragraph panel menu and paragraph styles offer four composers, the Middle Eastern & South Asian Single-line and Every-line (how all type is set, and the default) and a Standard Single-line and Every-line that set Indic, Arabic and Hebrew type glyph by glyph as the font maps it, for legacy fonts that keep a script on Latin character codes; `.ai` and EPS files do not carry the choice; scores and estimates unchanged; previously minor: kerning at the Type tool's caret at the start of a line sets the space before the character after it, #5111; previously minor: type's strokes in an envelope paint along its bent glyph outlines at their own weight, Distort Appearance on or off, as users' `.ai` files draw them, #6644; previously minor: a centred or right-aligned line of tracked type is aligned without the tracking after its last character, as the page of users' `.ai` files aligns it, #6610; previously minor: tracking and manual kerning in horizontally scaled type are thousandths of the em as the Horizontal Scale draws it, as the page of users' `.ai` files spaces such type; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: Direct Selection shows and drags the direction handles of type on a path's path, #3565; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; paint-only Arabic harakat keep joining with GDEF-mark ownership and Insert Kashidas base-letter paint; scores and estimates unchanged; custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: right-aligned area type sets the text after a line's last tab against the right edge; a soft return in justified type no longer keeps its line from being justified; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen) · **Target:** Adobe Illustrator 2026 (30.x)
Glyphs review (#6084): a positional variant no supported feature draws is accepted as a glyph choice. Entire Font respects the selection's variable axes and font version; the default cell can reset an unlisted choice without GSUB alternates. Contextual choices use the supplying face, including fallback. Feature-only boundaries preserve ligature clusters and Arabic mark attachment. Encoded characters insert unchanged except Arabic presentation forms with a joining base letter; normalization reports success only after insertion succeeds. Latest follow-up regressions await runtime verification. Scores and estimates unchanged.
@@ -41,7 +41,7 @@ against Illustrator's public documentation; **estimated** unless noted.
| Variable fonts | done | named instances as styles; Character panel › Variable Font sets each axis (`fontAxes`); the font menu's Font Technology › Variable lists only variable font families, with the script, kind and ★ filters ([Find, apply, and adjust variable fonts](https://helpx.adobe.com/illustrator/desktop/design-with-text/fonts-and-scripts/find-apply-and-adjust-variable-fonts.html)); a family with a variable file beside static ones counts as variable. Evidence: `font_menu::tests::the_variable_filter_lists_only_variable_families`, `tests_axes::a_family_with_variation_axes_is_variable`, `tests_sysfonts::a_family_with_a_variable_file_beside_static_ones_is_variable` |
| Fallback glyphs keep the text's weight and slant | done | #2491: a character from a fallback face is set in that family's face nearest the run's weight and slant; Bold Italic of a missing family is drawn Bold (Source Sans 3 has no Bold Italic) rather than Italic; a letter and its combining marks (a grapheme cluster) are drawn in one face, the first that has all of them, so marks the text's font lacks attach to their letter instead of drawing as missing glyphs (#4491). Vietnamese letters with two marks (Ể, Ứ, Ự) sit on their letter whether typed precomposed, decomposed or as a vowel plus a tone mark, built from GPOS mark-to-mark in fonts without the precomposed letters. Evidence: `tests::vietnamese` |
| Colour fonts (bitmap, COLR, OpenType SVG) | partial | bitmap glyphs (`sbix`, `CBDT`) done: the largest strike's PNG, transformed with the type, fill and stroke ignored; PDF Type 3 glyphs or images, SVG images with outlined text (live text leaves emoji to the viewer, their fonts not embedded), EPS and legacy `.ai` images, Create Outlines images; not `sbix` duplicate, flipped, JPEG or TIFF glyphs, or `CBDT` BGRA or mask data, or ruby; in envelopes they warp as images do, and a Warp effect moves them without bending them. COLR (v0 and v1) done: a glyph's layers as vector art (solid colours, linear and radial gradients that pad, repeat or reflect (the [COLR specification](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)'s extend modes), clip glyphs and boxes, blend modes, transforms, palette 0, the foreground colour from the run's fill, variable fonts at the face's instance), transformed with the type; drawn on the canvas, written as paths in SVG, EPS, legacy `.ai` and PDF with outlined text, as text in PDF (Type 3 glyphs), and Create Outlines makes groups of editable paths. Paints documents have no form for draw the glyph as an image (256 px per em): sweep gradients, Porter-Duff compositing, radial gradients from a circle that isn't the centre, radial gradients that repeat or reflect and start at a circle, gradients that repeat or reflect with a stop whose color isn't in the palette. Not ruby. COLR and SVG glyphs also go with type that geometry effects reshape (on the canvas and in exports), into Expand Appearance and EMF/WMF export, as their art, and bitmap glyphs as images. OpenType SVG done: a glyph's SVG document (its element `glyph<gid>`) is read by the SVG importer into vector art in font units, `currentColor` in the run's fill (and the legacy `context-fill` and `context-stroke` in its fill and stroke), a `viewBox` mapped onto the em square, and then drawn, exported and outlined as COLR glyphs are; in PDF real text such glyphs are text that draws nothing, with their art drawn where they sit. Images in glyph documents are in the art, holding their pixels until a document takes them in; text, scripts and embedded content are left out, as the table rules them out. Not CPAL palette variables. Evidence: `tests_svg_glyphs`, `svg/tests/it/svg_glyphs.rs`, `tests_colourfonts::svg_glyph_images_draw_and_outline`, `tests_colourfonts::create_outlines_turns_svg_glyphs_into_groups`, `tests_colourfonts::pdf_real_text_draws_svg_glyphs_as_art_and_keeps_their_characters`, `tests_colourfonts::expand_appearance_keeps_the_colour_glyphs_of_type_with_effects`, `render::tests_colrglyphs::colour_glyphs_go_with_type_that_a_geometry_effect_reshapes`, `tests_bitmaps`, `tests_colr`, `render::tests_bitmapglyphs`, `render::tests_colrglyphs`, `pdf::tests::colour_bitmap_glyphs_export_as_images`, `pdf::tests::colr_glyphs_export_as_vector_art`, `svg/tests/it/colour_glyphs.rs`, `eps` `colour_bitmap_glyphs_*`, `colr_glyphs_*` and `type_taken_back_for_the_page_limit_takes_its_glyph_images_with_it`, `tests_pathops::create_outlines_turns_bitmap_glyphs_into_images`, `tests_pathops::create_outlines_turns_colr_glyphs_into_layer_groups` |
| Every-line and Single-line composers | done | tuned by eye, never compared side by side |
| Every-line and Single-line composers | done | tuned by eye, never compared side by side; each in a Middle Eastern & South Asian and a Standard form (#4935), see below |
| Optical Margin Alignment | done | Type › Optical Margin Alignment, `type.opticalMarginAlignment`: per type object, with one setting for all the frames of a thread, in point and area type of left-to-right paragraphs, and at the brackets of type on a path whose first paragraph runs left to right; right-to-left paragraphs of point and area type, and type on a path whose first paragraph runs right to left, do not hang |
| System Layout | done | Character panel menu › System Layout, `type.systemLayout`: the whole document, off by default and for documents from before it, saved only when on. On, every text object advances by whole points (at least one when a character takes space). New point, area and path type, threaded frames, placed text, graph and dimension labels and pasted plain text inherit it. Evidence: `tests::system_layout_rounds_positive_advances_to_whole_points`, `typecmd::area_tests::system_layout_sets_the_document_and_every_text_object`, `panels::character::tests::system_layout_menu_item_toggles_the_document` |
| Fractional Widths | done | Character panel menu › Fractional Widths, `type.fractionalWidths`: per type object, and every frame of its threads. On by default and for documents from before it; saved only when off. Off, each character that takes space advances by a whole number of points, at least one, so small type does not run together. Evidence: `tests::fractional_widths_off_rounds_positive_advances_to_whole_points`, `typecmd::area_tests::fractional_widths_is_set_per_object_and_saved_only_when_off`, `panels::character::tests::fractional_widths_menu_item_toggles_the_type_object` |
@@ -62,7 +62,8 @@ against Illustrator's public documentation; **estimated** unless noted.
| Middle Eastern: bidirectional layout, Paragraph Direction | done | PDF export keeps harakat and zero-advance Noto Arabic dot glyphs in one compatible batch per layout line, with per-glyph vertical offsets (#6309). `crates/pdf/src/tests/realtext.rs` (`mark_text_*`) checks decoded cluster mappings, mixed Arabic/Latin/digits, contour placement against outline export, vertical columns, differing path rotations and PDF/X-1a/3/4. Editable-text import still needs ActualText support (#6165); separately styled or differently rotated clusters and external viewer search/copy remain outside this export-only evidence. |
| Middle Eastern and Indic: digit types (Character panel menu › Digits: Default, Arabic, Hindi, Farsi; Devanagari, Bengali, Gurmukhi, Gujarati, Odia, Tamil, Telugu, Kannada, Malayalam) | done | `text.setFormat` / `text.setRangeStyle {digits}` (`"devanagari"`, `"bengali"`, `"gurmukhi"`, `"gujarati"`, `"odia"`, `"tamil"`, `"telugu"`, `"kannada"`, `"malayalam"` added, #4942); the text keeps the typed digits, the glyphs and SVG export follow the style; carried by character styles. Not yet: `.ai` export of the setting; Indic digits typed as such stay as typed under another system. Evidence: `text::tests::indic_digits_map_to_their_scripts_block`, `tests::bidi::indic_digits_draw_the_scripts_own_digits`, `typecmd::area_tests::indic_digits_round_trip_through_the_commands_and_the_file` |
| Middle Eastern: Kashidas | done | Paragraph Insert Kashidas sets the length for justified Arabic area type; Character-menu Kashidas allows or excludes selected characters, on by default. A kashida is inserted only between two allowed joined characters. The character switch is retained in character styles and the native file; the length is retained in paragraph styles and the native file. Paint-only harakat (coloured or hidden marks) stay in one shaping cluster so letters keep joining; when the character-level pass matches, a glyph may take a later in-cluster character's run only if GDEF names it a mark (class 3) and that character is a harakat—otherwise the cluster start (a mark may miss its colour; a base never takes a mark's). Inserted tatweels take the base letter's paint—not a trailing mark's. Fonts without GDEF and some AAT/`morx` ligatures (e.g. Geeza Pro Allah) can leave a mark painted as its letter. No Character-panel harakat colour command yet. Evidence: `tests::harakat`. [Public help](https://helpx.adobe.com/illustrator/desktop/design-with-text/fonts-and-scripts/justify-text-using-kashida-and-hyphenation.html). |
| Middle Eastern: Middle Eastern composers, split caret | missing | Character Direction is done; editable bidirectional SVG text remains incomplete. |
| Middle Eastern & South Asian composers and Standard composers (Paragraph panel menu, paragraph styles, `text.setFormat {composer}`) | done / partial | #4935: per paragraph, four choices. Middle Eastern & South Asian Single-line and Every-line are how all type was already set (complex-script shaping on) and stay the default, so existing documents do not change. Standard Single-line and Every-line break lines the same way and set Indic, Arabic and Hebrew type glyph by glyph as the font maps its characters (no conjuncts, reordering, mark placement or joining), for legacy fonts that keep a script on Latin character codes. Indic, Arabic and the other joining scripts and Hebrew are the scripts left unshaped (their letters do not join, so Insert Kashidas adds no tatweel); Latin, Greek, Cyrillic, CJK, Thai and the rest keep their kerning and ligatures. The native file and paragraph styles keep the choice (`standardSingleLine` / `standardEveryLine`; an older VectorCraft cannot read a file that uses them). `.ai`, EPS and PDF import and export carry no composer: this app has no recorded format for it, so a Standard paragraph opened from or saved to those files comes back Middle Eastern & South Asian. Evidence: `tests::composers`, `tests::panelcmds::text_set_format_takes_the_four_composers`, `native_v3::all_four_composers_round_trip` |
| Middle Eastern: split caret | missing | Character Direction is done; editable bidirectional SVG text remains incomplete. |
| CJK: input methods (marked text, candidate window) | done | |
| CJK: kinsoku (Hard, Soft, None), the predefined mojikumi sets (None, YakumonoHankaku, GyomatsuYakumonoHankaku, GyomatsuYakumonoZenkaku, YakumonoZenkaku, with VectorCraft's own spacing for each) and Line-end Punctuation Half Width, tate-chu-yoko (auto) | done / partial | custom kinsoku sets, custom mojikumi sets and the Mojikumi Settings dialog missing |
| CJK: Kinsoku Shori Type (Push In First, Push Out First, Push Out Only) | done | Paragraph panel menu › Kinsoku Shori Type (`text.setFormat {kinsokuType}`), with the East Asian options ([Formatting Asian characters](https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html)); Push Out Only is the default, and a push-in closes the line's gaps next to CJK characters by at most a tenth of an em each (VectorCraft's own limit). Evidence: `layout::wrapping_tests::kinsoku_shori_type_pushes_a_closing_bracket_in_or_out`, `tests::vertical::kinsoku_shori_type_pushes_a_closing_bracket_in_or_out`, `typecmd::area_tests::kinsoku_shori_type_is_set_per_paragraph_and_saved_only_when_not_push_out_only` |
@@ -87,6 +88,7 @@ Character Styles menu New/Redefine and footer New capture the first selected cha
| Date | Change | Summary |
|---|---|---|
| 2026-11-14 | minor | Paragraph composers (#4935): `text.setFormat {composer}` and paragraph styles take `singleLine` and `everyLine` (the Middle Eastern & South Asian composers, what all type used and the default) and `standardSingleLine` and `standardEveryLine`, which break lines the same way and set a complex script (Indic, Arabic, Hebrew) glyph by glyph as the font maps its characters, with no conjuncts, reordering, marks placed or joining forms. The choice is per paragraph, saved in the native file only when it is not Every-line, and not written to `.ai`, EPS or PDF files, whose composer setting this app has no recorded format for. Scores and estimates unchanged. Tests `tests::composers`. |
| 2026-11-12 | minor | Glyphs review (#6084): validate contextual glyph choices against their supplying face, including fallback and overflow; keep feature-only boundaries inside ligatures and Arabic mark clusters while retaining drawing-attribute splits; preserve insertion failures instead of reporting normalization success. Deterministic engine, shaping and panel regression sources added; ligature range assertions use the fixture's unencoded glyph identity. Runtime proof pending. Scores and estimates unchanged. |
| 2026-11-12 | minor | Glyphs review (#6084): Entire Font resolves the selected font's version and variable axes; the default cell remains available to reset an unlisted choice with no listed alternates. Character insertion normalizes only Arabic presentation forms, preserving ordinary characters whose glyphs share Arabic substitution provenance. Add deterministic panel apply/reset/Undo regressions without OS-font dependencies. Scores and estimates unchanged. |
| 2026-11-09 | minor | Glyphs review (#6084): the engine accepts a positional alternate as a glyph choice when no supported feature draws it, not only an isolated character's alternates; both panel views exercise apply and Undo. OpenType style options preserve only a valid last on-value when enabling a stylistic set. Scores and estimates unchanged. |
+1
View File
@@ -456,6 +456,7 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
| Workspaces (save, reset, switch); each remembers the layout changes made in it across switches and restarts until Reset <name> | done | `UiState::workspace_changes` |
| Opening a file: after 0.4 s a progress window with the file name, a moving bar (reading counts no steps), how many more files wait, Cancel (Esc: the file doesn't open) and Continue in Background; never over another dialog or progress window | done | #5930; `opening::show`, `file.cancelOpen`, `file.openInBackground`. Save, Place and Close still show only the status bar's spinner (Place and Save run off the UI thread; Close is immediate) |
| Window › Help Bar shows or hides the tool-help strip apart from the status bar; kept with the preferences and in saved workspaces; Presentation Mode hides both bars | done | `window.helpBar`; `help_bar_toggle_is_independent_and_saved_in_workspaces`, `help_bar_and_status_bar_render_independently`, `legacy_help_bar_visibility_follows_each_layouts_status_bar` |
| Status bar: a click on the info field opens a Show menu that chooses its readout: Artboard Name, Current Tool (the default), Date and Time, Number of Undos (undo and redo counts) or Document Color Profile; kept with the UI state | done | `view.statusBarShow`; [public behavior reference](https://web.archive.org/web/2014/https://helpx.adobe.com/illustrator/using/workspace-basics.html); `the_status_bar_info_field_shows_the_chosen_readout`, `a_click_on_the_info_field_opens_the_show_menu`, `the_status_bar_show_choice_is_checked_and_saved`. The menu labels are VectorCraft's own |
| Background Export: a progress dialog with the file name, the artboard count and a bar (busy for one artboard and for formats made in one go), Cancel (Esc) and Continue in Background; it opens after 0.4 s and never over another dialog. A cancelled export writes no file | done | #2564; on the shared `vectorcraft_doc::cancel` token (#2546), so a cancelled render keeps no half-drawn pattern tile or effect raster. The bar moves between artboards, not within one. Save As, Export for Screens and Export Selection don't show it yet |
| Swatch, graphic style and symbol library panels: each library opens in a panel of its own, several at once, that floats, groups, docks and closes like any panel; opening an open library brings its panel forward; Previous / Next Library change the library in place; the panel menu's Persistent reopens the panel at startup with its view and find field (a library loaded from a file is read again; when its file is missing the panel reopens showing the file's path with Locate Library…, and the status bar names the file) | done | #2603; panel ids `library:<kind>:<id>`, `ui.libraryPanel {panel, library?, view?, showFind?, persistent?}`, `ui.libraryPanel.locate {panel, path?}`; the library panels have no sort option, as before |
| DXF export/import preserves intended curve closure | done | #1299; R13–2018 closed SPLINE bit set/read; an open curve ending at its start stays open; knots and control points unchanged; circular cubic paths export as native CIRCLE/ARC where stroke semantics permit; DXF Options' Preset menu and `document.exportDxf`'s `dxfPreset: "cnc"` set the CNC / CAM options (#5500) |