Merge main into fix/int-param-wrong-type

This commit is contained in:
dotCooCoo committed 2026-11-13 18:03:25 -08:00
commit c8bdb6ee06
83 files changed
+9110 -361

No files matched your search

+1 -1
View File
@@ -31,7 +31,7 @@ pub(crate) fn adapter_summary(info: &eframe::wgpu::AdapterInfo) -> String {
format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type)
}
/// Windows and Linux: no OS title bar; the app bar is the title bar (`vectorcraft_ui_egui::titlebar`).
/// Windows: no OS title bar; the app bar is the title bar (`vectorcraft_ui_egui::titlebar`).
/// macOS keeps its traffic lights over the integrated title strip.
///
/// Used on macOS and Windows (where VectorCraft keeps today's frame regardless of the
+61 -20
View File
@@ -763,33 +763,19 @@ impl Node {
children.iter().rposition(|c| !c.is_ruler_guide()).map_or(0, |i| i + 1)
}
/// Remove the ruler guides of this layer and of its sublayers. Other nodes hold none.
/// Remove the ruler guides of this layer and of its sublayers. Other nodes hold none. Only
/// layers that hold one are copied.
pub fn strip_ruler_guides(&mut self) {
if !self.holds_ruler_guides() {
return;
}
if let Some(ch) = self.children_mut() {
ch.retain(|c| !c.is_ruler_guide());
for c in ch.iter_mut().filter(|c| c.holds_ruler_guides()) {
Arc::make_mut(c).strip_ruler_guides();
}
if let Some(held) = held_guides(self, &Self::is_ruler_guide) {
strip_held(self, held);
}
}
/// Call `f` on the position (along the axis it crosses) of each ruler guide of this layer and
/// of its sublayers, with whether the guide is vertical. Only layers that hold one are copied.
pub fn map_ruler_guide_positions(&mut self, f: &mut impl FnMut(bool, &mut f64)) {
if !self.holds_ruler_guides() {
return;
}
if let Some(ch) = self.children_mut() {
for c in ch.iter_mut().filter(|c| c.is_ruler_guide() || c.holds_ruler_guides()) {
let c = Arc::make_mut(c);
match &mut c.kind {
NodeKind::RulerGuide { vertical, pos, .. } => f(*vertical, pos),
_ => c.map_ruler_guide_positions(f),
}
}
if let Some(held) = held_guides(self, &Self::is_ruler_guide) {
map_held(self, held, f);
}
}
@@ -834,6 +820,61 @@ impl Node {
}
}
/// The ruler guides a layer holds: its children that are one, by index in order (each with
/// nothing inside), and its sublayers holding one (with what they hold).
#[derive(Debug, Default)]
pub(super) struct HeldGuides(Vec<(usize, HeldGuides)>);
/// The ruler guides, by `is_guide`, that `n` holds if it is a layer, or `None` when it holds
/// none. `is_guide` looks at each child of `n` and of its sublayers once.
pub(super) fn held_guides(n: &Node, is_guide: &impl Fn(&Node) -> bool) -> Option<HeldGuides> {
if !n.is_layer() {
return None;
}
let held: Vec<_> = n
.children()
.into_iter()
.flatten()
.enumerate()
.filter_map(|(i, c)| if is_guide(c) { Some((i, HeldGuides::default())) } else { held_guides(c, is_guide).map(|h| (i, h)) })
.collect();
(!held.is_empty()).then_some(HeldGuides(held))
}
/// Remove the ruler guides of `layer` and of its sublayers that [`held_guides`] found (`held`).
/// Only the sublayers holding one are copied, and only those are visited.
pub(super) fn strip_held(layer: &mut Node, held: HeldGuides) {
let Some(ch) = layer.children_mut() else { return };
let mut held = held.0.into_iter().peekable();
let mut next = 0;
ch.retain_mut(|c| {
let at = next;
next += 1;
let Some((_, inner)) = held.next_if(|(i, _)| *i == at) else { return true };
// A sublayer holds something; a ruler guide has nothing inside.
if inner.0.is_empty() {
return false;
}
strip_held(Arc::make_mut(c), inner);
true
});
}
/// Call `f` (whether it is vertical, its position) on each ruler guide of `layer` and of its
/// sublayers that [`held_guides`] found (`held`), in the order they lie in. Only the sublayers
/// holding one, and the guides, are copied, and only those sublayers are visited.
pub(super) fn map_held(layer: &mut Node, held: HeldGuides, f: &mut impl FnMut(bool, &mut f64)) {
let Some(ch) = layer.children_mut() else { return };
for (i, inner) in held.0 {
let Some(c) = ch.get_mut(i) else { continue };
if !inner.0.is_empty() {
map_held(Arc::make_mut(c), inner, f);
} else if let NodeKind::RulerGuide { vertical, pos, .. } = &mut Arc::make_mut(c).kind {
f(*vertical, pos);
}
}
}
impl Node {
/// The Appearance panel's row for what this object's own fills and strokes paint around:
/// "Contents" for a group or layer (its members) and for an image (its pixels), "Characters"
+204
View File
@@ -598,3 +598,207 @@ fn compound_stroke_path_is_its_members_in_order() {
assert_eq!(bp.elements(), expected.elements());
assert!(!bp.elements().is_empty());
}
/// The sublayers in [`guide_layers`]'s chain, each inside the one before.
const GUIDE_CHAIN: u64 = 30;
/// How many children the layers of [`guide_layers`] hold: the layer's 6, 1 in the sublayer
/// without a guide, 2 at each of the two places the shared sublayer lies, the innermost
/// sublayer's 2 and 3 in each sublayer around it.
const GUIDE_LAYER_CHILDREN: usize = 6 + 1 + 2 * 2 + 2 + (GUIDE_CHAIN as usize - 1) * 3;
/// How many ruler guides the layers of [`guide_layers`] hold: one in each sublayer of the chain,
/// one at each place the shared sublayer lies and the layer's own.
const GUIDE_LAYER_GUIDES: usize = GUIDE_CHAIN as usize + 2 + 1;
/// A layer holding, in order: [`GUIDE_CHAIN`] sublayers, each inside the one before and holding an
/// object and a ruler guide; a sublayer with an object only; a sublayer with an object and a
/// guide; an object; that last sublayer again; and a guide. Guides differ in direction, artboard
/// and lock. Returns the layer, the sublayer without a guide and the one that lies twice.
fn guide_layers() -> (Node, Arc<Node>, Arc<Node>) {
let rect = |id| Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default_art()));
let guide = |id: u64| {
let kind = NodeKind::RulerGuide { vertical: id.is_multiple_of(2), pos: id as f64, artboard: id.is_multiple_of(3).then_some(7) };
let mut g = Node::new(NodeId(id), kind);
g.locked = id.is_multiple_of(5);
Arc::new(g)
};
let sublayer = |id, children: Vec<Arc<Node>>| {
let mut l = Node::layer(NodeId(id), "Sub", LayerColor::Preset(1));
if let Some(ch) = l.children_mut() {
*ch = children;
}
Arc::new(l)
};
let mut chain = sublayer(100, vec![rect(150), guide(200)]);
for depth in 1..GUIDE_CHAIN {
chain = sublayer(100 + depth, vec![rect(600 + depth), chain, guide(300 + depth)]);
}
let still = sublayer(500, vec![rect(501)]);
let twice = sublayer(510, vec![rect(511), guide(512)]);
let mut layer = Node::layer(NodeId(1), "Layer", LayerColor::Preset(0));
if let Some(ch) = layer.children_mut() {
*ch = vec![chain, Arc::clone(&still), Arc::clone(&twice), rect(2), Arc::clone(&twice), guide(3)];
}
(layer, still, twice)
}
/// Whether `a` and `b` hold the same children, none of them copied.
fn same_children(a: &Node, b: &Node) -> bool {
let (a, b) = (a.children().unwrap(), b.children().unwrap());
a.len() == b.len() && a.iter().zip(b).all(|(a, b)| Arc::ptr_eq(a, b))
}
/// Stripping the ruler guides of a layer looks at each child of the layer and of its sublayers
/// once, however deep the sublayers nest. The art and its order stay, a sublayer without a guide is
/// not copied, and a copy of the layer held elsewhere keeps its guides.
#[test]
fn stripping_ruler_guides_looks_at_each_child_of_nested_layers_once() {
use std::cell::Cell;
let (whole, still, twice) = guide_layers();
let ids = |n: &Node| {
let mut out = vec![];
n.walk(&mut |c| out.push(c.id));
out
};
let mut art = vec![];
whole.walk(&mut |c| {
if !c.is_ruler_guide() {
art.push(c.id);
}
});
assert_eq!(ids(&whole).len(), art.len() + GUIDE_LAYER_GUIDES);
let mut n = whole.clone();
let looked = Cell::new(0_usize);
let pick = |c: &Node| {
looked.set(looked.get() + 1);
c.is_ruler_guide()
};
let held = super::ops::held_guides(&n, &pick).unwrap();
assert_eq!(looked.get(), GUIDE_LAYER_CHILDREN, "each child of the layers is looked at once");
super::ops::strip_held(&mut n, held);
assert_eq!(looked.get(), GUIDE_LAYER_CHILDREN, "removing looks at nothing again");
assert_eq!(ids(&n), art, "the art stays, in its order");
let ch = n.children().unwrap();
assert!(Arc::ptr_eq(&ch[1], &still), "a sublayer without a guide is not copied");
assert!(Arc::ptr_eq(&ch[3], &whole.children().unwrap()[3]), "an object is not copied");
assert!(!Arc::ptr_eq(&ch[2], &twice) && !Arc::ptr_eq(&ch[4], &twice) && !Arc::ptr_eq(&ch[2], &ch[4]));
assert_eq!(
(ch[2].children().map(Vec::len), ch[4].children().map(Vec::len)),
(Some(1), Some(1)),
"a sublayer lying twice is stripped at both places"
);
// The copies held elsewhere (an undo step's, say) keep their guides.
assert_eq!(twice.children().map(Vec::len), Some(2));
assert_eq!(ids(&whole).len(), art.len() + GUIDE_LAYER_GUIDES);
// The method strips the same guides.
let mut same = whole.clone();
same.strip_ruler_guides();
assert_eq!(same, n);
assert!(Arc::ptr_eq(&same.children().unwrap()[1], &still));
// With no guide left there is nothing to remove, and nothing is copied.
let before = n.clone();
n.strip_ruler_guides();
assert!(same_children(&n, &before));
let mut empty = Node::layer(NodeId(900), "Empty", LayerColor::Preset(0));
empty.strip_ruler_guides();
assert_eq!(empty.children().map(Vec::len), Some(0));
// Only a layer holds ruler guides: a group is left as it is, on its own and in a layer.
let mut group = Node::group(NodeId(901), vec![Arc::clone(&twice)]);
assert!(super::ops::held_guides(&group, &Node::is_ruler_guide).is_none());
group.strip_ruler_guides();
assert!(Arc::ptr_eq(&group.children().unwrap()[0], &twice));
let group = Arc::new(group);
let mut around = Node::layer(NodeId(902), "Around", LayerColor::Preset(0));
around.children_mut().unwrap().push(Arc::clone(&group));
around.strip_ruler_guides();
assert!(Arc::ptr_eq(&around.children().unwrap()[0], &group));
}
/// Changing the positions of the ruler guides of a layer looks at each child of the layer and of
/// its sublayers once, however deep the sublayers nest. Each guide is changed once, in the order
/// the guides lie in, and keeps everything else about it; the art is unchanged, a sublayer without
/// a guide is not copied, and a copy of the layer held elsewhere keeps its positions.
#[test]
fn mapping_ruler_guide_positions_looks_at_each_child_of_nested_layers_once() {
use std::cell::Cell;
let (whole, still, twice) = guide_layers();
let mut lines = vec![];
whole.walk(&mut |c| {
if let NodeKind::RulerGuide { vertical, pos, .. } = c.kind {
lines.push((vertical, pos));
}
});
assert_eq!(lines.len(), GUIDE_LAYER_GUIDES);
assert!(lines.iter().any(|l| l.0) && lines.iter().any(|l| !l.0), "guides in both directions");
let mut n = whole.clone();
let looked = Cell::new(0_usize);
let pick = |c: &Node| {
looked.set(looked.get() + 1);
c.is_ruler_guide()
};
let held = super::ops::held_guides(&n, &pick).unwrap();
assert_eq!(looked.get(), GUIDE_LAYER_CHILDREN, "each child of the layers is looked at once");
let mut seen = vec![];
super::ops::map_held(&mut n, held, &mut |vertical, pos| {
seen.push((vertical, *pos));
*pos = *pos * 2.0 + 1.0;
});
assert_eq!(looked.get(), GUIDE_LAYER_CHILDREN, "changing looks at nothing again");
assert_eq!(seen, lines, "each guide once, in the order the guides lie in");
// The same nodes in the same order: a guide differs in its position alone, and the art not
// at all.
let (mut was, mut now) = (vec![], vec![]);
whole.walk(&mut |c| was.push(c));
n.walk(&mut |c| now.push(c));
assert_eq!(was.len(), now.len());
for (a, b) in was.into_iter().zip(now) {
if a.is_layer() {
assert_eq!((b.id, b.is_layer(), b.children().map(Vec::len)), (a.id, true, a.children().map(Vec::len)));
continue;
}
let mut want = a.clone();
if let NodeKind::RulerGuide { pos, .. } = &mut want.kind {
*pos = *pos * 2.0 + 1.0;
}
assert_eq!(b, &want);
}
let ch = n.children().unwrap();
assert!(Arc::ptr_eq(&ch[1], &still), "a sublayer without a guide is not copied");
assert!(Arc::ptr_eq(&ch[3], &whole.children().unwrap()[3]), "an object is not copied");
assert!(!Arc::ptr_eq(&ch[2], &twice) && !Arc::ptr_eq(&ch[4], &twice) && !Arc::ptr_eq(&ch[2], &ch[4]));
// The copy held elsewhere keeps its position.
assert!(matches!(twice.children().unwrap()[1].kind, NodeKind::RulerGuide { pos, .. } if pos == 512.0));
// The method changes the same guides, each once.
let mut same = whole.clone();
let mut calls = 0;
same.map_ruler_guide_positions(&mut |_, pos| {
calls += 1;
*pos = *pos * 2.0 + 1.0;
});
assert_eq!((calls, &same), (GUIDE_LAYER_GUIDES, &n));
assert!(Arc::ptr_eq(&same.children().unwrap()[1], &still));
// A function that leaves the positions as they are is still called on each guide.
let mut kept = whole.clone();
let mut calls = 0;
kept.map_ruler_guide_positions(&mut |_, _| calls += 1);
assert_eq!((calls, &kept), (GUIDE_LAYER_GUIDES, &whole));
// A layer without a guide, an empty layer and a group: nothing to change, nothing copied.
let mut bare = whole.clone();
bare.strip_ruler_guides();
let before = bare.clone();
let mut calls = 0;
bare.map_ruler_guide_positions(&mut |_, _| calls += 1);
assert!(same_children(&bare, &before));
let mut empty = Node::layer(NodeId(900), "Empty", LayerColor::Preset(0));
empty.map_ruler_guide_positions(&mut |_, _| calls += 1);
let mut group = Node::group(NodeId(901), vec![Arc::clone(&twice)]);
group.map_ruler_guide_positions(&mut |_, _| calls += 1);
assert!(Arc::ptr_eq(&group.children().unwrap()[0], &twice));
assert_eq!(calls, 0);
}
+2 -2
View File
@@ -43,7 +43,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Apply as Filter",
["Object", "Plug-ins", "Color Effects"],
None,
"{effect: a colour adjustment's effect id (adjust.brightnessContrast, adjust.curves, adjust.hueSaturation, adjust.levels, adjust.shiftToColor, adjust.temperatureTint, addon.color.exposure, addon.color.desaturate, addon.color.duotone or addon.color.invert), params?: {…} (as effect.apply; missing keys take the dialog defaults), fill?: true, stroke?: true, includeImages?: true, includePatterns?: true, ids?: [id…] (default: the selection)} recolour the objects and everything inside them as the live effect would draw them, but in their colours, as edit.colors.invert does (fills, strokes, type, gradient meshes, embedded images and pattern tiles), as one undo step; their effects stay. Duotone links a colour to its one tone's swatch as the live effect does. On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed}",
"{effect: a colour adjustment's effect id (adjust.brightnessContrast, adjust.curves, adjust.hueSaturation, adjust.levels, adjust.shiftToColor, adjust.temperatureTint, addon.color.exposure, addon.color.desaturate, addon.color.duotone or addon.color.invert), params?: {…} (as effect.apply; missing keys take the dialog defaults), fill?: true, stroke?: true, includeImages?: true, includePatterns?: true, ids?: [id…] (default: the selection)} recolour the objects and everything inside them as the live effect would draw them, but in their colours, as edit.colors.invert does (fills, strokes, type, gradient meshes, embedded images and pattern tiles), as one undo step (none when nothing changes); their effects stay. Duotone links a colour to its one tone's swatch as the live effect does. On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed}",
has_selection,
filter
),
@@ -70,7 +70,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Apply Nearest Swatch",
["Object", "Plug-ins", "Color Effects"],
None,
"{library?: as addon.color.nearestSwatch (default: \"document\"), fill?: true, stroke?: true, ids?: [id…] (default: the selection)} give each solid colour and gradient stop of the selected objects' fills and strokes (their type's and those of the objects inside them; gradient meshes too) the colour of its nearest swatch in the library, as addon.color.nearestSwatch finds it, as one undo step: a global or spot swatch's colour links to it. A library's swatches the colours take are added to the document's first, as swatch.library.add adds them (a spot colour stays spot); images and patterns keep their colours. On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed: paints changed, swatches: [the document swatches the colours took], added: [swatches added to the document]}",
"{library?: as addon.color.nearestSwatch (default: \"document\"), fill?: true, stroke?: true, ids?: [id…] (default: the selection)} give each solid colour and gradient stop of the selected objects' fills and strokes (their type's and those of the objects inside them; gradient meshes too) the colour of its nearest swatch in the library, as addon.color.nearestSwatch finds it, as one undo step (none when nothing changes): a global or spot swatch's colour links to it. A library's swatches the colours take are added to the document's first, as swatch.library.add adds them (a spot colour stays spot); images and patterns keep their colours. On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed: paints changed, swatches: [the document swatches the colours took], added: [swatches added to the document]}",
has_selection,
nearest::apply
),
+5 -5
View File
@@ -72,7 +72,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Make",
["Object", "Live Paint"],
Some("Cmd+Alt+X"),
"{ids?|id?} build a Live Paint group from the selected paths (paths, compound paths and groups of them; type, images and other objects are refused, nothing changes); each covered face starts with its front-most covering source's fill; with a Live Paint group among them, add the others to it as livePaint.merge does → {id, faces, edges}",
"{ids?|id?} build a Live Paint group from the selected paths (paths, compound paths and groups of them; type, images and other objects are refused, nothing changes); each covered face starts with its front-most covering source's fill; with a Live Paint group among them, add the others to it as livePaint.merge does; a Live Paint group alone has nothing to add, so it is selected and nothing changes (no undo step) → {id, faces, edges}",
has_selection_or_ids,
lp_make
),
@@ -81,7 +81,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Merge",
["Object", "Live Paint"],
None,
"{ids?|id?} add the other selected paths (compound paths, groups of paths and Live Paint groups too; type, images and other objects are refused, nothing changes) to the bottom-most Live Paint group, keeping its id, its paint and its own properties (name, lock, visibility, transparency, appearance, opacity mask, graphic style link) → {id, faces, edges}",
"{ids?|id?} add the other selected paths (compound paths, groups of paths and Live Paint groups too; type, images and other objects are refused, nothing changes) to the bottom-most Live Paint group, keeping its id, its paint and its own properties (name, lock, visibility, transparency, appearance, opacity mask, graphic style link); a Live Paint group alone has nothing to add, so it is selected and nothing changes (no undo step) → {id, faces, edges}",
has_multi_or_ids,
lp_merge
),
@@ -108,7 +108,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Gap Options",
[],
None,
"{id?, ids?: [id…] (instead of id; default: the selected Live Paint groups), detect?: bool (Gap Detection: paint stops at gaps up to size wide), size?: \"small\" (3 pt) | \"medium\" (6 pt) | \"large\" (12 pt) | pt (custom, over 0 up to 72) (Paint Stops At), color?: #rrggbb or a layer color's name such as \"Red\" (Gap Preview Color; a hex color with an alpha part, #rrggbbaa or #rgba, is an error), closeGaps?: bool (add an unpainted path across each gap up to size wide to the group's paths)} set the Gap Options of Live Paint groups (what is not given stays as it was; a group starts with detect false, small and Red) and make their faces again, keeping their paint → {ids, faces, gaps: [[x0,y0,x1,y1]…] (the gaps up to size wide that no path closes, from a loose end of a path to where it closes to; detect closes them for paint), closed (paths added)}",
"{id?, ids?: [id…] (instead of id; default: the selected Live Paint groups), detect?: bool (Gap Detection: paint stops at gaps up to size wide), size?: \"small\" (3 pt) | \"medium\" (6 pt) | \"large\" (12 pt) | pt (custom, over 0 up to 72) (Paint Stops At), color?: #rrggbb or a layer color's name such as \"Red\" (Gap Preview Color; a hex color with an alpha part, #rrggbbaa or #rgba, is an error), closeGaps?: bool (add an unpainted path across each gap up to size wide to the group's paths)} set the Gap Options of Live Paint groups (what is not given stays as it was; a group starts with detect false, small and Red) and make their faces again, keeping their paint; when every group already has the options and closeGaps finds no gap, nothing changes (no undo step) → {ids, faces, gaps: [[x0,y0,x1,y1]…] (the gaps up to size wide that no path closes, from a loose end of a path to where it closes to; detect closes them for paint), closed (paths added)}",
has_selection_or_ids,
lp_gap_options
),
@@ -117,7 +117,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Live Paint Bucket",
[],
None,
"{group?: id | ids?|id?: [id…] (paths to make live first, as livePaint.make does), point: [x,y], points?: [[x,y]…] (a drag polyline starting at point; 1 to 4096 finite canvas points; fills every crossed face of the same group), continuation?: [[[x,y]…]…] (further path chunks of 1 to 4096 finite canvas points each; each starts at the preceding chunk's last point; requires points), color?|swatch?|gradient?|none? (default: current fill; a color in #rrggbbaa or #rgba is refused), tint?: 0..100, keepModel?: bool (both as paint.setFill)} fill the face containing point, skipping hidden faces → {group, face}",
"{group?: id | ids?|id?: [id…] (paths to make live first, as livePaint.make does), point: [x,y], points?: [[x,y]…] (a drag polyline starting at point; 1 to 4096 finite canvas points; fills every crossed face of the same group), continuation?: [[[x,y]…]…] (further path chunks of 1 to 4096 finite canvas points each; each starts at the preceding chunk's last point; requires points), color?|swatch?|gradient?|none? (default: current fill; a color in #rrggbbaa or #rgba is refused), tint?: 0..100, keepModel?: bool (both as paint.setFill)} fill the face containing point, skipping hidden faces; when every face it reaches already has the paint, nothing changes (no undo step, and the recent colors stay as they are) → {group, face}",
has_doc,
lp_fill
),
@@ -126,7 +126,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Live Paint Bucket (Stroke)",
[],
None,
"{group: id, point: [x,y], color?|swatch?|none? (default: current stroke), width?: pt (default: current weight), tolerance?: pt (4), tint?: 0..100, keepModel?: bool (both as paint.setFill)} paint the edge nearest point → {group, edge}",
"{group: id, point: [x,y], color?|swatch?|none? (default: current stroke), width?: pt (default: current weight), tolerance?: pt (4), tint?: 0..100, keepModel?: bool (both as paint.setFill)} paint the edge nearest point; when it already has the paint and the width, nothing changes (no undo step, and the recent colors stay as they are) → {group, edge}",
has_doc,
lp_stroke_edge
),
+135 -33
View File
@@ -52,8 +52,34 @@ fn make_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result<
Ok((gid, nf, ne))
}
/// Select `ids` alone, without an undo step, when they are not selected that way already.
fn select_only(s: &mut Session, ids: &[NodeId]) -> Result<()> {
let st = s.doc()?;
let mut sel = st.selection.clone();
sel.set(ids.iter().copied());
if sel != st.selection {
s.select(|_, selection| *selection = sel)?;
}
Ok(())
}
/// Make or Merge given one Live Paint group and nothing else has nothing to add to it, so it leaves
/// the document as it is, records no undo step and selects the group: → its reply. `None` for any
/// other `roots`.
fn lone_live_group(s: &mut Session, roots: &[NodeId]) -> Result<Option<Value>> {
let d = &s.doc()?.doc;
let Some(&g) = roots.first().filter(|g| roots.iter().all(|r| r == *g)) else { return Ok(None) };
let Some(n) = d.node(g).filter(|n| is_live_paint(n)) else { return Ok(None) };
let reply = json!({ "id": g.0, "faces": b::faces(n).len(), "edges": b::edges(n).len() });
select_only(s, &[g])?;
Ok(Some(reply))
}
pub(super) fn lp_make(s: &mut Session, p: &Value) -> Result<Value> {
let roots = root_ids(s, p)?;
if let Some(reply) = lone_live_group(s, &roots)? {
return Ok(reply);
}
let (id, faces, edges) = s.edit("Make Live Paint", |d, sel| make_live(d, sel, &roots))?;
Ok(json!({ "id": id.0, "faces": faces, "edges": edges }))
}
@@ -130,6 +156,9 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
pub(super) fn lp_merge(s: &mut Session, p: &Value) -> Result<Value> {
let roots = root_ids(s, p)?;
if let Some(reply) = lone_live_group(s, &roots)? {
return Ok(reply);
}
let (id, faces, edges) = s.edit("Merge Live Paint", |d, sel| merge_live(d, sel, &roots))?;
Ok(json!({ "id": id.0, "faces": faces, "edges": edges }))
}
@@ -230,27 +259,58 @@ pub(super) fn lp_gap_options(s: &mut Session, p: &Value) -> Result<Value> {
};
let close = switch_or(p, "closeGaps", false, C)?;
let targets = live_targets(s, p)?;
let with_params = |mut options: GapOptions| {
options.detect = detect.unwrap_or(options.detect);
options.size = size.unwrap_or(options.size);
options.color = color.unwrap_or(options.color);
options
};
// When every group already has these options and Close Gaps With Paths has no gap to close,
// nothing changes: no undo step, and the reply is the same.
let unchanged = {
let d = &s.doc()?.doc;
let (mut faces, mut gaps, mut same) = (0, vec![], true);
for g in &targets {
let old = d.node(*g).ok_or(EngineError::NoNode(*g))?;
let options = old.gap_options();
if with_params(options) != options {
same = false;
break;
}
let open = open_gaps(old, options);
if close && !open.is_empty() {
same = false;
break;
}
faces += b::faces(old).len();
gaps.extend(open);
}
same.then_some((faces, gaps))
};
if let Some((faces, gaps)) = unchanged {
select_only(s, &targets)?;
return Ok(json!({ "ids": ids_json(&targets), "faces": faces, "gaps": gaps_json(&gaps), "closed": 0 }));
}
let (faces, gaps, closed) = s.edit("Gap Options", |d, sel| {
let (mut faces, mut gaps, mut closed) = (0, vec![], 0);
let mut changed = Beside::replacing(d, &targets);
for g in &targets {
let old = d.node(*g).cloned().ok_or(EngineError::NoNode(*g))?;
let mut options = old.gap_options();
options.detect = detect.unwrap_or(options.detect);
options.size = size.unwrap_or(options.size);
options.color = color.unwrap_or(options.color);
let options = with_params(old.gap_options());
let mut sources = source_nodes(&old);
let mut added = 0;
if close {
// Close Gaps With Paths adds an unpainted line across each gap to the group's paths.
for gap in po::find_gaps(&source_shapes(&sources).0, options.size.points()) {
let line = PathData::single(SubPath::polyline(&gap, false));
sources.push(Arc::new(Node::path(d.alloc_id(), line, Appearance::default())));
closed += 1;
added += 1;
}
}
closed += added;
let mut n = old.clone();
// The faces change only with what paint stops at, or with new paths.
if close || options.max_gap() != old.gap_options().max_gap() {
if added > 0 || options.max_gap() != old.gap_options().max_gap() {
let (children, _, _) = build_children(d, sources, options.max_gap())?;
if let Some(ch) = n.children_mut() {
*ch = children;
@@ -305,27 +365,9 @@ pub(super) fn lp_fill(s: &mut Session, p: &Value) -> Result<Value> {
let paint = paint_from(s, p)?.unwrap_or_else(|| s.paint.fill.clone());
let group = object_param(p, "group", C)?;
let roots = if group.is_none() { root_ids(s, p)? } else { vec![] };
let (g, face) = s.edit("Live Paint Bucket", |d, sel| {
let gid = match group {
Some(g) => {
if !d.node(g).is_some_and(is_live_paint) {
return Err(bad(C, format!("{g} is not a Live Paint group")));
}
g
}
None => {
let live_at = |face: fn(&Node, Point) -> Option<&Arc<Node>>| {
roots.iter().copied().find(|r| d.node(*r).is_some_and(|n| is_live_paint(n) && face(n, pt).is_some()))
};
match (live_at(b::visible_face_at), live_at(face_at)) {
(Some(g), _) => g,
// At a point on a hidden face of a Live Paint group among the objects, the command returns an error
// and does not merge the objects.
(None, Some(_)) => return Err(EngineError::Other("no Live Paint face at that point".into())),
(None, None) => make_live(d, sel, &roots)?.0,
}
}
};
// The faces the click or drag paints in Live Paint group `gid`: the visible face at the point,
// and every visible face the drag crosses; → (the face at the point, the faces).
let targets_in = |d: &Document, gid: NodeId| -> Result<(NodeId, std::collections::BTreeSet<NodeId>)> {
let fid = d
.node(gid)
.and_then(|n| b::visible_face_at(n, pt))
@@ -355,11 +397,58 @@ pub(super) fn lp_fill(s: &mut Session, p: &Value) -> Result<Value> {
targets.extend(map.hits_along(&chunk, None).regions.iter().filter_map(|i| face_ids.get(*i).copied()));
}
}
for target in targets {
d.node_mut(target).ok_or(EngineError::NoNode(target))?.appearance.set_fill(paint.clone());
Ok((fid, targets))
};
// The Live Paint group the fill paints; `None` when the objects are made into one first.
let live = {
let d = &s.doc()?.doc;
match group {
Some(g) => {
if !d.node(g).is_some_and(is_live_paint) {
return Err(bad(C, format!("{g} is not a Live Paint group")));
}
Some(g)
}
None => {
let live_at = |face: fn(&Node, Point) -> Option<&Arc<Node>>| {
roots.iter().copied().find(|r| d.node(*r).is_some_and(|n| is_live_paint(n) && face(n, pt).is_some()))
};
match (live_at(b::visible_face_at), live_at(face_at)) {
(Some(g), _) => Some(g),
// At a point on a hidden face of a Live Paint group among the objects, the command returns an error
// and does not merge the objects.
(None, Some(_)) => return Err(EngineError::Other("no Live Paint face at that point".into())),
(None, None) => None,
}
}
}
Ok((gid, fid))
})?;
};
let (g, face) = match live {
Some(gid) => {
let (fid, targets) = targets_in(&s.doc()?.doc, gid)?;
// Faces that already have the paint stay as they are: when every face has it, nothing
// changes and no undo step is recorded.
let d = &s.doc()?.doc;
let unpainted: Vec<NodeId> = targets.into_iter().filter(|t| d.node(*t).is_none_or(|f| f.appearance.fill_paint() != paint)).collect();
if unpainted.is_empty() {
return Ok(json!({ "group": gid.0, "face": fid.0 }));
}
s.edit("Live Paint Bucket", |d, _| {
for target in unpainted {
d.node_mut(target).ok_or(EngineError::NoNode(target))?.appearance.set_fill(paint.clone());
}
Ok((gid, fid))
})?
}
None => s.edit("Live Paint Bucket", |d, sel| {
let gid = make_live(d, sel, &roots)?.0;
let (fid, targets) = targets_in(d, gid)?;
for target in targets {
d.node_mut(target).ok_or(EngineError::NoNode(target))?.appearance.set_fill(paint.clone());
}
Ok((gid, fid))
})?,
};
s.remember_paint(&paint);
Ok(json!({ "group": g.0, "face": face.0 }))
}
@@ -375,9 +464,22 @@ pub(super) fn lp_stroke_edge(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad(C, "width out of range"));
}
let tol = number_or(p, "tolerance", 4.0, C)?.clamp(0.0, 1000.0);
let edge = s.edit("Live Paint Bucket", |d, _| {
let (eid, unchanged) = {
let d = &s.doc()?.doc;
let n = d.node(g).filter(|n| is_live_paint(n)).ok_or_else(|| bad(C, format!("{g} is not a Live Paint group")))?;
let eid = b::visible_edge_near(n, pt, tol).map(|e| e.id).ok_or_else(|| EngineError::Other("no Live Paint edge near that point".into()))?;
let e = b::visible_edge_near(n, pt, tol).ok_or_else(|| EngineError::Other("no Live Paint edge near that point".into()))?;
// An edge that already has the paint and the width (or has no stroke and gets none) stays as
// it is, and no undo step is recorded.
let unchanged = match e.appearance.stroke() {
Some(st) => st.paint == paint && st.width == width,
None => paint.is_none(),
};
(e.id, unchanged)
};
if unchanged {
return Ok(json!({ "group": g.0, "edge": eid.0 }));
}
let edge = s.edit("Live Paint Bucket", |d, _| {
let e = d.node_mut(eid).ok_or(EngineError::NoNode(eid))?;
e.appearance.set_stroke(paint.clone());
if let Some(st) = e.appearance.stroke_mut() {
+48 -30
View File
@@ -36,7 +36,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Invert Colors",
["Edit", "Edit Colors"],
None,
"{fill?: true, stroke?: true, includeImages?: true, includePatterns?: true, ids?} replace each colour by its RGB inverse (keeps the colour model) in fills, strokes, text, gradient meshes (with fills), colorized image fills (their pixels stay unchanged), other embedded images (a recoloured copy) and pattern tiles (a new pattern swatch; the original stays), as one undo step. On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed, notChanged: {locked, hidden} (when the selection is everything select.all takes: the locked and hidden objects it left out whose colors would have changed; an object both hidden and locked counts as hidden), warning?: set when notChanged counts any object}",
"{fill?: true, stroke?: true, includeImages?: true, includePatterns?: true, ids?} replace each colour by its RGB inverse (keeps the colour model) in fills, strokes, text, gradient meshes (with fills), colorized image fills (their pixels stay unchanged), other embedded images (a recoloured copy) and pattern tiles (a new pattern swatch; the original stays), as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed, notChanged: {locked, hidden} (when the selection is everything select.all takes: the locked and hidden objects it left out whose colors would have changed; an object both hidden and locked counts as hidden), warning?: set when notChanged counts any object}",
has_selection,
|s, p| recolor(s, p, "edit.colors.invert", "Invert Colors", &invert)
),
@@ -104,7 +104,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Blend Front to Back",
["Edit", "Edit Colors"],
None,
"{} ≥3 filled objects (solid fills or gradient meshes, which keep their shading): intermediate fills graded between the frontmost and backmost fill. On a path directly in a graph series, the graph also stores the new fill, as for the other Blend commands (docs/mcp.md) → {changed}",
"{} ≥3 filled objects (solid fills or gradient meshes, which keep their shading): intermediate fills graded between the frontmost and backmost fill. On a path directly in a graph series, the graph also stores the new fill, as for the other Blend commands (docs/mcp.md); no undo step when no fill changes → {changed}",
has_selection,
|s, _| blend(s, BlendOrder::Stack)
),
@@ -113,7 +113,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Blend Horizontally",
["Edit", "Edit Colors"],
None,
"{} ≥3 filled objects or meshes: fills graded between the leftmost and rightmost → {changed}",
"{} ≥3 filled objects or meshes: fills graded between the leftmost and rightmost; no undo step when no fill changes → {changed}",
has_selection,
|s, _| blend(s, BlendOrder::Horizontal)
),
@@ -122,7 +122,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Blend Vertically",
["Edit", "Edit Colors"],
None,
"{} ≥3 filled objects or meshes: fills graded between the topmost and bottommost → {changed}",
"{} ≥3 filled objects or meshes: fills graded between the topmost and bottommost; no undo step when no fill changes → {changed}",
has_selection,
|s, _| blend(s, BlendOrder::Vertical)
),
@@ -457,8 +457,8 @@ pub(crate) fn recolor_links(s: &mut Session, p: &Value, cmd: &str, label: &str,
run_pass(s, p, cmd, label, Recolor::with_links(Scope::of(p, cmd)?, f, links))
}
/// Run `pass` on the `ids` param's objects (default: the selection) as one undo step named `label`;
/// errors name the command `cmd`. The reply's `notChanged` counts the locked and hidden objects the
/// Run `pass` on the `ids` param's objects (default: the selection) as one undo step named `label`,
/// or none when the pass changes nothing; errors name the command `cmd`. The reply's `notChanged` counts the locked and hidden objects the
/// selection left out ([`left_out`]) that the pass would have changed.
fn run_pass(s: &mut Session, p: &Value, cmd: &str, label: &str, pass: Recolor) -> Result<Value> {
let (ids, left) = match ids_param(p, "ids", cmd)? {
@@ -471,20 +471,47 @@ fn run_pass(s: &mut Session, p: &Value, cmd: &str, label: &str, pass: Recolor) -
}
};
let colorized_ok = super::paint::check_colorized(&s.doc()?.doc).is_ok();
let (n, not_changed) = s.edit(label, |d, _| {
let (n, not_changed) = edit_if_changed(s, label, |_, d| {
let not_changed = NotChanged::of(pass.again().would_change(d, &left).into_iter().map(|(_, hidden)| hidden));
let n = keeping_series_paint(d, &ids, |d| {
let n = pass.run(d, &ids);
super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(cmd, e))?;
Ok(n)
})?;
Ok((n, not_changed))
Ok(((n, not_changed), n > 0))
})?;
let mut out = json!({ "changed": n });
not_changed.report(&mut out);
Ok(out)
}
/// [`Session::edit`] for an Edit Colors pass, which may change nothing: `f` runs on a copy of the
/// document (it gets the document as it is too) and returns its result with whether it changed the
/// copy. Only a changed copy becomes the document, as one undo step named `label`; otherwise the
/// undo and redo steps and the saved state stay as they were.
pub(crate) fn edit_if_changed<T>(s: &mut Session, label: &str, f: impl FnOnce(&Document, &mut Document) -> Result<(T, bool)>) -> Result<T> {
if s.script_running() {
return Err(EngineError::Busy);
}
// A typing session ends here as `s.edit` would end it, before the copy is taken, so that the
// copy holds what was typed.
if !s.previewing && super::typing_in_progress(s) {
super::settle_interaction(s)?;
}
let before = s.doc()?.doc.clone();
let mut doc = (*before).clone();
let (v, changed) = f(&before, &mut doc)?;
// The document is shared with `before` no longer, so `s.edit` does not copy it again.
drop(before);
if changed {
s.edit(label, |d, _| {
*d = doc;
Ok(())
})?;
}
Ok(v)
}
/// Run `recolor` on `d` (it returns how many objects it changed) over `roots`, then store on their graphs what it changed
/// on the graph series marks among `roots` and inside them, so the marks keep their new paint when the graph is drawn
/// again.
@@ -597,11 +624,6 @@ fn pass_targets(s: &Session, p: &Value, cmd: &str) -> Result<Targets> {
fn to_indexed(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "edit.colors.toIndexed";
let indexing = Indexing::of(s, p)?;
// A typing session ends here as `s.edit` would end it, before the copy is taken, so that the
// copy holds what was typed.
if !s.previewing && super::typing_in_progress(s) {
super::settle_interaction(s)?;
}
let remake = |b: &ImageBlob| indexing.convert(b);
let images = Scope { fill: false, stroke: false, images: true, patterns: false };
let pass = Recolor { remake: Some(&remake), ..Recolor::new(images, &same) };
@@ -609,22 +631,18 @@ fn to_indexed(s: &mut Session, p: &Value) -> Result<Value> {
// indexed PNG yet; it is not converted to find out. The empty PNG only gives it a new key.
let would = |b: &ImageBlob| (!b.indexed_png() && b.pixel_size().is_some()).then(|| ImageBlob::png(vec![]));
let (ids, left) = pass_targets(s, p, C)?;
let st = s.doc()?;
let colorized_ok = super::paint::check_colorized(&st.doc).is_ok();
let not_changed = NotChanged::of(
Recolor { remake: Some(&would), ..Recolor::new(images, &same) }.would_change(&st.doc, &left).into_iter().map(|(_, hidden)| hidden),
);
let mut doc = (*st.doc).clone();
let n = pass.run(&mut doc, &ids);
if let Some((w, h)) = indexing.too_large.get() {
return Err(bad(C, format!("an image of {w} × {h} pixels is too large to convert (at most {} pixels)", Indexing::MAX_PIXELS)));
}
if n > 0 {
s.edit("Convert to Indexed Color", |d, _| {
*d = doc;
super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(C, e))
})?;
}
let (n, not_changed) = edit_if_changed(s, "Convert to Indexed Color", |now, doc| {
let colorized_ok = super::paint::check_colorized(now).is_ok();
let not_changed = NotChanged::of(
Recolor { remake: Some(&would), ..Recolor::new(images, &same) }.would_change(now, &left).into_iter().map(|(_, hidden)| hidden),
);
let n = pass.run(doc, &ids);
if let Some((w, h)) = indexing.too_large.get() {
return Err(bad(C, format!("an image of {w} × {h} pixels is too large to convert (at most {} pixels)", Indexing::MAX_PIXELS)));
}
super::paint::check_colorized_kept(colorized_ok, doc).map_err(|e| bad(C, e))?;
Ok(((n, not_changed), n > 0))
})?;
let mut out = json!({ "changed": n });
not_changed.report(&mut out);
Ok(out)
@@ -923,7 +941,7 @@ fn blend(s: &mut Session, order: BlendOrder) -> Result<Value> {
super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(label, e))?;
Ok(changed)
};
let changed = s.edit(label, |d, _| keeping_series_paint(d, &ids, run))?;
let changed = edit_if_changed(s, label, |_, d| keeping_series_paint(d, &ids, run).map(|n| (n, n > 0)))?;
Ok(json!({ "changed": changed }))
}
+4 -1
View File
@@ -781,7 +781,10 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
// Each brush the art uses with its type, found by name in the Brushes panel as the renderer finds it (the first of two
// brushes with one name); a brush the panel does not hold draws as a plain stroke and has no type. A row names the type
// as the New Brush dialog does (`Art Brush`), and the panel translates these values when it shows them.
let kinds: HashMap<&str, &vectorcraft_brush::BrushKind> = library.iter().map(|b| (b.name.as_str(), &b.kind)).collect();
let mut kinds: HashMap<&str, &vectorcraft_brush::BrushKind> = HashMap::new();
for b in &library {
kinds.entry(b.name.as_str()).or_insert(&b.kind);
}
let brush_entries: Vec<Value> =
brushes.iter().map(|name| json!({ "name": name, "type": kinds.get(name.as_str()).map(|k| k.type_id()) })).collect();
let brush_rows: Vec<(String, String)> = brushes
+52 -9
View File
@@ -25,7 +25,7 @@ use super::dimension::EndedLink;
use super::edit::selected_roots;
use super::menucmds::{run_raw, squash};
use super::object::as_clipping_path;
use super::pathops::{assemble, node_path, outline_strokes, replace_leaves, styled_copy, with_transparency};
use super::pathops::{assemble, node_path, outlinable, outline_strokes, replace_leaves, styled_copy, with_transparency};
use super::{CommandSpec, EngineError, Result, Session, bad, cmd, has_selection, number_or, switch_or, text_param};
const C: &str = "object.expand";
@@ -47,7 +47,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Expand…",
["Object"],
None,
"{object?: true (symbol instances without effects (their fills' and strokes' included) and not in perspective → their art, as Break Link to Symbol places it (the instances that art holds stay instances), type → outlines, live shapes → paths, effects baked, blends → groups of their steps, repeats → groups of their instances, Intertwine groups → groups of their objects and of the parts drawn over the others (clip groups), envelopes → their distorted content, placed documents → editable copies of their art, as placing the file without link gives, its symbols, patterns, swatches and images joining the document), fill?: true (gradient fills → `gradient` art, pattern fills → their tiles in a clip group shaped like the object), stroke?: true (strokes → filled outlines, the stroked paths that baking effects leaves included), gradient?: \"objects\" (default: `steps` solid strips, concentric ellipses for radial gradients, wedges around the center for conic ones, nested squares for diamond ones) | \"mesh\" (a gradient mesh); both in a clip group shaped like the object (freeform gradients always become a mesh shaped like it), steps?: 1..1000 (255; a gradient that repeats or reflects gets the same whole number of them in each run, at least one, so a run starts on an object's edge; one that needs more than 256 runs across the box stays a gradient)} one undo step; a dimension whose art an option changes becomes a plain group of its art, except one selected with art it measures, directly or in groups without fills, strokes or effects of their own: its lines and label stay as they are, and if the new art no longer fits its link it stays where it was, no longer linked → {ids}",
"{object?: true (symbol instances without effects (their fills' and strokes' included) and not in perspective → their art, as Break Link to Symbol places it (the instances that art holds stay instances), type → outlines (its own fills and strokes on paths of its whole outline, which Fill and Stroke expand), live shapes → paths, effects baked, blends → groups of their steps, repeats → groups of their instances, Intertwine groups → groups of their objects and of the parts drawn over the others (clip groups), envelopes → their distorted content, placed documents → editable copies of their art, as placing the file without link gives, its symbols, patterns, swatches and images joining the document), fill?: true (gradient fills → `gradient` art, pattern fills → their tiles in a clip group shaped like the object), stroke?: true (strokes → filled outlines, the stroked paths that baking effects leaves included), gradient?: \"objects\" (default: `steps` solid strips, concentric ellipses for radial gradients, wedges around the center for conic ones, nested squares for diamond ones) | \"mesh\" (a gradient mesh); both in a clip group shaped like the object (freeform gradients always become a mesh shaped like it), steps?: 1..1000 (255; a gradient that repeats or reflects gets the same whole number of them in each run, at least one, so a run starts on an object's edge; one that needs more than 256 runs across the box stays a gradient)} one undo step; a dimension whose art an option changes becomes a plain group of its art, except one selected with art it measures, directly or in groups without fills, strokes or effects of their own: its lines and label stay as they are, and if the new art no longer fits its link it stays where it was, no longer linked → {ids}",
has_selection,
expand
),
@@ -56,7 +56,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Expand Options",
[],
None,
"{} what each Expand option would change in the selection → {object, fill, stroke, gradient, appearance, symbolArt?: {fill, stroke, gradient}} (true: something to expand; gradient: a gradient fill that Fill expands (in type, on the outline Object makes of a character), which Expand Gradient To applies to; appearance: appearance attributes Expand Appearance expands first, for which Object › Expand… is dimmed in the menus; symbolArt, when the selection holds symbol instances that Object expands: true when only their art holds it, which Fill and Stroke reach only with Object on)",
"{} what each Expand option would change in the selection → {object, fill, stroke, gradient, appearance, symbolArt?: {fill, stroke, gradient}} (true: something to expand; gradient: a gradient fill that Fill expands (in type, on the outline Object makes of a character, or of the whole type for the type object's own fills), which Expand Gradient To applies to; appearance: appearance attributes Expand Appearance expands first, for which Object › Expand… is dimmed in the menus; symbolArt, when the selection holds symbol instances that Object expands: true when only their art holds it, which Fill and Stroke reach only with Object on)",
has_selection,
|s, _| {
let roots = selected_roots(s)?;
@@ -189,21 +189,37 @@ impl Expandable {
e.placed |= matches!(c.kind, NodeKind::PlacedDocument(_));
e.repeats |= matches!(c.kind, NodeKind::Repeat(_));
e.intertwines |= matches!(c.kind, NodeKind::Intertwine { .. });
// Type's outlines take its characters' stroke and fill, and a path of its whole outline
// takes the type object's own fills and strokes (see `type.createOutlines`).
// Any stroke Outline Stroke outlines, not only the topmost one.
let own_stroke = c.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(st) if outlinable(st)));
let own_pattern = c.appearance.items.iter().any(|i| pattern_fill(d, i).is_some());
let own_gradient = c.appearance.items.iter().any(|i| gradient_fill(i).is_some());
// Type without an outline (empty, or only spaces) gets no path for its own fills and strokes.
let whole = match &c.kind {
NodeKind::Text(t) if own_stroke || own_pattern || own_gradient => text_whole_outline(t),
_ => None,
};
e.stroke |= match &c.kind {
// Type's outlines take its characters' stroke (see `type.createOutlines`).
NodeKind::Text(t) => t.runs.iter().any(|r| r.style.has_stroke()),
_ => shape && !c.appearance.stroke_paint().is_none(),
NodeKind::Text(t) => (own_stroke && whole.is_some()) || t.runs.iter().any(|r| r.style.has_stroke()),
_ => shape && own_stroke,
};
// Once one is found, the next path is not measured.
e.gradient = e.gradient
|| match &c.kind {
NodeKind::Text(t) => text_gradient_expands(d, t),
NodeKind::Text(t) => {
text_gradient_expands(d, t)
|| (own_gradient && whole.as_ref().is_some_and(|(path, tb)| text_object_gradient_expands(d, c, path, *tb)))
}
_ => shape && gradient_expands(d, c),
};
e.fill |= e.gradient;
e.fill |= match &c.kind {
NodeKind::Text(t) => t.runs.iter().any(|r| matches!(&r.style.fill, Paint::Pattern { pattern, .. } if d.pattern(pattern).is_some())),
_ => shape && c.appearance.items.iter().any(|i| pattern_fill(d, i).is_some()),
NodeKind::Text(t) => {
(own_pattern && whole.is_some())
|| t.runs.iter().any(|r| matches!(&r.style.fill, Paint::Pattern { pattern, .. } if d.pattern(pattern).is_some()))
}
_ => shape && own_pattern,
};
});
}
@@ -275,6 +291,33 @@ fn text_gradient_expands(d: &Document, t: &TextObject) -> bool {
|| vectorcraft_text::decorations(&lay, vectorcraft_text::FontDb::global(), t).iter().any(|(run, bar)| expands(*run, bar))
}
/// The path of type `t`'s whole outline in the document (glyphs, ruby glyphs and underline and
/// strikethrough bars), which `type.createOutlines` paints with the type object's own fills and
/// strokes, and the layout's bounds there; `None` when the type has no outline.
fn text_whole_outline(t: &TextObject) -> Option<(PathData, Rect)> {
let db = vectorcraft_text::FontDb::global();
let lay = vectorcraft_text::layout(db, t);
let mut all = BezPath::new();
for g in lay.glyphs.iter().chain(&lay.ruby) {
all.extend(g.outline.iter());
}
for (_, bar) in vectorcraft_text::decorations(&lay, db, t) {
all.extend(bar.iter());
}
let path = PathData::from_bezpath(&all).transformed(t.xf);
(!path.is_empty()).then(|| (path, t.xf.transform_rect_bbox(lay.bounds)))
}
/// Whether type node `n` has a gradient fill of its own (not its characters') that Fill expands
/// once Object has outlined it: [`gradient_expands`] on `path`, the type's whole outline
/// ([`text_whole_outline`]), with its unplaced gradients fixed to `tb`, the layout's bounds in the
/// document. Leaves the document as it is.
fn text_object_gradient_expands(d: &Document, n: &Node, path: &PathData, tb: Rect) -> bool {
let mut appearance = Appearance { items: n.appearance.items.clone(), ..Default::default() };
appearance.pin_gradients(tb);
gradient_expands(d, &Node::path(NodeId(u64::MAX), path.clone(), appearance))
}
/// [`gradient_expands`] for a path that no live-effect plug-in paints ([`expand_piece_fills`]).
fn piece_gradient_expands(d: &Document, l: &Node) -> bool {
if !l.appearance.items.iter().filter_map(gradient_fill).any(|(_, g)| g.gradient.is_spread()) {
+63
View File
@@ -6182,3 +6182,66 @@ fn graph_commands_refuse_params_of_the_wrong_type() {
s.execute("graph.setData", &json!({"id": id.0, "rows": [[1, null], [2, 3]], "series": null, "transpose": null})).unwrap();
assert_eq!(spec(&s).cells(), vec![vec![Some(1.0), None], vec![Some(2.0), Some(3.0)]]);
}
/// A `.ai` in PostScript form whose graph's records read whole (version 7 specification, appendix A)
/// opens as a graph whose data can be edited: Graph Data redraws it on its plot. Saving it as `.ai`
/// says its data and settings aren't written, in either form.
#[test]
fn a_graph_opened_from_ai_keeps_its_data_for_editing() {
let graph = "%_Gs\n%_100 200 300 100 Gb\n%_5 0 0 14 0 1 0 0 6 44 Gy\n%_10 2 0 0 90 80 0 Gd\n\
%_1 () Ga\n%_0 13 0 0 0 0 0 () GA\n%_2 () Ga\n%_0 14 0 0 0 0 0 () GA\n%_4 () Ga\n%_0 14 0 0 0 0 0 () GA\n\
%_2 2 1 1 Gz\n%_() Gc (East) Gc (Q1) Gc 5 Gc GC\n\
u\nu\n0.6 0 1 0 k\n110 100 m\n110 150 L\n130 150 L\n130 100 L\nf\nU\n%_2 1 0 0 Go\n\
u\n0 0 0 1 K\n100 200 m\n100 100 L\n300 100 L\nS\nU\nU\n%_GS\n";
let text = format!(
"%!PS-Adobe-3.0\n%%Creator: a script\n%%BoundingBox: 0 0 400 400\n%AI5_FileFormat 3\n%AI3_Cropmarks: 0 0 400 400\n%%EndComments\n\
%%BeginProlog\n%%EndProlog\n%%BeginSetup\n%%EndSetup\n%AI5_BeginLayer\n1 1 1 1 0 0 0 79 128 255 Lb\n(Graph) Ln\n0 A\n{graph}LB\n\
%AI5_EndLayer--\n%%PageTrailer\n%%Trailer\n%%EOF\n"
);
let dir = vectorcraft_testkit::temp_dir("graph-ai-open");
let path = dir.join("graph.ai");
std::fs::write(&path, text).unwrap();
let mut s = Session::new();
s.execute("document.open", &json!({"path": path})).unwrap();
let mut found = vec![];
s.doc().unwrap().doc.walk(|n| {
if n.extras().graph.is_some() {
found.push(n.id);
}
});
assert_eq!(found.len(), 1);
let id = found[0];
let before = spec(&s, id);
assert_eq!(
(before.series.as_slice(), before.categories.as_slice(), before.rows.as_slice()),
(&["East".to_string()][..], &["Q1".to_string()][..], &[vec![5.0]][..])
);
// The fill of the series' first mark.
let series_fill = |s: &Session| {
let mut fill = None;
s.doc().unwrap().doc.walk(|n| {
if n.extras().series_index == Some(0) && fill.is_none() {
let first = n.children().and_then(|c| c.first().cloned());
fill = first.and_then(|m| m.appearance.items.iter().find(|i| i.is_fill()).map(|i| i.paint().clone()));
}
});
fill
};
let painted = series_fill(&s);
assert!(painted.is_some());
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
s.execute("graph.setData", &json!({"id": id.0, "csv": ",East\nQ1,8\nQ2,2"})).unwrap();
let after = spec(&s, id);
assert_eq!(after.rows, [[8.0], [2.0]]);
assert_eq!(after.rect, before.rect, "the graph is redrawn on its plot");
assert_eq!(series_fill(&s), painted, "the series keeps the file's paint");
for (name, version) in [("v7.ai", Some("7")), ("pdf.ai", None)] {
let mut p = json!({"path": dir.join(name), "format": "ai"});
if let Some(v) = version {
p["aiVersion"] = json!(v);
}
let r = s.execute("file.saveAs", &p).unwrap();
let notes = r["warnings"].as_array().cloned().unwrap_or_default();
assert!(notes.iter().any(|w| w.as_str().is_some_and(|w| w.starts_with("graphs are written as their art"))), "{name}: {r}");
}
}
+2 -2
View File
@@ -96,7 +96,7 @@ pub fn proxy_specs() -> Vec<CommandSpec> {
"Invert",
[],
None,
"{stroke?: bool (default: the active proxy), ids?|id?, item?: appearance item index|null, target?: \"object\"|\"contents\"} invert the active proxy's colours of the selection (or ids; groups recolour their contents) keeping each colour's model, as edit.colors.invert does; the Appearance panel's active fill/stroke item (appearance.setActiveItem) is inverted instead when it is of that kind and no ids are given; with an object of a dynamic symbol instance selected by Direct Selection and no ids, id or item, that object's solid color changes for this instance only, and a gradient or pattern, or type whose characters differ in color, is refused; with nothing selected, invert the default. On a path directly in a graph series, the graph also stores the new color of the topmost visible fill or stroke (docs/mcp.md) → {changed}",
"{stroke?: bool (default: the active proxy), ids?|id?, item?: appearance item index|null, target?: \"object\"|\"contents\"} invert the active proxy's colours of the selection (or ids; groups recolour their contents) keeping each colour's model, as edit.colors.invert does; the Appearance panel's active fill/stroke item (appearance.setActiveItem) is inverted instead when it is of that kind and no ids are given; with an object of a dynamic symbol instance selected by Direct Selection and no ids, id or item, that object's solid color changes for this instance only, and a gradient or pattern, or type whose characters differ in color, is refused; with nothing selected, invert the default. On a path directly in a graph series, the graph also stores the new color of the topmost visible fill or stroke (docs/mcp.md); no undo step when no color changes → {changed}",
has_doc,
|s, p| proxy_recolor(s, p, "paint.invert", "Invert", &super::colorcmds::invert)
),
@@ -105,7 +105,7 @@ pub fn proxy_specs() -> Vec<CommandSpec> {
"Complement",
[],
None,
"{stroke?: bool (default: the active proxy), ids?|id?, item?: appearance item index|null, target?: \"object\"|\"contents\"} replace the active proxy's colours by their complements ((highest + lowest) − each component, over RGB or CMY; grey unchanged) keeping each colour's model; honours the Appearance panel's active item and a selected object of a dynamic symbol instance as paint.invert does; with nothing selected, the default → {changed}",
"{stroke?: bool (default: the active proxy), ids?|id?, item?: appearance item index|null, target?: \"object\"|\"contents\"} replace the active proxy's colours by their complements ((highest + lowest) − each component, over RGB or CMY; grey unchanged) keeping each colour's model; honours the Appearance panel's active item and a selected object of a dynamic symbol instance as paint.invert does; with nothing selected, the default; no undo step when no color changes → {changed}",
has_doc,
|s, p| proxy_recolor(s, p, "paint.complement", "Complement", &|c: Color| c.complement_keep_model())
),
+1 -1
View File
@@ -962,7 +962,7 @@ pub(crate) fn ordered_map<T: Sync, R: Send>(
// ---------- Outline Stroke ----------
/// Can Outline Stroke turn `st` into filled art?
fn outlinable(st: &StrokeLayer) -> bool {
pub(crate) fn outlinable(st: &StrokeLayer) -> bool {
st.visible && !st.paint.is_none() && st.width > 0.0
}
+21 -13
View File
@@ -793,7 +793,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export Preferences",
[],
None,
"{path?} write the preferences as a JSON file {format: \"vectorcraft-preferences\", version: 1, prefs: {key: value, …}}: every preference prefs.list lists and the eyedropper, perspectiveWidget, pathfinder, glyphSnap and pixelSnap groups, without the folder preferences fontsFolder, pluginsFolder, recoveryFolder and templatesFolder and without saved presets; a file over 1 MB, which prefs.import would refuse, is an error and is not written → {path, count}; without path → {data: the file's text, count}",
"{path?} write the preferences as a JSON file {format: \"vectorcraft-preferences\", version: 1, prefs: {key: value, …}}: every preference prefs.list lists and the eyedropper, perspectiveWidget, pathfinder, glyphSnap and pixelSnap groups, without the folder preferences fontsFolder, pluginsFolder, scratchPrimary, scratchSecondary, recoveryFolder and templatesFolder and without saved presets; a file over 1 MB, which prefs.import would refuse, is an error and is not written → {path, count}; without path → {data: the file's text, count}",
always,
export
),
@@ -802,7 +802,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Import Preferences",
[],
None,
"{path? | data?: the file's text} apply the preferences of a file prefs.export wrote (at most 1 MB). Every value is checked first, as prefs.set checks it: another format, a newer version, an unknown preference, a value of the wrong type or out of range, or a folder preference is an error, and nothing changes. Preferences the file leaves out keep their values; the open document's units stay as they are; no undo step; not a command.batch step → {imported: count}",
"{path? | data?: the file's text} apply the preferences of a file prefs.export wrote (at most 1 MB). Every value is checked first, as prefs.set checks it: another format, a newer version, an unknown preference, a value of the wrong type or out of range, or a folder preference (for scratchPrimary and scratchSecondary, a folder; the choices Startup and None are read) is an error, and nothing changes. Preferences the file leaves out keep their values; the open document's units stay as they are; no undo step; not a command.batch step → {imported: count}",
always,
import
),
@@ -818,8 +818,20 @@ pub const PREFS_VERSION: u64 = 1;
/// The largest preferences file `prefs.import` reads.
const MAX_PREFS_FILE_BYTES: usize = 1 << 20;
/// Folder preferences, which name folders on one computer: a preferences file leaves them out.
const FOLDER_PREFS: &[&str] = &["fontsFolder", "pluginsFolder", "recoveryFolder", "templatesFolder"];
/// Folder preferences, which name folders on one computer: a preferences file leaves them out, and
/// under automation read roots one outside them is not shown.
pub const FOLDER_PREFS: [&str; 6] = ["fontsFolder", "pluginsFolder", "scratchPrimary", "scratchSecondary", "recoveryFolder", "templatesFolder"];
/// The scratch disk choices that are not folders.
pub const SCRATCH_CHOICES: [&str; 2] = ["Startup", "None"];
/// Does `value`, set as preference `key`, name a folder: is `key` a folder preference
/// ([`FOLDER_PREFS`]) and `value`, trimmed as the app uses it, neither empty (the default folder)
/// nor a scratch disk choice ([`SCRATCH_CHOICES`])?
pub fn names_a_folder(key: &str, value: &str) -> bool {
let path = value.trim();
FOLDER_PREFS.contains(&key) && !path.is_empty() && !(key.starts_with("scratch") && SCRATCH_CHOICES.contains(&path))
}
/// The preferences `prefs.export` writes: every [`PREF_SPECS`] key but the [`FOLDER_PREFS`], and
/// the [`PREF_GROUPS`].
@@ -868,7 +880,9 @@ fn read_prefs_file(bytes: &[u8]) -> std::result::Result<Map<String, Value>, Stri
if prefs.is_empty() {
return Err("the file holds no preferences".into());
}
if let Some(key) = prefs.keys().find(|k| FOLDER_PREFS.contains(&k.as_str())) {
// A scratch disk choice or an empty scratch disk names no folder, and is read.
let folder = |k: &str, v: &Value| FOLDER_PREFS.contains(&k) && (!k.starts_with("scratch") || v.as_str().is_some_and(|v| names_a_folder(k, v)));
if let Some(key) = prefs.iter().find(|(k, v)| folder(k, v)).map(|(k, _)| k) {
return Err(format!("`{key}` names a folder, which preferences files leave out"));
}
Ok(prefs.clone())
@@ -893,14 +907,8 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "imported": values.len() }))
}
/// The preferences that name a folder: the [`FOLDER_PREFS`] and the scratch disks.
const PATH_PREFS: [&str; 6] = ["fontsFolder", "pluginsFolder", "scratchPrimary", "scratchSecondary", "recoveryFolder", "templatesFolder"];
/// The scratch disk choices that are not folders.
const SCRATCH_CHOICES: [&str; 2] = ["Startup", "None"];
/// The preferences as `prefs.get`, `prefs.list`, `prefs.set` and `prefs.reset` show them to the
/// request being served. Under automation read roots, a folder preference ([`PATH_PREFS`]) outside
/// request being served. Under automation read roots, a folder preference ([`FOLDER_PREFS`]) outside
/// them is `null`, as `ui.inspect` leaves it out, and an export preset's `folder` outside them is
/// left out. An empty value (the default folder) and a scratch
/// disk choice ([`SCRATCH_CHOICES`]) are shown. Without roots the preferences are shown as they are.
@@ -911,7 +919,7 @@ fn shown_prefs(prefs: &Prefs) -> Value {
}
// The app trims a folder before it uses it.
let hidden = |path: &str| !path.trim().is_empty() && crate::file_access::check_read(path.trim()).is_err();
for key in PATH_PREFS {
for key in FOLDER_PREFS {
let Some(path) = all[key].as_str() else { continue };
if hidden(path) && !(key.starts_with("scratch") && SCRATCH_CHOICES.contains(&path.trim())) {
all[key] = Value::Null;
+7 -4
View File
@@ -15,7 +15,7 @@ use vectorcraft_doc::swatches::{node_colors, node_paints, override_paints};
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
use vectorcraft_geom::{Point, Rect};
use super::colorcmds::{NotChanged, Recolor, Scope, keeping_series_paint, left_out};
use super::colorcmds::{NotChanged, Recolor, Scope, edit_if_changed, keeping_series_paint, left_out};
use super::{CommandSpec, Result, Session, always, bad, checked_ids_param, cmd, color_value, has_doc, index, str_param, switch_or, text_param};
pub fn specs() -> Vec<CommandSpec> {
@@ -34,7 +34,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Recolor Artwork",
["Edit", "Edit Colors"],
None,
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex)], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour] (what `group` is rewritten with; default: the rows' new colours, in order, excluded rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step. On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex)], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour] (what `group` is rewritten with; default: the rows' new colours, in order, excluded rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
has_doc,
apply
),
@@ -1661,7 +1661,7 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
};
let rename = text_param(p, "rename", C)?;
let colorized_ok = super::paint::check_colorized(&s.doc()?.doc).is_ok();
let (changed, edit, added, converted, not_changed) = s.edit(label, |d, _| {
let (changed, edit, added, converted, not_changed) = edit_if_changed(s, label, |now, d| {
// The rows' library swatches join the document (one it has with that name and colour is
// used as it is).
let mut added = vec![];
@@ -1716,7 +1716,10 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
let not_changed = NotChanged::of(
before.iter().filter(|(id, colors, _)| d.node(*id).is_some_and(|now| shown_colors(d, now) == *colors)).map(|(_, _, hidden)| *hidden),
);
Ok((changed, edit, added, map.converted.get(), not_changed))
// Rewriting the group's swatches and relinking its art are not counted in `changed`, so a
// pass that counts nothing compares the documents.
let any = changed > 0 || !added.is_empty() || *d != *now;
Ok(((changed, edit, added, map.converted.get(), not_changed), any))
})?;
let mut out = json!({ "changed": changed, "swatches": added });
not_changed.report(&mut out);
+30 -2
View File
@@ -4,7 +4,9 @@
use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_doc::{AreaFit, Document, Justify, Node, NodeId, NodeKind, RubyAlign, RubyPosition, RubySpan, TextObject};
use vectorcraft_doc::{
Appearance, AppearanceItem, AreaFit, Document, Justify, Node, NodeId, NodeKind, RubyAlign, RubyPosition, RubySpan, TextObject,
};
use vectorcraft_geom::{Affine, PathData, Vec2};
use super::edit::selected_roots;
@@ -39,7 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Create Outlines",
["Type"],
Some("Cmd+Shift+O"),
"{} convert the selected text to groups of compound paths (one per glyph); a frame of threaded text leaves its thread with the text it shows; a dimension whose label is outlined becomes a plain group of its art → {ids}",
"{} convert the selected text to groups of compound paths (one per glyph); the type object's own fills and strokes (not its characters') go on paths of its whole outline, below or above the glyphs as its Characters row places them; a frame of threaded text leaves its thread with the text it shows; a dimension whose label is outlined becomes a plain group of its art → {ids}",
has_selection,
create_outlines
),
@@ -672,13 +674,39 @@ fn create_outlines(s: &mut Session, _: &Value) -> Result<Value> {
}
placed.extend(ruby.map(|(_, r)| r));
let mut children = placed;
// The whole outline the object's own fills and strokes paint: every glyph, ruby glyph
// and bar, as the canvas paints them.
let mut all = kurbo::BezPath::new();
for g in lay.glyphs.iter().chain(&lay.ruby) {
all.extend(g.outline.iter());
}
// Underline and strikethrough bars become paths of their run's paint too (#847).
for (run, bar) in vectorcraft_text::decorations(&lay, vectorcraft_text::FontDb::global(), t) {
all.extend(bar.iter());
let st = t.runs.get(run).map(|r| r.style.clone()).unwrap_or_else(|| t.first_style());
let mut node = shape_node(d, PathData::from_bezpath(&bar).transformed(t.xf), None);
node.appearance = st.appearance().into();
children.push(Arc::new(node));
}
// The object's own fills and strokes (not its characters') paint the whole outline:
// those below the Characters row under the characters, the others over them, with
// their unplaced gradients fixed to the layout's bounds in the document.
let all = PathData::from_bezpath(&all).transformed(t.xf);
if !n.appearance.items.is_empty() && !all.is_empty() {
let (below, above) = n.appearance.split_contents();
let tb = t.xf.transform_rect_bbox(lay.bounds);
let mut whole = |items: &[AppearanceItem]| {
let mut ap = Appearance { items: items.to_vec(), ..Default::default() };
ap.pin_gradients(tb);
Arc::new(Node::path(d.alloc_id(), all.clone(), ap))
};
if !below.is_empty() {
children.insert(0, whole(below));
}
if !above.is_empty() {
children.push(whole(above));
}
}
let (par, idx, _) = d.position(tid).ok_or(EngineError::NoNode(tid))?;
d.remove(tid)?;
if children.is_empty() {
+187
View File
@@ -2446,6 +2446,193 @@ fn live_paint_stroke_edge() {
assert!(s.execute("livePaint.strokeEdge", &json!({"group": g.0, "point": [300, 300]})).is_err());
}
/// The undo and redo depths, the unsaved state and the revision of the active document.
fn history_state(s: &Session) -> (usize, usize, bool, u64) {
let st = s.doc().unwrap();
(st.history.undo.len(), st.history.redo.len(), st.is_dirty(), st.revision)
}
/// Draw a rectangle and undo it, so a redo step is waiting, then mark the document saved with `g`
/// alone selected.
fn redo_waiting_and_saved(s: &mut Session, g: NodeId) {
rect(s, 300.0, 300.0, 10.0, 10.0);
s.execute("edit.undo", &json!({})).unwrap();
s.execute("select.set", &json!({"ids": [g.0]})).unwrap();
s.doc_mut().unwrap().mark_saved();
}
/// The active document and its [`history_state`].
type Snapshot = (vectorcraft_doc::Document, (usize, usize, bool, u64));
fn snapshot(s: &Session) -> Snapshot {
((*s.doc().unwrap().doc).clone(), history_state(s))
}
/// After a Live Paint edit that changed nothing: the document, the undo and redo steps, the saved
/// state and the revision are as `before`, and Redo still brings back the rectangle
/// [`redo_waiting_and_saved`] undid. Undoes the rectangle again, marks the document saved and
/// takes a new `before`.
fn assert_unchanged(s: &mut Session, before: &mut Snapshot, what: &str) {
assert!(*s.doc().unwrap().doc == before.0, "{what}: the document is as it was");
assert_eq!(history_state(s), before.1, "{what}: no undo step, the redo step kept, still saved");
let children = layer_children(s);
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(layer_children(s), children + 1, "{what}: Redo brings back the rectangle");
s.execute("edit.undo", &json!({})).unwrap();
s.doc_mut().unwrap().mark_saved();
*before = snapshot(s);
}
#[test]
fn live_paint_fill_same_paint_is_no_op() {
let mut s = session();
let g = live(&mut s);
let drag = json!({"group": g.0, "point": [25, 50], "points": [[25, 50], [125, 50]], "color": "#00ff00"});
s.execute("livePaint.fill", &drag).unwrap();
redo_waiting_and_saved(&mut s, g);
// A color used since stays the newest recent color and the last color.
let blue = Color::rgb(0.0, 0.0, 1.0);
s.remember_paint_now(&Paint::solid(blue));
let recent = (s.recent_colors.clone(), s.last_solid);
let mut before = snapshot(&s);
let click = s.execute("livePaint.fill", &json!({"group": g.0, "point": [75, 50], "color": "#00ff00"})).unwrap();
let face = vectorcraft_tools::builder::face_at(&node(&s, g), Point::new(75.0, 50.0)).unwrap().id;
assert_eq!(click, json!({"group": g.0, "face": face.0}), "the usual reply");
assert_unchanged(&mut s, &mut before, "a click on a face with the paint");
s.execute("livePaint.fill", &drag).unwrap();
assert_unchanged(&mut s, &mut before, "a drag over faces with the paint");
// Without a group, the click finds the Live Paint group among the selected objects.
s.execute("livePaint.fill", &json!({"point": [125, 50], "color": "#00ff00"})).unwrap();
assert_unchanged(&mut s, &mut before, "a click in the selected group");
assert_eq!((s.recent_colors.clone(), s.last_solid), recent, "the recent colors are as they were");
// A drag that reaches one face without the paint is one undo step and remembers the color.
let red = Paint::solid(Color::from_hex("#ff0000").unwrap());
for x in [25, 75] {
s.execute("livePaint.fill", &json!({"group": g.0, "point": [x, 50], "color": "#ff0000"})).unwrap();
}
s.remember_paint_now(&Paint::solid(blue));
let depth = s.doc().unwrap().history.undo.len();
s.execute("livePaint.fill", &json!({"group": g.0, "point": [25, 50], "points": [[25, 50], [125, 50]], "color": "#ff0000"})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), depth + 1);
assert_eq!(Paint::solid(s.last_solid), red);
let gn = node(&s, g);
for x in [25.0, 75.0, 125.0] {
assert_eq!(vectorcraft_tools::builder::face_at(&gn, Point::new(x, 50.0)).unwrap().appearance.fill_paint(), red, "{x}");
}
}
#[test]
fn live_paint_bucket_click_with_the_face_paint_is_no_op() {
let mut s = session();
let g = live(&mut s);
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = Paint::solid(Color::rgb(0.0, 1.0, 1.0));
let click = |s: &mut Session, x: f64| {
s.pointer(&PointerEvent::new(PointerKind::Down, x, 50.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, x, 50.0), v).unwrap();
};
click(&mut s, 125.0);
redo_waiting_and_saved(&mut s, g);
let mut before = snapshot(&s);
click(&mut s, 125.0);
assert_unchanged(&mut s, &mut before, "a Bucket click on a face with the paint");
// A drag over faces with the paint changes nothing either.
click(&mut s, 25.0);
click(&mut s, 75.0);
redo_waiting_and_saved(&mut s, g);
let mut before = snapshot(&s);
s.pointer(&PointerEvent::new(PointerKind::Down, 25.0, 50.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 125.0, 50.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 125.0, 50.0), v).unwrap();
assert_unchanged(&mut s, &mut before, "a Bucket drag over faces with the paint");
}
#[test]
fn live_paint_stroke_edge_same_paint_and_width_is_no_op() {
let mut s = session();
let g = live(&mut s);
let call = json!({"group": g.0, "point": [100, 50], "color": "#ff0000", "width": 3});
let first = s.execute("livePaint.strokeEdge", &call).unwrap();
redo_waiting_and_saved(&mut s, g);
s.remember_paint_now(&Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
let last = s.last_solid;
let mut before = snapshot(&s);
assert_eq!(s.execute("livePaint.strokeEdge", &call).unwrap(), first, "the usual reply");
assert_unchanged(&mut s, &mut before, "an edge with the paint and the width");
assert_eq!(s.last_solid, last, "the last color is as it was");
// Another width is an edit.
s.execute("livePaint.strokeEdge", &json!({"group": g.0, "point": [100, 50], "color": "#ff0000", "width": 2})).unwrap();
assert_eq!(history_state(&s).0, before.1.0 + 1);
}
#[test]
fn live_paint_gap_options_same_values_are_no_op() {
let mut s = session();
let g = live_square_with_a_gap(&mut s);
let set = json!({"detect": true, "size": "small", "color": "#123456"});
let first = s.execute("livePaint.gapOptions", &set).unwrap();
redo_waiting_and_saved(&mut s, g);
let mut before = snapshot(&s);
assert_eq!(s.execute("livePaint.gapOptions", &set).unwrap(), first, "the usual reply");
assert_unchanged(&mut s, &mut before, "the options the group has");
s.execute("livePaint.gapOptions", &json!({})).unwrap();
assert_unchanged(&mut s, &mut before, "no options given");
// Close Gaps With Paths with a gap to close is an edit.
let r = s.execute("livePaint.gapOptions", &json!({"closeGaps": true})).unwrap();
assert_eq!(r["closed"], 1);
assert_eq!(history_state(&s).0, before.1.0 + 1);
}
#[test]
fn live_paint_gap_options_close_without_gaps_is_no_op() {
let mut s = session();
let g = live(&mut s);
redo_waiting_and_saved(&mut s, g);
let mut before = snapshot(&s);
let r = s.execute("livePaint.gapOptions", &json!({"id": g.0, "closeGaps": true})).unwrap();
assert_eq!((ids(&r), &r["faces"], &r["closed"], gaps_of(&r).len()), (vec![g], &json!(3), &json!(0), 0));
assert_unchanged(&mut s, &mut before, "no gap to close");
// With other options, the faces keep their ids when no path is added.
let faces = |s: &Session| vectorcraft_tools::builder::faces(&node(s, g)).iter().map(|f| f.id).collect::<Vec<_>>();
let ids_before = faces(&s);
s.execute("livePaint.gapOptions", &json!({"id": g.0, "closeGaps": true, "color": "#00ff00"})).unwrap();
assert_eq!(history_state(&s).0, before.1.0 + 1);
assert_eq!(faces(&s), ids_before);
}
#[test]
fn live_paint_make_existing_group_is_no_op() {
let mut s = session();
let g = live(&mut s);
redo_waiting_and_saved(&mut s, g);
let mut before = snapshot(&s);
let r = s.execute("livePaint.make", &json!({})).unwrap();
assert_eq!((NodeId(r["id"].as_u64().unwrap()), &r["faces"]), (g, &json!(3)));
assert_eq!(r["edges"].as_u64().unwrap(), vectorcraft_tools::builder::edges(&node(&s, g)).len() as u64);
assert_unchanged(&mut s, &mut before, "Make with the group alone");
}
#[test]
fn live_paint_merge_single_group_is_no_op() {
let mut s = session();
let g = live(&mut s);
let other = rect(&mut s, 300.0, 0.0, 50.0, 50.0);
redo_waiting_and_saved(&mut s, g);
// Given by id, the group is selected without an undo step.
s.execute("select.set", &json!({"ids": [other.0]})).unwrap();
let before = snapshot(&s);
let r = s.execute("livePaint.merge", &json!({"ids": [g.0]})).unwrap();
assert_eq!((NodeId(r["id"].as_u64().unwrap()), &r["faces"]), (g, &json!(3)));
assert_eq!(s.doc().unwrap().selection.objects, vec![g]);
assert!(*s.doc().unwrap().doc == before.0);
let (undo, redo, dirty, _) = history_state(&s);
assert_eq!((undo, redo, dirty), (before.1.0, before.1.1, before.1.2));
// A path to add is an edit.
s.execute("livePaint.merge", &json!({"ids": [g.0, other.0]})).unwrap();
assert_eq!(history_state(&s).0, before.1.0 + 1);
}
/// Shape Builder refuses an on/off option that is not true or false and a tolerance or gap that is
/// not a number, given as text or as another value of the wrong kind, naming the key; the document
/// and the undo history stay as they were. True, false and null still work.
+42
View File
@@ -109,6 +109,48 @@ fn saturate_keeps_a_color_it_does_not_change() {
assert_eq!(paint(&s, b), cmyk);
}
/// An Edit Colors pass, a Blend or Recolor Artwork that changes nothing records no undo step, and the
/// step that redo would bring back stays; one that changes a color still records one.
#[test]
fn edit_colors_that_change_nothing_record_no_undo_step() {
let mut s = session();
let gray = rect(&mut s, json!("#808080"));
let a = rect(&mut s, json!("#ff0000"));
let b = rect(&mut s, json!("#808080"));
let c = rect(&mut s, json!("#0000ff"));
s.execute("select.set", &json!({"ids": [a.0, b.0, c.0]})).unwrap();
s.execute("edit.colors.blendFrontToBack", &json!({})).unwrap();
// A step for redo to bring back.
s.execute("edit.colors.invert", &json!({"ids": [a.0]})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
let history = |s: &Session| {
let h = &s.doc().unwrap().history;
(h.undo.len(), h.redo.len())
};
let before = history(&s);
assert_eq!(before.1, 1, "one step to redo");
let doc = s.doc().unwrap().doc.clone();
let cases = [
("edit.colors.invert", json!({"fill": false, "stroke": false})),
("edit.colors.saturate", json!({"intensity": 0})),
("edit.colors.toRGB", json!({})),
("edit.colors.adjustBalance", json!({"mode": "rgb", "r": 0})),
("edit.colors.blendFrontToBack", json!({})),
("recolor.apply", json!({"map": {"#ff0000": "#ff0000"}})),
// The complement of a gray is the same gray.
("paint.complement", json!({"ids": [gray.0], "stroke": false})),
("addon.color.filter", json!({"effect": "addon.color.invert", "fill": false, "stroke": false})),
];
for (id, p) in cases {
let v = s.execute(id, &p).unwrap();
assert_eq!(v["changed"], 0, "{id}");
assert_eq!(history(&s), before, "{id}: no undo step, and redo is kept");
assert_eq!(s.doc().unwrap().doc, doc, "{id}: the document is unchanged");
}
s.execute("edit.colors.invert", &json!({})).unwrap();
assert_eq!(history(&s), (before.0 + 1, 0), "a pass that changes colors is one undo step");
}
/// Adjust Color Balance refuses a channel that is not a number, which it would otherwise read as 0.
#[test]
fn adjust_balance_refuses_a_channel_that_is_not_a_number() {
+153
View File
@@ -712,6 +712,159 @@ fn type_in_symbol_art_reports_a_gradient_only_when_it_expands() {
}
}
/// Selected type "Hi" at 64 pt whose characters have no paint, with fills and strokes of its own:
/// each of `items` is an `appearance.setItem` edit of a new object-level stroke when it has a
/// `weight`, else of a new object-level fill; the first `below` of them paint below the characters.
fn type_with_own_paint(s: &mut Session, items: &[Value], below: usize) -> NodeId {
let t = run(s, "text.create", json!({"x": 25, "y": 110, "text": "Hi", "size": 64}))["id"].as_u64().unwrap();
run(s, "select.set", json!({"ids": [t]}));
run(s, "paint.setFill", json!({"none": true}));
run(s, "paint.setStroke", json!({"none": true}));
for (i, item) in items.iter().enumerate() {
let add = if item.get("weight").is_some() { "appearance.addStroke" } else { "appearance.addFill" };
run(s, add, json!({"target": "object"}));
let mut p = item.clone();
p["index"] = json!(i);
run(s, "appearance.setItem", p);
}
run(s, "appearance.moveItem", json!({"from": "contents", "to": below}));
NodeId(t)
}
fn blue_stroke() -> Value {
json!({"color": "#0000ff", "weight": 5})
}
fn red_blue() -> Value {
json!({"gradient": {"kind": "linear", "stops": [{"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#0000ff"}]}})
}
/// Create Outlines draws what the type drew: a gradient fill of the type object's own, below its
/// characters, keeps one gradient across both glyphs over the layout's box, and its stroke stays
/// over them.
#[test]
fn create_outlines_draws_the_type_objects_own_paint() {
let mut s = session();
type_with_own_paint(&mut s, &[red_blue(), blue_stroke()], 1);
let before = render(&s);
run(&mut s, "type.createOutlines", json!({}));
let after = render(&s);
let n = differing(&before, &after, 24);
assert!(n < 40, "{n} pixels differ");
assert!(differing(&before, &render(&session()), 24) > 1000, "the type paints something");
}
/// `object.expand.info` reports the type object's own stroke, pattern fill and gradient fill, which
/// Object turns into paths of its whole outline: a gradient only when that outline's box needs no
/// more runs than are written.
#[test]
fn type_objects_own_stroke_pattern_and_gradient_are_reported() {
let mut s = session();
type_with_own_paint(&mut s, &[blue_stroke()], 0);
let info = run(&mut s, "object.expand.info", json!({}));
assert_eq!((info["object"].clone(), info["stroke"].clone(), info["fill"].clone()), (json!(true), json!(true), json!(false)), "{info}");
let mut s = session();
pattern_rect(&mut s, Rect::new(150.0, 150.0, 190.0, 190.0), false);
let t = type_with_own_paint(&mut s, &[json!({"swatch": "Dots"})], 0);
run(&mut s, "select.set", json!({"ids": [t.0]}));
let info = run(&mut s, "object.expand.info", json!({}));
assert_eq!((info["fill"].clone(), info["gradient"].clone(), info["stroke"].clone()), (json!(true), json!(false), json!(false)), "{info}");
// 0.4 pt runs across about 80 pt: under the limit; 0.02 pt runs: far over it.
for (len, expands) in [(40.0, true), (2.0, false)] {
let mut s = session();
let gradient = json!({"gradient": {"kind": "linear", "spread": "repeat", "repeats": 100, "start": [25, 100], "end": [25.0 + len, 100],
"stops": [{"offset": 0, "color": "#ffff00"}, {"offset": 1, "color": "#004080"}]}});
type_with_own_paint(&mut s, &[gradient], 0);
let info = run(&mut s, "object.expand.info", json!({}));
assert_eq!((info["gradient"].clone(), info["fill"].clone()), (json!(expands), json!(expands)), "{len}: {info}");
run(&mut s, "object.expand", json!({}));
let (gradients, texts) = gradients_and_type(&s);
assert_eq!(texts, 0, "{len}: outlined");
assert_eq!(gradients == 0, expands, "{len}: {gradients} gradient fills left");
}
}
/// Type with only spaces has no outline for its own stroke or pattern fill to go on, so
/// `object.expand.info` reports neither.
#[test]
fn type_without_an_outline_reports_no_own_stroke_or_fill() {
let mut s = session();
pattern_rect(&mut s, Rect::new(150.0, 150.0, 190.0, 190.0), false);
let t = run(&mut s, "text.create", json!({"x": 25, "y": 110, "text": " ", "size": 64}))["id"].as_u64().unwrap();
run(&mut s, "select.set", json!({"ids": [t]}));
run(&mut s, "paint.setFill", json!({"none": true}));
run(&mut s, "paint.setStroke", json!({"none": true}));
for (i, item) in [json!({"swatch": "Dots"}), blue_stroke()].into_iter().enumerate() {
let add = if item.get("weight").is_some() { "appearance.addStroke" } else { "appearance.addFill" };
run(&mut s, add, json!({"target": "object"}));
let mut p = item;
p["index"] = json!(i);
run(&mut s, "appearance.setItem", p);
}
let info = run(&mut s, "object.expand.info", json!({}));
assert_eq!(
(info["object"].clone(), info["stroke"].clone(), info["fill"].clone(), info["gradient"].clone()),
(json!(true), json!(false), json!(false), json!(false)),
"{info}"
);
}
/// How many objects in the document have a visible stroke with paint and weight.
fn painted_strokes(s: &Session) -> usize {
let mut n = 0;
s.doc().unwrap().doc.walk(|c| {
n += usize::from(
c.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(st) if st.visible && !st.paint.is_none() && st.width > 0.0)),
);
});
n
}
/// A visible stroke under a topmost stroke with no paint still has something for Stroke to
/// outline, on type's own appearance and on a path: `object.expand.info` reports it, and Expand
/// outlines it.
#[test]
fn a_stroke_under_an_unpainted_stroke_is_reported_and_outlined() {
let mut s = session();
type_with_own_paint(&mut s, &[blue_stroke(), json!({"none": true, "weight": 1})], 0);
let mut r = session();
run(&mut r, "shape.rectangle", json!({"x": 40, "y": 40, "width": 100, "height": 80}));
run(&mut r, "paint.setStroke", json!({"color": "#0000ff"}));
run(&mut r, "stroke.set", json!({"weight": 4}));
run(&mut r, "appearance.addStroke", json!({"target": "object"}));
let top = node(&r, selected(&r).id).appearance.items.len() - 1;
run(&mut r, "appearance.setItem", json!({"index": top, "none": true}));
for (what, s) in [("type", &mut s), ("path", &mut r)] {
let info = run(s, "object.expand.info", json!({}));
assert_eq!(info["stroke"], json!(true), "{what}: {info}");
run(s, "object.expand", json!({}));
assert_eq!(painted_strokes(s), 0, "{what}: the stroke is outlined");
}
}
/// Expand keeps the type object's own stroke and gradient fill through Object: Stroke outlines the
/// stroke and Fill expands the gradient, and with those options off they stay live on the path of
/// the whole outline. The picture stays the same either way.
#[test]
fn expand_keeps_the_type_objects_own_paint() {
for (opts, live) in [(json!({}), false), (json!({"fill": false, "stroke": false}), true)] {
let mut s = session();
type_with_own_paint(&mut s, &[red_blue(), blue_stroke()], 1);
let before = render(&s);
run(&mut s, "object.expand", opts.clone());
let after = render(&s);
assert!(mean_diff(&before, &after) < 2.0, "{opts}: {}", mean_diff(&before, &after));
let (gradients, texts) = gradients_and_type(&s);
assert_eq!(texts, 0, "{opts}: outlined");
assert_eq!(gradients == 1, live, "{opts}: {gradients} gradient fills");
let mut strokes = 0;
s.doc().unwrap().doc.walk(|n| strokes += usize::from(!n.appearance.stroke_paint().is_none()));
assert_eq!(strokes == 1, live, "{opts}: {strokes} strokes");
}
}
#[test]
fn the_mesh_option_makes_a_mesh_that_paints_the_gradient() {
for gradient in [
+45
View File
@@ -1043,6 +1043,51 @@ fn create_outlines_matches_text_bounds() {
assert!(s.doc().unwrap().doc.node(t).is_some());
}
/// The type object's own fills and strokes (not its characters') become paths of its whole outline,
/// with ids of their own: those below the Characters row under the glyph paths, the others over
/// them, in their order. The group keeps no appearance of its own, and Undo brings the type back.
#[test]
fn create_outlines_keeps_the_objects_own_fills_and_strokes() {
let mut s = session();
let t = text(&mut s, "Hi", 64.0);
s.execute("select.set", &json!({"ids": [t.0]})).unwrap();
for (cmd, p) in [
("appearance.addFill", json!({"target": "object"})),
("appearance.setItem", json!({"index": 0, "color": "#ff0000"})),
("appearance.addStroke", json!({"target": "object"})),
("appearance.setItem", json!({"index": 1, "color": "#0000ff", "weight": 5})),
("appearance.addFill", json!({"target": "object"})),
("appearance.setItem", json!({"index": 2, "color": "#00ff00", "opacity": 50})),
// The red fill paints below the characters; the stroke and the green fill over them.
("appearance.moveItem", json!({"from": "contents", "to": 1})),
] {
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd} {p}: {e}"));
}
let own = node(&s, t).appearance.items.clone();
assert_eq!(own.len(), 3);
let r = ids(&s.execute("type.createOutlines", &json!({})).unwrap());
let g = node(&s, r[0]);
assert!(g.appearance.items.is_empty(), "the group paints nothing of its own");
let ch = g.children().unwrap();
assert_eq!(ch.len(), 4, "a path below, the two glyphs, a path above");
let (first, last) = (&ch[0], &ch[3]);
assert_eq!(first.appearance.items, own[..1], "the item below the characters");
assert_eq!(last.appearance.items, own[1..], "the items over them, in their order");
for c in [first, last] {
assert!(matches!(c.kind, NodeKind::Path { .. }), "{:?}", c.kind);
assert!(c.id != t && c.id != g.id, "a fresh id");
}
assert!(first.id != last.id);
for c in &ch[1..3] {
assert_eq!(c.appearance.fill_paint(), Paint::solid(Color::BLACK), "the characters keep their own paint");
}
// The whole-outline paths cover both glyphs.
let glyphs = ch[1].geometric_bounds().unwrap().union(ch[2].geometric_bounds().unwrap());
assert!(close(first.geometric_bounds().unwrap(), glyphs, 1e-6), "{:?} vs {glyphs:?}", first.geometric_bounds());
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(node(&s, t).appearance.items, own, "one undo step brings the type back");
}
/// Colour bitmap glyphs (emoji) become embedded images where they sat; glyphs showing one image
/// share its pixels.
#[test]
+10 -1
View File
@@ -12,7 +12,7 @@ fn is_bad_params(r: Result<Value>) -> bool {
}
/// Folder preferences, which a preferences file leaves out.
const FOLDERS: [&str; 4] = ["fontsFolder", "pluginsFolder", "recoveryFolder", "templatesFolder"];
const FOLDERS: [&str; 6] = ["fontsFolder", "pluginsFolder", "scratchPrimary", "scratchSecondary", "recoveryFolder", "templatesFolder"];
/// A preferences file holding `prefs`, as `prefs.export` writes one.
fn file(prefs: Value) -> String {
@@ -46,7 +46,9 @@ fn in_file(s: &Session) -> Value {
fn exported_preferences_import_unchanged() {
let mut s = changed();
s.prefs.fonts_folder = "/fonts/here".into();
s.prefs.scratch_primary = "/scratch/here".into();
let r = s.execute("prefs.export", &json!({})).unwrap();
assert!(!r["data"].as_str().unwrap().contains("/scratch/here"), "a scratch disk folder is not written");
let text = r["data"].as_str().unwrap().to_string();
let written: Value = serde_json::from_str(&text).unwrap();
assert_eq!((written["format"].as_str(), written["version"].as_u64()), (Some(PREFS_FORMAT), Some(1)));
@@ -71,6 +73,7 @@ fn exported_preferences_import_unchanged() {
assert_eq!(t.doc().unwrap().doc.units, Unit::Millimeters, "the document's units stay as they are");
assert_eq!(t.doc().unwrap().history.undo.len(), undo, "no undo step");
assert_eq!(t.prefs.fonts_folder, "", "folders are not carried over");
assert_eq!(t.prefs.scratch_primary, "Startup", "nor is a scratch disk");
// Through a file, too.
let path = std::env::temp_dir().join(format!("vc-prefs-{}.json", std::process::id())).to_string_lossy().to_string();
@@ -96,6 +99,10 @@ fn a_hand_written_file_sets_what_it_names_and_leaves_the_rest() {
assert_eq!(s.prefs.keyboard_increment, 3.0);
assert_eq!(s.prefs.guide_color, "#abcdef");
assert_eq!(s.prefs.history_states, 77, "a preference the file leaves out keeps its value");
// A scratch disk choice names no folder, and is read.
let choices = file(json!({"scratchPrimary": "None", "scratchSecondary": "Startup"}));
assert_eq!(s.execute("prefs.import", &json!({"data": choices})).unwrap(), json!({"imported": 2}));
assert_eq!((s.prefs.scratch_primary.as_str(), s.prefs.scratch_secondary.as_str()), ("None", "Startup"));
}
#[test]
@@ -119,6 +126,8 @@ fn a_bad_preferences_file_is_refused_and_nothing_changes() {
(json!({"data": file(json!({"uiAccent": "blue", "historyStates": 5000}))}), "`historyStates` must be a whole number between 5 and 1000"),
(json!({"data": file(json!({"uiAccent": "blue", "eyedropper": 5}))}), "`eyedropper` must be an object"),
(json!({"data": file(json!({"uiAccent": "blue", "fontsFolder": "/fonts"}))}), "`fontsFolder` names a folder"),
(json!({"data": file(json!({"uiAccent": "blue", "scratchPrimary": "/scratch"}))}), "`scratchPrimary` names a folder"),
(json!({"data": file(json!({"uiAccent": "blue", "scratchSecondary": " scratch "}))}), "`scratchSecondary` names a folder"),
(json!({"data": too_large}), "larger than 1 MB"),
(json!({"data": 5}), "`data` must be a string"),
(json!({"path": "/a.json", "data": file(json!({"uiAccent": "blue"}))}), "give `path` or `data`"),
+30
View File
@@ -7488,3 +7488,33 @@ proptest! {
prop_assert!(!notes.iter().any(|n| n.contains("art this can't read")), "the records aren't art: {:?}", notes);
}
}
/// A graph in `.ai` editing data whose records read whole (version 7 specification, appendix A), of
/// a table `rows` × `cols` (its label row and column included): a series group tagged by its
/// column, and the axes on the plot's edges.
fn live_graph_text(rows: &str, cols: &str) -> String {
format!(
"%_Gs\n%_10 90 110 10 Gb\n%_5 0 0 14 0 1 0 0 6 44 Gy\n%_10 2 0 0 90 80 0 Gd\n\
%_1 () Ga\n%_0 13 0 0 0 0 0 () GA\n%_2 () Ga\n%_0 14 0 0 0 0 0 () GA\n%_4 () Ga\n%_0 14 0 0 0 0 0 () GA\n\
%_{rows} {cols} 1 1 Gz\n%_() Gc (East) Gc (Q1) Gc 5 Gc GC\n\
u\nu\n0 0 0 1 k\n20 10 m\n20 50 L\n40 50 L\n40 10 L\nf\nU\n%_2 1 0 0 Go\nu\n0 0 0 1 K\n10 90 m\n10 10 L\n110 10 L\nS\nU\nU\n%_GS\n"
)
}
proptest! {
#![proptest_config(config())]
/// A `.ai` graph that reads whole, then cut or damaged, or with a table of any size (zero, past
/// the limits, past what memory holds), never panics, and its drawn art always comes in.
#[test]
fn ai_live_graph_never_panics(cut in 0usize..800, edits in prop::collection::vec((0usize..800, prop::sample::select(vec!['0', '9', '-', '.', ' ', '\n', '(', ')', '/', '%', '_', 'G', 'c', 'C', 'o', 's', 'S', 'u', 'U'])), 0..12), rows in prop_oneof![Just(2u64), 0u64..20_000, Just(u64::MAX)], cols in prop_oneof![Just(2u64), 0u64..400, Just(4_000_000_000u64)]) {
let text = mutate_text(&live_graph_text("2", "2"), cut, &edits);
survive("mutated live .ai graph", || Some(vectorcraft_eps::layered_ai(&ai_private(&text), Document::new(100.0, 100.0), vec![], false, true, 1.0).0))?;
let sized = live_graph_text(&rows.to_string(), &cols.to_string());
let (doc, notes, read) = vectorcraft_eps::layered_ai(&ai_private(&sized), Document::new(4000.0, 200.0), vec![], false, true, 1.0);
prop_assert!(read, "{:?}", notes);
let mut paths = 0;
doc.walk(|n| paths += usize::from(matches!(n.kind, vectorcraft_doc::NodeKind::Path { .. })));
prop_assert_eq!(paths, 2, "{:?}", notes);
}
}
+4
View File
@@ -56,6 +56,7 @@ pub(super) const CLIPPING: &str = "clipping groups and clipping layers whose cli
pub(super) const CLIP_PAINT: &str = "the fills and strokes of clipping paths that a plain fill and line can't draw are written as paths of their own inside the clipping (fills under the clipped art, strokes over it) in the editing data for other apps";
pub(super) const CLIP_PAINT_MASKS: &str = "the opacity masks of clipping paths whose fills and strokes are written as paths of their own stay on the clipping path, not on those paths, in the editing data for other apps";
pub(super) const LIVE: &str = "blends, meshes, repeats, placed documents and intertwines are written as their art in the editing data for other apps";
pub(super) const GRAPHS: &str = "graphs are written as their art, without their data or settings, in the editing data for other apps";
pub(super) const STROKES: &str = "strokes a plain line can't draw (inside or outside the path, variable width, dots, dashes fitted to corners, gradients, patterns, arrowheads) are written as filled outlines, and brushed strokes as their brush's art, in the editing data for other apps";
pub(super) const ITEM_TRANSPARENCY: &str =
"the opacity and blending modes of single fills and strokes are left out of the editing data for other apps";
@@ -622,6 +623,9 @@ impl<'a> Writer<'a> {
if self.in_symbol {
self.wrote_fixed |= symbols::redrawn(n);
}
if n.extras().graph.is_some() && !self.in_look {
self.warn(GRAPHS);
}
// On the layers or in an opacity mask's art, outside art cut to a clipping object: with its
// art style, when it has one.
if !self.in_look
+6 -3
View File
@@ -78,7 +78,8 @@
//!
//! - Graphs (version 7 specification §17): `%_Gs`, the graph's data and settings on `%_` lines,
//! its drawn art as ordinary groups, paths and type (each object followed by `%_… Go`), `%_GS`.
//! The drawn art is read; the data and settings are left out, with a note.
//! The drawn art is read as it is. Its group keeps the data and settings when they read whole
//! ([`graph`]); otherwise they are left out, with a note.
//!
//! - Swatches: the palette (`%AI5_BeginPalette`), read by [`super::palette`], replaces the
//! default swatches.
@@ -133,6 +134,7 @@ mod art;
mod containers;
mod directives;
mod document;
mod graph;
mod masks;
mod on_path;
mod ops;
@@ -146,12 +148,13 @@ pub use document::{
symbols, variables,
};
pub(crate) use document::{slot_frame, slot_of};
use graph::Graph;
pub(crate) use ops::{read_art_style, read_style_list, style_moves_with};
#[cfg(test)]
pub(crate) use raster::with_image_limits;
pub(crate) use types::MAX_NODES;
pub use types::PlacedPage;
use types::{BLEND_BUDGET, BrushArtColors, FLIP, Frame, GState, Graph, Kind, PatternHead, PendingEnvelope, Place, PlacedTail, Raster, SymbolHead};
use types::{BLEND_BUDGET, BrushArtColors, FLIP, Frame, GState, Kind, PatternHead, PendingEnvelope, Place, PlacedTail, Raster, SymbolHead};
#[cfg(test)]
pub use types::{GRAPH_PLAIN, GRAPH_UNENDED, LINKED_PLACEHOLDERS, NON_NATIVE_ART, NON_NATIVE_ART_UNREAD, VERSIONED_UNENDED};
pub(super) use types::{blend_mode, blend_name};
@@ -670,7 +673,7 @@ struct Reader<'a> {
brushes_kept: BrushesKept,
/// Brush objects that weren't read.
brushes_unread: usize,
/// The graph being read (see [`Reader::graph_record`]).
/// The graph being read (see [`graph`]).
graph: Option<Graph>,
/// The multi-layer mask being read (`Mb` … `MB`), which goes on past a layer's end.
multi_mask: Option<masks::MultiMask>,
+3 -1
View File
@@ -1165,7 +1165,9 @@ impl<'a> Reader<'a> {
}
pub(super) fn finish(mut self) -> Result<Structure, String> {
if self.graph.take().is_some() {
if self.graph.is_some() {
self.graph_plain();
self.graph = None;
self.warn(super::types::GRAPH_UNENDED);
}
// Envelopes whose plugin never closed them keep their drawn art.
+681
View File
@@ -0,0 +1,681 @@
//! A graph's records (version 7 specification §17 and appendix A) and the live graph they give.
//!
//! A graph is `%_Gs`, its functional records on `%_` lines (`Gb`, `Gy`, `Gd`, any `Gj`, three
//! `Ga` … `GA` axes, any `Gw`, `Gz`, `Gc` cells and `GC`), any `version Gt` … `GT` customizations, its
//! drawn art in one group (objects followed by `%_… Go`), then `%_GS`. The drawn art is always
//! read as it is. The group also keeps the graph's data and settings ([`GraphSpec`]) when every
//! record has the shape and values appendix A gives and the model holds each setting, the table
//! has data, the art draws the plot's left and bottom edges, and each series' group is tagged, is
//! one of the graph's own groups and paints its paths with one fill and one stroke, which the
//! graph keeps as the series' paint.
//! Any other graph stays plain art, with a note.
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use kurbo::{PathSeg, Point};
use vectorcraft_doc::{Appearance, GraphKind, GraphSpec, MAX_GRAPH_CATEGORIES, MAX_GRAPH_SERIES, SeriesPaint, TickLength};
use super::types::{GRAPH_OPS, GRAPH_PLAIN, GRAPH_UNENDED, Kind};
use super::{Affine, AppearanceItem, BlendMode, Node, NodeId, NodeKind, Paint, Reader, Rect, V, obj};
/// Most cells of a graph's table, its label row and column included.
const MAX_CELLS: usize = 2_600_000;
/// Longest cell string (appendix A, `Gc`).
const MAX_CELL_TEXT: usize = 255;
/// Most characters of an axis label's text before or after its numbers (appendix A, `Ga`, `GA`).
const MAX_AFFIX: usize = 9;
/// Most tick marks per division a graph draws.
const MAX_TICK_MARKS: usize = 20;
/// Most divisions of a value axis with set values.
const MAX_DIVISIONS: f64 = 100.0;
/// How far an axis line may be from the plot's edge, in points.
const EDGE: f64 = 0.01;
/// The axes in the order the records give them: bottom, left, right.
const AXES: [i64; 3] = [1, 2, 4];
/// The `Go` targets appendix A lists.
const TARGETS: [i64; 11] = [1, 2, 4, 5, 6, 8, 9, 10, 15, 20, 22];
/// The version of a graph's customizations (appendix A, `Gt`).
const CUSTOM_VERSION: i64 = 2;
/// `Go`'s target for one series, including its legend.
const SERIES: i64 = 2;
/// A graph being read (`%_Gs` … `%_GS`).
#[derive(Debug)]
pub(super) struct Graph {
/// Between `Gt` and `GT`, where the graph's settings may use paint and type operators on `%_`
/// lines too.
pub(super) settings: bool,
/// How many frames were open at its `Gs`: a layer that ends with fewer ends the graph.
pub(super) frames: usize,
/// How many objects the innermost frame held at `Gs`: the drawn art is the one after them.
siblings: usize,
/// The records read so far, while they can still give a live graph.
live: Option<Box<Records>>,
}
/// Where the records are, in the order appendix A gives.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
enum Stage {
#[default]
Bounds,
Style,
Dialog,
/// Before the `Ga` of axis `n`.
Axis(usize),
/// Before the `GA` of axis `n`.
AxisEnd(usize),
Widths,
Cells,
/// After `GC`: customizations, then the drawn art.
Done,
/// Between `Gt` and `GT`.
Custom,
}
/// One axis: `whichAxis beforeString Ga` and `useManualValues tickMarkType minimumValue maximumValue
/// betweenValue smallTicksPerValue drawMarksBetweenLabels afterString GA`.
#[derive(Debug, Default)]
struct Axis {
before: Vec<u8>,
manual: bool,
tick: TickLength,
min: f64,
max: f64,
between: f64,
small: usize,
between_labels: bool,
after: Vec<u8>,
}
/// A cell of the table (`Gc`).
#[derive(Debug)]
enum Cell {
Num(f64),
Text(Vec<u8>),
}
/// The records of a graph read so far.
#[derive(Debug, Default)]
struct Records {
stage: Stage,
spec: GraphSpec,
axes: [Axis; 3],
/// `Gw`: the first column and how many widths.
widths: Vec<(usize, usize)>,
/// `Gz`: rows, columns, first data row and first data column.
size: Option<[usize; 4]>,
cells: Vec<Cell>,
/// The groups `Go` tags as one series, and the column each names.
series: Vec<(NodeId, usize)>,
}
/// A whole number.
fn int(v: &V) -> Option<i64> {
v.num().filter(|x| x.is_finite() && x.fract() == 0.0 && x.abs() < 1e15).map(|x| x as i64)
}
/// 0 or 1.
fn flag(v: &V) -> Option<bool> {
match int(v)? {
0 => Some(false),
1 => Some(true),
_ => None,
}
}
fn finite(v: &V) -> Option<f64> {
v.num().filter(|x| x.is_finite())
}
/// A count from 0 to `max`.
fn count(v: &V, max: usize) -> Option<usize> {
usize::try_from(int(v)?).ok().filter(|n| *n <= max)
}
/// `tickMarkType`: 13 none, 14 short, 15 the length of the plot.
fn tick(v: &V) -> Option<TickLength> {
match int(v)? {
13 => Some(TickLength::None),
14 => Some(TickLength::Short),
15 => Some(TickLength::Full),
_ => None,
}
}
/// `graphType`: 5 grouped column, 6 stacked column, 7 line, 10 area. Pie (8) and scatter (9) graphs
/// keep settings the records don't give the model, and other values are not graph types.
fn kind(v: &V) -> Option<GraphKind> {
match int(v)? {
5 => Some(GraphKind::Column),
6 => Some(GraphKind::StackedColumn),
7 => Some(GraphKind::Line),
10 => Some(GraphKind::Area),
_ => None,
}
}
/// A percentage of the available width, 1 to 1000.
fn percent(v: &V) -> Option<f64> {
finite(v).filter(|p| (1.0..=1000.0).contains(p))
}
/// The tick count and values of an axis: with set values (`useManualValues` 1), the divisions
/// between its lowest and highest value, a whole number of `betweenValue` steps from the lowest up.
fn values(a: &Axis) -> Option<(usize, Option<f64>, Option<f64>)> {
if !a.manual {
return Some((0, None, None));
}
let n = (a.max - a.min) / a.between;
let whole = n.round();
let exact = (n - whole).abs() <= 1e-6 * whole.max(1.0);
(a.between > 0.0 && a.max > a.min && exact && (1.0..=MAX_DIVISIONS).contains(&whole)).then_some((whole as usize, Some(a.min), Some(a.max)))
}
impl Records {
/// Take the record `w` with its operands `vals`; `None` when its shape, values or place aren't
/// those appendix A gives, or the model doesn't hold a value it sets. `to_doc` takes art space
/// to the document.
fn step(&mut self, w: &str, vals: &[V], to_doc: Affine) -> Option<()> {
match (w, self.stage) {
("Gb", Stage::Bounds) => {
let [l, t, r, b] = vals else { return None };
let [l, t, r, b] = [finite(l)?, finite(t)?, finite(r)?, finite(b)?];
let plot = to_doc.transform_rect_bbox(Rect::new(l, b, r, t));
let sound = r > l && t > b && plot.width() > 0.0 && plot.height() > 0.0 && plot.width().is_finite() && plot.height().is_finite();
sound.then_some(())?;
self.spec.rect = plot;
self.stage = Stage::Style;
}
("Gy", Stage::Style) => {
self.style(vals)?;
self.stage = Stage::Dialog;
}
("Gd", Stage::Dialog) => {
let [col_width, precision, series_order, both_axes, bar, group, edge] = vals else { return None };
count(col_width, 20).filter(|w| *w >= 3)?;
count(precision, 10)?;
// `useBothAxis` copies one axis' values to the other, which the model doesn't do.
(!flag(both_axes)?).then_some(())?;
self.spec.first_column_in_front = flag(series_order)?;
self.spec.column_width = percent(bar)?;
self.spec.cluster_width = percent(group)?;
self.spec.edge_to_edge = flag(edge)?;
self.stage = Stage::Axis(0);
}
("Ga", Stage::Axis(n)) if n < AXES.len() => {
let [axis, V::Str(before)] = vals else { return None };
(int(axis)? == *AXES.get(n)?).then_some(())?;
self.axes.get_mut(n)?.before = before.clone();
self.stage = Stage::AxisEnd(n);
}
("GA", Stage::AxisEnd(n)) => {
let [manual, ticks, min, max, between, small, between_labels, V::Str(after)] = vals else { return None };
let a = self.axes.get_mut(n)?;
(a.manual, a.tick) = (flag(manual)?, tick(ticks)?);
(a.min, a.max, a.between) = (finite(min)?, finite(max)?, finite(between)?);
a.small = count(small, 1000)?;
a.between_labels = flag(between_labels)?;
a.after = after.clone();
self.stage = Stage::Axis(n + 1);
}
("Gw", Stage::Axis(3) | Stage::Widths) => {
// `col width1 … widthX numParams Gw`: numParams counts `col` and the 1 to 14 widths.
let (params, rest) = vals.split_last()?;
let params = count(params, 15).filter(|p| *p >= 2 && *p == rest.len())?;
let (col, widths) = rest.split_first()?;
let col = count(col, MAX_CELLS)?;
widths.iter().all(|w| int(w).is_some_and(|w| w == -1 || (3..=20).contains(&w))).then_some(())?;
self.widths.push((col, params - 1));
self.stage = Stage::Widths;
}
("Gz", Stage::Axis(3) | Stage::Widths) => {
let [rows, cols, first_row, first_col] = vals else { return None };
let (rows, cols) = (count(rows, MAX_CELLS)?, count(cols, MAX_CELLS)?);
let (first_row, first_col) = (usize::from(flag(first_row)?), usize::from(flag(first_col)?));
rows.checked_sub(first_row).filter(|c| (1..=MAX_GRAPH_CATEGORIES).contains(c))?;
cols.checked_sub(first_col).filter(|s| (1..=MAX_GRAPH_SERIES).contains(s))?;
rows.checked_mul(cols).filter(|n| *n <= MAX_CELLS)?;
self.widths.iter().all(|(col, n)| col.checked_add(*n).is_some_and(|end| end <= cols)).then_some(())?;
self.size = Some([rows, cols, first_row, first_col]);
self.stage = Stage::Cells;
}
("Gc", Stage::Cells) => {
// One to fifteen values, at most one of them a string.
let strings = vals.iter().filter(|v| matches!(v, V::Str(_))).count();
((1..=15).contains(&vals.len()) && strings <= 1).then_some(())?;
let [rows, cols, ..] = self.size?;
(self.cells.len() + vals.len() <= rows * cols).then_some(())?;
for v in vals {
self.cells.push(match v {
V::Str(s) if s.len() <= MAX_CELL_TEXT => Cell::Text(s.clone()),
_ => Cell::Num(finite(v)?),
});
}
}
("GC", Stage::Cells) if vals.is_empty() => self.stage = Stage::Done,
// `version Gt`, of version 2. Customizations are edits made after the graph was built, which
// the model can't replay: only an empty list keeps the graph live.
("Gt", Stage::Done) => {
let [version] = vals else { return None };
(int(version)? == CUSTOM_VERSION).then_some(())?;
self.stage = Stage::Custom;
}
("GT", Stage::Custom) if vals.is_empty() => self.stage = Stage::Done,
_ => return None,
}
Some(())
}
/// `graphType shadow dataPointOrder pieLegendStyle drawMarks drawLines drawLinesAsShapes
/// drawLegendsAcrossTop lineShapeWidth whichAxis [piePercentage piePctDigits] Gy`.
fn style(&mut self, vals: &[V]) -> Option<()> {
let (base, pie) = match vals.len() {
10 => (vals, None),
12 => vals.split_at_checked(10).map(|(b, p)| (b, Some(p)))?,
_ => return None,
};
let [ty, shadow, order, legend, marks, lines, shapes, across, width, axis] = base else { return None };
self.spec.kind = kind(ty)?;
self.spec.drop_shadow = flag(shadow)?;
self.spec.first_row_in_front = flag(order)?;
// 14: legends as in bar and line graphs; 15 (in wedges) and 16 (none) are pie styles.
(int(legend)? == 14).then_some(())?;
self.spec.legend = true;
self.spec.mark_points = flag(marks)?;
self.spec.connect_points = flag(lines)?;
// Lines drawn as shapes have a width the model doesn't keep.
(!flag(shapes)?).then_some(())?;
self.spec.filled_lines = false;
self.spec.legend_across_top = flag(across)?;
finite(width).filter(|w| (0.0..=100.0).contains(w))?;
// 44: the series are measured against the left axis; 45 (right) isn't kept per series.
(int(axis)? == 44).then_some(())?;
if let Some([percentage, digits]) = pie {
// Pie percentages, which only pie graphs show; shown (1) isn't kept.
(!flag(percentage)?).then_some(())?;
int(digits).filter(|d| *d >= 0)?;
}
Some(())
}
/// The graph's data and settings, its strings read as names in `names`; `None` when the table
/// or an axis holds what the model can't.
fn finish(&self, names: &mut obj::Names) -> Option<GraphSpec> {
let [rows, cols, first_row, first_col] = self.size?;
let mut spec = self.spec.clone();
let text = |names: &mut obj::Names, b: &[u8], max: usize| {
let t = names.quiet(b);
(t.chars().count() <= max && !t.chars().any(char::is_control)).then(|| names.bytes(b))
};
// Axes: the bottom one is the category axis, the left one the value axis; the right one keeps
// its settings for when it is shown.
let [bottom, left, right] = &self.axes;
(bottom.before.is_empty() && bottom.after.is_empty() && !bottom.manual).then_some(())?;
(!left.between_labels && !right.between_labels).then_some(())?;
(spec.category_tick_length, spec.category_tick_marks) = (bottom.tick, bottom.small.max(1));
spec.ticks_between_labels = bottom.between_labels;
(spec.tick_length, spec.tick_marks) = (left.tick, left.small.max(1));
(spec.right_tick_length, spec.right_tick_marks) = (right.tick, right.small.max(1));
(spec.category_tick_marks <= MAX_TICK_MARKS && spec.tick_marks <= MAX_TICK_MARKS && spec.right_tick_marks <= MAX_TICK_MARKS).then_some(())?;
(spec.ticks, spec.axis_min, spec.axis_max) = values(left)?;
(spec.right_ticks, spec.right_axis_min, spec.right_axis_max) = values(right)?;
spec.prefix = text(names, &left.before, MAX_AFFIX)?;
spec.suffix = text(names, &left.after, MAX_AFFIX)?;
spec.right_prefix = text(names, &right.before, MAX_AFFIX)?;
spec.right_suffix = text(names, &right.after, MAX_AFFIX)?;
// The table, row by row; cells left out at its end are empty.
let cell = |r: usize, c: usize| self.cells.get(r * cols + c);
let label = |names: &mut obj::Names, r: usize, c: usize| match cell(r, c) {
None => Some(String::new()),
Some(Cell::Text(t)) => text(names, t, MAX_CELL_TEXT),
Some(Cell::Num(_)) => None,
};
// The corner of a table with both label row and label column holds nothing.
let corner_empty = match cell(0, 0) {
None => true,
Some(Cell::Text(t)) => t.is_empty(),
Some(Cell::Num(_)) => false,
};
if first_row == 1 && first_col == 1 && !corner_empty {
return None;
}
spec.series = if first_row == 1 { (first_col..cols).map(|c| label(names, 0, c)).collect::<Option<_>>()? } else { vec![] };
spec.categories = if first_col == 1 { (first_row..rows).map(|r| label(names, r, 0)).collect::<Option<_>>()? } else { vec![] };
let mut data = Vec::with_capacity(rows - first_row);
for r in first_row..rows {
let row = (first_col..cols)
.map(|c| match cell(r, c) {
None => Some(None),
Some(Cell::Text(t)) if t.is_empty() => Some(None),
Some(Cell::Text(_)) => None,
Some(Cell::Num(v)) => Some(Some(*v)),
})
.collect::<Option<Vec<_>>>()?;
data.push(row);
}
data.iter().flatten().any(Option::is_some).then_some(())?;
spec.set_cells(data);
Some(spec)
}
/// The series index of each group `Go` tagged as one series, by id: every series once, its
/// columns counted in the table or among the series alike. `None` when the tags are missing,
/// repeated or out of range: the series' paint is read from its group.
fn series_tags(&self) -> Option<HashMap<NodeId, u32>> {
let [_, cols, _, first_col] = self.size?;
let n = cols - first_col;
let ids: HashSet<NodeId> = self.series.iter().map(|(id, _)| *id).collect();
(ids.len() == self.series.len() && self.series.len() == n).then_some(())?;
let indexes = |offset: usize| -> Option<HashMap<NodeId, u32>> {
let mut seen = HashSet::new();
let tags: HashMap<NodeId, u32> = self
.series
.iter()
.map(|(id, col)| {
let s = col.checked_sub(offset).filter(|s| *s < n && seen.insert(*s))?;
Some((*id, u32::try_from(s).ok()?))
})
.collect::<Option<_>>()?;
Some(tags)
};
// With a label column, the columns read as the table's or as the series' are told apart by the
// set they make; without one, they are the same.
match (indexes(0), indexes(first_col)) {
(Some(a), Some(b)) if a == b => Some(a),
(Some(a), None) | (None, Some(a)) => Some(a),
_ => None,
}
}
}
/// Whether `art` draws the plot `plot`'s left edge and its bottom edge (the document's y runs down)
/// as straight stroked lines: the value axis and the category axis, drawn on the plot's edges.
fn draws_axes(art: &Node, plot: Rect) -> bool {
let near = |a: Point, b: Point| (a - b).hypot() <= EDGE;
let on = |s: &PathSeg, a: Point, b: Point| match s {
PathSeg::Line(l) => (near(l.p0, a) && near(l.p1, b)) || (near(l.p0, b) && near(l.p1, a)),
_ => false,
};
let (top_left, bottom_left, bottom_right) = (Point::new(plot.x0, plot.y0), Point::new(plot.x0, plot.y1), Point::new(plot.x1, plot.y1));
let (mut left, mut bottom) = (false, false);
let mut stack = vec![art];
while let Some(n) = stack.pop() {
// Only shown objects draw the axes, and a path only with a stroke.
if !n.visible || n.opacity <= 0.0 || (left && bottom) {
continue;
}
let stroked = n.appearance.items.iter().any(|it| !it.is_fill() && it.visible() && it.opacity() > 0.0 && !it.paint().is_none());
if let NodeKind::Path { path, .. } = &n.kind
&& stroked
{
for s in path.to_bezpath().segments() {
left |= on(&s, top_left, bottom_left);
bottom |= on(&s, bottom_left, bottom_right);
}
}
stack.extend(n.children().into_iter().flatten().map(|c| &**c));
}
left && bottom
}
/// Give the groups among `n`'s children that `tags` holds their series index.
fn tag_series(n: &mut Node, tags: &HashMap<NodeId, u32>) {
for c in n.children_mut().into_iter().flatten() {
if let Some(i) = tags.get(&c.id) {
Arc::make_mut(c).extras_mut().series_index = Some(*i);
}
}
}
/// Whether every node `tags` holds is a group among `n`'s children: the graph draws its series
/// groups again as its own children.
fn tags_groups(n: &Node, tags: &HashMap<NodeId, u32>) -> bool {
let found = n.children().into_iter().flatten().filter(|c| tags.contains_key(&c.id) && matches!(c.kind, NodeKind::Group { .. })).count();
found == tags.len()
}
/// The paint of the shown fill (`fill`) or stroke of `p`, with a stroke's weight; `None` when it
/// has none. `Err` when it has more than one, or that fill or stroke has an opacity, a blend mode
/// or effects of its own, which a series' paint doesn't hold.
fn shown(p: &Node, fill: bool) -> Result<Option<(Paint, f64)>, ()> {
let mut items = p.appearance.items.iter().filter(|it| it.is_fill() == fill && it.visible());
let Some(item) = items.next() else { return Ok(None) };
if items.next().is_some() || item.opacity() != 1.0 || item.blend() != BlendMode::Normal || !item.effects().is_empty() {
return Err(());
}
if item.paint().is_none() {
return Ok(None);
}
let width = match item {
AppearanceItem::Stroke(s) => s.width,
AppearanceItem::Fill(_) => 0.0,
};
Ok(Some((item.paint().clone(), width)))
}
/// Whether `n` is shown, fully opaque, in Normal mode, not isolated and without an opacity mask:
/// the graph draws its series groups and their marks so.
fn as_drawn(n: &Node) -> bool {
n.visible && n.opacity == 1.0 && n.blend == BlendMode::Normal && !n.isolate && n.extras().mask.is_none()
}
/// Each series' fill and stroke, read from its group (`tags`), which holds paths only, one at
/// least: the paths with a fill share it, and every path has the same stroke or none. Only a line
/// graph (`line`) has paths without a fill: its lines. `None` when they differ, or the group, its
/// own appearance or a path is drawn otherwise than [`as_drawn`].
fn series_paints(art: &Node, tags: &HashMap<NodeId, u32>, line: bool) -> Option<Vec<SeriesPaint>> {
let mut paints = vec![SeriesPaint::default(); tags.len()];
for group in art.children().into_iter().flatten() {
let Some(slot) = tags.get(&group.id).and_then(|i| paints.get_mut(usize::try_from(*i).ok()?)) else { continue };
(as_drawn(group) && *group.appearance == Appearance::default()).then_some(())?;
let paths: Vec<&Arc<Node>> = group.children().into_iter().flatten().collect();
(!paths.is_empty() && paths.iter().all(|p| matches!(p.kind, NodeKind::Path { .. }))).then_some(())?;
let (mut fills, mut strokes) = (vec![], vec![]);
for p in &paths {
as_drawn(p).then_some(())?;
fills.extend(shown(p, true).ok()?);
strokes.push(shown(p, false).ok()?);
}
let fill = fills.first().map(|(paint, _)| paint.clone());
fills.iter().all(|(paint, _)| Some(paint) == fill.as_ref()).then_some(())?;
(line || fills.len() == paths.len()).then_some(())?;
let stroke = strokes.first().cloned().flatten();
strokes.iter().all(|s| *s == stroke).then_some(())?;
slot.fill = fill;
(slot.stroke, slot.stroke_width) = match stroke {
Some((paint, width)) => (Some(paint), Some(width)),
None => (Some(Paint::None), None),
};
}
Some(paints)
}
impl<'a> Reader<'a> {
/// A graph's records: `%_Gs` starts the graph on a layer, `GS` ends it, and its data and settings
/// (the operators in [`GRAPH_OPS`], and any operator on a `%_` line between `Gt` and `GT`) are
/// taken with their operands `vals`. Its drawn art, and anything else, is read as usual. `true`
/// when `w` was one of them. `ended`: whether a group and a mesh had just ended before `w`, which
/// a `Go` tag after them leaves so.
pub(super) fn graph_record(&mut self, w: &str, vals: &[V], hidden: bool, ended: (bool, bool)) -> bool {
let depth = self.frames.len();
let Some(g) = self.graph.as_mut() else {
// Outside a graph, its operators stay ones the reader doesn't know.
if w == "Gs" && hidden && !self.frames.is_empty() {
let siblings = self.frames.last().map_or(0, |f| f.children.len());
// A graph is live only where its art is in the document's space, in a layer or a group.
let placed = self.pattern.is_none()
&& self.symbol.is_none()
&& vals.is_empty()
&& matches!(self.frames.last().map(|f| &f.kind), Some(Kind::Layer(_) | Kind::Group | Kind::Clip));
self.graph = Some(Graph { settings: false, frames: depth, siblings, live: placed.then(Box::default) });
return true;
}
return false;
};
// The frame the graph started in closed: its art isn't where it was.
if depth < g.frames {
self.graph_plain();
}
let Some(g) = self.graph.as_mut() else { return false };
let stage = g.live.as_ref().map(|r| r.stage);
match w {
// A graph doesn't start inside another: the one being read goes on.
"Gs" => {
self.graph_plain();
self.warn(GRAPH_UNENDED);
}
"GS" => self.graph_end(vals.is_empty() && hidden),
"Gt" | "GT" => {
g.settings = w == "Gt";
self.graph_step(w, vals, hidden);
}
"Go" => {
self.graph_tag(vals, hidden);
(self.group_ended, self.mesh_ended) = ended;
}
_ if GRAPH_OPS.contains(&w) => self.graph_step(w, vals, hidden),
_ if hidden && g.settings => self.graph_plain(),
_ => {
// Before its table ends, a graph has only its records.
if !matches!(stage, None | Some(Stage::Done)) {
self.graph_plain();
}
return false;
}
}
true
}
/// The graph being read can't be live: its art stays plain, with a note.
pub(super) fn graph_plain(&mut self) {
if let Some(g) = self.graph.as_mut() {
g.live = None;
}
self.warn(GRAPH_PLAIN);
}
/// Take a functional record or customization on a `%_` line.
fn graph_step(&mut self, w: &str, vals: &[V], hidden: bool) {
if self.graph.as_ref().is_none_or(|g| g.live.is_none()) {
return;
}
let to_doc = if w == "Gb" { self.space() } else { Affine::IDENTITY };
let ok = hidden && self.graph.as_mut().and_then(|g| g.live.as_mut()).and_then(|r| r.step(w, vals, to_doc)).is_some();
if !ok {
self.graph_plain();
}
}
/// `target column row whichAxis Go` after an object of the drawn art: a group tagged as one
/// series is kept with the column it names.
fn graph_tag(&mut self, vals: &[V], hidden: bool) {
let depth = self.frames.len();
let last = self
.after_object
.then(|| self.frames.last().and_then(|f| f.children.last()))
.flatten()
.map(|n| (n.id, matches!(n.kind, NodeKind::Group { .. })));
let Some(g) = self.graph.as_mut() else { return };
let inside = depth > g.frames;
let Some(r) = g.live.as_mut() else { return };
let tag = match vals {
[target, column, row, axis] if hidden && r.stage == Stage::Done => {
let (row, axis) = (int(row), int(axis));
// A series is the whole column, measured on the left axis (2) or with no axis given (0):
// the model keeps no series on a row or on the right axis.
let whole_column = row == Some(0) && matches!(axis, Some(0 | 2));
int(target).filter(|t| TARGETS.contains(t) && row.is_some() && axis.is_some()).zip(int(column)).map(|(t, c)| (t, c, whole_column))
}
_ => None,
};
let ok = match (tag, last) {
(Some((SERIES, column, true)), Some((id, true))) if inside => usize::try_from(column).ok().map(|c| r.series.push((id, c))).is_some(),
(Some((SERIES, ..)), _) => false,
(Some(_), Some(_)) => true,
_ => false,
};
if !ok {
self.graph_plain();
}
}
/// `GS`: the graph ends. Its drawn art is the one object its frame gained, a group; it keeps the
/// graph's data and settings when they read whole (`whole`) and the art is registered on its plot.
fn graph_end(&mut self, whole: bool) {
let Some(g) = self.graph.take() else { return };
let depth = self.frames.len();
let live = g.live.filter(|r| whole && r.stage == Stage::Done && depth == g.frames);
let spec = live.as_ref().and_then(|r| r.finish(&mut self.names).zip(r.series_tags()));
let attached = spec.is_some_and(|(mut spec, tags)| {
let Some(art) = self.frames.last_mut().filter(|f| f.children.len() == g.siblings + 1).and_then(|f| f.children.last_mut()) else {
return false;
};
if !matches!(art.kind, NodeKind::Group { clip: false, .. }) || !tags_groups(art, &tags) || !draws_axes(art, spec.rect) {
return false;
}
let Some(placed) = art.geometric_bounds().filter(|b| b.width() > 0.0 && b.height() > 0.0) else { return false };
let r = spec.rect;
if r.x0 < placed.x0 - EDGE || r.y0 < placed.y0 - EDGE || r.x1 > placed.x1 + EDGE || r.y1 > placed.y1 + EDGE {
return false;
}
let Some(paints) = series_paints(art, &tags, spec.kind == GraphKind::Line) else { return false };
spec.series_paints = paints;
spec.placed = Some(placed);
tag_series(art, &tags);
art.extras_mut().graph = Some(Box::new(spec));
true
});
if !attached {
self.warn(GRAPH_PLAIN);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use vectorcraft_color::Color;
use vectorcraft_geom::shapes;
/// A graph's art: one series group (id 2) holding one mark painted `ap`, the group changed by
/// `group`.
fn art(ap: Appearance, group: impl Fn(&mut Node)) -> Node {
let mark = Arc::new(Node::path(NodeId(3), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), ap));
let mut series = Node::group(NodeId(2), vec![mark]);
group(&mut series);
Node::group(NodeId(1), vec![Arc::new(series)])
}
/// A series whose mark has two fills has no one paint, so the graph can't draw it again.
#[test]
fn a_series_mark_with_two_fills_has_no_series_paint() {
let red = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
let one = Appearance::basic(red.clone(), Paint::None, 0.0);
let mut two = one.clone();
two.items.extend(one.items.iter().find(|i| i.is_fill()).cloned());
let tags = HashMap::from([(NodeId(2), 0)]);
let kept = series_paints(&art(one, |_| {}), &tags, false).expect("one fill");
assert_eq!((kept[0].fill.as_ref(), kept[0].stroke.as_ref()), (Some(&red), Some(&Paint::None)));
assert!(series_paints(&art(two, |_| {}), &tags, false).is_none());
}
/// A series group that is hidden, see-through or in another blending mode is not drawn again so.
#[test]
fn a_series_group_drawn_otherwise_has_no_series_paint() {
let ap = || Appearance::basic(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::None, 0.0);
let tags = HashMap::from([(NodeId(2), 0)]);
assert!(series_paints(&art(ap(), |g| g.visible = false), &tags, false).is_none(), "hidden");
assert!(series_paints(&art(ap(), |g| g.opacity = 0.5), &tags, false).is_none(), "50% opaque");
assert!(series_paints(&art(ap(), |g| g.blend = BlendMode::Multiply), &tags, false).is_none(), "Multiply");
}
}
+8 -37
View File
@@ -1,12 +1,9 @@
use super::containers::close;
use super::document::slot_of;
use super::types::{
BLENDS, FLIP, Frame, GRAPH_OPS, GRAPH_PLAIN, GRAPH_UNENDED, IGNORED, Kind, MAX_DEPTH, MAX_NODES, MAX_TAG_TEXT, MAX_TAGS, Place, URL_TAG,
line_width,
};
use super::types::{BLENDS, FLIP, Frame, GRAPH_UNENDED, IGNORED, Kind, MAX_DEPTH, MAX_NODES, MAX_TAG_TEXT, MAX_TAGS, Place, URL_TAG, line_width};
use super::{
Affine, Appearance, AppearanceItem, Arc, BlendMode, BrushesKept, Dash, FillLayer, FillRule, Global, Gradient, GradientDef, Graph, HashMap,
HashSet, Instance, Knockout, LayerColor, LineCap, LineJoin, Node, NodeId, NodeKind, Paint, Reader, Rect, ShownNames, StrokeLayer, V, obj, paint,
Affine, Appearance, AppearanceItem, Arc, BlendMode, BrushesKept, Dash, FillLayer, FillRule, Global, Gradient, GradientDef, HashMap, HashSet,
Instance, Knockout, LayerColor, LineCap, LineJoin, Node, NodeId, NodeKind, Paint, Reader, Rect, ShownNames, StrokeLayer, V, obj, paint,
};
impl<'a> Reader<'a> {
@@ -69,6 +66,7 @@ impl<'a> Reader<'a> {
/// `LB`: a graph started in this layer that hasn't ended doesn't go on past it; the layer ends.
fn layer_end(&mut self) -> Result<(), String> {
if self.graph.as_ref().is_some_and(|g| g.frames >= self.frames.len()) {
self.graph_plain();
self.graph = None;
self.warn(GRAPH_UNENDED);
}
@@ -158,7 +156,7 @@ impl<'a> Reader<'a> {
let mesh_ended = std::mem::take(&mut self.mesh_ended);
let vals = self.operands();
let vals = self.take_head(vals);
if self.graph_record(w, hidden) {
if self.graph_record(w, &vals, hidden, (group_ended, mesh_ended)) {
return Ok(());
}
// Only `Bh` reads an undefined number. Anywhere else it would reach a point or a size, so
@@ -428,33 +426,6 @@ impl<'a> Reader<'a> {
Ok(())
}
/// A graph's records (version 7 specification §17 and appendix A): `%_Gs` starts the graph on
/// a layer, `GS` ends it, and its data and settings (the operators in [`GRAPH_OPS`], and any
/// operator on a `%_` line between `Gt` and `GT`) are left out with their operands. Its drawn
/// art, and anything else, is read as usual. `true` when `w` was one of them.
fn graph_record(&mut self, w: &str, hidden: bool) -> bool {
let Some(g) = self.graph.as_mut() else {
// Outside a graph, its operators stay ones the reader doesn't know.
if w == "Gs" && hidden && !self.frames.is_empty() {
self.graph = Some(Graph { settings: false, frames: self.frames.len() });
self.warn(GRAPH_PLAIN);
return true;
}
return false;
};
match w {
// A graph doesn't start inside another: the one being read goes on.
"Gs" => self.warn(GRAPH_UNENDED),
"GS" => self.graph = None,
"Gt" => g.settings = true,
"GT" => g.settings = false,
_ if GRAPH_OPS.contains(&w) => {}
_ if hidden && g.settings => {}
_ => return false,
}
true
}
/// `… Lb`: a layer's options, `visible preview unlocked printing dimmed`, then the colour index
/// and its RGB. The colour index is at 5 with fewer than ten operands, 6 with ten to twelve
/// (`masks` before it) and 7 with thirteen or more (one more flag before it). Four places after
@@ -588,9 +559,9 @@ impl<'a> Reader<'a> {
return;
}
self.image_tail = false;
// An object's tags (`XT`) follow it one after another, and an image's follow the `XH` that
// ends its data.
if matches!(w, "Xy" | "Xd" | "XW" | "BB" | "LB" | "XT" | "XH") {
// An object's tags (`XT`, and a graph's `Go`) follow it one after another, and an image's
// follow the `XH` that ends its data.
if matches!(w, "Xy" | "Xd" | "XW" | "BB" | "LB" | "XT" | "XH" | "Go") {
return;
}
self.after_object = false;
+3 -13
View File
@@ -436,8 +436,8 @@ pub const NON_NATIVE_ART_UNREAD: &str = "non-native art (a placed PDF's content)
/// The name of the group a `/ForeignObject`'s art comes in as.
pub const NON_NATIVE_ART: &str = "Non-native art";
/// The note for a file with a graph (`%_Gs` … `%_GS`): its drawn art comes in, its data and
/// settings don't.
/// The note for a file with a graph (`%_Gs` … `%_GS`) whose data and settings can't be kept: its
/// drawn art comes in as plain art.
pub const GRAPH_PLAIN: &str = "graphs come in as plain art, without their data or settings";
/// The note for a graph that starts inside another or doesn't end before its layer does: the art
@@ -445,18 +445,8 @@ pub const GRAPH_PLAIN: &str = "graphs come in as plain art, without their data o
pub const GRAPH_UNENDED: &str = "a graph's records don't end where they should: its art was read as it is";
/// A graph's records (the version 7 specification's chapter 17 and appendix A): two-letter
/// operators starting with `G`, read and left out with their operands.
/// operators starting with `G`, read with their operands.
pub(super) const GRAPH_OPS: &[&str] = &[
"G1", "G+", "Ga", "GA", "Gb", "Gc", "GC", "Gd", "GD", "Ge", "Gf", "Gg", "Gi", "Gj", "Gl", "Gm", "Go", "Gp", "Gr", "Gs", "GS", "Gt", "GT", "Gv",
"Gw", "GX", "Gx", "Gy", "Gz",
];
/// A graph being read (`%_Gs` … `%_GS`).
#[derive(Debug)]
pub(super) struct Graph {
/// Between `Gt` and `GT`, where the graph's settings may use paint and type operators on `%_`
/// lines too.
pub(super) settings: bool,
/// How many frames were open at its `Gs`: a layer that ends with fewer ends the graph.
pub(super) frames: usize,
}
+218
View File
@@ -10547,6 +10547,7 @@ fn type_with_an_art_brush_keeps_its_drawn_look() {
}
use read::{GRAPH_PLAIN, GRAPH_UNENDED};
use vectorcraft_doc::{GraphKind, TickLength};
/// Editing data in the legacy format (version 7 specification, chapter 2): `%AI5_FileFormat 2.0`,
/// the art size and the template box in the header, then `body`.
@@ -10688,6 +10689,223 @@ fn a_graphs_records_take_their_operands() {
assert_eq!(r.warnings, [GRAPH_PLAIN]);
}
/// A graph's style record (`Gy`) for a grouped column graph: no shadow, legends as in column
/// graphs, lines without marks, measured against the left axis.
const LIVE_STYLE: &str = "%_5 0 0 14 0 1 0 0 6 44 Gy\n";
/// A graph's dialog record (`Gd`): columns 90% wide in clusters 80% wide.
const LIVE_DIALOG: &str = "%_10 2 0 0 90 80 0 Gd\n";
/// A graph's axes, bottom, left and right: the bottom one with no tick marks, between its labels;
/// the left one labeled `$` … ` units`, with two tick marks a division.
const LIVE_AXES: &str = "%_1 () Ga\n%_0 13 0 0 0 0 1 () GA\n%_2 ($) Ga\n%_0 14 0 0 0 2 0 ( units) GA\n%_4 () Ga\n%_0 14 0 0 0 0 0 () GA\n";
/// A graph's table: series East and West, categories Q1 to Q3, and an empty cell (West in Q2).
const LIVE_TABLE: &str = "%_4 3 1 1 Gz\n%_() Gc (East) Gc (West) Gc\n%_(Q1) Gc 5 3 (Q2) Gc 7 () Gc (Q3) Gc 4 6 Gc GC\n";
/// A column of a graph's series at `x`, tagged as one data bar.
fn series_bar(x: f64) -> String {
format!("0 0 0 1 k\n{}f\n%_4 1 0 0 Go\n", rect_path(x, 100.0, x + 20.0, 150.0))
}
/// The first series' mark in [`live_art`].
fn series_mark() -> String {
format!("0 0 0 1 k\n{}f\n", rect_path(110.0, 100.0, 130.0, 150.0))
}
/// [`series_mark`] filled and stroked, then an outline stroked alike with no fill.
fn series_mark_and_outline() -> String {
format!("0 0 0 1 k\n0 0 0 1 K\n{}B\n{}S\n", rect_path(110.0, 100.0, 130.0, 150.0), rect_path(112.0, 100.0, 118.0, 120.0))
}
/// The drawn art of the graph [`live_graph`] gives: two series groups, each tagged as one series by
/// its table column, and the axes on the plot's left and bottom edges.
fn live_art() -> String {
format!(
"u\n{}U\n%_2 1 0 0 Go\nu\n{}U\n%_2 2 0 0 Go\nu\n0 0 0 1 K\n100 200 m\n100 100 L\n300 100 L\nS\nU\n%_9 0 0 2 Go\n",
series_bar(110.0),
series_bar(140.0)
)
}
/// A graph whose records read whole, written from the version 7 specification's appendix A, on the
/// plot 100 100 300 200 (art space).
fn live_graph() -> String {
format!("%_Gs\n%_100 200 300 100 Gb\n{LIVE_STYLE}{LIVE_DIALOG}{LIVE_AXES}{LIVE_TABLE}u\n{}U\n%_GS\n", live_art())
}
/// The graphs in `doc`'s art, and the series groups tagged in them.
fn live_graphs(doc: &Document) -> (Vec<Node>, usize) {
let (mut graphs, mut tagged) = (vec![], 0);
doc.walk(|n| {
if n.extras().graph.is_some() {
graphs.push(n.clone());
}
tagged += usize::from(n.extras().series_index.is_some());
});
(graphs, tagged)
}
fn same_rect(a: Rect, b: Rect) -> bool {
(a.x0 - b.x0).abs() + (a.y0 - b.y0).abs() + (a.x1 - b.x1).abs() + (a.y1 - b.y1).abs() < 1e-9
}
/// A graph whose records read whole keeps its data and settings on its group, which holds its
/// drawn art as it is, each series group tagged with its index.
#[test]
fn a_graph_whose_records_read_whole_keeps_its_data_and_settings() {
let r = read(stream7(&layer7("Graph", &live_graph())).as_bytes()).unwrap();
assert!(r.warnings.is_empty(), "{:?}", r.warnings);
let a = art(&r.doc);
assert_eq!(a.len(), 1);
let g = a[0].extras().graph.clone().expect("a live graph");
assert_eq!(g.kind, GraphKind::Column);
assert_eq!(g.series, ["East", "West"]);
assert_eq!(g.categories, ["Q1", "Q2", "Q3"]);
assert_eq!(g.cells(), [[Some(5.0), Some(3.0)], [Some(7.0), None], [Some(4.0), Some(6.0)]]);
assert_eq!((g.column_width, g.cluster_width), (90.0, 80.0));
assert_eq!((g.prefix.as_str(), g.suffix.as_str(), g.tick_length, g.tick_marks), ("$", " units", TickLength::Short, 2));
assert_eq!((g.category_tick_length, g.ticks_between_labels), (TickLength::None, true));
assert_eq!((g.ticks, g.axis_min, g.axis_max), (0, None, None));
assert!(g.legend && !g.legend_across_top && !g.mark_points && g.connect_points && !g.drop_shadow && !g.edge_to_edge, "{g:?}");
// The drawn art: two series groups and the axes, as written.
let kids = a[0].children().unwrap();
assert_eq!(kids.len(), 3);
let index: Vec<_> = kids.iter().map(|k| k.extras().series_index).collect();
assert_eq!(index, [Some(0), Some(1), None]);
assert!(kids[..2].iter().all(|k| k.children().is_some_and(|c| c.len() == 1)));
// Each series keeps its marks' fill, and no stroke, for when the graph is drawn again.
assert_eq!(g.series_paints.len(), 2);
let fill = kids[0].children().unwrap()[0].appearance.items.iter().find(|i| i.is_fill()).map(|i| i.paint().clone());
assert!(g.series_paints.iter().all(|p| p.fill == fill && p.stroke.as_ref().is_some_and(|s| s.is_none())), "{:?}", g.series_paints);
let axes = kids[2].children().unwrap()[0].geometric_bounds().unwrap();
assert!(same_rect(g.rect, axes), "the plot is where the axes are: {:?} {axes:?}", g.rect);
assert_eq!(g.placed, a[0].geometric_bounds());
}
/// The graph types the records give: 5 grouped column, 6 stacked column, 7 line, 10 area; and the
/// style and dialog settings, each kept as the graph's.
#[test]
fn a_graphs_type_and_settings_come_from_its_records() {
let live = |style: &str, dialog: &str, axes: &str| {
let text = live_graph().replace(LIVE_STYLE, style).replace(LIVE_DIALOG, dialog).replace(LIVE_AXES, axes);
let r = read(stream7(&layer7("Graph", &text)).as_bytes()).unwrap();
assert!(r.warnings.is_empty(), "{style}{dialog}: {:?}", r.warnings);
art(&r.doc)[0].extras().graph.clone().expect("a live graph")
};
for (ty, kind) in [(5, GraphKind::Column), (6, GraphKind::StackedColumn), (7, GraphKind::Line), (10, GraphKind::Area)] {
let g = live(&format!("%_{ty} 0 0 14 0 1 0 0 6 44 Gy\n"), LIVE_DIALOG, LIVE_AXES);
assert_eq!(g.kind, kind, "{ty}");
}
let axes = LIVE_AXES.replace("%_0 14 0 0 0 2 0 ( units) GA", "%_1 15 0 100 25 0 0 () GA");
let g = live("%_7 1 1 14 1 0 0 1 6 44 0 2 Gy\n", "%_10 2 1 0 120 50 1 Gd\n", &axes);
assert!(g.drop_shadow && g.first_row_in_front && g.mark_points && !g.connect_points && g.legend_across_top, "{g:?}");
assert!(g.first_column_in_front && g.edge_to_edge, "{g:?}");
assert_eq!((g.column_width, g.cluster_width), (120.0, 50.0));
assert_eq!((g.ticks, g.axis_min, g.axis_max, g.tick_length, g.tick_marks), (4, Some(0.0), Some(100.0), TickLength::Full, 1));
// A line graph's series draws its line unfilled beside its filled marks.
let text = live_graph().replace(LIVE_STYLE, "%_7 0 0 14 0 1 0 0 6 44 Gy\n").replacen(&series_mark(), &series_mark_and_outline(), 1);
let r = read(stream7(&layer7("Graph", &text)).as_bytes()).unwrap();
assert!(r.warnings.is_empty(), "{:?}", r.warnings);
assert!(art(&r.doc)[0].extras().graph.is_some());
// An empty list of customizations, of the version appendix A gives (2), sets nothing.
let text = live_graph().replace("GC\n", "GC\n%_2 Gt\n%_GT\n");
let r = read(stream7(&layer7("Graph", &text)).as_bytes()).unwrap();
assert!(r.warnings.is_empty(), "{:?}", r.warnings);
assert!(art(&r.doc)[0].extras().graph.is_some());
}
/// A graph keeps its drawn art and stays plain, with one note, when a record has a shape or value
/// appendix A doesn't give, sets what the model doesn't keep, or the table, the series tags or the
/// art don't fit the graph.
#[test]
fn graphs_the_model_cant_keep_stay_plain_art() {
let cases: Vec<(&str, String)> = vec![
("an eleventh style value", live_graph().replace(LIVE_STYLE, "%_5 0 0 14 0 1 0 0 6 44 0 Gy\n")),
("eleven dialog values", live_graph().replace(LIVE_DIALOG, "%_10 2 0 0 90 80 0 0 0 0 0 Gd\n")),
("a fourth axis", live_graph().replace(LIVE_AXES, &format!("{LIVE_AXES}%_8 () Ga\n%_0 14 0 0 0 0 0 () GA\n"))),
("ten axis values", live_graph().replace("%_0 14 0 0 0 0 0 () GA", "%_0 14 0 0 0 0 0 () 0 0 GA")),
("a pie graph", live_graph().replace("%_5 0 0 14", "%_8 0 0 14")),
("a scatter graph", live_graph().replace("%_5 0 0 14", "%_9 0 0 14")),
("type 11", live_graph().replace("%_5 0 0 14", "%_11 0 0 14")),
("legends in wedges", live_graph().replace("%_5 0 0 14", "%_5 0 0 15")),
("the right axis", live_graph().replace("6 44 Gy", "6 45 Gy")),
("lines as shapes", live_graph().replace("%_5 0 0 14 0 1 0", "%_5 0 0 14 0 1 1")),
("both axes alike", live_graph().replace(LIVE_DIALOG, "%_10 2 0 1 90 80 0 Gd\n")),
("a subscription", live_graph().replace(LIVE_DIALOG, &format!("{LIVE_DIALOG}%_0 0 1 1 1 Gj\n"))),
("a customization", live_graph().replace("GC\n", "GC\n%_2 Gt\n%_(Bars) GD\n%_GT\n")),
("customizations without their version", live_graph().replace("GC\n", "GC\n%_Gt\n%_GT\n")),
("customizations of another version", live_graph().replace("GC\n", "GC\n%_3 Gt\n%_GT\n")),
("bounds upside down", live_graph().replace("%_100 200 300 100 Gb", "%_100 100 300 200 Gb")),
("a plot the axes aren't on", live_graph().replace("%_100 200 300 100 Gb", "%_50 200 300 100 Gb")),
("a text data cell", live_graph().replace("7 () Gc", "(seven) Gc () Gc")),
("a table of empty cells", live_graph().replace(LIVE_TABLE, "%_4 3 1 1 Gz\n%_() Gc (East) Gc (West) Gc\n%_GC\n")),
("a cell past the table", live_graph().replace("4 6 Gc GC", "4 6 1 Gc GC")),
("too many categories", live_graph().replace("%_4 3 1 1 Gz", "%_10002 3 1 1 Gz")),
("a table too large", live_graph().replace("%_4 3 1 1 Gz", "%_4000000000 4000000000 1 1 Gz")),
("a number as a label", live_graph().replace("(West) Gc", "2025 Gc")),
("a series untagged", live_graph().replace("%_2 2 0 0 Go", "%_4 2 0 0 Go")),
("a series tagged twice", live_graph().replace("%_2 2 0 0 Go", "%_2 1 0 0 Go")),
("a path tagged as a series", live_graph().replacen("%_4 1 0 0 Go", "%_2 1 0 0 Go", 1)),
("a target the specification doesn't list", live_graph().replace("%_9 0 0 2 Go", "%_3 0 0 2 Go")),
("art before its group", live_graph().replace("GC\nu\n", &format!("GC\n{}f\nu\n", rect_path(0.0, 0.0, 5.0, 5.0)))),
("a record on a line that shows", live_graph().replace("%_10 2 0 0 90 80 0 Gd", "10 2 0 0 90 80 0 Gd")),
("series groups inside another group", live_graph().replace("GC\nu\n", "GC\nu\nu\n").replace("U\n%_GS", "U\nU\n%_GS")),
(
"two fills in one series",
live_graph().replacen(
"f\n%_4 1 0 0 Go\nU\n",
&format!("f\n%_4 1 0 0 Go\n0 0 0 0.5 k\n{}f\nU\n", rect_path(112.0, 100.0, 118.0, 120.0)),
1,
),
),
("axes filled, not stroked", live_graph().replace("300 100 L\nS\n", "300 100 L\nf\n")),
("a series tagged on a row", live_graph().replace("%_2 2 0 0 Go", "%_2 2 1 0 Go")),
("a series tagged on the right axis", live_graph().replace("%_2 2 0 0 Go", "%_2 2 0 4 Go")),
("an unfilled mark in a column series", live_graph().replacen(&series_mark(), &series_mark_and_outline(), 1)),
("a series' mark in a group of its own", live_graph().replacen(&series_mark(), &format!("u\n{}U\n", series_mark()), 1)),
(
"an untagged graph of one series",
live_graph()
.replace(LIVE_TABLE, "%_2 2 1 1 Gz\n%_() Gc (East) Gc (Q1) Gc 5 Gc GC\n")
.replace("%_2 2 0 0 Go", "%_4 1 0 0 Go")
.replace("%_2 1 0 0 Go", "%_4 1 0 0 Go"),
),
];
for (what, text) in cases {
let r = read(stream7(&layer7("Graph", &text)).as_bytes()).unwrap_or_else(|e| panic!("{what}: {e}"));
assert_eq!(r.warnings, [GRAPH_PLAIN], "{what}");
assert_eq!(live_graphs(&r.doc), (vec![], 0), "{what}");
let mut kept = false;
r.doc.walk(|n| kept |= n.children().is_some_and(|c| c.len() == 3));
assert!(kept, "{what}: the drawn art is kept");
}
}
/// A graph in a group or a clipping group keeps its data on its own group, not the container's; of
/// two graphs in one layer, each is kept or left plain on its own, and the note is given once.
#[test]
fn graphs_are_kept_one_by_one_wherever_they_are() {
let clip = format!("q\n{}W n\n{}Q\n", rect_path(0.0, 0.0, 400.0, 400.0), live_graph());
for (what, text) in [("in a group", format!("u\n{}U\n", live_graph())), ("in a clipping group", clip)] {
let r = read(stream7(&layer7("Graph", &text)).as_bytes()).unwrap();
assert!(r.warnings.is_empty(), "{what}: {:?}", r.warnings);
let outer = &art(&r.doc)[0];
assert!(outer.extras().graph.is_none(), "{what}");
let (graphs, tagged) = live_graphs(&r.doc);
assert_eq!((graphs.len(), tagged), (1, 2), "{what}");
assert!(outer.children().unwrap().iter().any(|c| c.id == graphs[0].id), "{what}: the graph's own group");
}
let pie = live_graph().replace("%_5 0 0 14", "%_8 0 0 14");
let body = format!("{}{pie}{}", live_graph(), live_graph());
let r = read(stream7(&layer7("Graph", &body)).as_bytes()).unwrap();
assert_eq!(r.warnings, [GRAPH_PLAIN]);
let a = art(&r.doc);
assert_eq!(a.len(), 3);
let live: Vec<bool> = a.iter().map(|n| n.extras().graph.is_some()).collect();
assert_eq!(live, [true, false, true]);
}
/// Editing data in the legacy format (`%AI5_FileFormat 2.0`, ten `Lb` operands), then `body`.
fn mask_stream7(body: &str) -> String {
format!(
+1
View File
@@ -124,6 +124,7 @@ const STROKES: &str =
"strokes a plain line can't draw (inside or outside the path, variable width, gradients, brushes, arrowheads) are written as filled outlines";
const IMAGE_ALPHA: &str = "transparent image pixels are written over white";
const LIVE: &str = "symbols, blends, envelopes, meshes, repeats, placed documents and intertwines are written as their art";
const GRAPHS: &str = "graphs are written as their art, without their data or settings";
/// The warning for an image left out because it can't be decoded: the note raster exports give
/// (`vectorcraft-engine`'s `rasterfx::undecoded_warning`).
const UNDECODED: &str = "an image couldn't be decoded and is missing from the picture";
+4 -1
View File
@@ -9,7 +9,7 @@ use super::{
ROTATED_TYPE, Rect, STROKES, SUBLAYERS, Shape, StrokeLayer, SubPath, TITLE_AND_COLOR_NAMES, TRANSPARENCY, TYPE, TYPE_ATTRIBUTES, TextKind,
TextObject, UNDECODED, Vec2, Write, ai_ops, latin, ps, stroke,
};
use super::{CONIC, CONIC_WEDGES, DIAMOND, HUE_STOPS, SPREAD, SPREAD_CAPPED};
use super::{CONIC, CONIC_WEDGES, DIAMOND, GRAPHS, HUE_STOPS, SPREAD, SPREAD_CAPPED};
pub(super) struct Writer<'a> {
doc: &'a Document,
@@ -254,6 +254,9 @@ impl<'a> Writer<'a> {
if n.name.as_deref().is_some_and(|s| !s.is_empty()) && !n.is_layer() {
self.warn(NAMES);
}
if n.extras().graph.is_some() {
self.warn(GRAPHS);
}
let locked = locked || n.locked;
match &n.kind {
NodeKind::Layer { children, clip, .. } => {
+1 -1
View File
@@ -1549,7 +1549,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"ui.actionSet.save",
"Save Actions…",
"",
"{set?: index, id?, path?} write the Actions panel's set at set (0 is the top set; default: the current set) with its actions to an action set file (.vcactions) at path, else a picked file named after the set (the web downloads it). id holds the panel's own set id, which its menu passes: the set with this id is saved wherever it is now, and set is not read. A set over 8 MiB as a file, with more than 1,000 actions or with an action of more than 10,000 steps is not written; the panel menu's Save Actions… → {path}",
"{set?: index, id?, path?} write the Actions panel's set at set (0 is the top set; default: the current set) with its actions to an action set file (.vcactions) at path, else a picked file named after the set (the web downloads it). id holds the panel's own set id, which its menu passes: the set with this id is saved wherever it is now, and set is not read. A set over 8 MiB as a file, with more than 1,000 actions or with an action of more than 10,000 steps is not written, nor is a set with a prefs.set step (also in a batch step) that sets a folder preference to a folder (an error names the action and the preference; an empty folder and the scratch disk choices Startup and None save); the panel menu's Save Actions… → {path}",
),
(
"ui.actionSet.load",
+24 -1
View File
@@ -107,7 +107,12 @@ impl BrushCache {
vectorcraft_brush::serde_json::to_string(v).unwrap_or_default().hash(&mut h);
h.finish()
});
self.lib = vectorcraft_brush::library(doc).into_iter().map(|b| (b.name.clone(), Arc::new(b))).collect();
// Of two brushes with one name, a stroke that names it draws with the first, as
// `vectorcraft_brush::find` and the exports take it.
self.lib.clear();
for b in vectorcraft_brush::library(doc) {
self.lib.entry(b.name.clone()).or_insert_with(|| Arc::new(b));
}
}
/// [`Self::key`] for the brush library `doc` holds (checked once a frame, `stamp`).
@@ -388,6 +393,24 @@ mod tests {
assert!(!dark(a.pixel(100, 58)) && dark(b.pixel(100, 58)));
}
/// Of two brushes with one name, a stroke that names it draws with the first.
#[test]
fn a_stroke_draws_with_the_first_of_two_brushes_with_its_name() {
use vectorcraft_brush::{Brush, BrushKind, Calligraphic};
let nib = |size: f64| Brush { name: "Twin".into(), kind: BrushKind::Calligraphic(Calligraphic { size, ..Default::default() }) };
let doc = |lib: &[Brush]| {
let mut d = doc_with_line(Some("Twin"), 1.0);
vectorcraft_brush::store(&mut d, lib);
d
};
let (thin, wide) = (nib(1.0), nib(20.0));
let first = render(&mut Renderer::new(), &doc(std::slice::from_ref(&thin))).pixels;
let second = render(&mut Renderer::new(), &doc(std::slice::from_ref(&wide))).pixels;
assert_ne!(first, second, "the two nibs paint differently");
let both = render(&mut Renderer::new(), &doc(&[thin, wide])).pixels;
assert!(both == first, "the stroke draws with the first brush named Twin");
}
#[test]
fn stained_symbol_instance() {
let mut d = Document::new(100.0, 100.0);
+472
View File
@@ -0,0 +1,472 @@
//! The 8 x 8 block edges of a block-coded image (a JPEG, or a copy of one saved in another format)
//! smoothed away before it is traced.
//!
//! A JPEG codes each 8 x 8 block on its own and rounds each block's brightness in coarse steps, which
//! leaves a small step at every block edge. Where an area's tone changes slowly, as a dark ground does,
//! those steps decide which of two palette colors a whole block gets, and the trace follows the block
//! edges as a staircase. The block grid is found in the image itself: the mean step between
//! neighboring pixels peaks at one position in every eight, across and down, at every block edge and
//! not only at every other one (a pattern of 16 px squares has that too). Where it does, the step
//! at each block edge is spread evenly over the eight pixels around it when it is small and those
//! pixels hold no edge. Larger steps are left as they are. How large a step is smoothed, and whether
//! each row keeps part of its own step, depends on the trace's mode and number of colors (see
//! [`Strength`]). The deblocking filters of ITU-T H.263
//! Annex J and ISO/IEC 14496-2 (MPEG-4 Part 2) Annex F.3.1 treat block edges the same way: small steps
//! between blocks become ramps, and large ones are kept.
use std::sync::Mutex;
use crate::{Raster, parallel_map, quantize};
/// The block size of a JPEG.
const BLOCK: usize = 8;
/// Steps between neighboring pixels of this many levels or more are edges, left out when the grid is
/// measured. No block-edge step this large is smoothed.
const EDGE: f64 = 16.0;
/// The mean step at the block edges must be this many times the mean step at the other positions,
/// across and down, for the image to count as block-coded.
const PEAK: f64 = 1.5;
/// The smallest limit on the block-edge steps that are smoothed (levels, after the image's own slope
/// is taken out); the limit is under `EDGE` too.
const LEAST: f64 = 2.5;
/// Fixed-point scale of the working copy: sixteenths of a level.
const SCALE: f64 = 16.0;
/// How the block edges are smoothed.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct Strength {
/// The largest block-edge step that is smoothed: this many times the extra step the block edges
/// show on average, at least `LEAST` and under `EDGE`.
reach: f64,
/// A block edge with a step of this many levels or more between neighbors in the pixels around
/// it is left as it is.
guard: f64,
/// How far one row's step may differ from its stretch's mean step and still be smoothed, as a
/// share of the limit. The rest of a row's own step is kept.
row_share: f64,
}
/// For a trace in black and white, which thresholds the image without smoothing it first: small
/// steps only, each row with its own.
pub(crate) const BLACK_AND_WHITE: Strength = Strength { reach: 2.0, guard: 8.0, row_share: 0.5 };
/// For a trace of up to 16 colors: each row with its own step.
pub(crate) const FEW_COLORS: Strength = Strength { reach: 8.0, guard: 13.0, row_share: 0.5 };
/// For a trace of more than 16 colors: larger steps, but only each stretch's mean step, so that
/// every row of a stretch moves by the same amount.
pub(crate) const MANY_COLORS: Strength = Strength { reach: 4.0, guard: EDGE, row_share: 0.0 };
/// Where the block edges of a block-coded image are, and how large their steps are.
#[derive(Clone, Copy, Debug, PartialEq)]
struct Grid {
/// A block edge lies between columns `x - 1` and `x` when `x % 8 == across`.
across: usize,
/// A block edge lies between rows `y - 1` and `y` when `y % 8 == down`.
down: usize,
/// The extra step the block edges show on average over the other positions, across or down,
/// whichever is smaller.
extra: f64,
}
/// Positions counted when the grid is measured: two blocks, so that a pattern of 16 px or more
/// (a checkerboard, cells of a picture enlarged 16 times), whose edges fall on every other block
/// edge only, is not taken for blocks.
const SPAN: usize = 2 * BLOCK;
/// For one direction, from the mean step between neighboring opaque pixels at each of 16 positions:
/// the position (of eight) where it peaks at both block edges of the span, the extra step those
/// show over the other positions, and whether there is no step at all at the other positions; `None`
/// when no position stands out.
fn peak(sum: &[f64; SPAN], count: &[u64; SPAN]) -> Option<(usize, f64, bool)> {
if count.contains(&0) {
return None;
}
let mean: Vec<f64> = sum.iter().zip(count).map(|(&s, &n)| s / n as f64).collect();
let pair = |at: usize| (mean.get(at).copied().unwrap_or(0.0), mean.get(at + BLOCK).copied().unwrap_or(0.0));
let at = (0..BLOCK).max_by(|&a, &b| {
let (pa, pb) = (pair(a), pair(b));
pa.0.min(pa.1).total_cmp(&pb.0.min(pb.1))
})?;
let (first, second) = pair(at);
let others = || mean.iter().enumerate().filter(|&(i, _)| i != at && i != at + BLOCK).map(|(_, &m)| m);
let rest = others().sum::<f64>() / (SPAN - 2) as f64;
(first.min(second) > PEAK * rest).then_some((at, (first + second) / 2.0 - rest, others().all(|m| m == 0.0)))
}
/// The block grid of `img`, if it has one.
fn grid(img: &Raster) -> Option<Grid> {
let (w, h) = (img.width as usize, img.height as usize);
if w < 2 * SPAN || h < 2 * SPAN || img.rgba.len() != w * h * 4 {
return None;
}
let px = img.rgba.as_chunks::<4>().0;
let luma = |p: &[u8; 4]| (p[3] == 255).then(|| f64::from(quantize::luma(*p)));
let (mut across, mut down) = (([0.0; SPAN], [0u64; SPAN]), ([0.0; SPAN], [0u64; SPAN]));
for y in 0..h {
for x in 0..w {
let Some(here) = px.get(y * w + x).and_then(luma) else { continue };
let add = |bins: &mut ([f64; SPAN], [u64; SPAN]), at: usize, other: Option<f64>| {
if let Some(step) = other.map(|o| (here - o).abs()).filter(|&s| s < EDGE) {
bins.0[at % SPAN] += step;
bins.1[at % SPAN] += 1;
}
};
if x > 0 {
add(&mut across, x, px.get(y * w + x - 1).and_then(luma));
}
if y > 0 {
add(&mut down, y, px.get((y - 1) * w + x).and_then(luma));
}
}
}
let (across, extra_across, flat_across) = peak(&across.0, &across.1)?;
let (down, extra_down, flat_down) = peak(&down.0, &down.1)?;
// Blocks that are each one flat color, with no step at all inside them, are cells of a picture
// enlarged eight times, which stay as they are.
if flat_across && flat_down {
return None;
}
Some(Grid { across, down, extra: extra_across.min(extra_down) })
}
/// Smooths one stretch of a block edge in `band` (values in sixteenths of a level, 3 channels per
/// pixel): `lines` (1 to 8) lines that cross the edge, the pixel at position `i` (0 to 7; the edge lies between
/// 3 and 4) of line `l` starting at `band[index(l, i)]`, where `opaque(l, i)` says whether it is fully
/// opaque. The stretch's step is the mean over its lines of the step across the edge less the slope
/// on either side. A stretch of opaque pixels whose step is under `limit` on every channel, with no
/// step of `strength.guard` or more between neighbors in its pixels (across, the edge itself aside, or
/// along), has that step spread over the eight pixels of each line: with the line's own difference
/// from it, to at most `strength.row_share` of `limit` either way, each pixel moves by the step times
/// 3.5/8, 2.5/8, 1.5/8 or 0.5/8 by its distance from the edge, so the pixels in the middle of the
/// blocks hardly move.
fn smooth_edge(
band: &mut [i16],
lines: usize,
index: impl Fn(usize, usize) -> usize,
opaque: impl Fn(usize, usize) -> bool,
limit: f64,
strength: Strength,
) {
if lines == 0 || lines > BLOCK || !(0..lines).all(|l| (0..BLOCK).all(|i| opaque(l, i))) {
return;
}
let at = |l: usize, i: usize, k: usize| f64::from(band.get(index(l, i) + k).copied().unwrap_or(0)) / SCALE;
// Each line's step on each channel, and the largest step within the pixels around the edge.
let mut steps = [[0.0; 3]; BLOCK];
let steps = steps.get_mut(..lines).unwrap_or_default();
let mut inner = 0.0f64;
for (l, step) in steps.iter_mut().enumerate() {
for (k, s) in step.iter_mut().enumerate() {
let p: [f64; BLOCK] = std::array::from_fn(|i| at(l, i, k));
*s = (p[4] - p[3]) - ((p[3] - p[2]) + (p[5] - p[4])) / 2.0;
for i in (0..BLOCK - 1).filter(|&i| i != 3) {
inner = inner.max((p[i + 1] - p[i]).abs());
}
// And from this line to the next: a line along the edge is an edge too.
if l + 1 < lines {
for (i, &here) in p.iter().enumerate() {
inner = inner.max((at(l + 1, i, k) - here).abs());
}
}
}
}
let mean: [f64; 3] = std::array::from_fn(|k| steps.iter().map(|s| s[k]).sum::<f64>() / lines as f64);
if inner >= strength.guard || mean.iter().any(|m| m.abs() >= limit) {
return;
}
let own = limit * strength.row_share;
for (l, step) in steps.iter().enumerate() {
for k in 0..3 {
let step = mean[k] + (step[k] - mean[k]).clamp(-own, own);
for i in 0..BLOCK / 2 {
let shift = (step * (3.5 - i as f64) / BLOCK as f64 * SCALE).round() as i16;
if let Some(p) = band.get_mut(index(l, 3 - i) + k) {
*p = p.saturating_add(shift);
}
if let Some(p) = band.get_mut(index(l, 4 + i) + k) {
*p = p.saturating_sub(shift);
}
}
}
}
}
/// Where the stretches of eight lines start along a block edge `len` lines long, when they start at
/// the lines with `l % 8 == at`: the first, from line 0, can be shorter. Each as (first line, count).
fn stretches(len: usize, at: usize) -> Vec<(usize, usize)> {
let mut out: Vec<(usize, usize)> = if at > 0 { vec![(0, at.min(len))] } else { vec![] };
out.extend((at..len).step_by(BLOCK).map(|s| (s, BLOCK.min(len - s))));
out
}
/// `f` of each of `bands` (with what it needs to know about the band), which it may change, spread
/// over the available cores.
fn each_band<K: Copy + Send, T: Send>(bands: Vec<(K, &mut [T])>, f: impl Fn(K, &mut [T]) + Sync) {
let bands: Vec<Mutex<(K, &mut [T])>> = bands.into_iter().map(Mutex::new).collect();
parallel_map(&bands, |band| {
// Each band is locked by one worker only, so the lock is never held elsewhere.
if let Ok(mut band) = band.lock() {
let (first, values) = &mut *band;
f(*first, values);
}
});
}
/// The first block edge (of positions `at`, `at + 8`, ...) with four pixels before it.
fn first_edge(at: usize) -> usize {
if at >= BLOCK / 2 { at } else { at + BLOCK }
}
/// Smooths the block edges of `v`, rows `top` on of the image (`w` pixels of 3 channels, in
/// sixteenths of a level, from the first row of a stretch of rows to the last row of one), where
/// `opaque(y, x)` is set: the edges between columns `x - 1` and `x` with `x % 8 == across` in stretches
/// of eight rows that start at the rows with `y % 8 == down`, then the edges between rows `e - 1` and
/// `e` for each `e` of `edges` in stretches of eight columns that start at the columns with
/// `x % 8 == across` (see `smooth_edge`).
fn smooth_strip(
v: &mut [i16],
top: usize,
w: usize,
grid: &Grid,
edges: &[usize],
opaque: impl Fn(usize, usize) -> bool,
(limit, strength): (f64, Strength),
) {
let row = w * 3;
if w < BLOCK || row == 0 {
return;
}
for (at, rows) in stretches(v.len() / row, (grid.down + BLOCK - top % BLOCK) % BLOCK) {
let Some(band) = v.get_mut(at * row..(at + rows) * row) else { continue };
for e in (first_edge(grid.across)..=w - BLOCK / 2).step_by(BLOCK) {
smooth_edge(band, rows, |l, i| (l * w + e - BLOCK / 2 + i) * 3, |l, i| opaque(top + at + l, e - BLOCK / 2 + i), limit, strength);
}
}
for &e in edges {
let Some(band) = e.checked_sub(top + BLOCK / 2).and_then(|at| v.get_mut(at * row..(at + BLOCK) * row)) else { continue };
for (left, columns) in stretches(w, grid.across) {
smooth_edge(band, columns, |l, i| (i * w + left + l) * 3, |l, i| opaque(e - BLOCK / 2 + i, left + l), limit, strength);
}
}
}
/// The edges between rows smoothed in one piece of work, with the stretches of rows around them.
const STRIP: usize = 8;
/// `img` with its block edges smoothed away as `strength` says, or `None` when it shows no block grid.
/// The image is worked on in strips of rows, each with the stretches of rows its `STRIP` edges between
/// rows need, so only the copy it returns is as large as the image.
pub(crate) fn deblocked(img: &Raster, strength: Strength) -> Option<Raster> {
let grid = grid(img)?;
let limit = (strength.reach * grid.extra).clamp(LEAST, EDGE);
let (w, h) = (img.width as usize, img.height as usize);
let px = img.rgba.as_chunks::<4>().0;
let opaque = |y: usize, x: usize| px.get(y * w + x).is_some_and(|p| p[3] == 255);
let edges: Vec<usize> = (first_edge(grid.down)..=h.saturating_sub(BLOCK / 2)).step_by(BLOCK).collect();
let groups: Vec<&[usize]> = edges.chunks(STRIP).collect();
// The rows each strip writes: from four rows above its first edge (the top of the image for the
// first strip) to four rows below its last (the bottom of the image for the last strip).
let mut rgba = img.rgba.clone();
let mut bands = vec![];
let mut rest: &mut [u8] = &mut rgba;
let mut above = 0;
for (n, group) in groups.iter().enumerate() {
let below = if n + 1 == groups.len() { h } else { group.last().map_or(h, |e| e + BLOCK / 2) };
let (band, after) = std::mem::take(&mut rest).split_at_mut_checked(below.checked_sub(above)? * w * 4)?;
bands.push(((above, *group), band));
rest = after;
above = below;
}
// The first row of the stretch of rows that holds row `y`, and the row after the stretch.
let stretch = |y: usize| {
let first = if y < grid.down { 0 } else { y - (y - grid.down) % BLOCK };
(first, if y < grid.down { grid.down } else { first + BLOCK }.min(h))
};
each_band(bands, |(above, group), band| {
let below = above + band.len() / (w * 4);
let (first, last) = (stretch(above).0, stretch(below.saturating_sub(1)).1);
let Some(source) = px.get(first * w..last * w) else { return };
let mut v: Vec<i16> = source.iter().flat_map(|p| [p[0], p[1], p[2]].map(|c| i16::from(c) * SCALE as i16)).collect();
smooth_strip(&mut v, first, w, &grid, group, opaque, (limit, strength));
let skip = (above - first) * w;
for (p, c) in band.as_chunks_mut::<4>().0.iter_mut().zip(v.as_chunks::<3>().0.iter().skip(skip)) {
for k in 0..3 {
p[k] = ((i32::from(c[k]) + 8).div_euclid(16)).clamp(0, 255) as u8;
}
}
});
Some(Raster { width: img.width, height: img.height, rgba })
}
#[cfg(test)]
mod tests {
use super::*;
/// A number in -1..1 that looks random, from `x`, `y` and `k`.
fn jitter(x: u32, y: u32, k: u32) -> f64 {
let mut n = x.wrapping_mul(0x9E37_79B1) ^ y.wrapping_mul(0x85EB_CA77) ^ k.wrapping_mul(0xC2B2_AE3D);
n ^= n >> 15;
n = n.wrapping_mul(0x2C1B_3C6D);
n ^= n >> 12;
f64::from(n % 2001) / 1000.0 - 1.0
}
/// A dark ground that brightens slowly to the right, with a level of noise and, when `blocks`,
/// every 8 x 8 block (counted from `(dx, dy)`) moved by up to 2 levels, as a JPEG leaves it.
fn ground(w: u32, h: u32, blocks: bool, dx: u32, dy: u32) -> Raster {
Raster::from_fn(w, h, |x, y| {
let offset = if blocks { 2.0 * jitter((x + dx) / 8, (y + dy) / 8, 9) } else { 0.0 };
let v = 20.0 + 30.0 * f64::from(x) / f64::from(w) + offset + jitter(x, y, 0);
let v = v.round().clamp(0.0, 255.0) as u8;
[v, v, v, 255]
})
}
/// The mean step between neighboring columns at the block edges (`x % 8 == across`) and elsewhere.
fn steps(img: &Raster, across: u32) -> (f64, f64) {
let (mut on, mut off) = ((0.0, 0), (0.0, 0));
for y in 0..img.height {
for x in 1..img.width {
let d = (f64::from(img.pixel(x, y)[0]) - f64::from(img.pixel(x - 1, y)[0])).abs();
let bin = if x % 8 == across { &mut on } else { &mut off };
bin.0 += d;
bin.1 += 1;
}
}
(on.0 / f64::from(on.1), off.0 / f64::from(off.1))
}
#[test]
fn the_block_grid_is_found_where_the_blocks_are() {
let g = grid(&ground(160, 120, true, 0, 0)).unwrap();
assert_eq!((g.across, g.down), (0, 0));
// The same image with 3 columns and 5 rows cut off: its block edges are at x % 8 == 5, y % 8 == 3.
let g = grid(&ground(160, 120, true, 3, 5)).unwrap();
assert_eq!((g.across, g.down), (5, 3));
assert!(g.extra > 0.5, "{}", g.extra);
}
#[test]
fn an_image_without_blocks_is_left_as_it_is() {
assert_eq!(grid(&ground(160, 120, false, 0, 0)), None);
assert!(deblocked(&ground(160, 120, false, 0, 0), FEW_COLORS).is_none());
// A picture of four flat colors enlarged eight times has steps only at its cells' edges, and
// none within them; two of its colors are 6 levels apart.
let colors = [[30, 30, 36, 255], [36, 30, 30, 255], [200, 60, 40, 255], [240, 220, 120, 255]];
let cells = Raster::from_fn(160, 120, |x, y| colors[((jitter(x / 8, y / 8, 1) + 1.0) * 2.0).min(3.0) as usize]);
assert_eq!(grid(&cells), None);
// So does a picture of many shades enlarged eight times, as a photo's would.
let shades = Raster::from_fn(160, 120, |x, y| {
let v = (40.0 + 0.6 * f64::from(x / 8 * 8) + 0.5 * f64::from(y / 8 * 8) + 3.0 * jitter(x / 8, y / 8, 4)).round() as u8;
[v, v.saturating_sub(10), v.saturating_add(10), 255]
});
assert_eq!(grid(&shades), None);
// A noisy checkerboard of 16 px squares 10 levels apart has its steps on every other block edge.
let squares = Raster::from_fn(160, 120, |x, y| {
let v = (20.0 + 10.0 * f64::from((x / 16 + y / 16) % 3) + 4.0 * jitter(x, y, 2)).round() as u8;
[v, v, v, 255]
});
assert_eq!(grid(&squares), None);
// Too small to hold two spans of 16 px each way.
assert_eq!(grid(&ground(31, 120, true, 0, 0)), None);
}
#[test]
fn the_steps_at_block_edges_become_ramps() {
for ((dx, dy), strength) in [((0, 0), FEW_COLORS), ((3, 5), FEW_COLORS), ((0, 0), MANY_COLORS), ((0, 0), BLACK_AND_WHITE)] {
let img = ground(160, 120, true, dx, dy);
let across = (8 - dx % 8) % 8;
let (on, off) = steps(&img, across);
assert!(on > 2.0 * off, "before: {on} at the block edges, {off} elsewhere");
let out = deblocked(&img, strength).unwrap();
let (on, off) = steps(&out, across);
assert!(on < 1.25 * off, "after: {on} at the block edges, {off} elsewhere");
// The ground's own slope stays: 30 levels across the image.
let mean = |r: &Raster, x: u32| (0..r.height).map(|y| f64::from(r.pixel(x, y)[0])).sum::<f64>() / f64::from(r.height);
assert!((mean(&out, 156) - mean(&out, 4) - (mean(&img, 156) - mean(&img, 4))).abs() < 0.5);
}
}
#[test]
fn stretches_cover_every_line_once() {
assert_eq!(stretches(20, 0), [(0, 8), (8, 8), (16, 4)]);
assert_eq!(stretches(20, 3), [(0, 3), (3, 8), (11, 8), (19, 1)]);
assert_eq!(stretches(2, 3), [(0, 2)]);
}
#[test]
fn with_many_colors_every_row_of_a_stretch_moves_alike() {
let img = ground(160, 120, true, 0, 0);
let v: Vec<i16> = img.rgba.chunks(4).flat_map(|p| [p[0], p[1], p[2]].map(|c| i16::from(c) * SCALE as i16)).collect();
// How far each pixel moves when the edges between columns are smoothed.
let shifts = |strength: Strength| -> Vec<i16> {
let mut out = v.clone();
for top in (0..120).step_by(8) {
let band = &mut out[top * 160 * 3..(top + 8) * 160 * 3];
for e in (8..=156).step_by(8) {
smooth_edge(band, 8, |l, i| (l * 160 + e - 4 + i) * 3, |_, _| true, 4.0, strength);
}
}
out.iter().zip(&v).map(|(o, i)| o - i).step_by(3).collect()
};
let (many, few) = (shifts(MANY_COLORS), shifts(FEW_COLORS));
let differ = |s: &[i16]| {
(0..160)
.flat_map(|x| (0..120).step_by(8).map(move |top| (x, top)))
.filter(|&(x, top)| (top..top + 8).any(|y| s[y * 160 + x] != s[top * 160 + x]))
.count()
};
assert!(many.iter().filter(|&&s| s != 0).count() > 160 * 120 / 2);
assert_eq!(differ(&many), 0);
// With few colors, each row keeps part of its own step.
assert!(differ(&few) > 160 * 15 / 2, "{}", differ(&few));
}
#[test]
fn edges_and_fine_lines_stay_sharp() {
// Black lines 1 to 4 px wide and white gaps between them on a block-coded mid-gray ground, one
// line on a block edge.
let base = ground(160, 120, true, 0, 0);
let lines = [(16, 1), (31, 2), (40, 3), (61, 4)];
let img = Raster::from_fn(160, 120, |x, y| {
if lines.iter().any(|&(at, wide)| (at..at + wide).contains(&x)) {
[0, 0, 0, 255]
} else {
let v = base.pixel(x, y)[0] + 80;
[v, v, v, 255]
}
});
let out = deblocked(&img, FEW_COLORS).unwrap();
for y in 0..120 {
for &(at, wide) in &lines {
for x in at..at + wide {
assert_eq!(out.pixel(x, y), [0, 0, 0, 255], "line pixel ({x}, {y})");
}
// The ground beside a line moves by no more than a block's offset (the edges between
// rows in its column are smoothed; the one across the line is not).
for x in [at - 1, at + wide] {
let moved = (i32::from(out.pixel(x, y)[0]) - i32::from(img.pixel(x, y)[0])).abs();
assert!(moved <= 3, "beside the line, ({x}, {y}) moved {moved}");
}
}
}
}
#[test]
fn transparent_pixels_keep_their_colors() {
let base = ground(160, 120, true, 0, 0);
let img = Raster::from_fn(160, 120, |x, y| {
let mut p = base.pixel(x, y);
if x >= 100 {
p[3] = if x < 104 { 128 } else { 0 };
}
p
});
let out = deblocked(&img, FEW_COLORS).unwrap();
for y in 0..120 {
for x in 100..160 {
assert_eq!(out.pixel(x, y), img.pixel(x, y), "({x}, {y})");
}
}
assert_eq!(out.rgba.chunks(4).map(|p| p[3]).collect::<Vec<_>>(), img.rgba.chunks(4).map(|p| p[3]).collect::<Vec<_>>());
}
}
+1
View File
@@ -49,6 +49,7 @@
mod centerline;
mod contour;
mod deblock;
mod fit;
mod gradient;
mod group;
+16 -4
View File
@@ -3,7 +3,7 @@ use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use super::layers::{Layers, parallel_map_at_most};
use super::params::{Method, Mode, TraceParams};
use super::raster::{Raster, TraceError};
use super::{AtomicUsize, PathData, Quantized, TRANSPARENT, TracedGradient, TracedShape, gradient, group, logo, quantize, smooth};
use super::{AtomicUsize, PathData, Quantized, TRANSPARENT, TracedGradient, TracedShape, deblock, gradient, group, logo, quantize, smooth};
/// One traced shape: an outer contour plus its holes, filled with `color`, or (with `stroke`)
/// lines stroked with it.
@@ -209,9 +209,21 @@ fn trace_paths(img: &Raster, params: &TraceParams, max_anchors: usize, steps: &(
Some(name) if params.ignore_white => Some(logo::parse_hex(name).ok_or_else(|| TraceError::BadPalette(name.clone()))?),
_ => None,
};
// A photo is traced from a copy with its noise smoothed away (see `smooth`).
let smoothed = (params.mode != Mode::BlackAndWhite && quantize::continuous_tone(img)).then(|| smooth::smoothed(img));
let img = smoothed.as_ref().unwrap_or(img);
// A JPEG's 8 x 8 block edges are smoothed away first (see `deblock`).
let strength = match params.mode {
Mode::BlackAndWhite => deblock::BLACK_AND_WHITE,
_ if params.colors > 16 => deblock::MANY_COLORS,
_ => deblock::FEW_COLORS,
};
// A photo is traced from a copy with its noise smoothed away (see `smooth`); the deblocked copy is
// dropped once it is smoothed.
let photo = |img: &Raster| params.mode != Mode::BlackAndWhite && quantize::continuous_tone(img);
let prepared = match deblock::deblocked(img, strength) {
Some(deblocked) if photo(&deblocked) => Some(smooth::smoothed(&deblocked)),
Some(deblocked) => Some(deblocked),
None => photo(img).then(|| smooth::smoothed(img)),
};
let img = prepared.as_ref().unwrap_or(img);
go_on()?;
// Gradients are found first and kept out of the palette: no colour is spent on bands of them.
// Grayscale finds them in the image's grays (as its flat colours are), so their stops are gray.
+68
View File
@@ -2111,6 +2111,74 @@ fn small_accents_of_other_colors_leave_a_tinted_photo_continuous_tone() {
}
}
/// `img` saved as a JPEG of `quality` and read back.
fn through_jpeg(img: &Raster, quality: u8) -> Raster {
let rgb: Vec<u8> = img.rgba.chunks(4).flat_map(|p| [p[0], p[1], p[2]]).collect();
let mut bytes = vec![];
image::codecs::jpeg::JpegEncoder::new_with_quality(&mut bytes, quality)
.encode(&rgb, img.width, img.height, image::ExtendedColorType::Rgb8)
.unwrap();
Raster::decode(&bytes).unwrap()
}
/// The straight segments of `res`' paths that run across or down, at least 2 px long: for each, whether
/// it runs down, its column (down) or row (across), its length, and whether it is a step's riser, the
/// segments before and after it both running the other way and turning the path the same way.
fn axis_segments(res: &TraceResult) -> Vec<(bool, f64, f64, bool)> {
let mut out = vec![];
for sp in res.paths.iter().flat_map(|p| &p.path.subpaths) {
let n = sp.anchors.len();
let seg = |i: usize| {
let (a, b) = (&sp.anchors[i % n], &sp.anchors[(i + 1) % n]);
let straight = a.h_out.distance(a.p) < 1e-6 && b.h_in.distance(b.p) < 1e-6;
let (dx, dy) = (b.p.x - a.p.x, b.p.y - a.p.y);
// 1 across, 2 down, 0 neither; and the direction along it.
let axis = if !straight || dx.hypot(dy) < 2.0 {
0
} else if dy.abs() < 0.05 {
1
} else if dx.abs() < 0.05 {
2
} else {
0
};
(axis, dx.signum(), dy.signum(), dx.hypot(dy), a.p)
};
let last = if sp.closed { n } else { n.saturating_sub(1) };
for i in 0..last {
let (axis, _, _, len, p) = seg(i);
if axis == 0 {
continue;
}
let (before, after) = (seg(i + n - 1), seg(i + 1));
let riser = sp.closed && before.0 != 0 && before.0 != axis && after.0 == before.0 && before.1 == after.1 && before.2 == after.2;
out.push((axis == 2, if axis == 2 { p.x } else { p.y }, len, riser));
}
}
out
}
#[test]
fn a_jpegs_blocks_are_not_traced_as_steps() {
// A dark noisy ground whose tone changes slowly across and down, saved as a JPEG of quality 40.
let img = through_jpeg(
&Raster::from_fn(320, 240, |x, y| {
let v = 14.0 + 22.0 * f64::from(x) / 320.0 + 14.0 * f64::from(y) / 240.0;
let c = [0.9 * v, v, 0.8 * v].map(|c| (c + 8.0 * jitter(x, y, 3)).round().clamp(0.0, 255.0) as u8);
[c[0], c[1], c[2], 255]
}),
40,
);
let res = trace(&img, &preset("16 Colors").unwrap());
// The image's border is left out.
let segments: Vec<_> = axis_segments(&res).into_iter().filter(|s| s.1 > 0.6 && s.1 < if s.0 { 319.4 } else { 239.4 }).collect();
let on_grid: Vec<_> = segments.iter().filter(|s| (s.1 / 8.0 - (s.1 / 8.0).round()).abs() * 8.0 < 0.6).collect();
// By chance, 15 in 100 segments are within 0.6 px of a block edge.
assert!(on_grid.len() * 4 < segments.len().max(1), "{} of {} straight segments on the block edges: {segments:?}", on_grid.len(), segments.len());
let risers: Vec<_> = on_grid.iter().filter(|s| s.3 && s.2 >= 4.0).collect();
assert!(risers.is_empty(), "risers of 4 px or more on the block edges: {risers:?}");
}
#[test]
fn tinted_flat_art_stays_flat_art() {
let tints: [(&str, &[[f64; 3]]); 4] = [("gray", &GRAY_RAMP), ("sepia", &SEPIA), ("blue", &BLUE), ("duotone", &DUOTONE)];
+315 -111
View File
@@ -73,8 +73,8 @@ pub(crate) fn task_bar_shows_type(app: &VectorcraftApp) -> bool {
/// A basic shape selected with the Selection tool shows a Shape Properties button in place of Lock.
/// Selected type also shows the font family, font style and Font Size controls before its Fill.
/// While a Type tool edits type, or has type selected, the bar shows only those controls and the
/// Fill. The font controls take a second row when one row would be wider than the canvas, and
/// narrow there to fit it.
/// Fill. When one row would be wider than the canvas, the font controls take a row of their own,
/// narrowed to fit it, and the actions wrap onto rows under the handle's ([`bar_layout`]).
/// Its handle drags it anywhere on the canvas; unpinned it keeps that offset as it follows the
/// selection, pinned it stays put ([`crate::state::TaskBarPlace`]).
pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
@@ -231,7 +231,7 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
}
items.push((tl!("Duplicate"), "copy", "edit.duplicate", none()));
}
let (fill, stroke, fill_mixed, stroke_mixed) = chip_paints(app, ui.ctx());
let paints = chip_paints(app, ui.ctx());
let colored = has_colors(&st.doc, &st.selection.objects);
let doc = st.uid;
// Under the selection's lowest corner on screen, centered on the selection (the view may be
@@ -239,23 +239,47 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
let lowest = xf.quad(b).iter().map(|c| c.y).fold(f32::NEG_INFINITY, f32::max);
let anchor = pos2(xf.to_screen(b.center()).x, lowest);
let bounds = xf.rect.shrink(8.0);
// The canvas's width less the frame's margins and stroke.
let room = bounds.width() - BAR_FRAME;
// On a canvas too narrow for the type controls at their narrowest, the bar leaves them out.
let fonts = fonts && bounds.width() - 18.0 >= crate::panels::character::task_bar_min_room();
let fonts = fonts && room >= crate::panels::character::task_bar_min_room();
// The selected objects' Fill, Stroke, Recolor Artwork (when they have colours to recolour) and
// Lock (a basic shape's properties instead), left out with the Artboard tool. A Type tool's bar
// has the Fill alone.
let chips: Vec<Chip> = [
(!on_artboards, Chip::Fill),
(!on_artboards && !typing, Chip::Stroke),
(!on_artboards && !typing && colored, Chip::Recolor),
(!on_artboards && !typing, Chip::Lock),
]
.into_iter()
.filter_map(|(shown, chip)| shown.then_some(chip))
.collect();
let widths: Vec<f32> = items.iter().map(|(label, ..)| action_width(ui, label)).collect();
let font_w = fonts.then(|| {
let w = crate::panels::character::TASK_BAR_WIDTHS;
w.iter().sum::<f32>() + BAR_GAP * (w.len() - 1) as f32
});
let spacing = ui.spacing().item_spacing.y;
let chip_widths: Vec<f32> = chips.iter().map(|c| c.width()).collect();
let layout = bar_layout(&widths, &chip_widths, font_w, room, bar_max_rows(bounds.height(), spacing));
// On a canvas too small for its handle and More Options: no bar, rather than one that runs off
// the canvas.
let fonts = layout.as_ref().is_some_and(|l| l.fonts);
ui.ctx().data_mut(|d| d.insert_temp(task_bar_id().with("fonts"), fonts));
// The width of the bar's frame (margins and stroke), its handle, Fill and Stroke chips,
// Recolor Artwork, Lock or Shape Properties, and More Options, each after a 6-point gap.
let chips: f32 =
[(!on_artboards, 26.0), (!on_artboards && !typing, 26.0), (!on_artboards && !typing && colored, 30.0), (!on_artboards && !typing, 30.0)]
.iter()
.filter(|(shown, _)| *shown)
.map(|(_, w)| w + 6.0)
.sum();
let (font_row, est) = size_estimate(&items, fonts, 18.0 + 4.0 + chips + 36.0, bounds.width());
let Some(layout) = layout else { return };
let est = layout.size(spacing);
// Its place under the selection, then where the handle moved it, kept on the canvas (with the
// bar's size last frame, the estimate before it first shows).
// bar's size last frame, the layout's size before it first shows and whenever the layout
// changed since, as after the canvas or the selection changed).
let under = pos2(anchor.x - est.x / 2.0, anchor.y + 28.0);
let id = task_bar_id();
let size = egui::AreaState::load(ui.ctx(), id).and_then(|s| s.size).unwrap_or(est);
let unchanged = ui.ctx().data_mut(|d| {
let last = d.get_temp::<Vec2>(id.with("layout"));
d.insert_temp(id.with("layout"), est);
last == Some(est)
});
let size = egui::AreaState::load(ui.ctx(), id).and_then(|s| s.size).filter(|_| unchanged).unwrap_or(est);
let keep_in = |p: Pos2| p.clamp(bounds.min, (bounds.max - size).max(bounds.min));
let place = &mut app.ui.task_bar_place;
// Just unpinned: follow the selection from the pinned spot.
@@ -285,95 +309,88 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
.inner_margin(egui::Margin::symmetric(8, 6))
.shadow(egui::epaint::Shadow { offset: [0, 3], blur: 10, spread: 0, color: Color32::from_black_alpha(70) })
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 6.0;
let (g, grip) = ui.allocate_exact_size(vec2(4.0, 28.0), Sense::drag());
let active = grip.hovered() || grip.dragged();
ui.painter().rect_filled(g.shrink2(vec2(0.5, 4.0)), CornerRadius::same(2), if active { t.text_dim } else { t.button_border });
if grip.dragged() {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
moved = grip.drag_delta();
} else if grip.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);
}
for (label, icon, cmd, params) in &items {
let galley = ui.painter().layout_no_wrap(label.to_string(), egui::FontId::proportional(13.0), t.text_strong);
let (r, resp) = ui.allocate_exact_size(vec2(galley.size().x + 38.0, 30.0), Sense::click());
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, *label));
if resp.hovered() {
ui.painter().rect_filled(r, CornerRadius::same(3), t.hover);
}
ui.painter().rect_stroke(r, CornerRadius::same(3), Stroke::new(1.0, t.button_border), StrokeKind::Inside);
crate::icons::paint(ui, icon, egui::Rect::from_min_size(r.min + vec2(8.0, 7.0), vec2(16.0, 16.0)), t.icon);
ui.painter().galley(pos2(r.left() + 30.0, r.center().y - galley.size().y / 2.0), galley, t.text_strong);
if resp.clicked() {
run = Some((*cmd, params.clone()));
}
}
// Type's font family, font style and Font Size, which act as the Character
// panel's do: on the characters a Type tool selects, else on the selected type.
if fonts && !font_row {
crate::panels::character::task_bar(app, ui, f32::INFINITY);
}
// The selected objects' Fill, Stroke, Recolor Artwork and Lock (a basic shape's
// properties instead), left out with the Artboard tool. A Type tool's bar has
// the Fill alone.
if !on_artboards && paint_chip(ui, &t, &fill, fill_mixed, None, tl!("Fill")) {
app.session.fill_active = true;
show_swatches = true;
}
if !on_artboards && !typing {
// The Stroke chip, drawn as a ring as the Control bar's is.
if paint_chip(ui, &t, &stroke, stroke_mixed, Some(4.0), tl!("Stroke")) {
app.session.fill_active = false;
show_swatches = true;
}
// Recolor Artwork, when the selection has colours to recolour.
if colored && widgets::icon_button(ui, "palette", tl!("Recolor Artwork"), false, 30.0).clicked() {
run = Some(("ui.recolorDialog", json!({})));
}
if let Some(shape) = &shape
&& let NodeKind::Path { live: Some(live), .. } = &shape.kind
{
// The shape's properties in a popover that stays open while its fields and
// its Corner dropdown are used.
let props = widgets::icon_button(ui, "shapes", tl!("Shape Properties"), false, 30.0);
widgets::popover(&props, props.clicked(), |ui| {
ui.set_min_width(250.0);
crate::panels::transform::live_shape_rows(app, ui, shape, live, "task-bar-shape", true);
});
} else {
// The Lock button is off in isolation mode, as Object › Lock › Selection is.
let lockable = crate::menus::enabled(app, "object.lock");
if widgets::icon_button_enabled(ui, "lock", tl!("Lock (⌘2)"), false, lockable, 30.0).clicked() {
run = Some(("object.lock", json!({})));
}
}
}
let more = widgets::icon_button(ui, "ellipsis", tl!("More Options"), false, 30.0);
egui::Popup::menu(&more).show(|ui| {
ui.set_min_width(170.0);
let bar = [
(tl!("Hide Bar"), "window.taskBar", false),
(tl!("Pin Bar Position"), "window.taskBar.pin", pinned),
(tl!("Reset Bar Position"), "window.taskBar.reset", false),
];
for (label, cmd, checked) in bar {
if widgets::menu_item(ui, label, true, checked) {
run = Some((cmd, json!({})));
}
}
ui.separator();
if widgets::menu_item(ui, tl!("Show Properties Panel"), true, false) {
run = Some(("window.panel", json!({"panel": "properties"})));
}
});
});
if font_row {
// The first row holds the handle and More Options; actions that don't fit beside
// them go on the rows after it, in order.
for row in 0..layout.rows {
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 6.0;
// The canvas's width less the frame's margins and stroke.
crate::panels::character::task_bar(app, ui, bounds.width() - 18.0);
ui.spacing_mut().item_spacing.x = BAR_GAP;
if row == 0 {
let (g, grip) = ui.allocate_exact_size(vec2(BAR_HANDLE, 28.0), Sense::drag());
let active = grip.hovered() || grip.dragged();
ui.painter().rect_filled(
g.shrink2(vec2(0.5, 4.0)),
CornerRadius::same(2),
if active { t.text_dim } else { t.button_border },
);
if grip.dragged() {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
moved = grip.drag_delta();
} else if grip.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);
}
}
for ((label, icon, cmd, params), at) in items.iter().zip(&layout.actions) {
if *at == Some(row) && action_button(ui, &t, label, icon) {
run = Some((*cmd, params.clone()));
}
}
// Type's font family, font style and Font Size, which act as the Character
// panel's do: on the characters a Type tool selects, else on the selected type.
if row == 0 && fonts && !layout.font_row {
crate::panels::character::task_bar(app, ui, f32::INFINITY);
}
for (chip, at) in chips.iter().zip(&layout.chips) {
if *at != row {
continue;
}
match paint_or_object_chip(app, ui, &t, *chip, &paints, shape.as_ref()) {
Some(ChipClick::Fill(fill)) => {
app.session.fill_active = fill;
show_swatches = true;
}
Some(ChipClick::Run(cmd)) => run = Some((cmd, json!({}))),
None => {}
}
}
if row != 0 {
return;
}
let more = widgets::icon_button(ui, "ellipsis", tl!("More Options"), false, BAR_MORE);
egui::Popup::menu(&more).show(|ui| {
ui.set_min_width(170.0);
// The actions too wide for any row of the bar.
let listed = items.iter().zip(&layout.actions).filter(|(_, at)| at.is_none());
let mut any = false;
for ((label, _, cmd, params), _) in listed {
any = true;
if widgets::menu_item_name(ui, label, true, false) {
run = Some((*cmd, params.clone()));
}
}
if any {
ui.separator();
}
let bar = [
(tl!("Hide Bar"), "window.taskBar", false),
(tl!("Pin Bar Position"), "window.taskBar.pin", pinned),
(tl!("Reset Bar Position"), "window.taskBar.reset", false),
];
for (label, cmd, checked) in bar {
if widgets::menu_item(ui, label, true, checked) {
run = Some((cmd, json!({})));
}
}
ui.separator();
if widgets::menu_item(ui, tl!("Show Properties Panel"), true, false) {
run = Some(("window.panel", json!({"panel": "properties"})));
}
});
});
}
if layout.font_row {
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = BAR_GAP;
crate::panels::character::task_bar(app, ui, room);
});
}
});
@@ -413,14 +430,201 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
}
}
/// Whether the type controls go on a second row, and the bar's estimated size before it first
/// shows: `items` and, when `fonts`, the font family, font style and Font Size controls, which take
/// a second row when one row, with the bar's other controls `fixed` points wide, would be wider than
/// `room` (and narrow to fit it there).
fn size_estimate(items: &[(&str, &str, &str, serde_json::Value)], fonts: bool, fixed: f32, room: f32) -> (bool, Vec2) {
let font_w: f32 = crate::panels::character::TASK_BAR_WIDTHS.iter().filter(|_| fonts).map(|w| w + 6.0).sum();
let items_w = if fonts { fixed } else { 150.0 } + items.iter().map(|(l, _, _, _)| l.len() as f32 * 7.2 + 44.0).sum::<f32>();
if fonts && items_w + font_w > room { (true, vec2(items_w.max((font_w + 16.0).min(room)), 80.0)) } else { (false, vec2(items_w + font_w, 44.0)) }
/// The width of the Contextual Task Bar's frame: its margins and stroke on both sides.
const BAR_FRAME: f32 = 18.0;
/// The gap between the bar's controls.
const BAR_GAP: f32 = 6.0;
/// The width of the bar's handle.
const BAR_HANDLE: f32 = 4.0;
/// The width of the bar's More Options button.
const BAR_MORE: f32 = 30.0;
/// The height of a row of the bar's controls.
const BAR_ROW: f32 = 30.0;
/// The controls the Contextual Task Bar shows after its actions: the Fill and Stroke chips,
/// Recolor Artwork, and Lock or a basic shape's Shape Properties.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Chip {
Fill,
Stroke,
Recolor,
Lock,
}
impl Chip {
fn width(self) -> f32 {
match self {
Chip::Fill | Chip::Stroke => 26.0,
Chip::Recolor | Chip::Lock => 30.0,
}
}
}
/// What a click on one of the bar's [`Chip`]s does: make the Fill (`true`) or the Stroke active and
/// bring up Swatches, or run a command.
enum ChipClick {
Fill(bool),
Run(&'static str),
}
/// Where each of the Contextual Task Bar's controls goes.
#[derive(Debug, PartialEq)]
struct BarLayout {
/// Each action's row (0 is the row with the handle and More Options), or `None` for an action
/// wider than a row or past the rows the canvas's height allows, which More Options lists
/// instead.
actions: Vec<Option<usize>>,
/// Each chip's row.
chips: Vec<usize>,
/// Whether the bar shows the font controls it was given.
fonts: bool,
/// Whether the font controls take a row of their own, after the others.
font_row: bool,
/// The number of rows before the font controls' row.
rows: usize,
/// The bar's width, its frame included.
width: f32,
}
impl BarLayout {
/// The bar's size, with `spacing` points between its rows.
fn size(&self, spacing: f32) -> Vec2 {
let rows = (self.rows + usize::from(self.font_row)) as f32;
vec2(self.width, rows * BAR_ROW + (rows - 1.0) * spacing + 14.0)
}
}
/// How many rows of the Contextual Task Bar fit in `height` points, with `spacing` points between
/// them.
fn bar_max_rows(height: f32, spacing: f32) -> usize {
((height - 14.0 + spacing) / (BAR_ROW + spacing)).floor().max(0.0) as usize
}
/// The Contextual Task Bar's layout in `room` points (the canvas's width less the frame) and at
/// most `max_rows` rows, for actions and chips the given widths wide, and the font controls `fonts`
/// wide when shown. One row holds everything when it fits. Otherwise the font controls take a row
/// of their own, narrowed to the room, and the actions wrap: the first row keeps the handle, the
/// chips and More Options, and each action goes on the last row when it fits there, else on a new
/// row. When the handle, the chips and More Options don't fit in one row, the chips take rows of
/// their own after the actions. An action wider than a row, or one that would need a row past
/// `max_rows`, goes in More Options; without a row to spare the font controls are left out. `None`
/// when not even the handle and More Options, and the chips' rows, fit.
fn bar_layout(actions: &[f32], chips: &[f32], fonts: Option<f32>, room: f32, max_rows: usize) -> Option<BarLayout> {
// Puts a control `w` wide on the last row when it fits there, else on a new row.
fn place(rows: &mut Vec<f32>, w: f32, room: f32) -> usize {
match rows.last_mut() {
Some(last) if *last + BAR_GAP + w <= room => *last += BAR_GAP + w,
_ => rows.push(w),
}
rows.len() - 1
}
let ends = BAR_HANDLE + BAR_GAP + BAR_MORE;
if room < ends || max_rows == 0 {
return None;
}
let chips_w: f32 = chips.iter().map(|w| w + BAR_GAP).sum();
let actions_w: f32 = actions.iter().map(|w| w + BAR_GAP).sum();
let one_row = ends + chips_w + actions_w + fonts.map_or(0.0, |w| w + BAR_GAP);
if one_row <= room {
return Some(BarLayout {
actions: vec![Some(0); actions.len()],
chips: vec![0; chips.len()],
fonts: fonts.is_some(),
font_row: false,
rows: 1,
width: one_row + BAR_FRAME,
});
}
let chips_first = ends + chips_w <= room;
let mut chip_rows = vec![];
let chips: Vec<usize> = chips.iter().map(|w| if chips_first { 0 } else { place(&mut chip_rows, *w, room) }).collect();
if 1 + chip_rows.len() > max_rows {
return None;
}
let font_row = fonts.is_some() && 1 + chip_rows.len() < max_rows;
let action_rows = max_rows - chip_rows.len() - usize::from(font_row);
let mut rows = vec![if chips_first { ends + chips_w } else { ends }];
// Once an action needs a row past the last one, it and the actions after it go in More Options,
// keeping their order.
let mut full = false;
let actions: Vec<Option<usize>> = actions
.iter()
.map(|w| {
if *w > room || full {
return None;
}
let mut next = rows.clone();
let row = place(&mut next, *w, room);
full = row >= action_rows;
(!full).then(|| {
rows = next;
row
})
})
.collect();
let chips = chips.into_iter().map(|row| if chips_first { 0 } else { rows.len() + row }).collect();
let font_w = if font_row { fonts.map_or(0.0, |w| w.min(room)) } else { 0.0 };
let width = rows.iter().chain(&chip_rows).fold(font_w, |a, b| a.max(*b)) + BAR_FRAME;
Some(BarLayout { actions, chips, fonts: font_row, font_row, rows: rows.len() + chip_rows.len(), width })
}
/// The width of the Contextual Task Bar's action button for `label`.
fn action_width(ui: &Ui, label: &str) -> f32 {
ui.painter().layout_no_wrap(label.to_string(), egui::FontId::proportional(13.0), Color32::PLACEHOLDER).size().x + 38.0
}
/// One of the Contextual Task Bar's action buttons: `icon` and `label`, named for screen readers.
/// Returns whether it was clicked.
fn action_button(ui: &mut Ui, t: &Tokens, label: &str, icon: &str) -> bool {
let galley = ui.painter().layout_no_wrap(label.to_string(), egui::FontId::proportional(13.0), t.text_strong);
let (r, resp) = ui.allocate_exact_size(vec2(galley.size().x + 38.0, BAR_ROW), Sense::click());
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, label));
if resp.hovered() {
ui.painter().rect_filled(r, CornerRadius::same(3), t.hover);
}
ui.painter().rect_stroke(r, CornerRadius::same(3), Stroke::new(1.0, t.button_border), StrokeKind::Inside);
crate::icons::paint(ui, icon, egui::Rect::from_min_size(r.min + vec2(8.0, 7.0), vec2(16.0, 16.0)), t.icon);
ui.painter().galley(pos2(r.left() + 30.0, r.center().y - galley.size().y / 2.0), galley, t.text_strong);
resp.clicked()
}
/// One of the Contextual Task Bar's chips, with the Fill and Stroke `paints` ([`chip_paints`]) and
/// the basic `shape` whose properties take Lock's place. Returns what a click on it does.
fn paint_or_object_chip(
app: &mut VectorcraftApp,
ui: &mut Ui,
t: &Tokens,
chip: Chip,
paints: &(vectorcraft_color::Paint, vectorcraft_color::Paint, bool, bool),
shape: Option<&vectorcraft_doc::Node>,
) -> Option<ChipClick> {
let (fill, stroke, fill_mixed, stroke_mixed) = paints;
match chip {
Chip::Fill => paint_chip(ui, t, fill, *fill_mixed, None, tl!("Fill")).then_some(ChipClick::Fill(true)),
// The Stroke chip, drawn as a ring as the Control bar's is.
Chip::Stroke => paint_chip(ui, t, stroke, *stroke_mixed, Some(4.0), tl!("Stroke")).then_some(ChipClick::Fill(false)),
Chip::Recolor => {
widgets::icon_button(ui, "palette", tl!("Recolor Artwork"), false, 30.0).clicked().then_some(ChipClick::Run("ui.recolorDialog"))
}
Chip::Lock => {
if let Some(shape) = shape
&& let NodeKind::Path { live: Some(live), .. } = &shape.kind
{
// The shape's properties in a popover that stays open while its fields and its
// Corner dropdown are used.
let props = widgets::icon_button(ui, "shapes", tl!("Shape Properties"), false, 30.0);
widgets::popover(&props, props.clicked(), |ui| {
ui.set_min_width(250.0);
crate::panels::transform::live_shape_rows(app, ui, shape, live, "task-bar-shape", true);
});
None
} else {
// The Lock button is off in isolation mode, as Object › Lock › Selection is.
let lockable = crate::menus::enabled(app, "object.lock");
widgets::icon_button_enabled(ui, "lock", tl!("Lock (⌘2)"), false, lockable, 30.0).clicked().then_some(ChipClick::Run("object.lock"))
}
}
}
}
/// The paints the Fill and Stroke chips show, and whether each is mixed ("?"): the proxies', or
+64 -27
View File
@@ -947,12 +947,6 @@ fn names_a_loaded_library(v: &Value) -> bool {
}
}
/// The preferences that hold a folder, by their keys in `ui.engine_prefs` and the Preferences dialog.
const PREF_FOLDERS: [&str; 6] = ["fontsFolder", "pluginsFolder", "scratchPrimary", "scratchSecondary", "recoveryFolder", "templatesFolder"];
/// The scratch disk choices that are not paths.
const SCRATCH_CHOICES: [&str; 2] = ["Startup", "None"];
/// May the request being served read `path`? Under an automation read root (a control client's
/// request), `ui.inspect` leaves out a path outside the root, as `ui.menu.list` leaves out a recent
/// file or a listed script outside it. Another platform's absolute path
@@ -975,11 +969,11 @@ fn unreadable_absolute(s: &str) -> bool {
}
/// Is `s` written as a path that the request may not read: an absolute path or a `file:` URL
/// ([`unreadable_absolute`]), `~` or a path under it, or a path that starts with `.` or `..` and a
/// separator? It is checked as the file access check reads it, relative to the working folder. Other
/// text with a separator (`a/b`) stays.
/// ([`unreadable_absolute`]), as written or with surrounding whitespace trimmed, `~` or a path under
/// it, or a path that starts with `.` or `..` and a separator? It is checked as the file access check
/// reads it, relative to the working folder. Other text with a separator (`a/b`) stays.
fn unreadable_path_like(s: &str) -> bool {
if unreadable_absolute(s) {
if unreadable_absolute(s) || unreadable_absolute(s.trim()) {
return true;
}
let t = s.trim_start();
@@ -1048,24 +1042,63 @@ fn percent_decoded(s: &str) -> String {
String::from_utf8_lossy(&out).into_owned()
}
/// The params of each step of each action of action set `set` (`ui.action_sets`).
fn steps_mut(set: &mut Value) -> impl Iterator<Item = &mut serde_json::Map<String, Value>> {
/// The command and params of each step of each action of action set `set` (`ui.action_sets`).
fn steps_mut(set: &mut Value) -> impl Iterator<Item = (String, &mut serde_json::Map<String, Value>)> {
let actions = set.get_mut("actions").and_then(Value::as_array_mut).into_iter().flatten();
let steps = actions.filter_map(|action| action.get_mut("steps").and_then(Value::as_array_mut)).flatten();
steps.filter_map(|step| step.get_mut(1).and_then(Value::as_object_mut))
steps.filter_map(|step| {
let command = step.get(0).and_then(Value::as_str).unwrap_or_default().to_string();
step.get_mut(1).and_then(Value::as_object_mut).map(|params| (command, params))
})
}
/// Takes out of the params of a recorded step running `command` the paths the request may not read:
/// the folder preferences' values [`leave_out_unreadable_pref_steps`] takes out, and what
/// [`leave_out_unreadable_params`] takes out, each in one pass over the params.
fn leave_out_unreadable_step(command: &str, params: &mut serde_json::Map<String, Value>) {
leave_out_unreadable_pref_steps(command, params);
leave_out_unreadable_params(params);
}
/// Takes out of the params of a step running `command` the folder preferences' values the request
/// may not read ([`shows_folder`]): in a `prefs.set` step, given as `{key, value}` or in `values`; in
/// a `command.batch` step, the same in each of its commands, at any depth.
fn leave_out_unreadable_pref_steps(command: &str, params: &mut serde_json::Map<String, Value>) {
match command {
"prefs.set" => {
if let Some(Value::Object(values)) = params.get_mut("values") {
leave_out_unreadable_folders(values);
}
if let (Some(key), Some(value)) = (params.get("key").and_then(Value::as_str), params.get("value").and_then(Value::as_str))
&& !shows_folder(key, value)
{
params.remove("value");
}
}
"command.batch" => {
for step in params.get_mut("commands").and_then(Value::as_array_mut).into_iter().flatten().filter_map(Value::as_object_mut) {
let command = step.get("command").and_then(Value::as_str).unwrap_or_default().to_string();
if let Some(Value::Object(params)) = step.get_mut("params") {
leave_out_unreadable_pref_steps(&command, params);
}
}
}
_ => {}
}
}
/// Takes out of a recorded step's params, at any depth (the commands of a `command.batch` step), the
/// paths the request may not read: the value of a path param
/// ([`vectorcraft_engine::file_access::is_path_key`]: `path`, `file`, `diffPath`, `destinationFolder`
/// and the like), each path of a list under such a param, and under any other param, as a key too, a
/// string written as a path ([`unreadable_path_like`]).
/// string written as a path ([`unreadable_path_like`]). An empty or blank value names no path and stays.
fn leave_out_unreadable_params(params: &mut serde_json::Map<String, Value>) {
use vectorcraft_engine::file_access::is_path_key;
let shown = |p: &str| p.trim().is_empty() || readable_value(p);
params.retain(|key, v| {
!unreadable_path_like(key)
&& match v.as_str() {
Some(p) => !unreadable_path_like(p) && !(is_path_key(key) && !readable_value(p)),
Some(p) => !unreadable_path_like(p) && !(is_path_key(key) && !shown(p)),
None => true,
}
});
@@ -1073,7 +1106,7 @@ fn leave_out_unreadable_params(params: &mut serde_json::Map<String, Value>) {
if let Value::Array(paths) = v
&& is_path_key(key)
{
paths.retain(|p| p.as_str().is_none_or(readable_value));
paths.retain(|p| p.as_str().is_none_or(shown));
}
leave_out_unreadable_values(v);
}
@@ -1108,8 +1141,8 @@ fn leave_out_unreadable_paths(app: &VectorcraftApp, ui: &mut serde_json::Map<Str
}
}
}
for step in ui.get_mut("action_sets").and_then(Value::as_array_mut).into_iter().flatten().flat_map(steps_mut) {
leave_out_unreadable_params(step);
for (command, params) in ui.get_mut("action_sets").and_then(Value::as_array_mut).into_iter().flatten().flat_map(steps_mut) {
leave_out_unreadable_step(&command, params);
}
if let Some(Value::Object(prefs)) = ui.get_mut("engine_prefs") {
leave_out_unreadable_folders(prefs);
@@ -1130,20 +1163,24 @@ fn leave_out_unreadable_paths(app: &VectorcraftApp, ui: &mut serde_json::Map<Str
}
}
/// Takes out of `prefs` the folder preferences ([`PREF_FOLDERS`]) the request may not read, as written
/// or trimmed as the app uses it. An empty value (no folder) and a scratch disk choice
/// ([`SCRATCH_CHOICES`]) stay.
/// Takes out of `prefs` the folder preferences
/// ([`vectorcraft_engine::cmd::prefscmds::FOLDER_PREFS`]) the request may not read ([`shows_folder`]).
fn leave_out_unreadable_folders(prefs: &mut serde_json::Map<String, Value>) {
for key in PREF_FOLDERS {
let Some(written) = prefs.get(key).and_then(Value::as_str) else { continue };
let path = written.trim();
if path.is_empty() || (key.starts_with("scratch") && SCRATCH_CHOICES.contains(&path)) || (readable(written) && readable(path)) {
continue;
for key in vectorcraft_engine::cmd::prefscmds::FOLDER_PREFS {
if prefs.get(key).and_then(Value::as_str).is_some_and(|written| !shows_folder(key, written)) {
prefs.remove(key);
}
prefs.remove(key);
}
}
/// May the request see `written` as the value of preference `key`? Yes unless it names a folder
/// ([`vectorcraft_engine::cmd::prefscmds::names_a_folder`]: an empty value and a scratch disk choice
/// do not) that the request may not read as written, or trimmed as the app uses it, also as a `file:`
/// URL ([`readable_value`]).
fn shows_folder(key: &str, written: &str) -> bool {
!vectorcraft_engine::cmd::prefscmds::names_a_folder(key, written) || (readable(written) && readable_value(written.trim()))
}
fn key_from(name: &str) -> Option<egui::Key> {
egui::Key::from_name(name).or(match name.to_ascii_lowercase().as_str() {
"enter" | "return" => Some(egui::Key::Enter),
+36
View File
@@ -293,6 +293,42 @@ fn an_absolute_path_outside_the_read_root_is_unreadable() {
});
}
/// Under a read root, an absolute path or a `file:` URL outside it is written as a path also with
/// whitespace around it, and a recorded step's text param loses it; a path inside the root stays.
#[test]
fn a_spaced_absolute_path_outside_the_read_root_is_left_out() {
let base = crate::tests_folder::Folder::new("unreadable-spaced");
std::fs::create_dir_all(base.join("in")).unwrap();
let roots = vectorcraft_engine::file_access::AutomationRoots::new(&[&base.join("in")], &[]).unwrap();
let inside = format!(" {} ", base.join("in").join("a.svg").to_string_lossy());
let mut params = json!({"target": " /outside/root/x", "name": "\tfile:///outside/root/x ", "keep": inside, "list": [" /outside/root/y"]});
vectorcraft_engine::file_access::confine(roots.as_ref(), || {
assert!(super::unreadable_path_like(" /outside/root/x"));
assert!(super::unreadable_path_like("\tfile:///outside/root/x "));
assert!(!super::unreadable_path_like(&inside), "{inside}");
super::leave_out_unreadable_params(params.as_object_mut().unwrap());
});
assert_eq!(params, json!({"keep": inside, "list": []}));
}
/// Under a read root, an empty or blank value names no path, so a recorded step keeps it under a path
/// param and in a path param's list, a folder preference reset in a `prefs.set` step's `values`
/// included; a path outside the root is still left out.
#[test]
fn an_empty_path_param_stays_under_a_read_root() {
let base = crate::tests_folder::Folder::new("unreadable-empty");
std::fs::create_dir_all(base.join("in")).unwrap();
let roots = vectorcraft_engine::file_access::AutomationRoots::new(&[&base.join("in")], &[]).unwrap();
let mut params = json!({
"values": {"fontsFolder": "", "templatesFolder": " ", "recoveryFolder": "/outside/root/x"},
"path": "", "destinationFolder": " ", "files": ["", "/outside/root/y"],
});
vectorcraft_engine::file_access::confine(roots.as_ref(), || {
super::leave_out_unreadable_step("prefs.set", params.as_object_mut().unwrap());
});
assert_eq!(params, json!({"values": {"fontsFolder": "", "templatesFolder": " "}, "path": "", "destinationFolder": " ", "files": [""]}));
}
/// Without a read root, a `file:` URL that names another host may be read, and a recorded step keeps
/// it.
#[test]
@@ -263,6 +263,40 @@ mod tests {
assert_eq!((d.str("size"), d.f64("custom", 0.0)), ("large".to_string(), GapSize::LARGE));
}
/// OK on the options the group has, with Preview on or off, closes the dialog and records no
/// undo step: the redo step stays and a saved document stays saved.
#[test]
fn ok_on_unchanged_options_records_no_undo_step() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 300, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 50, "y": 50, "width": 100, "height": 100})).unwrap();
app.run("select.all", json!({})).unwrap();
let g = app.run("livePaint.make", json!({})).unwrap()["id"].as_u64().unwrap();
app.run("shape.rectangle", json!({"x": 200, "y": 200, "width": 10, "height": 10})).unwrap();
app.run("edit.undo", json!({})).unwrap();
app.run("select.set", json!({"ids": [g]})).unwrap();
app.session.doc_mut().unwrap().mark_saved();
let state = |app: &VectorcraftApp| {
let st = app.session.doc().unwrap();
(st.history.undo.len(), st.history.redo.len(), st.is_dirty())
};
let before = state(&app);
for preview in [false, true] {
app.run("ui.livePaintGapOptions", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("preview".into(), json!(preview));
frame(&mut app);
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none(), "preview={preview}: OK closes the dialog");
assert_eq!(state(&app), before, "preview={preview}: no undo step");
assert_eq!(options(&app, g), GapOptions::default());
}
// A changed option is one undo step.
app.run("ui.livePaintGapOptions", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("detect".into(), json!(true));
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!(state(&app).0, before.0 + 1);
}
/// A Gap Preview Color with an alpha part is refused and leaves the group's options as they
/// were; `#rrggbb` still sets them.
#[test]
+2 -2
View File
@@ -1783,7 +1783,7 @@ mod tests {
/// The Color Theme Picker's picks (the `themePicks` field) give the rows that aren't excluded
/// the palette of the art picked, in row order, repeating it when the rows outnumber its
/// colors, and the art previews them. Picks that touch no art leave the rows as they are, and
/// OK keeps the recolor as one undo step.
/// OK with rows that give the art its own colors back records no undo step.
#[test]
fn theme_picks_give_the_rows_the_palette_of_the_art_picked() {
let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
@@ -1822,7 +1822,7 @@ mod tests {
assert_eq!(app.session.doc().unwrap().history.undo.len(), undo, "nothing is committed before OK");
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!((fill_hex(&app, red), fill_hex(&app, blue)), ("#ff0000".into(), "#0000ff".into()), "the excluded row kept red");
assert_eq!(app.session.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
assert_eq!(app.session.doc().unwrap().history.undo.len(), undo, "the art is unchanged: no undo step");
}
const RED: &str = "rgb 255 0 0";
+1
View File
@@ -5889,6 +5889,7 @@ theme Appearance Външен вид
@msg no such color няма такъв цвят
@msg {_1} cannot be used on Windows {_1} не може да се използва в Windows
@msg more than one action is named “{_1}” повече от едно действие се казва „{_1}“
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set действието „{_1}“ задава предпочитанието за папка {_2}; изтрийте тази стъпка, за да запазите набора
@msg no symbol named `{n}` няма символ с име `{n}`
Smudge Stick… Размазваща пръчка…
Smudge Stick Размазваща пръчка
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -5892,6 +5892,7 @@ mark-style Japanese Japanski
@msg no such color nema takve boje
@msg {_1} cannot be used on Windows {_1} se ne može koristiti na Windowsu
@msg more than one action is named “{_1}” više od jedne akcije ima naziv „{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set akcija „{_1}” postavlja postavku foldera {_2}; izbrišite taj korak da biste sačuvali skup
@msg no symbol named `{n}` nema simbola pod nazivom `{n}`
Smudge Stick… Štapić za razmazivanje…
Smudge Stick Štapić za razmazivanje
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -5771,6 +5771,7 @@ digits Malayalam Malaiàlam
@msg no such color no existeix aquest color
@msg {_1} cannot be used on Windows {_1} no es pot fer servir al Windows
@msg more than one action is named “{_1}” més d’una acció es diu “{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set l’acció “{_1}” defineix la preferència de carpeta {_2}; suprimiu aquest pas per desar el conjunt
@msg name the file poseu un nom al fitxer
@msg New Window isn't available yet: a document opens in one window Finestra nova encara no està disponible: un document s’obre en una sola finestra
@msg no active document no hi ha cap document actiu
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -6203,6 +6203,7 @@ mark-style Japanese Japonské
@msg no such color taková barva neexistuje
@msg {_1} cannot be used on Windows Zkratku {_1} nelze ve Windows použít
@msg more than one action is named “{_1}” název „{_1}“ má více než jedna akce
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set akce „{_1}“ nastavuje předvolbu složky {_2}; chcete-li sadu uložit, tento krok smažte
@msg no symbol named `{n}` žádný symbol s názvem `{n}`
Smudge Stick… Rozmazávací tyčinka…
Smudge Stick Rozmazávací tyčinka
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -5771,6 +5771,7 @@ swatch Bright Violet Kraftig violet
@msg no such color ingen sådan farve
@msg {_1} cannot be used on Windows {_1} kan ikke bruges i Windows
@msg more than one action is named “{_1}” mere end én handling hedder »{_1}«
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set handlingen »{_1}« angiver mappeindstillingen {_2}; slet det trin for at gemme sættet
@msg no symbol named `{n}` intet symbol med navnet `{n}`
Remove Color Profile… Fjern farveprofil…
Color wheel Farvehjul
Can't render this file because it contains an unexpected character in line 2 and column 73.
File diff suppressed because it is too large. Load diff
+1
View File
@@ -6155,6 +6155,7 @@ effect Points Σημεία
@msg no such color δεν υπάρχει τέτοιο χρώμα
@msg {_1} cannot be used on Windows Το {_1} δεν μπορεί να χρησιμοποιηθεί στα Windows
@msg more than one action is named “{_1}” περισσότερες από μία ενέργειες ονομάζονται «{_1}»
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set η ενέργεια «{_1}» ορίζει την προτίμηση φακέλου {_2}· διαγράψτε αυτό το βήμα για να αποθηκεύσετε το σύνολο
@msg no symbol named `{n}` κανένα σύμβολο με όνομα `{n}`
Smudge Stick… Μουτζούρα…
Smudge Stick Μουτζούρα
Can't render this file because it is too large.
+1
View File
@@ -6146,6 +6146,7 @@ mark-style Japanese Japonesas
@msg no such color no existe ese color
@msg {_1} cannot be used on Windows {_1} no se puede usar en Windows
@msg more than one action is named “{_1}” más de una acción se llama “{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set la acción “{_1}” establece la preferencia de carpeta {_2}; elimine ese paso para guardar el conjunto
@msg no symbol named `{n}` no hay ningún símbolo llamado `{n}`
Smudge Stick… Difuminar con barra…
Smudge Stick Difuminar con barra
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -6166,6 +6166,7 @@ mark-style Japanese Japanilainen
@msg no such color väriä ei ole
@msg {_1} cannot be used on Windows {_1} ei ole käytettävissä Windowsissa
@msg more than one action is named “{_1}” useamman kuin yhden toiminnon nimi on ”{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set toiminto ”{_1}” asettaa kansioasetuksen {_2}; poista tämä vaihe, jotta voit tallentaa sarjan
@msg no symbol named `{n}` symbolia nimeltä `{n}` ei ole
Smudge Stick… Sumennuskynä…
Smudge Stick Sumennuskynä
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -6198,6 +6198,7 @@ theme Appearance Apparence
@msg no such color couleur inexistante
@msg {_1} cannot be used on Windows {_1} ne peut pas être utilisé sous Windows
@msg more than one action is named “{_1}” plusieurs scripts s’appellent « {_1} »
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set le script « {_1} » définit la préférence de dossier {_2} ; supprimez cette étape pour enregistrer le jeu
@msg no symbol named `{n}` aucun symbole nommé `{n}`
Smudge Stick… Estompe…
Smudge Stick Estompe
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -7218,6 +7218,7 @@ antiAlias Sharp शार्प
@msg more than 10000 linked files: package dependencies in smaller parts 10000 से अधिक लिंक्ड फ़ाइलें: पैकेज निर्भरता छोटे भागों में
@msg more than 256 commands 256 से अधिक कमांड
@msg more than one action is named “{_1}” एक से अधिक कार्रवाई का नाम "{_1}" रखा गया है।
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set कार्रवाई "{_1}" फ़ोल्डर प्राथमिकता {_2} सेट करती है; सेट सेव करने के लिए वह चरण हटाएँ
@msg Move Panel to New Window is not available: floating panels stay in the main window नई विंडो में पैनल को स्थानांतरित करना उपलब्ध नहीं है: अस्थायी पैनल मुख्य विंडो में रहते हैं
@msg move requires a destination panel move के लिए गंतव्य पैनल चाहिए
@msg move requires an existing destination panel move के लिए मौजूदा गंतव्य पैनल चाहिए
Can't render this file because it is too large.
+1
View File
@@ -6186,6 +6186,7 @@ imageTrace Outline Körvonal
@msg no such color nincs ilyen szín
@msg {_1} cannot be used on Windows A(z) {_1} nem használható Windows rendszeren
@msg more than one action is named “{_1}” több művelet neve is „{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set a(z) „{_1}” művelet beállítja a(z) {_2} mappabeállítást; a készlet mentéséhez törölje ezt a lépést
@msg no symbol named `{n}` nincs `{n}` nevű szimbólum
Smudge Stick… Elmosó rúd…
Smudge Stick Elmosó rúd
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -5771,6 +5771,7 @@ swatch Bright Violet Violet cerah
@msg no such color tidak ada warna seperti itu
@msg {_1} cannot be used on Windows {_1} tidak dapat digunakan di Windows
@msg more than one action is named “{_1}” lebih dari satu tindakan bernama “{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set tindakan “{_1}” mengatur preferensi folder {_2}; hapus langkah itu untuk menyimpan set
@msg no symbol named `{n}` tidak ada simbol bernama `{n}`
Remove Color Profile… Hapus profil warna…
Color wheel Roda warna
Can't render this file because it contains an unexpected character in line 2429 and column 5.
File diff suppressed because it is too large. Load diff
+1
View File
@@ -5868,6 +5868,7 @@ lighting Light ライト
@msg no such color 指定されたカラーが見つかりません
@msg {_1} cannot be used on Windows {_1} は Windows では使用できません
@msg more than one action is named “{_1}” 「{_1}」という名前のアクションが複数あります
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set アクション「{_1}」がフォルダーの環境設定 {_2} を設定しています。セットを保存するにはそのステップを削除してください
@msg no symbol named `{n}` `{n}` という名前のシンボルはありません
Smudge Stick… スマッジスティック…
Smudge Stick スマッジスティック
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -5927,6 +5927,7 @@ imageTrace Outline კონტური
@msg no such color ასეთი ფერი არ არის
@msg {_1} cannot be used on Windows {_1} ვერ გამოიყენება Windows-ში
@msg more than one action is named “{_1}” „{_1}“ ერთზე მეტი მოქმედების სახელია
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set მოქმედება „{_1}“ აყენებს საქაღალდის პარამეტრს {_2}; ნაკრების შესანახად წაშალეთ ეს ნაბიჯი
@msg no symbol named `{n}` სიმბოლო სახელით `{n}` არ არის
@msg no saved selection recalled შენახული მონიშვნა გამოძახებული არ არის
@msg The last start of VectorCraft ended on {name} before its window appeared, so it started on {summary}. To try that graphics processor again, change Preferences › Performance › Graphics Processor or start with WGPU_BACKEND set VectorCraft-ის ბოლო გაშვება ფანჯრის გამოჩენამდე შეწყდა (გრაფიკული პროცესორი: {name}), ამიტომ VectorCraft გაეშვა: {summary}. ამ გრაფიკული პროცესორის ხელახლა საცდელად შეცვალეთ პარამეტრები › წარმადობა › გრაფიკული პროცესორი ან გაუშვით WGPU_BACKEND ცვლადის მითითებით
Can't render this file because it is too large.
+1
View File
@@ -5785,6 +5785,7 @@ lighting Light 광원
@msg no such color 해당 색상이 없습니다
@msg {_1} cannot be used on Windows {_1}은(는) Windows에서 사용할 수 없습니다
@msg more than one action is named “{_1}” “{_1}”(이)라는 이름의 액션이 둘 이상 있습니다
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set 액션 “{_1}”이(가) 폴더 환경 설정 {_2}을(를) 설정합니다. 세트를 저장하려면 해당 단계를 삭제하세요
@msg no symbol named `{n}` 이름이 `{n}`인 심볼이 없습니다
Smudge Stick… 문지르기 막대…
Smudge Stick 문지르기 막대
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -6347,6 +6347,7 @@ swatch Bright Violet Felviolet
@msg no such color kleur bestaat niet
@msg {_1} cannot be used on Windows {_1} kan niet worden gebruikt in Windows
@msg more than one action is named “{_1}” meer dan één actie heet „{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set de actie „{_1}” stelt de mapvoorkeur {_2} in; verwijder die stap om de set op te slaan
@msg no symbol named `{n}` geen symbool met de naam `{n}`
Remove Color Profile… Kleurprofiel verwijderen…
Color wheel Kleurenwiel
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -6058,6 +6058,7 @@ mark-style Japanese Japońskie
@msg no such color brak takiego koloru
@msg {_1} cannot be used on Windows Skrótu {_1} nie można używać w systemie Windows
@msg more than one action is named “{_1}” więcej niż jedna operacja nazywa się „{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set operacja „{_1}” ustawia preferencję folderu {_2}; usuń ten krok, aby zapisać zestaw
@msg no symbol named `{n}` brak symbolu o nazwie `{n}`
Smudge Stick… Rozmazywacz…
Smudge Stick Rozmazywacz
Can't render this file because it contains an unexpected character in line 2 and column 73.
File diff suppressed because it is too large. Load diff
+1
View File
@@ -5809,6 +5809,7 @@ lighting Light Свет
@msg no such color такого цвета нет
@msg {_1} cannot be used on Windows Сочетание {_1} нельзя использовать в Windows
@msg more than one action is named “{_1}” несколько действий называются «{_1}»
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set действие «{_1}» задаёт настройку папки {_2}; удалите этот шаг, чтобы сохранить набор
@msg no symbol named `{n}` нет символа с именем `{n}`
Smudge Stick… Растушёвка…
Smudge Stick Растушёвка
Can't render this file because it is too large.
+1
View File
@@ -6156,6 +6156,7 @@ theme Appearance Utseende
@msg no such color färgen finns inte
@msg {_1} cannot be used on Windows {_1} kan inte användas i Windows
@msg more than one action is named “{_1}” fler än en åtgärd heter ”{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set åtgärden ”{_1}” anger mappinställningen {_2}; ta bort det steget för att spara uppsättningen
@msg no symbol named `{n}` ingen symbol med namnet `{n}`
Angular Vinkelmått
Away from the Line Bort från linjen
Can't render this file because it is too large.
+248 -11
View File
@@ -1486,7 +1486,8 @@ fn string_literals(e: &str, keep: impl Fn(&str, &str) -> bool) -> Vec<String> {
/// For translators, `cargo test -p vectorcraft-ui-egui dump_source_strings` writes every English
/// interface string to `VECTORCRAFT_I18N_DUMP=<file>`, and every status and error message as a
/// catalog template to `VECTORCRAFT_I18N_DUMP_MESSAGES=<file>`, one per line.
/// catalog template that [`untranslated_report`] checks to `VECTORCRAFT_I18N_DUMP_MESSAGES=<file>`,
/// one per line.
#[test]
fn dump_source_strings() {
if let Ok(path) = std::env::var("VECTORCRAFT_I18N_DUMP") {
@@ -1498,10 +1499,27 @@ fn dump_source_strings() {
std::fs::write(path, text).expect("write dump");
}
if let Ok(path) = std::env::var("VECTORCRAFT_I18N_DUMP_MESSAGES") {
std::fs::write(path, message_literals().iter().map(|m| format!("{m}\n")).collect::<String>()).expect("write dump");
std::fs::write(path, message_dump()).expect("write dump");
}
}
/// The text [`dump_source_strings`] writes to `VECTORCRAFT_I18N_DUMP_MESSAGES`.
fn message_dump() -> String {
reported_messages().iter().map(|m| format!("{m}\n")).collect()
}
/// The translators' message dump lists every message the untranslated report checks, the
/// phrases a parameter schema's error builds included.
#[test]
fn message_dump_lists_the_reported_messages() {
let dump = message_dump();
let lines: std::collections::BTreeSet<&str> = dump.lines().collect();
for phrase in SCHEMA_PHRASES {
assert!(lines.contains(phrase), "the dump skips {phrase:?}");
}
assert!(lines.contains("the color book is cut short"));
}
fn cs() -> Lang {
Lang::from_code("cs").expect("cs registered")
}
@@ -1640,7 +1658,7 @@ fn untranslated_report() {
undo.extend(liquify.iter().filter_map(|k| vectorcraft_tools::distort::liquify::LiquifyKind::parse(k)).map(|k| format!("{} Tool", k.label())));
assert_eq!(scan.formatted.iter().collect::<Vec<_>>(), ["{} Tool"], "step names built with format! (make them with Session::edit_named)");
assert!(scan.templates.len() >= 3, "scan found only the templates {:?}", scan.templates);
let messages = message_literals();
let messages = reported_messages();
assert!(messages.len() > 300, "scan found only {} messages", messages.len());
let (swatches, groups) = vectorcraft_color::default_swatches(vectorcraft_color::cms::Model::Rgb);
// The greys' `K=` values read the same in any language.
@@ -1741,6 +1759,36 @@ fn untranslated_report() {
println!("{out}");
}
/// The status and error messages [`untranslated_report`] checks: the message literals of
/// [`MESSAGE_CRATES`] and the phrases a parameter schema's error builds at run time
/// ([`SCHEMA_PHRASES`]), which no literal holds.
fn reported_messages() -> std::collections::BTreeSet<String> {
let mut messages = message_literals();
messages.extend(SCHEMA_PHRASES.iter().map(|p| p.to_string()));
messages
}
/// The untranslated report checks the messages of the effects and of the crates whose errors the
/// engine and the effects pass on, and the phrases a parameter schema's error builds.
#[test]
fn untranslated_report_checks_every_message_crate_and_schema_phrase() {
let reported = reported_messages();
let passed_on = [
("effects", "the SVG filter has no primitives"),
("color", "not a swatch library (.vcswatches or .gpl)"),
("render", "invalid scale {scale}"),
("three-d", "3D effects require one to ten lights"),
("pathops", "the shapes are too degenerate to combine"),
];
for (krate, m) in passed_on {
assert!(message_literals_in(&[krate]).contains(m), "{krate}: {m}");
assert!(reported.contains(m), "the report skips {krate}: {m}");
}
for phrase in SCHEMA_PHRASES {
assert!(reported.contains(*phrase), "the report skips the schema phrase {phrase:?}");
}
}
/// The names [`MENU_KEEP_AS_IS`] lists are menu labels, and no catalog that keeps them in English
/// translates them.
#[test]
@@ -2723,6 +2771,84 @@ fn f(i: &mut Interp, interp: &mut Interp) -> JsResult<Value> {
assert_eq!(found, ["{what}: the object is not a File or a Folder", "File.seek: the mode must be 0, 1 or 2", "the path has an empty step"]);
}
/// The scan reads the message a `.map_err` closure returns, a literal, a `format!` string or a
/// constant, whatever the closure's parameter, from each branch of an `if` and each arm of a
/// `match`, and given to a variant of an enum whose name ends in `Fail`, and not a closure that
/// passes the error on, a `json!` value's keys, nor the steps of a script result's path
/// ([`NOT_MESSAGES`]).
#[test]
fn message_scan_reads_map_err_closures() {
let code = r#"
fn f(text: &str, n: usize) -> Result<u32, String> {
let doc = parse(text).map_err(|e| format!("the filter isn't valid XML: {e}"))?;
let a = at(doc).map_err(|place| format!("[{i}]{place}"))?;
let b = at(doc).map_err(|place| format!(".{k}{place}"))?;
let c = at(doc).map_err(|e| format!("{name}: {e}"))?;
let n = u32::try_from(n).map_err(|_| "too many blocks".to_string())?;
let m = u16::try_from(n).map_err(move |(a, b)| LIMIT.into())?;
let k = read(doc).map_err(|e| e.to_string())?;
let j = read(doc).map_err(|e| bad(C, e))?;
let i = read(doc).map_err(|e| if e == "{x}" { CUT_SHORT.into() } else { e })?;
let h = read(doc).map_err(|e| match e {
Error::Io(_) => "the file can't be read".to_string(),
other => fail(json!({"objects": [other.to_string()]})),
})?;
let g = i32::try_from(n).map_err(|_| CompileFail::Syntax("the pattern is too large".into()))?;
let f = read(doc).map_err(|e| {
self.published = None;
format!("the clipboard can't be read: {e}")
})?;
Ok(n)
}
"#;
let consts =
[("LIMIT", "the name is too long"), ("CUT_SHORT", "the book is cut short")].map(|(k, v)| (k.to_string(), vec![v.to_string()])).into();
let want = [
"the pattern is too large",
"the filter isn't valid XML: {e}",
"{name}: {e}",
"too many blocks",
"the name is too long",
"the book is cut short",
"the file can't be read",
"the clipboard can't be read: {e}",
];
assert_eq!(source_messages(code, &[], &consts), want);
assert!(message_literals_in(&["color"]).contains("the color book is cut short"));
assert!(message_literals_in(&["color"]).contains("not a swatch library: {e}"));
assert!(message_literals_in(&["js"]).contains("regular expression too large"));
assert!(message_literals_in(&["effects"]).contains("the SVG filter isn't valid XML: {e}"));
}
/// 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]
fn message_scan_reads_named_map_err_handlers() {
let code = r#"
fn encode(img: &Image) -> Result<Vec<u8>, String> {
let fail = |e: gif::EncodingError| format!("GIF encoding failed: {e}");
let gone = move |_| GONE.to_string();
let size = if img.is_empty() { WRONG.into() } else { 0 };
let mut enc = Encoder::new(img).map_err(fail)?;
enc.write(img).map_err(fail)?;
enc.check().map_err(gone)?;
enc.close().map_err(unreadable)?;
enc.into_inner().map_err(Error::Io)
}
fn unreadable(e: impl std::fmt::Display) -> String {
let e = e.to_string();
format!("the file can't be read: {e}")
}
"#;
let consts = [("GONE", "the encoder is gone"), ("WRONG", "the image is wrong")].map(|(k, v)| (k.to_string(), vec![v.to_string()])).into();
let want = ["GIF encoding failed: {e}", "the encoder is gone", "the file can't be read: {e}"];
assert_eq!(source_messages(code, &[], &consts), want);
let render = message_literals_in(&["render"]);
assert!(render.contains("GIF encoding failed: {e}") && render.contains("JPEG encoding failed: {e}"));
assert!(message_literals_in(&["engine"]).contains("Data Recovery can't keep copies in {path}: {e}"));
}
/// The scan stops at a test module whose `cfg` is `test` or `all(test, …)`, and reads on past a
/// declaration of a test file and a module that is not only for tests.
#[test]
@@ -3911,8 +4037,13 @@ const COMPLETE_MESSAGES: &[&str] = &[
"nl",
];
/// Crates whose error and status messages reach the status bar.
const MESSAGE_CRATES: &[&str] = &["ui-egui", "engine", "doc", "format", "svg", "pdf", "eps", "text", "plugins", "metafile", "cad", "trace", "js"];
/// Crates whose error and status messages reach the status bar, the crates whose errors the
/// engine and the effects pass on included (effects, swatch libraries, raster sizes and encoders,
/// 3D solids, path operations).
const MESSAGE_CRATES: &[&str] = &[
"ui-egui", "engine", "doc", "format", "svg", "pdf", "eps", "text", "plugins", "metafile", "cad", "trace", "js", "effects", "color", "render",
"three-d", "pathops",
];
/// Where a message literal starts: a status, an error value, a `thiserror` message.
const MESSAGE_MARKERS: &[&str] = &[".status(", "ui.status = ", "status = ", "Other(", "Err(", "ok_or(", "ok_or_else(|| ", "#[error("];
@@ -3957,9 +4088,10 @@ const NAME_VARIANTS: &[&str] = &["UnknownCommand", "Ps"];
/// `EngineError::Disabled(command id, reason)`.
const LATER_MESSAGE_VARIANTS: &[(&str, usize)] = &[("Disabled", 1)];
/// Messages that are signals, not text for people, and the name of a plug-in export that an
/// error message holds (`vc_manifest points outside memory`).
const NOT_MESSAGES: &[&str] = &["quit", "cancelled", "vc_manifest"];
/// Messages that are signals, not text for people, the name of a plug-in export that an error
/// message holds (`vc_manifest points outside memory`), and the steps of the path to a script
/// result's part that an error message holds (`vc.run: the result{place} is too large for a script`).
const NOT_MESSAGES: &[&str] = &["quit", "cancelled", "vc_manifest", "[{i}]{place}", ".{k}{place}"];
/// Every status and error message literal in [`MESSAGE_CRATES`] (test modules aside), as catalog
/// templates: `{}` becomes `{_1}`, `{_2}` … and format specs are dropped (`{n:?}` → `{n}`).
@@ -4077,8 +4209,11 @@ fn named_const<'a>(rest: &str, consts: &'a std::collections::BTreeMap<String, Ve
/// The message literals in `code` outside its comments, as catalog templates (see
/// [`message_literals`]): the literal after each of [`MESSAGE_MARKERS`], the message argument of an
/// error enum's variant (the first, as in `PsError::Limit(…)` and `Error::Manifest(…)`, or the one
/// error enum's variant, an enum whose name ends in `Error` or `Fail` (the first argument, as in
/// `PsError::Limit(…)`, `Error::Manifest(…)` and `CompileFail::Syntax(…)`, or the one
/// [`LATER_MESSAGE_VARIANTS`] gives; not [`NAME_VARIANTS`]),
/// the messages a `.map_err` closure returns (`.map_err(|e| format!("…: {e}"))`, see
/// [`closure_returns`]) or the handler a `.map_err(name)` names returns (see [`handler_returns`]),
/// and the message argument of each call in `helpers` (a call and the number of arguments before
/// its message), a literal, a `format!` string or the name of one of `consts` (see
/// [`str_consts`]), each one with or without a `&` before it. A key's name alone (`` `tint` ``)
@@ -4086,20 +4221,34 @@ fn named_const<'a>(rest: &str, consts: &'a std::collections::BTreeMap<String, Ve
fn source_messages(code: &str, helpers: &[(&str, usize)], consts: &std::collections::BTreeMap<String, Vec<String>>) -> Vec<String> {
let code = &without_comments(code);
let after_markers = MESSAGE_MARKERS.iter().flat_map(|marker| code.match_indices(marker).map(|(at, _)| &code[at + marker.len()..]));
let in_variants = code.match_indices("Error::").filter_map(|(at, m)| {
let in_variants = ["Error::", "Fail::"].into_iter().flat_map(|enum_end| code.match_indices(enum_end)).filter_map(|(at, m)| {
let rest = &code[at + m.len()..];
let (variant, args) = rest.split_at(rest.find(|c: char| !c.is_ascii_alphanumeric() && c != '_').unwrap_or(rest.len()));
let named = variant.starts_with(|c: char| c.is_ascii_uppercase()) && !NAME_VARIANTS.contains(&variant);
let before = LATER_MESSAGE_VARIANTS.iter().find(|(v, _)| *v == variant).map_or(0, |&(_, n)| n);
if named { skip_args(args.strip_prefix('(')?, before) } else { None }
});
let in_map_err = code.match_indices(".map_err(").flat_map(|(at, m)| {
let rest = code[at + m.len()..].trim_start();
let params = rest.strip_prefix("move").map_or(rest, str::trim_start).strip_prefix('|');
params.and_then(|p| p.find('|').map(|end| &p[end + 1..])).map(closure_returns).unwrap_or_default()
});
let mut handlers = vec![];
for (at, m) in code.match_indices(".map_err(") {
let rest = &code[at + m.len()..];
let name = &rest[..rest.find(|c: char| !c.is_ascii_alphanumeric() && c != '_').unwrap_or(rest.len())];
if name.starts_with(|c: char| c.is_ascii_lowercase()) && rest[name.len()..].starts_with(')') && !handlers.contains(&name) {
handlers.push(name);
}
}
let in_handlers = handlers.into_iter().flat_map(|name| handler_returns(code, name));
let in_helpers = helpers.iter().flat_map(|&(call, before)| {
code.match_indices(call)
.filter(|&(at, _)| call.starts_with('.') || !code[..at].ends_with(|c: char| c.is_alphanumeric() || c == '_' || c == '.'))
.filter_map(move |(at, _)| skip_args(&code[at + call.len()..], before))
});
let mut out = vec![];
for rest in after_markers.chain(in_variants).chain(in_helpers) {
for rest in after_markers.chain(in_variants).chain(in_map_err).chain(in_handlers).chain(in_helpers) {
let rest = rest.trim_start();
let rest = rest.strip_prefix('&').map_or(rest, str::trim_start);
let rest = rest.strip_prefix("format!(").map_or(rest, str::trim_start);
@@ -4150,6 +4299,94 @@ fn skip_args(args: &str, n: usize) -> Option<&str> {
None
}
/// Where each value the error handler `name` of a `.map_err(name)` in `code` can return starts:
/// the closure the file binds to that name (`let fail = |e| format!("…: {e}");`, up to its `;`)
/// or the body of the function of that name (`fn unreadable(e: …) -> String { … }`), read as
/// [`closure_returns`] reads a closure.
fn handler_returns<'a>(code: &'a str, name: &str) -> Vec<&'a str> {
let (bound, declared) = (format!("let {name} = "), format!("fn {name}("));
let mut out = vec![];
for (at, m) in code.match_indices(bound.as_str()).chain(code.match_indices(declared.as_str())) {
if code[..at].ends_with(|c: char| c.is_alphanumeric() || c == '_') {
continue;
}
let rest = &code[at + m.len()..];
if m == bound {
let rest = rest.strip_prefix("move").map_or(rest, str::trim_start);
if let Some(body) = rest.strip_prefix('|').and_then(|p| p.find('|').map(|end| &p[end + 1..])) {
out.extend(closure_returns(statement(body)));
}
} else if let Some(open) = rest.find('{') {
out.extend(closure_returns(&rest[open + 1..]));
}
}
out
}
/// The statement `code` starts with, up to its `;` or the bracket that closes the block it is in.
fn statement(code: &str) -> &str {
let (mut depth, mut chars) = (0usize, code.char_indices());
while let Some((at, c)) = chars.next() {
match c {
'(' | '[' | '{' => depth += 1,
')' | ']' | '}' => match depth.checked_sub(1) {
Some(d) => depth = d,
None => return &code[..at],
},
';' if depth == 0 => return &code[..at],
'"' => loop {
match chars.next() {
Some((_, '\\')) => {
chars.next();
}
Some((_, '"')) | None => break,
_ => {}
}
},
_ => {}
}
}
code
}
/// 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.
fn closure_returns(body: &str) -> Vec<&str> {
let mut out = vec![body];
let (mut depth, mut chars) = (0usize, body.char_indices());
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..]);
}
}
')' | ']' | '}' => 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..]),
'"' => loop {
match chars.next() {
Some((_, '\\')) => {
chars.next();
}
Some((_, '"')) | None => break,
_ => {}
}
},
_ => {}
}
}
out
}
/// Source up to its inline test module (`#[cfg(test)] mod tests {`, or a `cfg(all(test, …))` one);
/// declarations of test files (`#[cfg(test)] mod tests_x;`) don't end it.
fn without_test_module(text: &str) -> &str {
+1
View File
@@ -5828,6 +5828,7 @@ theme Appearance Görünüm
@msg no such color öyle bir renk yok
@msg {_1} cannot be used on Windows {_1} Windows'ta kullanılamaz
@msg more than one action is named “{_1}” birden fazla eylemin adı “{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set “{_1}” eylemi {_2} klasör tercihini ayarlıyor; seti kaydetmek için o adımı silin
@msg no symbol named `{n}` `{n}` adında bir sembol yok
Artboard Options: edit with the Artboard tool Çalışma Yüzeyi Seçenekleri: Çalışma Yüzeyi aracıyla düzenleme
@msg this is a PostScript file (an .ai saved in an older format or without PDF compatibility, or an EPS file), which can't be opened yet: save it as PDF, PDF-compatible .ai or SVG bu henüz açılamayan bir PostScript dosyasıdır (eski bir formatta kaydedilmiş veya PDF uyumluluğu olmayan bir .ai veya bir EPS dosyası): PDF, PDF uyumlu .ai veya SVG olarak kaydedin
Can't render this file because it contains an unexpected character in line 5 and column 25.
+1
View File
@@ -5804,6 +5804,7 @@ lighting Light Світло
@msg no such color такого кольору немає
@msg {_1} cannot be used on Windows Сполучення {_1} не можна використовувати у Windows
@msg more than one action is named “{_1}” кілька дій мають назву «{_1}»
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set дія «{_1}» задає параметр папки {_2}; видаліть цей крок, щоб зберегти набір
@msg no symbol named `{n}` немає символу з назвою `{n}`
Smudge Stick… Розтушовування…
Smudge Stick Розтушовування
Can't render this file because it is too large.
+1
View File
@@ -5805,6 +5805,7 @@ theme Appearance Giao diện
@msg no such color không có màu như vậy
@msg {_1} cannot be used on Windows không thể dùng {_1} trên Windows
@msg more than one action is named “{_1}” có nhiều hành động tên là “{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set hành động “{_1}” đặt tùy chọn thư mục {_2}; hãy xóa bước đó để lưu bộ
@msg no symbol named `{n}` không có biểu tượng nào tên `{n}`
Smudge Stick… Bút chì xóa mờ…
Smudge Stick Bút chì xóa mờ
Can't render this file because it contains an unexpected character in line 204 and column 5.
+1
View File
@@ -6034,6 +6034,7 @@ lighting Light 光源
@msg no such color 没有此颜色
@msg {_1} cannot be used on Windows {_1} 在 Windows 上不能使用
@msg more than one action is named “{_1}” 有多个动作名为“{_1}”
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set 动作“{_1}”设置了文件夹首选项 {_2};请删除该步骤后再存储动作组
@msg no symbol named `{n}` 没有名为 `{n}` 的符号
Smudge Stick… 涂抹棒…
Smudge Stick 涂抹棒
Can't render this file because it contains an unexpected character in line 2 and column 73.
+1
View File
@@ -5868,6 +5868,7 @@ lighting Light 光源
@msg no such color 沒有這個顏色
@msg {_1} cannot be used on Windows {_1} 無法在 Windows 上使用
@msg more than one action is named “{_1}” 有多個動作名為「{_1}」
@msg the action “{_1}” sets the folder preference {_2}; delete that step to save the set 動作「{_1}」設定了資料夾偏好設定 {_2};請刪除該步驟後再儲存動作組
@msg no symbol named `{n}` 沒有名為 `{n}` 的符號
Smudge Stick… 塗抹棒…
Smudge Stick 塗抹棒
Can't render this file because it contains an unexpected character in line 6 and column 47.
+1 -1
View File
@@ -1550,7 +1550,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
crate::panels::actions::SAVE_SET,
"Save Actions…",
"",
"{set?: index, id?, path?} write the Actions panel's set at set (0 is the top set; default: the current set) with its actions to an action set file (.vcactions) at path, else a picked file named after the set (the web downloads it). id holds the panel's own set id, which its menu passes: the set with this id is saved wherever it is now, and set is not read. A set over 8 MiB as a file, with more than 1,000 actions or with an action of more than 10,000 steps is not written; the panel menu's Save Actions… → {path}",
"{set?: index, id?, path?} write the Actions panel's set at set (0 is the top set; default: the current set) with its actions to an action set file (.vcactions) at path, else a picked file named after the set (the web downloads it). id holds the panel's own set id, which its menu passes: the set with this id is saved wherever it is now, and set is not read. A set over 8 MiB as a file, with more than 1,000 actions or with an action of more than 10,000 steps is not written, nor is a set with a prefs.set step (also in a batch step) that sets a folder preference to a folder (an error names the action and the preference; an empty folder and the scratch disk choices Startup and None save); the panel menu's Save Actions… → {path}",
),
(
crate::panels::actions::LOAD_SET,
+42
View File
@@ -3512,6 +3512,48 @@ mod tests {
}
}
/// `ui.actionSet.save` refuses a set with a step that sets a folder preference to a folder, as
/// `{key, value}`, in `values` or in a batch step's commands at any depth, with an error that names
/// the action and the preference, and writes no file. An empty folder, a scratch disk choice and
/// other preferences save.
#[test]
fn save_actions_refuses_a_step_that_sets_a_folder_preference() {
let mut app = app_with_sets();
let files = with_files(&mut app, "/sets/x.vcactions");
let step = |command: &str, params: Value| (command.to_string(), params);
let nested = json!({"commands": [{"command": "command.batch", "params": {"commands": [
{"command": "prefs.set", "params": {"values": {"fontsFolder": "fonts"}}},
]}}]});
for (steps, key) in [
(vec![step("prefs.set", json!({"key": "scratchPrimary", "value": "scratch"}))], "scratchPrimary"),
(vec![step("prefs.set", json!({"values": {"uiAccent": "green", "templatesFolder": "/Users/me/Templates"}}))], "templatesFolder"),
(
vec![
step("object.move", json!({"dx": 1, "dy": 0})),
step(
"command.batch",
json!({"commands": [{"command": "prefs.set", "params": {"key": "scratchSecondary", "value": " /Volumes/Fast "}}]}),
),
],
"scratchSecondary",
),
(vec![step("command.batch", nested)], "fontsFolder"),
] {
app.ui.action_sets[1] = ActionSet::new("Other", vec![Action::new("Scratch", steps)]);
let e = app.run(SAVE_SET, json!({"set": 1, "path": "/sets/x.vcactions"})).unwrap_err();
assert_eq!(e, format!("the action “Scratch” sets the folder preference {key}; delete that step to save the set"));
assert!(files.borrow().is_empty(), "no file is written for {key}");
}
let kept = vec![
step("prefs.set", json!({"values": {"scratchPrimary": "None", "scratchSecondary": " Startup ", "fontsFolder": "", "uiAccent": "green"}})),
step("prefs.set", json!({"key": "pluginsFolder", "value": ""})),
step("x.y", json!({"key": "fontsFolder", "value": "fonts"})),
];
app.ui.action_sets[1] = ActionSet::new("Other", vec![Action::new("Scratch", kept)]);
assert_eq!(app.run(SAVE_SET, json!({"set": 1, "path": "/sets/x.vcactions"})).unwrap(), json!({"path": "/sets/x.vcactions"}));
assert!(files.borrow().contains_key("/sets/x.vcactions"));
}
/// A file that is not an action set file, or is too large, is refused with a message, and no
/// set is added.
#[test]
+32 -1
View File
@@ -169,6 +169,30 @@ fn ui_steps_in<'a>(command: &str, params: &'a Value) -> Vec<&'a Value> {
.collect()
}
/// A folder preference whose value in a step running `command` with `params` names a folder
/// ([`vectorcraft_engine::cmd::prefscmds::names_a_folder`]): in a `prefs.set` step, given as
/// `{key, value}` or in `values`, and in a `command.batch` step, in any of its commands at any depth.
/// Every such value is found, also one under `values` that `{key, value}` replaces when the step runs,
/// because [`write_set`] writes the params as they are.
fn folder_pref_in(command: &str, params: &Value) -> Option<String> {
use vectorcraft_engine::cmd::prefscmds::names_a_folder;
match command {
"prefs.set" => {
let names = |key: &str, value: &Value| value.as_str().is_some_and(|v| names_a_folder(key, v));
let pair = params.get("key").and_then(Value::as_str).filter(|key| params.get("value").is_some_and(|v| names(key, v)));
let values = params.get("values").and_then(Value::as_object).into_iter().flatten();
pair.map(str::to_string).or_else(|| values.filter(|(key, v)| names(key, v)).map(|(key, _)| key.clone()).next())
}
"command.batch" => {
let mut steps = params.get("commands").and_then(Value::as_array).into_iter().flatten();
steps.find_map(|step| {
folder_pref_in(step.get("command").and_then(Value::as_str).unwrap_or_default(), step.get("params").unwrap_or(&Value::Null))
})
}
_ => None,
}
}
/// `set` as the text of an action set file.
pub fn write_set(set: &ActionSet) -> String {
let actions = set
@@ -281,7 +305,9 @@ pub(super) fn set_file_stem(name: &str) -> String {
/// the set (the web downloads it) → `{path}`. `id` is the panel's own set id ([`ActionSet::id`]),
/// which the panel menu passes: the set with this id is saved wherever it is when the file dialog
/// answers, and `set` is not read. A set that [`read_set`] would refuse (larger than 8 MiB as a
/// file, more than 1,000 actions, an action with more than 10,000 steps) is not written.
/// file, more than 1,000 actions, an action with more than 10,000 steps) is not written, nor is a set
/// with a step that sets a folder preference to a folder ([`folder_pref_in`]), which names a folder
/// on this computer: the error names the action and the preference.
pub fn save_set(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
let len = app.ui.action_sets.len();
let set = match (p.get("id"), p.get("set")) {
@@ -292,6 +318,11 @@ pub fn save_set(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
(_, Some(v)) => v.as_u64().and_then(|i| usize::try_from(i).ok()).filter(|&i| i < len).ok_or("no such action set")?,
};
let Some(s) = app.ui.action_sets.get(set) else { return Err("no such action set".into()) };
let folder =
s.actions.iter().find_map(|a| a.steps.iter().find_map(|(command, params)| folder_pref_in(command, params)).map(|key| (&a.name, key)));
if let Some((action, key)) = folder {
return Err(format!("the action “{}” sets the folder preference {}; delete that step to save the set", action, key));
}
let text = write_set(s);
// What Save Actions… writes, Load Actions… reads back.
read_set(&text, "")?;
+11 -1
View File
@@ -69,6 +69,16 @@ pub(crate) fn document_brushes(st: &DocState) -> Rc<Vec<Shown>> {
MEMO.with(|m| m.borrow_mut().get(&st.doc, st.revision, || vectorcraft_brush::library(&st.doc).iter().map(|b| Shown::of(&st.doc, b)).collect()))
}
/// The brushes of `shown` by name: of two with one name, the first, the one a stroke that names
/// it draws with and `brush.get` gives.
fn by_name(shown: &[Shown]) -> HashMap<&str, &Shown> {
let mut map = HashMap::new();
for b in shown {
map.entry(b.name.as_str()).or_insert(b);
}
map
}
/// The cache key of the stroke preview of brush definition `def` in `doc` (`art`: its art): the
/// definition and every resource of `doc` the art uses ([`art_resources`]: patterns with their
/// options, symbols, swatches and colour groups, gradients, images, styles…), so the preview
@@ -298,7 +308,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
// definitions and preview keys are the document version's, worked out once.
let doc = app.session.active().map(|d| d.doc.clone());
let memo = app.session.active().map(document_brushes).unwrap_or_default();
let defs: HashMap<&str, &Shown> = memo.iter().map(|b| (b.name.as_str(), b)).collect();
let defs = by_name(&memo);
let mut clicked: Option<(String, egui::Modifiers)> = None;
let mut options: Option<String> = None;
let mut moved: Option<Value> = None;
@@ -821,3 +821,36 @@ fn previews_follow_the_swatches_images_and_pattern_options_their_art_uses() {
assert_eq!(change(&mut app, what, f), (brushes, symbols, what.to_string()));
}
}
/// Of two brushes with one name, the row of that name previews and drags the first, the one
/// `brush.get` gives and a stroke that names it draws with. Reading the library numbers the second
/// ("Twin 2"), so it gets a row of its own.
#[test]
fn rows_of_two_brushes_with_one_name_show_the_first() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
let mut twins: Vec<Brush> = Vec::new();
app.session
.edit("Brushes", |d, _| {
let mut lib = vectorcraft_brush::library(d);
let kinds: Vec<_> = ["Charcoal", "Dots"].iter().map(|n| lib.iter().find(|b| b.name == *n).unwrap().kind.clone()).collect();
twins = kinds.into_iter().map(|kind| Brush { name: "Twin".into(), kind }).collect();
lib.extend(twins.iter().cloned());
vectorcraft_brush::store(d, &lib);
Ok(())
})
.unwrap();
let rows: Vec<(String, String)> = brushes(&mut app).0.into_iter().filter(|b| b.0.starts_with("Twin")).map(|b| (b.0, b.1)).collect();
assert_eq!(rows, [("Twin".to_string(), "art".to_string()), ("Twin 2".to_string(), "scatter".to_string())], "the panel lists both");
let got = app.run("brush.get", json!({"name": "Twin"})).unwrap();
let memo = document_brushes(app.session.active().unwrap());
let shown = by_name(&memo)["Twin"];
assert_eq!(shown.ty, "art");
assert_eq!(shown.def, got, "the row shows and drags what brush.get gives");
// Rows of one name that reach the panel unnumbered still show the first.
let st = app.session.active().unwrap();
let raw: Vec<Shown> = twins.iter().map(|b| Shown::of(&st.doc, b)).collect();
let shown = by_name(&raw)["Twin"];
assert_eq!(shown.ty, "art");
assert_eq!(shown.def, got, "the first of two rows of one name is the one shown");
}
+56
View File
@@ -945,6 +945,62 @@ fn ui_inspect_leaves_out_relative_paths_in_recorded_steps() {
let _ = std::fs::remove_dir_all(base);
}
/// `ui.inspect` leaves out of a recorded `prefs.set` step the value of a folder preference outside the
/// read root, given as `{key, value}` or in `values`, also in a batch step's commands at any depth: a
/// bare name or a subfolder (in the working folder, outside the root), a path with spaces around it and
/// a `file:` URL. A folder inside the root, an empty value, a scratch disk choice, other preferences and
/// another command's params stay, and the UI state is not changed.
#[test]
fn ui_inspect_leaves_out_folder_preferences_in_recorded_prefs_steps() {
let (mut app, tx, base) = confined("inspect-prefs-steps");
let (inside, outside) = (s(base.join("in")), s(base.join("outside")));
let url = if outside.starts_with('/') { format!("file://{outside}") } else { format!("file:///{}", outside.replace('\\', "/")) };
let folders = ["fontsFolder", "pluginsFolder", "scratchPrimary", "scratchSecondary", "recoveryFolder", "templatesFolder"];
let mut steps: Vec<Value> = folders.iter().map(|k| json!(["prefs.set", {"key": k, "value": "scratch"}])).collect();
steps.push(json!(["prefs.set", {"values": folders.iter().map(|k| (k.to_string(), json!("tmp/scratch"))).collect::<serde_json::Map<_, _>>()}]));
steps.push(json!(["prefs.set", {"values": {
"scratchPrimary": format!(" {outside} "), "fontsFolder": url, "pluginsFolder": format!(" {url}"), "recoveryFolder": "Startup",
"templatesFolder": inside, "scratchSecondary": " None ", "uiAccent": "green",
}}]));
steps.push(json!(["prefs.set", {"key": "scratchPrimary", "value": "Startup"}]));
steps.push(json!(["prefs.set", {"key": "recoveryFolder", "value": ""}]));
steps.push(json!(["prefs.set", {"key": "fontsFolder", "value": inside}]));
let batch = |commands: Value| json!({"commands": commands});
let inner = batch(json!([{"command": "prefs.set", "params": {"values": {"scratchSecondary": "tmp/scratch", "uiAccent": "red"}}}]));
steps.push(json!([
"command.batch",
batch(json!([
{"command": "prefs.set", "params": {"key": "scratchPrimary", "value": "scratch"}},
{"command": "command.batch", "params": inner},
]))
]));
steps.push(json!(["x.y", {"key": "scratchPrimary", "value": "scratch"}]));
let set: crate::panels::actions::ActionSet =
serde_json::from_value(json!({"name": "set", "actions": [{"name": "prefs", "steps": steps}]})).unwrap();
app.ui.action_sets = vec![set];
let r = request(&mut app, &tx, "ui.inspect", json!({}));
let shown = &r["result"]["ui"]["action_sets"][0]["actions"][0]["steps"];
let mut want: Vec<Value> = folders.iter().map(|k| json!(["prefs.set", {"key": k}])).collect();
want.push(json!(["prefs.set", {"values": {}}]));
want.push(json!(["prefs.set", {"values": {"templatesFolder": inside, "scratchSecondary": " None ", "uiAccent": "green"}}]));
want.push(json!(["prefs.set", {"key": "scratchPrimary", "value": "Startup"}]));
want.push(json!(["prefs.set", {"key": "recoveryFolder", "value": ""}]));
want.push(json!(["prefs.set", {"key": "fontsFolder", "value": inside}]));
let inner = batch(json!([{"command": "prefs.set", "params": {"values": {"uiAccent": "red"}}}]));
want.push(json!([
"command.batch",
batch(json!([
{"command": "prefs.set", "params": {"key": "scratchPrimary"}},
{"command": "command.batch", "params": inner},
]))
]));
want.push(json!(["x.y", {"key": "scratchPrimary", "value": "scratch"}]));
assert_eq!(shown, &json!(want), "{r}");
assert!(!r.to_string().contains("tmp/scratch") && !r.to_string().contains(&outside.replace('\\', "\\\\")), "{r}");
assert_eq!(app.ui.action_sets[0].actions[0].steps[0].1, json!({"key": "fontsFolder", "value": "scratch"}), "the UI state is not changed");
let _ = std::fs::remove_dir_all(base);
}
/// Two libraries loaded from outside the read root under the same file name, only the second of them
/// in a library panel: `ui.inspect` and `swatch.library.list` show the second under the same id, and
/// that id finds it.
+10 -2
View File
@@ -80,6 +80,14 @@ fn in_screen_mode(ctx: &egui::Context, mode: u8) -> VectorcraftApp {
app
}
/// A point on the empty canvas, low enough to miss the Contextual Task Bar under the selection
/// (on a narrow canvas its actions wrap onto more rows and can reach the canvas's center).
fn open_canvas_point(app: &VectorcraftApp, ctx: &egui::Context) -> egui::Pos2 {
let p = app.canvas_rect.unwrap().lerp_inside(egui::vec2(0.5, 0.85));
assert!(crate::canvas::task_bar_rect(ctx).is_none_or(|bar| !bar.expand(40.0).contains(p)), "the task bar covers {p:?}");
p
}
fn begin_tools_move(app: &mut VectorcraftApp, ctx: &egui::Context) -> (Option<[f32; 2]>, egui::Pos2) {
app.run("window.panel.float", json!({"panel": "tools", "x": 120, "y": 140})).unwrap();
frame(app, ctx, vec![]);
@@ -241,7 +249,7 @@ fn navigation_drag_keeps_screen_mode(kind: &str) {
_ => panic!("unknown navigation drag"),
};
frame(&mut app, &ctx, vec![]);
let start = app.canvas_rect.unwrap().center();
let start = open_canvas_point(&app, &ctx);
let end = start + egui::vec2(35.0, 20.0);
let pointer = |pos, pressed| egui::Event::PointerButton { pos, button, pressed, modifiers: Default::default() };
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(start), pointer(start, true)]);
@@ -551,7 +559,7 @@ fn held_escape_that_cancels_a_dialog_or_leaves_presentation_skips_a_command_boun
fn a_popup_takes_escape_before_full_screen_exits() {
let ctx = egui::Context::default();
let mut app = in_screen_mode(&ctx, 2);
let pos = app.canvas_rect.unwrap().center();
let pos = open_canvas_point(&app, &ctx);
let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Secondary, pressed, modifiers: Default::default() };
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(pos), button(true)]);
frame(&mut app, &ctx, vec![button(false)]);
+94
View File
@@ -767,6 +767,100 @@ fn selected_types_font_controls_take_a_second_row_on_a_narrow_canvas() {
assert!(canvas.contains_rect(r) && r.height() < 60.0, "no font controls on a 160 px screen: {r:?} in {canvas:?}");
}
/// The labels drawn inside the task bar after `frames` frames on a screen `size` points in `ctx`,
/// with the bar's rect and the canvas's.
fn bar_texts_on_screen(app: &mut VectorcraftApp, ctx: &egui::Context, size: egui::Vec2, frames: usize) -> (Vec<(String, Rect)>, Rect, Rect) {
let screen = Rect::from_min_size(Pos2::ZERO, size);
let mut texts = vec![];
for _ in 0..frames {
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), ..Default::default() }, |ui| canvas::show(app, ui));
out.textures_delta.clear();
texts = shapes_text(&out.shapes.iter().map(|c| c.shape.clone()).collect::<Vec<_>>());
}
let r = canvas::task_bar_rect(ctx).expect("the task bar shows");
(texts.into_iter().filter(|(_, t)| r.contains(t.center())).collect(), r, app.canvas_rect.expect("the canvas is laid out"))
}
/// On a canvas narrower than one row of the bar's actions, the actions wrap onto more rows, in
/// order, and the bar stays whole on the canvas, also on the first frame after the canvas narrows.
#[test]
fn a_task_bars_actions_wrap_on_a_narrow_canvas() {
let mut app = app();
app.run("tool.select", json!({"tool": "selection"})).unwrap();
let circle = id(app.run("path.create", json!({"d": "M100 300 A100 100 0 1 1 300 300 A100 100 0 1 1 100 300 Z"})).unwrap());
let t = id(app.run("text.createInPath", json!({"path": circle, "mode": "onPath", "text": "Round", "at": [90, 300]})).unwrap());
select(&mut app, &[t]);
let actions = ["Create Outlines", "Type on a Path Options", "Center on Top", "Center on Bottom", "Dynamic Text", "Duplicate"];
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let (texts, r, canvas) = bar_texts_on_screen(&mut app, &ctx, vec2(1800.0, 700.0), 3);
assert!(canvas.contains_rect(r) && r.height() < 60.0, "one row where it fits: {r:?} in {canvas:?}");
// The first frame after the canvas narrows, then once the bar settles.
for frames in [1, 3] {
let (texts, r, canvas) = bar_texts_on_screen(&mut app, &ctx, vec2(760.0, 700.0), frames);
assert!(canvas.contains_rect(r), "{frames} frames: {r:?} in {canvas:?}");
let ys: Vec<f32> = actions.iter().map(|label| at(&texts, label).y).collect();
assert!(ys.windows(2).all(|w| w[0] <= w[1]), "{frames} frames: the actions keep their order: {ys:?}");
assert!(ys[0] < ys[ys.len() - 1], "{frames} frames: the actions take more than one row: {texts:?}");
}
assert!(actions.iter().all(|label| has(&texts, label)), "{texts:?}");
}
/// On a canvas too narrow for an action's button, or too short for the rows the actions would
/// wrap onto, More Options lists those actions, and the chips take rows after the actions when they
/// don't fit beside the handle and More Options. Narrower than the handle and More Options, the bar
/// doesn't show.
#[test]
fn a_task_bar_action_wider_than_the_canvas_goes_in_more_options() {
let mut app = app();
app.run("tool.select", json!({"tool": "selection"})).unwrap();
let a = id(app.run("shape.rectangle", json!({"x": 40, "y": 40, "width": 120, "height": 100})).unwrap());
let b = id(app.run("shape.ellipse", json!({"x": 70, "y": 60, "width": 50, "height": 50})).unwrap());
select(&mut app, &[a, b]);
app.run("object.compoundPath.make", json!({})).unwrap();
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let (texts, r, canvas) = bar_texts_on_screen(&mut app, &ctx, vec2(160.0, 700.0), 3);
assert!(canvas.contains_rect(r), "{r:?} in {canvas:?}");
assert!(has(&texts, "Edit Path") && has(&texts, "Duplicate") && !has(&texts, "Release Compound Path"), "{texts:?}");
// More Options, after the frame's margin and the handle on the first row.
let more = r.min + vec2(9.0 + 4.0 + 6.0 + 15.0, 7.0 + 15.0);
let click = |app: &mut VectorcraftApp, p: Pos2| {
let press = |pressed| Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers: Default::default() };
let screen = Rect::from_min_size(Pos2::ZERO, vec2(160.0, 700.0));
let mut texts = vec![];
for events in [vec![Event::PointerMoved(p)], vec![press(true)], vec![press(false)], vec![]] {
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), events, ..Default::default() }, |ui| canvas::show(app, ui));
out.textures_delta.clear();
texts = shapes_text(&out.shapes.iter().map(|c| c.shape.clone()).collect::<Vec<_>>());
}
texts
};
let texts = click(&mut app, more);
// Menu items are drawn after a space for the check mark.
let item = |label: &str| texts.iter().find(|(t, _)| t.trim() == label).map(|(_, r)| r.center());
assert!(item("Hide Bar").is_some(), "More Options opens: {texts:?}");
let release = item("Release Compound Path").unwrap_or_else(|| panic!("More Options lists the action: {texts:?}"));
click(&mut app, release);
let st = app.session.active().unwrap();
assert_eq!(st.selection.objects.len(), 2, "the paths come apart, selected");
assert!(st.selection.objects.iter().all(|i| matches!(st.doc.node(*i).unwrap().kind, NodeKind::Path { .. })));
// On a canvas too short for the rows the actions would wrap onto, More Options lists them, in
// order: the bar keeps at most the first.
let (texts, r, canvas) = bar_texts_on_screen(&mut app, &ctx, vec2(160.0, 150.0), 3);
assert!(canvas.contains_rect(r), "{r:?} in {canvas:?}");
let shown = ["Group", "Unite", "Duplicate"].map(|label| has(&texts, label));
assert!(!shown[1] && !shown[2], "{texts:?}");
let screen = Rect::from_min_size(Pos2::ZERO, vec2(60.0, 700.0));
for _ in 0..3 {
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), ..Default::default() }, |ui| canvas::show(&mut app, ui));
out.textures_delta.clear();
}
assert!(canvas::task_bar_rect(&ctx).is_none(), "no room for the handle and More Options: no bar");
}
/// When the canvas narrows so far that the bar leaves its font controls out, the font family
/// field it drew before no longer takes the mouse wheel.
#[test]
+4 -1
View File
@@ -345,7 +345,10 @@ Tile Edge Color: Object → Pattern → Tile Edge Color… (`ui.tileEdgeColor`)
`patternTileEdgeColor` (`prefs.set`), the colour pattern editing mode draws the tile edge and the swatch bounds in.
A `color` with an alpha part (`#rrggbbaa` or `#rgba`) is an error, and the preference does not change.
Window title bar: on Windows and Linux the window has no OS decorations and the app bar is the title bar. Its
Window title bar: on Windows the window has no OS decorations and the app bar is the title bar. On Linux and the BSDs
the app bar is the title bar by default only on a Wayland session without server-side decorations, such as GNOME, in a
window not opened through XWayland. Elsewhere the desktop draws the frame and the app bar has no caption buttons,
unless VectorCraft Title Bar on Every Desktop or `VECTORCRAFT_TITLEBAR=app` turns the app frame on (see below). The
caption buttons (Minimize, Maximize/Restore, Close) are 46 pt each. By default all three sit at the bar's right end.
On Linux and the BSDs, when the desktop leaves the window's frame to the app (a Wayland session without server-side
decorations, such as GNOME), the window is not opened through XWayland and `VECTORCRAFT_TITLEBAR` is unset, they
+7 -3
View File
@@ -121,7 +121,7 @@ A file opened from the file manager (double-click, Open With, a drop on the exec
## Linux: Wayland and X11
On GNOME/Wayland, enable **Preferences › User Interface › System Title Bar** and restart to use winit's font-free Adwaita window controls (`wayland-csd-adwaita-notitle`); the existing custom title bar remains the Linux default. On X11, on a Wayland compositor that draws server-side decorations such as KDE Plasma, and in a window opened through XWayland, enable **Preferences › User Interface › VectorCraft Title Bar on Every Desktop** and restart to use the app bar as the title bar instead of the desktop's frame. `VECTORCRAFT_TITLEBAR=app`, `=system` or `=desktop` chooses the frame for one run and takes precedence over System Title Bar and VectorCraft Title Bar on Every Desktop. The variable is case-sensitive and surrounding spaces are ignored; any other value, such as `unknown`, is ignored and does not override System Title Bar.
On GNOME/Wayland, enable **Preferences › User Interface › System Title Bar** and restart to use winit's font-free Adwaita window controls (`wayland-csd-adwaita-notitle`); the app bar is the title bar by default only on a Wayland compositor that leaves the window's frame to the app, such as GNOME's, in a window not opened through XWayland (see the drop and pen items below). On X11, on a Wayland compositor that draws server-side decorations such as KDE Plasma, and in a window opened through XWayland, enable **Preferences › User Interface › VectorCraft Title Bar on Every Desktop** and restart to use the app bar as the title bar instead of the desktop's frame. `VECTORCRAFT_TITLEBAR=app`, `=system` or `=desktop` chooses the frame for one run and takes precedence over System Title Bar and VectorCraft Title Bar on Every Desktop. The variable is case-sensitive and surrounding spaces are ignored; any other value, such as `unknown`, is ignored and does not override System Title Bar.
The window runs natively on Wayland (eframe's `wayland` feature) and on X11. On machines with two GPUs it renders on the one the desktop runs on unless Preferences say otherwise; see [Desktop graphics processor](#desktop-graphics-processor) (#502). The system clipboard (`apps/vectorcraft/src/clipboard.rs`) is arboard with its `wayland-data-control` feature:
@@ -296,10 +296,14 @@ other `sv-*` locale resolve to it), Georgian (`ka`, complete; `ka-GE` and `ka_GE
`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). Czech, German, Greek, Spanish, French, Georgian, Hungarian, Italian, Japanese, Korean, Polish, Brazilian Portuguese, Russian, Simplified Chinese, Traditional Chinese, Swedish, Ukrainian, Vietnamese, Finnish, Turkish, Catalan and Dutch
translate status and error messages (`COMPLETE_MESSAGES` in `i18n::tests`); the untranslated report lists the
message literals the scan finds that one of them has no row for. The scan reads `Err("…")`, `Other(…)`,
message literals the scan finds, and the phrases a parameter schema's error builds at run time
(`SCHEMA_PHRASES`), that one of them has no row for. The scan covers the crates in `MESSAGE_CRATES`, the
effects and the crates whose errors the engine passes on included. It reads `Err("…")`, `Other(…)`,
`#[error(…)]` and `status(…)` messages, messages given to an error enum's variant (`PsError::Limit(…)`, the reason
in `EngineError::Disabled(id, …)`), to the engine's `bad(cmd, …)`, `err(…)` or `error(…)`, and to the PDF writer's
`bad(…)` or `failed(…)`, and skips calls inside comments
`bad(…)` or `failed(…)`, and the messages a `.map_err(|e| …)` closure returns (from each `if` branch,
`match` arm and statement of a block) or the handler a `.map_err(name)` names returns (a closure bound with `let name = |e| …;` or a
function `fn name(…)`), and skips calls inside comments
(`VECTORCRAFT_I18N_DUMP_MESSAGES=messages.txt cargo test -p vectorcraft-ui-egui dump_source_strings` lists them
all). A missing row shows the English message. Other languages show messages in English until they add `@msg`
rows.
+8 -1
View File
@@ -237,7 +237,14 @@ private editing data. VectorCraft:
from 0 to 9 leaves the mode as it was.
Legacy `.ai` placed EPS files in the version 7 form (`` ` `` … `~` with no `%AI5_BeginPlace`) are read like
other placed files without a preview: as the page's art in their box. Graphs (`%_Gs` … `%_GS`) come in as their
drawn art, as plain groups, paths and type, without their data or settings, with a note.
drawn art. A grouped column, stacked column, line or area graph also keeps its table, type, axes and settings
when every record has the shape and values the version 7 specification's appendix A gives
([the specification](https://13thmonkey.org/documentation/fonts/AI7FileFormat.pdf), printed pp. 109–112
and 146–158), its table holds at least one number, its art draws the plot's left and bottom edges, and each series'
group is tagged once and paints its marks with one fill and one stroke, which the graph keeps as that series'
paint; Graph Data then edits it. Other graphs (pie and scatter graphs, graphs with designs or
customizations, records of later versions) come in as plain groups, paths and type, with a note. Saving a graph to
`.ai`, in either form, writes its art without its data or settings, with a warning.
Legacy `.ai` patterns in the version 7 form (a list of `@` and `&` layers, `_ &` for the tile's background)
open as pattern swatches, with a fill's offset, scale, rotation, reflection and shear applied before its
matrix. Legacy `.ai` linked images in
+4 -4
View File
@@ -7,7 +7,7 @@ Per-language status of VectorCraft's interface. How the catalogs work and how to
[target-app-parity.md](target-app-parity.md).
**How it is measured:** rows with a translation in each `crates/ui-egui/src/i18n/<code>.tsv`, counted on
origin/main `01e165af`, except the rows that give a count date: those were counted on the `main` commit named in the row (the other dated rows on `main` at `cb0a7d9`, 2026-10-21; the Portuguese row on `main` at `d26dd933a`, 2026-10-31).
origin/main `01e165af`, except the rows that give a count date: those were counted on the `main` commit named in the row (the rows dated 2026-10-21 on `main` at `cb0a7d9`).
The reference is the French catalog, which was complete when counted: 3,416 interface
strings (menus, command labels, `tl!` literals: panels, dialogs, tooltips, Preferences) plus 604 `@msg` status and
error messages, 4,020 in all. A language's % is its rows over 4,020 (capped at 100% per part). A missing
@@ -32,10 +32,10 @@ Chinese by `imachus`). Only Georgian is recorded as reviewed by a native speaker
| Hindi | `hi` | 8,782 rows (2026-11-13): 3,014 `@msg`, 47 `@msgplural`, 41 `@plural`; no gaps in the untranslated report | menus, dialogs, tooltips and scanned messages; contributor-approved loanword terminology; agent wording pass | UI and document text shape with HarfRust; installed desktop Devanagari fallback, or a `Deva` craft-fonts face; web font still needed | contributor terminology review; 2026-11-13 wording pass on messages and longer labels, with a glossary-term test; wider proofread welcome | complete catalog, machine-assisted draft | native review, layout and web font |
| Arabic | `ar` | 0 | none | document text: bidi layout and Paragraph Direction; interface: no right-to-left layout, no Arabic shaping in egui | no | none | 25–40 |
| French | `fr` | 4,020 / 4,020 (100%) | all | Latin | no | full | — (review) |
| Portuguese | `pt-br` | 6,106 catalog entries (counted 2026-10-31 on `main` at `d26dd933a`): menus, `tl!` literals and messages complete when counted; one/other plurals | all | Latin | contributor is a Brazilian Portuguese speaker; further native review welcome | full | — (review) |
| Portuguese | `pt-br` | 9,260 rows, 3,445 of them `@msg` and 48 `@msgplural` (counted 2026-11-13): the untranslated report lists 39 missing messages for it; one/other plurals | all | Latin | contributor is a Brazilian Portuguese speaker; further native review welcome | full | — (review) |
| Indonesian | `id` | 5,279 rows, 750 of them `@msg` (counted 2026-10-21): menus and `tl!` literals complete when counted; its messages are partial; one plural form | dialogs and tooltips all; 750 message rows (French has 796) | Latin | no | full | — (review) |
| Japanese | `ja` | 4,004 / 4,020 (99.6%) | all | CJK UI font as above; Japanese IME; vertical type partial; Japanese crop marks and composition settings | no | full | — (review) |
| German | `de` | 3,952 / 4,020 (98%; menus, literals and messages complete when counted) | all (602 of 604 message rows; landed 2026-10-10) | Latin | contributor-written, not reviewed | full | — (review) |
| German | `de` | 3,952 / 4,020 (98%; menus, literals and messages complete when counted) | all (3,433 `@msg` and 48 `@msgplural` rows, counted 2026-11-13: the untranslated report lists 48 missing messages for it) | Latin | contributor-written, not reviewed | full | — (review) |
| Korean | `ko` | 4,870 rows (counted 2026-10-21): menus, `tl!` literals and messages complete when counted; one plural form | all | Hangul from an installed system font on the desktop (Apple SD Gothic Neo, Malgun Gothic, Noto Sans CJK KR…); the web build has no Korean UI font yet (craft-fonts); IME path exists | no (AI-drafted) | full | — (review; web font) |
| Vietnamese | `vi` | 4,886 rows (counted 2026-10-21): menus, `tl!` literals and messages complete when counted; one plural form; 4,046 plain + 18 `@plural` + 28 contextual + 794 `@msg` | all | Latin with Vietnamese diacritics (stacked marks attach in precomposed, decomposed and keyboard forms, #4491; glyph tests pass) | contributor is a Vietnamese speaker; AI-assisted draft, further native review welcome | full | — (review) |
@@ -50,7 +50,7 @@ plus review. Native-speaker review is human work and isn't in the hours.
| Language | Code | Translated | Status |
|---|---|---|---|
| Traditional Chinese (Taiwan) | `zh-hant` | 4,892 rows, 790 of them `@msg` (counted 2026-10-21): menus, `tl!` literals and messages complete when counted (80% overall) | partial |
| Italian | `it` | 4,011 / 4,020 | full |
| Italian | `it` | 8,757 rows, 3,422 of them `@msg` and 48 `@msgplural` (counted 2026-11-13): the untranslated report lists 40 missing messages for it | full |
| Dutch | `nl` | 7,299 rows, 1,609 of them `@msg` and 47 `@msgplural` (counted 2026-11-13 on `main` at `9a1a158a3`): in `COMPLETE_MESSAGES`, and the untranslated report lists the same missing messages for it as for German; one/other plurals | full |
| Danish | `da` | 5,279 rows, 750 of them `@msg` (counted 2026-10-21): menus and `tl!` literals complete when counted; its messages are partial; one/other plurals | full |
| Russian | `ru` | 4,009 / 4,020 | full |
+37 -11
View File
@@ -148,12 +148,14 @@ the suite) keep the agent to the folders you give it:
in a recorded action's steps in `ui.action_sets`, also in a batch step's commands, the `path`, `paths`, `file`,
`files` and `folder` params, a param whose name ends in `Path`, `Paths`, `File`, `Files` or `Folder` (`diffPath`,
`destinationFolder`), the entries of a list under such a param, and under any other param, as a key or in any
list, an absolute path or a `file:` URL outside the roots (any case of `file:`, `%XX` escapes decoded; a URL that
list, an absolute path or a `file:` URL outside the roots, also with whitespace around it (any case of `file:`, `%XX` escapes decoded; a URL that
names another host is always left out), and `~`, a path under `~` or a path that starts with `./` or `../`
(either separator) that resolves outside the roots from the app's working folder; and the folder
preferences in `ui.engine_prefs` and in an open Preferences dialog's `ui.dialog.fields`
(`fontsFolder`, `pluginsFolder`, `scratchPrimary`, `scratchSecondary`, `recoveryFolder`, `templatesFolder`; an
empty folder and the scratch disk choices `Startup` and `None` stay). A library loaded from a file outside the
preferences in `ui.engine_prefs`, in an open Preferences dialog's `ui.dialog.fields` and in a recorded
`prefs.set` step (its `value` for such a `key`, and the entries of `values`), also in a batch step's commands
(`fontsFolder`, `pluginsFolder`, `scratchPrimary`, `scratchSecondary`, `recoveryFolder`, `templatesFolder`, checked
as written and trimmed, a bare name or a subfolder from the app's working folder; an empty folder and the scratch
disk choices `Startup` and `None` stay). A library loaded from a file outside the
roots shows as `loaded/<file name>` wherever `ui_inspect` and `ui.docking` name it: its id, its panel's id, the
Color Guide's `ui.color_guide_limit`, a closed panel's key in `ui.docking_hidden` and the `library` and `panel`
params of a recorded action's steps in `ui.action_sets`, and the keys of shortcut overrides (`panel:<panel id>`
@@ -3232,7 +3234,11 @@ already walks Image Trace. Short agent entry points:
after the set (the web downloads it), and returns `{path}`. `id` holds the panel's own set id, which the panel menu
passes: the set with this id is saved wherever it is when the file dialog answers, and `set` is not read. A set that
would be larger than 8 MiB as a file, has more than 1,000 actions or has an action of more than 10,000 steps is not
written, and the command returns the same error as a load of such a file. `ui.actionSet.load {path? | data?}` reads
written, and the command returns the same error as a load of such a file. Nor is a set with a `prefs.set` step, also
in a batch step's commands, that sets a folder preference (`fontsFolder`, `pluginsFolder`, `scratchPrimary`,
`scratchSecondary`, `recoveryFolder`, `templatesFolder`) to a folder, which names a folder on this computer: the
error `the action “<name>” sets the folder preference <key>; delete that step to save the set` names the first such
action and preference. An empty folder and the scratch disk choices `Startup` and `None` save. `ui.actionSet.load {path? | data?}` reads
the file at `path`, else a picked one, or the file's text `data`, adds its set after the other sets and returns
`{set, name, actions}`. A set named like one already in the panel gets the next free number (`Print 2`), and the
other sets and the current set stay as they are. An action set file (`.vcactions`) is JSON:
@@ -3535,6 +3541,12 @@ already walks Image Trace. Short agent entry points:
`livePaint.fill` does not fill a face that is hidden on its own. With `group`, a point on a hidden face is an
error. With `ids`, at a point on a hidden face it fills the face there of another Live Paint group among the
objects; otherwise it returns an error and does not merge the objects.
A Live Paint command that changes nothing records no undo step, keeps the redo steps, leaves a saved document saved
and replies as usual: `livePaint.fill` (a click, or a Bucket drag) when every face it reaches already has the paint,
`livePaint.strokeEdge` when the edge already has the paint and the width, `livePaint.gapOptions` (and the Gap Options
dialog's OK) when every group already has the options and `closeGaps` finds no gap, and `livePaint.make` or
`livePaint.merge` given one Live Paint group alone, which they select. Such a fill or stroke also leaves the recent
colors and the last color as they are. `livePaint.gapOptions` makes a group's faces again, with new ids, only when it adds a path or when Gap Detection is turned on or off or given a new size while it is on.
`brush.selectionArt {ids?|id?}` (a query) replies `{art}`: the object that `brush.new` given the same `ids` or `id`,
or the same selection, takes as a new scatter or art brush's art and as a new pattern brush's side tile. Several
@@ -3944,6 +3956,9 @@ For `edit.colors.*`, `fill: false` leaves colorized image fills unchanged. `reco
`edit.colors.toGrayscale` and `edit.colors.adjustBalance` with `mode: "gray"` and `convert: true` store an embedded image
with one gray channel, so a PDF writes it in gray.
`includePatterns: false` leaves patterns out. The Blend commands also grade gradient meshes, which keep their shading.
The `edit.colors.*` commands, including the Blend commands, and `recolor.apply`, `paint.invert`, `paint.complement`,
`addon.color.filter` and `addon.color.applyNearestSwatch` record no undo step when they change nothing, for example
`edit.colors.invert` with `fill: false` and `stroke: false`, or a Blend whose objects already have the graded fills.
`edit.colors.saturate` needs `intensity`, a number from -100 to 100 (a number outside the range counts as its nearest
end). Without one, or with `null`, it answers `` missing number `intensity` ``; with a value that is not a number, such as
`"40"`, it answers `` `intensity` must be a number, not "40" ``. Either way it changes nothing.
@@ -4935,7 +4950,9 @@ stay live. `object.expand.info` answers which options have something to expand i
(`{object, fill, stroke, gradient, appearance, symbolArt?}`; `gradient` says whether Fill has a gradient fill, which Expand
Gradient To applies to, that it turns into art: it is false when every such fill repeats or reflects in more than 256
runs across the box it fills, which for type, symbol art included, is the box of each outline Object makes of a character,
ruby character, underline or strikethrough; `appearance` whether the selection has appearance attributes Expand Appearance expands first,
ruby character, underline or strikethrough, and for a fill of the type object itself the box of its whole outline;
`stroke` and `fill` count the type object's own strokes and pattern fills as well as its characters' (its own
only when the type has an outline, which type of only spaces does not); `appearance` whether the selection has appearance attributes Expand Appearance expands first,
for which Object → Expand… is dimmed in the menus; `symbolArt: {fill, stroke, gradient}`, present when the selection
holds symbol instances that `object` expands, whether only their art holds it, which Fill and Stroke reach only with
`object` on), and `object.mesh.create` on a gradient-filled object colours the
@@ -6271,12 +6288,13 @@ Preferences. `prefs.reset` resets the preferences at once, without the question.
`prefs.export {path?}` writes the preferences as a JSON file, `{"format": "vectorcraft-preferences", "version": 1,
"prefs": {…}}`, and replies `{path, count}`; without `path` it replies `{data, count}` with the file's text. The file
holds every preference `prefs.list` lists and the `eyedropper`, `perspectiveWidget`, `pathfinder`, `glyphSnap` and
`pixelSnap` groups. It leaves out the folder preferences (`fontsFolder`, `pluginsFolder`, `recoveryFolder`, `templatesFolder`) and
saved presets. An export over 1 MB, the most `prefs.import` reads, is an error and writes nothing.
`pixelSnap` groups. It leaves out the folder preferences (`fontsFolder`, `pluginsFolder`, `scratchPrimary`, `scratchSecondary`,
`recoveryFolder`, `templatesFolder`) and saved presets. An export over 1 MB, the most `prefs.import` reads, is an error and writes nothing.
`prefs.import {path | data}` applies such a file and replies `{imported}`, the number of preferences it
set. It checks every value first, as `prefs.set` does: a file over 1 MB, malformed JSON, another `format`, a newer
`version`, an empty `prefs`, an unknown preference, a value of the wrong type or out of range, or a folder preference
is an error, and nothing changes. Preferences the file leaves out keep their values. An import leaves the open
is an error, and nothing changes. For `scratchPrimary` and `scratchSecondary` only a folder is an error: an empty
value and the choices `Startup` and `None` are read. Preferences the file leaves out keep their values. An import leaves the open
document's units as they are, records no undo step, and is saved with the other preferences. An open Preferences
dialog shows the imported values. `prefs.import` is refused as a `command.batch` step. The dialog's Export Preferences… and Import Preferences… buttons run the two
commands with a save or open dialog; the web build downloads the exported file and has no Import Preferences… button.
@@ -8353,6 +8371,14 @@ indent and bullet or number again.
{"name":"run_command","arguments":{"command":"text.thread.add","params":{"from":42,"at":[300,120]}}}
```
`type.createOutlines` (Type › Create Outlines) makes a group with a path per glyph, ruby glyph and underline or
strikethrough bar, each painted as its characters are. The type object's own fills and strokes (the items around the
Appearance panel's Characters row, not the characters' formatting) go on paths of the type's whole outline: the items
below the Characters row on one path under the glyph paths, the others on one path over them, in their order and with
their opacity, blend mode, effects and stroke settings. Their gradients that are not placed are fixed to the type's
layout box, as the canvas paints them, so one gradient spans every glyph. The group itself has no fills or strokes.
`object.expand` outlines type with this command, so Fill and Stroke expand those paths' gradients, patterns and strokes.
`type.createOutlines` (Type › Create Outlines) and `effect.expandAppearance` (when it outlines type, as Expand
Appearance describes) take an outlined frame of threaded text out of its thread with the text it shows, and the other
frames keep the text they hold. When the thread's last frame is outlined, the text it has no room for, which its
@@ -11116,7 +11142,7 @@ the other colour adjustments (Effect › Color Adjustments); each colour keeps i
`addon.color.filter {effect, params?, fill?, stroke?, includeImages?, includePatterns?, ids?}` applies any colour
adjustment, the add-on's or one of Effect › Color Adjustments', to the colours themselves instead of as a live effect:
fills, strokes, type, gradient meshes, embedded images and pattern tiles, as `edit.colors.invert` reaches them, as one
undo step. Missing `params` take the effect's dialog defaults; the objects' own effects stay as they are.
undo step (none when nothing changes). Missing `params` take the effect's dialog defaults; the objects' own effects stay as they are.
```json
{"name":"run_command","arguments":{"command":"effect.apply","params":{"effect":"addon.color.exposure","params":{"exposure":1.5}}}}
@@ -11283,7 +11309,7 @@ spot, deltaE}]}]}` (`values` as a default swatch name reads them: `C=10 M=20 Y=3
`addon.color.applyNearestSwatch {library?, fill?, stroke?, ids?}` (Object › Plug-ins › Color Effects › Find Nearest
Swatch…, whose dialog lists each colour's three closest swatches with their difference; Apply runs it) gives each solid
colour and gradient stop of the selected objects' fills and strokes (and gradient meshes) the colour of its nearest
swatch, as one undo step. A global or spot swatch's colour links to it. The library's swatches the colours take are
swatch, as one undo step (none when nothing changes). A global or spot swatch's colour links to it. The library's swatches the colours take are
added to the document's first, as `swatch.library.add` adds them, so a spot colour from a colour book stays spot;
images and patterns keep their colours. → `{changed, swatches: [the document swatches the colours took], added}`
+11
View File
@@ -667,6 +667,7 @@ since 2026-10-01.
- **Colour emoji with bitmap glyphs:** `sbix` (Apple Color Emoji) and `CBDT` (Noto Color Emoji) glyphs draw as their largest strike's PNG, placed with the type and unpainted by its fill; PDF writes them in Type 3 glyphs or as images, SVG as images with outlined text, EPS and legacy `.ai` as images, and Create Outlines makes embedded images. Synthetic test fonts in `crates/text/src/test_fonts.rs`; tests `crates/text/src/tests/bitmaps.rs`, `crates/render/src/tests/bitmapglyphs.rs`, `crates/svg/tests/it/colour_glyphs.rs`, `pdf::tests::colour_bitmap_glyphs_export_as_images`, the `eps` `colour_bitmap_glyphs_*` tests and `tests_pathops::create_outlines_turns_bitmap_glyphs_into_images`. COLR and OpenType SVG fonts remain.
- **COLR colour fonts:** v0 and v1 glyphs draw as vector layers (solid colours, linear and radial gradients, clips, blend modes, the foreground colour from the run's fill) on the canvas, as paths in SVG, EPS, legacy `.ai` and PDF with outlined text, as Type 3 text in PDF, and as editable groups with Create Outlines; sweep gradients and Porter-Duff compositing draw the glyph as an image. Measured by `tests_colr`, `render::tests_colrglyphs`, `pdf::tests::colr_glyphs_export_as_vector_art`, `svg/tests/it/colour_glyphs.rs`, `eps` `colr_glyphs_*`, `tests_pathops::create_outlines_turns_colr_glyphs_into_layer_groups`. Scores unchanged (estimated).
- **OpenType SVG colour fonts:** each glyph's SVG document is read by the SVG importer (registered by the engine) into vector art in the run's colours, then drawn, exported and outlined as COLR glyphs are; PDF real text writes them as text that draws nothing and draws their art where they sit. Measured by `tests_svg_glyphs`, `svg/tests/it/svg_glyphs.rs`, `tests_colourfonts::create_outlines_turns_svg_glyphs_into_groups`, `tests_colourfonts::pdf_real_text_draws_svg_glyphs_as_art_and_keeps_their_characters`. Scores unchanged (estimated).
- **Create Outlines keeps the type object's own appearance:** Type › Create Outlines and Object › Expand put the type object's own fills and strokes (the Appearance panel's items around its Characters row) on paths of the whole outline, below or above the glyph paths as that row places them, with one gradient across every glyph, so the outlines draw what the type drew; `object.expand.info` reports those strokes, pattern fills and gradient fills. Outlined characters keep their stroke and fill (the help page, <https://help.adobe.com/archive/en_US/illustrator/cs5/illustrator_cs5_help.pdf#page=337>); a type object's appearance is separate from its characters' (the help page, <https://helpx.adobe.com/illustrator/using/appearance-attributes.html>); where the object's items go is VectorCraft's own rule. Measured by `tests::pathops::create_outlines_keeps_the_objects_own_fills_and_strokes`, `tests::objexpand::create_outlines_draws_the_type_objects_own_paint`, `tests::objexpand::type_objects_own_stroke_pattern_and_gradient_are_reported`, `tests::objexpand::type_without_an_outline_reports_no_own_stroke_or_fill`, `tests::objexpand::a_stroke_under_an_unpainted_stroke_is_reported_and_outlined` and `tests::objexpand::expand_keeps_the_type_objects_own_paint`. Scores unchanged (estimated).
- **Composite fonts that two documents define differently:** when two open documents each define a composite font (Type › Composite Fonts…) by the same name with different parts, each document draws and exports its type in its own definition: in a tiled or floating window drawn while the front document draws, when it is placed in a document that defines the name differently, and in an export made while another document is in front. Evidence: `tests::composite::nested_loans_of_one_name_use_each_documents_definition` and `threads_lending_one_name_at_once_use_their_own_definitions` (`crates/text`), `tests::fontchange::a_placed_document_draws_its_own_definition_of_a_name_the_page_defines` (`crates/render`). Scores unchanged (estimated).
- **Character-style Auto leading:** capture and explicit style attributes retain Auto as a reset, distinct from omitted leading. Redefine and later numeric updates preserve local leading overrides; the Character Styles marker recognizes Auto correctly. Regression assertions cover partial definitions, Undo/Redo and native save/load serialization. Public references: [Character and paragraph styles](https://helpx.adobe.com/illustrator/using/character-paragraph-styles.html) and [Leading](https://helpx.adobe.com/illustrator/using/line-character-spacing.html).
- **Character-style numeric bounds:** `charStyle.new`, `charStyle.edit`, and `charStyle.setAttrs` accept size from 0.1 to 1296 pt, explicit leading from 0.1 to 5000 pt, horizontal and vertical scale from 1% to 10,000%, and baseline shift and Tate-chu-yoko offsets from -1296 to 1296 pt. Out-of-range input leaves the style and Undo history unchanged; Auto leading remains available. These limits match the Character panel controls.
@@ -758,6 +759,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- Batch…: Override Save and Override Export name each file with the extension of the format the step writes, however the step spells the format (`.svg` and `SVG` give `.svg`, `png8` gives `.png`), in `action.batch`.
- Batch…: Override Export writes the files of an Export for Screens or Export Assets step into a folder for each source file or data set inside the destination folder, under the names the export gives them (`action.batch`). The folder and file names drop trailing periods and spaces (`a..svg` gives `a`). When two source files would get the same name that way (compared without case), or a later file's folder or file would take the name of an output an earlier file wrote, of a source file in the destination folder or, for data sets, of a file already there, Batch adds `-2`, `-3`… to the later one's name.
- Actions panel menu: Save Actions… writes the current action set with all its actions to a file, and Load Actions… adds the set from such a file to the panel ([Manage a set of actions](https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/automate-actions/manage-a-set-of-actions.html); `ui.actionSet.save`, `ui.actionSet.load`). The file is VectorCraft's own action set file (`.vcactions`); a loaded set named like one in the panel gets the next free number.
- Actions panel menu: Save Actions… does not write a set with a step that sets a folder preference (the Fonts, Plug-ins, Templates and Recovery folders and the two scratch disks) to a folder, and names the action and the preference instead; an empty folder and the scratch disk choices Startup and None save. Export Preferences leaves out both scratch disks, and `ui.inspect` under automation read roots leaves such a folder outside them out of recorded steps. These are VectorCraft's own rules (`ui.actionSet.save`, `prefs.export`).
- Actions panel menu: Load Actions… also reads action sets saved as `.aia` files ([Actions panel overview](https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/automate-actions/actions-panel-overview.html); `actionSet.read`, `ui.actionSet.load`). VectorCraft's own rules: the set comes in with all its actions. A step with a label and no recorded values comes in as the one menu command with the step's label, when that command is directly in a top menu, is what its menu bar item runs with no values and opens no dialog. A step that is off in the file stays excluded from playback. The other steps, recorded menu items included, are left out, and the status bar says how many.
- Actions panel: the panel menu's Action Options… renames the selected action and keeps its steps ([Actions panel overview](https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/automate-actions/actions-panel-overview.html): the menu item opens a dialog that renames the action or gives it a function key and color; `ui.action.options`). It also sets the action's function key and color.
- Actions panel: Create New Action (bottom bar) and the panel menu's New Action… ask for the new action's name, set, function key and color, and Record adds the action and starts recording into it ([Create new actions](https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/automate-actions/record-actions.html): the New Action dialog takes the action's name and the set it goes in; `ui.action.new`, `ui.action.play`). The function key (F1 to F15, with Ctrl or Command and Shift) plays the action. An action's function key plays the action even when a command has the same shortcut, and the command keeps it. VectorCraft's own rules, which the page does not cover: when several actions have the same key the first in panel order plays; a copied action has no key; New Action does not open while an action is recording. The color is kept with the action for Button Mode, which VectorCraft does not have yet.
@@ -853,6 +855,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- With the Artboard tool, the contextual task bar sits under the selected artboards and offers Resize (Artboard Options for the active artboard), Duplicate (each selected artboard, in one undo step, the copies then selected), Rearrange All (with two or more artboards) and Export (Export for Screens with the selected artboards checked). This follows Illustrator's bar: while the Artboard tool is in use, it has options for resizing, duplicating and exporting artboards (the [Contextual Task Bar announcement](https://community.adobe.com/questions-652/contextual-task-bar-in-illustrator-2025-quick-actions-when-you-need-them-1546580); Rearrange and Export on the bar: [Managing Artboards in Illustrator](https://creativepro.com/managing-artboards-in-illustrator/)).
- The contextual task bar offers more next steps by selection (<https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html>): an open path Join and Edit Path (the Direct Selection tool), a closed path Edit Path, a compound path Edit Path and Release Compound Path, a clipping group Edit Clipping Path and Release Clipping Mask instead of Ungroup and Isolate, an image selected with vector art Make Clipping Mask instead of Unite, point or area type Convert To Area Type or Convert To Point Type beside Create Outlines, and type on a path, for which the overview names an item to add an effect and rearrange the text, Type on a Path Options (`type.pathOptions`; its options: <https://helpx.adobe.com/illustrator/using/creating-type-path.html>) beside Create Outlines. Evidence: `crates/ui-egui/src/tests/taskbar.rs`.
- While a Type tool (Type, Area Type, Type on a Path and their vertical versions) adds or edits type, the contextual task bar shows the font family menu, the font style menu, the Font Size combo and the Fill chip (<https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html>); the Touch Type tool shows no bar, as the same page describes. Type selected with a selection tool shows the same three font controls beside its Create Outlines, conversion and Type on a Path items (<https://helpx.adobe.com/illustrator/desktop/design-with-text/fonts-and-scripts/font-options-overview.html>). The controls act as the Character panel's do: on the characters a Type tool selects, else on every selected type object, with the size left blank where the sizes differ. VectorCraft's own rules: a Type tool's bar leaves out the object actions, the Stroke chip, Recolor Artwork and Lock; a Type tool shows no bar before it adds type or with other art selected; type selected with other art shows no font controls; the font controls go on a second row when one row would be wider than the canvas, and narrow to fit a canvas narrower than they are; while a Type tool edits type, the Fill chip shows the edited characters' fill ("?" where it differs). Evidence: `the_type_tools_show_font_and_fill_controls`, `the_type_tools_show_no_bar_without_type`, `selected_type_shows_font_controls_beside_its_actions`, `the_task_bars_font_size_sets_what_the_character_panel_would`, `the_type_tools_fill_chip_activates_the_fill`, `the_type_tools_bar_is_named_and_stays_on_the_canvas`, `selected_types_font_controls_take_a_second_row_on_a_narrow_canvas` and `the_type_tools_fill_chip_shows_the_edited_characters_fill` in `crates/ui-egui/src/tests/taskbar.rs`.
- The help page describes the contextual task bar as one horizontal row (<https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/workspace-overview.html>) and gives no rule for a canvas narrower than that row. VectorCraft's own rule: the bar stays whole on the canvas. When its actions don't fit in one row, they wrap, in order, onto rows under the row with the handle, the chips and More Options; an action wider than any row, or one that would need a row past the canvas's height, is listed in More Options instead; when the chips don't fit beside the handle and More Options, they take rows after the actions; with no row to spare for the font controls, the bar leaves them out; a canvas too small for the handle and More Options shows no bar. Evidence: `a_task_bars_actions_wrap_on_a_narrow_canvas` and `a_task_bar_action_wider_than_the_canvas_goes_in_more_options` in `crates/ui-egui/src/tests/taskbar.rs`.
- With a live rectangle, rounded rectangle, ellipse or polygon selected with the Selection tool, the contextual task bar shows a Shape Properties button in place of Lock. It opens a popup with the shape's rows from the Transform panel (corner radius, pie angles, or sides, angle, corner and radius), which edit it through `object.setLiveShape`. The overview describes this: when a shape drawn with a shape tool (Rectangle, Star) is selected, the bar offers to change its properties where Lock Object would be ([Contextual Task Bar overview](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html)). Object › Lock and ⌘2 still lock the shape. Not done: stars, which the app draws as plain paths. Evidence: `a_basic_shape_shows_its_properties_in_place_of_lock`, `the_shape_properties_popup_edits_the_shape` and `other_selections_keep_lock` in `crates/ui-egui/src/tests/taskbar.rs`.
- The contextual task bar has a Stroke chip beside the Fill chip, drawn with the paint the Stroke proxy shows (a "?" when the selected objects' strokes differ, as on the Fill chip); a click brings the Stroke proxy forward and shows the Swatches panel wherever it is docked, floating or closed, as a click on the Fill chip does for the Fill proxy. The reference app's bar has Fill and Stroke controls for changing an object's colors ([Contextual Task Bar overview](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html)). Evidence: `the_task_bar_shows_a_stroke_chip_beside_fill` and `the_task_bar_chips_follow_the_proxies_and_show_swatches_anywhere` in `crates/ui-egui/src/canvas/tests.rs`.
- With anchor points selected with Direct Selection, the contextual task bar offers Remove Anchor Points, Connect (`path.join`), Cut Path, Corner and Smooth (`path.convertAnchors` with `to` set to `corner` or `smooth`), the commands of the Control bar's anchor buttons. As in Illustrator, whose bar has items that delete the selected anchors, join selected end points, split the path at the selected anchors, and make the selected anchors corner or smooth points ([Contextual Task Bar overview](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html)). Not done: Simplify, which the bar offers only while no anchors are selected, and the bar's Smooth item that adjusts a path's curvature, a command the app doesn't have (Object › Path › Smooth).
@@ -879,6 +882,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- Hindi wording (2026-11-13): rows outside the plug-in messages keep their English's meaning, quantities and clauses, and use the catalog's save, swatch, crop, resolution, path and type terms; a test checks those terms and the point unit in every row; native review remains; scores and estimates unchanged.
- Hindi terms (2026-11-13): every row that names a variable (data merge, variable fonts and widths, environment variables) says वेरिएबल, and joining paths, anchor points, point type and lines says जोड़ें instead of शामिल हों, which stays for joining the community; a test checks both terms in every row; scores and estimates unchanged.
- Hindi English words (2026-11-13): 264 rows no longer keep English words in their sentences, repeat a parameter's name in Hindi or garble them, among them "unknown align", which now names the alignment; lists of accepted values such as `(left|right|top|bottom)` stay as their English writes them; two tests check every row; native review remains; scores and estimates unchanged.
- Italian messages (2026-11-13): the Italian catalog (`it`) has 1,802 more status and error message rows, and the untranslated report's missing Italian messages go from 1,842 to 40; the translations are VectorCraft's own and await native review; scores and estimates unchanged. See [localization-parity.md](localization-parity.md).
- Window › Help Bar shows or hides the tool-help strip at the bottom of the window apart from the status bar (`window.helpBar`). Each setting is kept with the UI preferences and in saved workspaces, and Presentation Mode hides both bars. Layouts saved before the setting existed show the Help Bar where they show the status bar (`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`, `a_help_bar_setting_the_file_lacks_is_saved`).
- Czech render-site labels: desktop/web file filters, diagnostics, suggested preset names and contributor tooltips/plurals now use catalog lookups; gradients have Czech adjective agreement and printer marks have a separate context (PDF/Print and Summary). Search, Home, toolbar/panel tooltips and Preferences already look up their labels. Every complete catalog has rows for these labels and for the Roman and Japanese printer mark styles. Evidence: `i18n::tests::czech_render_site_follow_up`, `i18n::tests::complete_catalogs_translate_render_site_labels`, `dialogs::tests_modal::printer_mark_labels_are_distinct_from_language_names`; see [localization-parity.md](localization-parity.md).
- The History panel, Edit › Undo and Edit › Redo translate the names of the steps that apply or redefine a character or paragraph style and of the step that redefines a graphic style: each such step keeps its template (`Apply {name}`, `Redefine {name}`, `Redefine Graphic Style “{name}”`) and the style's name, every complete catalog has a row for each template, and the panel and the menu show the style's name as the document holds it, except the Normal styles' names, which they show in the interface language (`steps_named_after_a_style_list_the_template_around_the_name`, `undo_and_redo_name_a_style_step_around_the_style_name`).
@@ -891,6 +895,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
The status bar's messages for documents opened or saved with notes and for discarded or restored recovered documents, and the Global Edit options' Results line, do the same (`open_save_and_recovery_messages_take_the_plural_form` in `crates/ui-egui/src/i18n/tests.rs`); the warnings for linked images and placed documents output as their previews and the errors for a page past a placed file's last page or artboard name their counts in the singular or the plural in English.
- Edit › Undo and Edit › Redo, in the in-window and native menus, name the step in the interface language as the History panel lists it (`panels::history::step_name`), so when the catalog has no plain row for a step named after an effect, such as Feather, the menu shows the translation of the effect's menu row without its ellipsis (`undo_and_redo_name_the_step_as_the_history_panel_does`).
- The History panel translates the undo step names the engine, the tools and the shell write as literals: the untranslated report (`untranslated_report`) lists any a complete catalog lacks, and a step whose catalog row exists only with an ellipsis (such as an effect's menu name) shows that row without the ellipsis.
- The German catalog (`crates/ui-egui/src/i18n/de.tsv`) has an `@msg` row for the status and error messages the untranslated report (`untranslated_report`) finds in the sources, 3,433 `@msg` rows in all: the errors of commands, scripts, file import and export and plug-ins. The report lists 48 German messages; 38 of them are the composite font, select-a-path and justification order errors that open #7211, #7214 and #7116 translate. A message with two placeholders in a row (`Template::parse` in `crates/ui-egui/src/i18n/catalog.rs`) is still shown in English.
- The History panel menu has Step Backward and Step Forward, which run Edit › Undo and Edit › Redo and are disabled when there is no step to undo or redo, and Set History Limit…, which opens Preferences at Performance, where History States is set.
- The History panel menu's Clear History (`edit.clearHistory`) removes every step to undo and to redo and leaves the document as it is; it is not an undo step itself, and it is disabled when there is no step to clear.
- The New Document from State button at the bottom of the History panel (`edit.newDocumentFromState`) makes a new document, which becomes active, from the state the panel has selected ([public source](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/undo-edits-and-manage-design-history.html)). VectorCraft's own rules: the new document takes the next Untitled-N name, is marked unsaved, has nothing selected and has no steps to undo or redo, and the source document and its steps stay as they are.
@@ -909,6 +914,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- The errors of the 3D effects (Extrude & Bevel, Revolve, Inflate, Rotate and their Classic forms) show in the status bar in the interface language: the art a 3D effect cannot build a solid from, invalid light, graphics and surface settings, and the notes for an object that draws no 3D faces or more wireframe edges than the limit. Each has a row in every catalog that translates all status and error messages, and the effect's name and the values in the message are translated or kept as written (`three_d_refusals_are_translated_in_every_complete_catalog`, `three_d_refusals_translate_with_their_values`).
- The errors of the parameter checks that many commands share show in the status bar in the interface language: a value that is not a number where a number goes (`object.move` with `"dx": "60 mm"`, and `object.rotate`, `object.setBounds` and the other commands that call `check_numbers`), a missing number or index, `ids` that are not a list of object ids, an object id that is not a non-negative integer or names no object, and a date that is not Unix seconds. Each has a row in every catalog that translates all status and error messages, and in Bulgarian, Danish, Indonesian and Dutch (`shared_param_check_errors_are_translated`).
- A parameter schema's errors show in the status bar with what the value must be in the interface language, for every type a schema has (a number with each kind of range and with a unit, an integer and its range, true or false, a string, a list of names, an object id, a list of object ids, a color, a point, an object and a list), in every catalog that translates all status and error messages; the path, the refused value, the bounds, the unit and the names stay as the English gives them. The error for a value that is not one of its names is also translated in Bulgarian, Bosnian, Danish, Indonesian and Dutch (`parameter_schema_expected_phrases_are_translated`, `bracketed_message_parts_translate_only_as_exact_messages`).
- The untranslated report lists the status and error messages of the effects, swatch libraries, raster sizes and encoders, 3D solids and path operations that a catalog lacks, the messages that a `.map_err` closure or a named error handler returns, and the phrases a parameter schema's error builds for what a value must be (`untranslated_report_checks_every_message_crate_and_schema_phrase`, `message_scan_reads_map_err_closures`, `message_scan_reads_named_map_err_handlers`).
- Export commands run through MCP, the control channel or the CLI refuse a key that no format takes, and warn about a key that only another format takes (`{"format": "pdf", "quality": 80}` writes the PDF with the warning "`quality` was not used: PDF files don't read it"; `an_option_only_another_format_reads_gets_a_note`, `control_export_notes_an_option_the_format_does_not_read`, `convert_warns_about_an_unused_option_only_when_one_was_given`), and a command that writes one format (`document.exportPdf`, `document.exportEps`, `document.exportDxf`) or takes one format's options (`document.pdfSettings`, `pdf.preset.save`) refuses a key that format doesn't take. An unknown key inside `marks`, `bleed`, `compression`, `output`, `advanced`, `security` or `flattener` is refused by its path.
- Save commands run through MCP, the control channel or the CLI (`document.save`, `file.saveAs`, `file.saveCopy`, `file.saveAsTemplate`, `app.save`) refuse a key that no save format takes, beside the path or in `options`. Export for Screens refuses a key it doesn't take, and a key that no format takes in a format row or in a format's settings, by its path (`formats[1].marks.useDocumentBleed`); Export Assets (`assets.export`, `assets.settings.set`) checks the rows and settings it is given the same way.
- Commands that read their `ids` (or `slices`) list themselves refuse a list with an entry that is not a non-negative integer, and a value that is not a list, and change nothing; they no longer drop the entry and act on the rest (Copy Appearance From, the Edit Colors commands and Overprint Black, Find and Replace, `layer.highlight`, `layer.move`, `library.add`, the Links panel commands, `object.transform`, Make Pattern, the Repeat commands, the slice commands, Join, Average and Join, `plugin.run`, `symbol.edit`, Make Opacity Mask; `tests::ids_without_selection::an_ids_entry_that_is_not_an_id_is_refused_and_changes_nothing`). The error for an entry of an object id list names the key, the entry and its value ("`ids` entry 1 is true, not a non-negative integer object id"), with a row in every catalog that has the other object id errors.
@@ -1377,6 +1383,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- **Image Trace, curve fitting tolerance:** the outline fitter keeps cutting a run while a point stays farther than the tolerance from its curve, so a run of fewer than six points or one cut 14 times no longer keeps a piece over the tolerance. Pieces already within the tolerance do not change, and noisy art can get more anchors. Tests: `logo::bezier::tests`, `logo::outline::tests`. Scores and hours unchanged.
- **Image Trace, gray photos:** Color and Grayscale smooth a gray photo within its tones before choosing its colors, as they do a color photo. A picture with at least 95% of its opaque pixels within 8 levels across their channels counts as continuous tone when 8 colors leave an error of more than 6 levels and more than 0.065 of the error of one color, instead of 0.1, unless 16 colors leave at most a fifth of the error of 8 (VectorCraft's own values). That exception keeps gray flat art of up to 16 clean levels on its old route; anti-aliased or noisy gray flat art can now count as continuous tone too. Most gray photos the change reaches, and very noisy gray scans of flat art, trace with fewer specks and fewer staircase edges. Some 16 Colors and High Fidelity Photo palettes of gray photos grow toward the requested count, with more anchors and regions. Some gray illustrations and sketches get more anchors and staircase edges at 16 Colors and High Fidelity Photo, and some 6 Colors traces get more staircase edges. Tests: `tests::a_gray_photo_is_continuous_tone_as_its_color_original_is`, `tests::a_gray_photo_is_smoothed_before_it_is_traced`. Scores and hours unchanged.
- **Image Trace, tinted photos:** Color and Grayscale smooth a sepia, single-hue or duotone photo within its tones before choosing its colors, as they do a gray photo. A picture with at least 95% of its opaque pixels within 6 levels of its tone curve counts as continuous tone under the same 0.065 rule as a neutral picture. The tone curve runs through the median color of each 8-level stretch along the direction in which the picture's colors spread the most, and a pixel on it must also lie within 6 levels of the plane the colors spread along most, so art in several unrelated colors is not counted (VectorCraft's own rule and values). The neutral rule's exception for 16 colors leaving at most a fifth of the error of 8 applies to it too. Clean tinted bands of 2, 3 and 9 levels and tinted scans of flat art with up to 8 levels of noise stay on the flat-art route. On the synthetic tinted photos the 16 Colors trace keeps 12 to 15 colors instead of 6 to 13, with 525 to 708 anchors instead of up to 1,402. A duotone with strong noise on each channel can still miss the curve and stay unsmoothed. Tests: `tests::a_tinted_photo_is_continuous_tone_as_a_gray_photo_is`, `tests::small_accents_of_other_colors_leave_a_tinted_photo_continuous_tone`, `tests::tinted_flat_art_stays_flat_art`, `tests::pictures_without_tones_are_not_continuous_tone`, `tests::a_tinted_photo_is_smoothed_before_it_is_traced`. Scores and hours unchanged.
- **Image Trace, JPEG blocks:** Color, Grayscale and Black and White traces smooth the edges of a JPEG's 8 × 8 blocks before tracing, so a dark ground whose tone changes slowly is no longer traced as staircases along the block edges. The block grid is found in the image itself: the mean step between neighboring pixels must peak at one position in eight, across and down. A cropped JPEG and a JPEG saved in another format are smoothed too. A picture of flat 8 × 8 cells is left as it is, and art made of 8 × 8 cells with slight texture inside each cell is smoothed as a JPEG copy would be. A small step at a block edge, with no edge in the eight pixels around it, is spread over those eight pixels, and larger steps are kept, as the deblocking filters of ITU-T H.263 Annex J and MPEG-4 Part 2 Annex F.3.1 do. Black and White smooths only the smallest steps, and traces of more than 16 colors move every row of a stretch of eight by the same amount (VectorCraft's own rule and values). On a 4000 × 3000 photo saved as JPEG, the straight outline segments that lie on the block grid fall from 52% and 51% (across and down) to 24% and 29% at 16 Colors, and from 54% and 51% to 43% and 42% at High Fidelity Photo; staircase runs fall from 83 to 67 (16 Colors), 11 to 1 (6 Colors), 30 to 13 (Black and White Logo) and 428 to 403 (High Fidelity Photo). A 600 px photo saved as a quality-40 JPEG has 4 staircase runs instead of 2 at 16 Colors. Images without a block grid trace as before. Tests: `tests::a_jpegs_blocks_are_not_traced_as_steps`, `deblock::tests`. Scores and hours unchanged.
- **Image Trace, Document Library color groups:** with Document Swatches, the panel's Colors menu and `"colorGroup"` trace with one color group's colors instead of every swatch, as the public panel documentation describes Document Library; code-drawn tests in `crates/engine` and the panel.
- **Image Trace, Document Library colors:** with Document Swatches, traced fills and strokes use the displayed colors of process, global, spot and tint swatches without links, so editing a swatch leaves the trace unchanged; swatch-library colors are also unlinked; code-drawn tests in `crates/engine`.
- **Image Trace, flattened slivers:** in a Color, Grayscale or Black and White trace with Fills, a traced region whose outline straightens onto one line (a single pixel, or a one-pixel row along an edge, its pieces shared with the regions beside it) is left out instead of becoming a selectable path with no area, which paints nothing. Snap Curves To Lines straightens more outlines, so it leaves out more of these. Without Fills, the region's 1 px stroke draws it, and it is kept. Code-drawn tests in `crates/trace`.
@@ -1435,6 +1442,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
View › Show Live Paint Gaps (`view.livePaintGaps`) draws the gaps of the selected Live Paint groups up to their Paint Stops At size, each in its group's Gap Preview Color, until Hide Live Paint Gaps or Hide Edges hides them ([Live Paint gaps](https://web.archive.org/web/20260105111201/https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/find-and-close-gaps-in-live-paint-groups.html)).
Double-clicking the Live Paint Selection tool opens its Tool Options ([Live Paint Selection tool options](https://web.archive.org/web/20250904012025/https://helpx.adobe.com/illustrator/using/selecting-objects.html)): with Select Fills off, a click selects an edge instead of a face; with Select Strokes off, Alt-click selects a face instead of an edge; Color and Width set the color and width of the highlight on the face or edge under the pointer (red and 4 px by default). The options last across tool switches and are saved with the preferences (`tool.setOption {tool: "livePaintSelection"}`).
As VectorCraft's own rule, OK in Live Paint Selection Tool Options, Live Paint Bucket Options, Gap Options and Tile Edge Color gives an error for a color with an alpha part (`#rrggbbaa` or `#rgba`) and changes nothing.
As VectorCraft's own rule, a Live Paint edit that changes nothing records no undo step, keeps the redo steps and leaves a saved document saved: a Live Paint Bucket click or drag over faces that already have the fill, a stroke on an edge that already has the paint and weight, Gap Options OK with the options the groups have and no gap to close, and Make or Merge with one Live Paint group alone. Such a fill or stroke also leaves the recent colors as they are. Regression tests: `live_paint_fill_same_paint_is_no_op`, `live_paint_bucket_click_with_the_face_paint_is_no_op`, `live_paint_stroke_edge_same_paint_and_width_is_no_op`, `live_paint_gap_options_same_values_are_no_op`, `live_paint_gap_options_close_without_gaps_is_no_op`, `live_paint_make_existing_group_is_no_op` and `live_paint_merge_single_group_is_no_op` in `crates/engine/src/tests/build.rs`, and `ok_on_unchanged_options_records_no_undo_step` in `crates/ui-egui/src/dialogs/live_paint_gaps.rs`.
As VectorCraft's own rule, `tool.setOption` for the Live Paint Bucket and the Live Paint Selection tool, chosen or not, checks every value before it sets any: a switch that is not `true` or `false`, a `color` that is not an RGB color or a layer color's name, or that has an alpha part, a `width` that is not a number and an option the tool does not have give an error naming the option, and nothing is set or saved. A `width` outside 1 to 20 px is still set to the nearest end of that range. Saved settings that hold an invalid value still load, and the tool keeps its default for that option. Evidence: `tests::build::{live_paint_tool_options_refuse_invalid_values_and_change_nothing, live_paint_tool_options_take_rgb_colors_and_clamp_the_width, live_paint_tools_load_saved_settings_with_invalid_values}`.
As VectorCraft's own rule, `tool.setOption` for the Shape Builder, chosen or not, checks every value the same way: a switch that is not `true` or `false`, a `pickColorFrom` or `selection` that is not one of its names, a `gapLength` that is not a number, a `highlightColor` that is not an RGB color or a layer color's name, or that has an alpha part, and an option the tool does not have give an error naming the option, and nothing is set or saved. A `gapLength` outside 0 to 72 pt is still set to the nearest end of that range. Evidence: `tests::build::{shape_builder_tool_options_refuse_invalid_values_and_change_nothing, shape_builder_tool_options_take_valid_values_and_clamp_the_gap}`.
A drag of 3 screen pixels or more with the Live Paint Selection tool draws a marquee and selects the faces and edges it touches, partly enclosed ones included, and a Shift-drag adds them to the selection or removes them from it ([Modify Live Paint groups](https://web.archive.org/web/20261006115247/https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/modify-live-paint-groups.html)). A click and a marquee change the selection on release, and Escape before the release leaves the selection as it was. Locked Live Paint groups, those on a locked layer or artboard, and in isolation mode those outside the isolated art are not highlighted or selected.
@@ -1647,6 +1655,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
A `.ai` opened from its editing data opens its Objects on Path groups live, with their path, their objects in order along it, Pivot and Rotate, and their art where the file draws it; a group whose spacing has been dragged, or with options an Objects on Path group doesn't hold, opens as a plain group (`crates/eps/src/import/ai/tests.rs`).
`.ai` symbol definitions and placed instances open as live symbols, in the Symbols panel's order; an instance of a symbol that isn't read, or whose appearance differs from its symbol's, comes in as the page draws it (`crates/eps/src/import/ai/tests.rs`).
In a `.ai` opened from its editing data, an object in a pattern's art or a brush's art with an art style VectorCraft reads opens as itself with its effects live, as an object on a layer does, and an object in a pattern's art keeps the id of a graphic style in the file's list (`crates/eps/src/import/ai/tests.rs`).
A graph in a `.ai` whose records have the shape and values the published version 7 specification gives ([the specification](https://13thmonkey.org/documentation/fonts/AI7FileFormat.pdf), printed pp. 109–112 and 146–158) opens as a live grouped column, stacked column, line or area graph with its saved art, table, axes and settings, and Graph Data edits it ([the help page](https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/visualize-data/add-graph-data.html)); other graphs keep their art as plain objects with a note, and saving a graph to `.ai` warns that its data and settings aren't written (`crates/eps/src/import/ai/tests.rs`, `crates/engine/src/cmd/graph/tests.rs`).
Blends and envelopes in the definitions of a `.ai`'s symbols, patterns and brushes' art count against the same per-file limits on blend layout and envelope checks as the layers' art, so a file with many definitions does not get those limits again for each one (`crates/eps/src/import/ai/read/directives.rs`).
A `.ai` or EPS whose editing data has brushes opens with the file's Calligraphic, Scatter, Art and Bristle brushes in the Brushes panel in place of the default ones, in the file's order: the Calligraphic size, roundness and angle with their variation, the Scatter size, spacing, scatter and rotation, the Bristle settings, and the Scatter and Art brushes' art (Art brushes in the older and newer forms of their objects). A brush library `.ai` (brushes and no layers) opens from its PDF part with its brushes, so Other Library lists them. An Art brush in Tints keeps that colorization. Pattern brushes and brushes that can't be read are left out with a note. Paths with a Calligraphic brush, and paths with an Art brush in the newer form at 100% in Tints that stretches art of solid-filled paths unflipped, open as the path with the brush on its stroke. Paths with an Art brush in the older form, and other brushed paths, still come in as their drawn look (part of #372 and #637; `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
In a `.ai` opened from its editing data, a path or type object with Offset Path, Outline Object or Outline Stroke on the whole object opens as itself with those effects live, in their order and shown or hidden; on a fill or stroke of type they stay on that fill or stroke. Offset Path keeps its Offset, Joins and Miter Limit, and Outline Stroke takes its width from the stroke. An Offset Path with a setting missing, out of range or not read keeps the drawn art, as does a path with a Path effect on one fill or stroke (`crates/eps/src/import/ai/style/tests.rs`, `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
@@ -1844,6 +1853,8 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- **Brush art of copies:** symbol instances, inline graphics and repeat copies of a brushed path keep their own brush art between frames, as the same path on the page does. The renderer also keeps the stroke outlines of brush art and the evaluation of a live object in it, such as an envelope that a scatter brush places. The brush art is made again when the path, its stroke or the brush changes, and when the art of a symbol or pattern that the brush art can show changes. On one thread at 1000 × 1000 pixels (the median frame, with the median fastest frame in brackets), 2,000 paths on the page whose scatter brush art is an envelope take 94 ms (80 ms) a frame instead of 400 ms (306 ms), and 2,000 instances of a symbol whose art is a brushed path take 13.4 ms (12.0 ms) instead of 19.3 ms (15.6 ms), with the same pixels.
- **Two brushes with one name:** when a document stores two brushes with the same name, a stroke that names it draws on the canvas with the first of them, as `brush.get`, Brush Options, expanding, outlining and the SVG, PDF, EPS and `.ai` exports take it. Document Info gives that brush's type, and the Brushes panel's row of that name previews and drags the first brush. Reading the library numbers the second brush ("Name 2"), so the panel lists it in a row of its own that shows it.
- **Live objects in symbols and masks:** symbol instances and inline graphics whose symbol is a blend, an envelope, a repeat, an Intertwine object or a gradient mesh, or a group that holds one, draw the evaluation the renderer keeps for that object between frames, as the same object on the page does. So do opacity masks whose art is such an object, and such objects in clip groups in Outline view. The object is evaluated again when the symbols, patterns, fonts or color settings it shows change. Symbol art with effects of its own, or that holds a symbol instance, an image, a placed file, type with an inline graphic or a raster effect, is still placed and evaluated again in every frame. At 1000 × 1000 pixels, a page of 2,000 instances of a symbol that holds an envelope takes 28 ms a frame instead of 126 ms, with the same pixels.
- **Live objects in documents with many symbols:** a live object, or an object with effects, that shows symbols or patterns is not walked again in a later frame to find them while the document's symbols and patterns stay the same. One that shows a placed file is walked in every frame. At 1000 × 1000 pixels, a page of 2,000 envelopes around instances of the last 2,000 of 10,000 symbols takes 30 ms a frame, and 83 ms when every frame walks them again, with the same pixels.