Merge main into fix/graph-series-gradient-per-mark

# Conflicts:
#	docs/mcp.md
This commit is contained in:
dotCooCoo committed 2026-11-13 15:49:27 -08:00
commit 252ff7782a
62 files changed
+2986 -193

No files matched your search

+237 -44
View File
@@ -3,6 +3,7 @@
//! the ruler origin and the objects an edit touches), so a file holding something beyond it could be
//! opened but not edited: one object, artboard or guide out there made every move fail.
use std::collections::BTreeSet;
use std::sync::Arc;
use vectorcraft_geom::{Point, Rect};
@@ -72,27 +73,41 @@ fn clipping(n: &Node) -> Option<bool> {
}
}
/// Does `n`, or any object in it, reach beyond the canvas? A container is looked into object by
/// object: its own bounds leave out a layer's hidden objects and, when it clips, all but its
/// clipping path.
fn reaches_beyond(n: &Node) -> bool {
match clipping(n) {
None => beyond(n),
Some(_) => n.children().is_some_and(|c| c.iter().any(|c| reaches_beyond(c))),
/// The objects of a layer or group that a walk picked, by index in order, each with what was
/// picked inside it (nothing for an object that is not a container).
#[derive(Debug, Default)]
struct Picked(Vec<(usize, Picked)>);
/// What in `n` reaches beyond the canvas, by `far`, or `None` when nothing does. A container is
/// looked into object by object: its own bounds leave out a layer's hidden objects and, when it
/// clips, all but its clipping path. Each object is measured once, and the objects a clipping
/// path beyond the canvas clips are not measured: they go with it (see [`clips_beyond`]).
fn reach(n: &Node, far: &impl Fn(&Node) -> bool) -> Option<Picked> {
let Some(clip) = clipping(n) else { return far(n).then(Picked::default) };
let mut inner = Vec::new();
for (i, c) in n.children().into_iter().flatten().enumerate() {
if let Some(p) = reach(c, far) {
inner.push((i, p));
if clip && i == 0 {
break;
}
}
}
(!inner.is_empty()).then_some(Picked(inner))
}
/// Does `n` clip by a path that reaches beyond the canvas? Then the path and the objects it clips
/// go together, so no other object becomes the clipping path.
fn clips_beyond(n: &Node) -> bool {
clipping(n) == Some(true) && n.children().and_then(|c| c.first()).is_some_and(|c| reaches_beyond(c))
/// Does `n`, whose objects beyond the canvas are `found`, clip by a path that reaches beyond it?
/// Then the path and the objects it clips go together, so no other object becomes the clipping
/// path.
fn clips_beyond(n: &Node, found: &Picked) -> bool {
clipping(n) == Some(true) && found.0.first().is_some_and(|(i, _)| *i == 0)
}
/// Add the ids of `n` and the layers in it, if it is a layer, to `layers`: their layer guides go
/// with them.
fn layers_in(n: &Node, layers: &mut Vec<NodeId>) {
fn layers_in(n: &Node, layers: &mut BTreeSet<NodeId>) {
if matches!(n.kind, NodeKind::Layer { .. }) {
layers.push(n.id);
layers.insert(n.id);
}
if clipping(n).is_some() {
for c in n.children().into_iter().flatten() {
@@ -109,22 +124,22 @@ fn guides_in(n: &Node) -> usize {
}
}
/// Remove the objects in `node` that reach beyond the canvas: a layer or group keeps those of its
/// objects within it, unless its clipping path reaches beyond (see [`clips_beyond`]); anything
/// else goes whole. Only containers holding such an object are copied. Recursion follows the
/// nesting, which [`Document::limit_depth`] bounds. The layers removed are added to `layers`, and
/// the ruler guides they held to `guides`.
fn drop_children_beyond(node: &mut Arc<Node>, dropped: &mut usize, layers: &mut Vec<NodeId>, guides: &mut usize) {
if !node.children().is_some_and(|c| c.iter().any(|c| reaches_beyond(c))) {
return;
}
/// Remove the objects in `node` that reach beyond the canvas, which [`reach`] `found`: a layer or
/// group keeps those of its objects within it, unless its clipping path reaches beyond (see
/// [`clips_beyond`]); anything else goes whole. Only containers holding such an object are
/// copied, and only those are visited again. Recursion follows the nesting, which
/// [`Document::limit_depth`] bounds. The layers removed are added to `layers`, and the ruler
/// guides they held to `guides`.
fn drop_children_beyond(node: &mut Arc<Node>, found: Picked, dropped: &mut usize, layers: &mut BTreeSet<NodeId>, guides: &mut usize) {
let Some(children) = Arc::make_mut(node).children_mut() else { return };
let mut found = found.0.into_iter().peekable();
let mut next = 0;
children.retain_mut(|c| {
if !reaches_beyond(c) {
return true;
}
if clipping(c).is_some() && !clips_beyond(c) {
drop_children_beyond(c, dropped, layers, guides);
let at = next;
next += 1;
let Some((_, inner)) = found.next_if(|(i, _)| *i == at) else { return true };
if clipping(c).is_some() && !clips_beyond(c, &inner) {
drop_children_beyond(c, inner, dropped, layers, guides);
return true;
}
layers_in(c, layers);
@@ -134,21 +149,49 @@ fn drop_children_beyond(node: &mut Arc<Node>, dropped: &mut usize, layers: &mut
});
}
/// Is `id` unset, or not one of `ids`? The check takes time logarithmic in the number of ids.
fn not_in<T: Ord>(id: Option<T>, ids: &BTreeSet<T>) -> bool {
id.is_none_or(|i| !ids.contains(&i))
}
/// Remove the ruler guides of layer `layer` and of its sublayers that `out` picks, adding how many
/// to `dropped`. Only layers holding one are copied.
/// to `dropped`. `out` looks at each object in the layers once. Only layers holding one are
/// copied.
fn drop_guides(layer: &mut Arc<Node>, out: &impl Fn(&Node) -> bool, dropped: &mut usize) {
fn holds(n: &Node, out: &impl Fn(&Node) -> bool) -> bool {
n.is_layer() && n.children().is_some_and(|ch| ch.iter().any(|c| out(c) || holds(c, out)))
/// The objects of `n`, if it is a layer, that `out` picks (with nothing inside), and its
/// sublayers holding one (with what they hold), or `None` when it holds none.
fn holds(n: &Node, out: &impl Fn(&Node) -> bool) -> Option<Picked> {
if !n.is_layer() {
return None;
}
let inner: Vec<(usize, Picked)> = n
.children()
.into_iter()
.flatten()
.enumerate()
.filter_map(|(i, c)| if out(c) { Some((i, Picked::default())) } else { holds(c, out).map(|p| (i, p)) })
.collect();
(!inner.is_empty()).then_some(Picked(inner))
}
if !holds(layer, out) {
return;
fn drop(layer: &mut Arc<Node>, held: Picked, dropped: &mut usize) {
let Some(children) = Arc::make_mut(layer).children_mut() else { return };
let mut held = held.0.into_iter().peekable();
let mut next = 0;
children.retain_mut(|c| {
let at = next;
next += 1;
let Some((_, inner)) = held.next_if(|(i, _)| *i == at) else { return true };
// A sublayer holds something; an object picked itself has nothing inside.
if inner.0.is_empty() {
*dropped += 1;
return false;
}
drop(c, inner, dropped);
true
});
}
let Some(children) = Arc::make_mut(layer).children_mut() else { return };
let before = children.len();
children.retain(|c| !out(c));
*dropped += before - children.len();
for c in children.iter_mut().filter(|c| c.is_layer()) {
drop_guides(c, out, dropped);
if let Some(held) = holds(layer, out) {
drop(layer, held, dropped);
}
}
@@ -162,9 +205,10 @@ impl Document {
/// whose artboards were all removed has none left.
pub fn drop_beyond_canvas(&mut self) -> BeyondCanvas {
let mut gone = BeyondCanvas::default();
let mut layers = vec![];
let mut layers = BTreeSet::new();
for layer in &mut self.layers {
if clips_beyond(layer) {
let Some(found) = reach(layer, &beyond) else { continue };
if clips_beyond(layer, &found) {
let layer = Arc::make_mut(layer);
if let NodeKind::Layer { children, clip, .. } = &mut layer.kind {
for c in children.iter() {
@@ -177,7 +221,7 @@ impl Document {
*clip = false;
}
} else {
drop_children_beyond(layer, &mut gone.objects, &mut layers, &mut gone.guides);
drop_children_beyond(layer, found, &mut gone.objects, &mut layers, &mut gone.guides);
}
}
if gone.objects > 0 {
@@ -192,13 +236,13 @@ impl Document {
self.retire_artboard_id(*id);
}
gone.artboards = removed.len();
let removed: BTreeSet<u32> = removed.into_iter().collect();
// The saved list, when the guides are not nodes yet ([`Document::guides_into_nodes`]).
let guides = self.saved_guides.len();
self.saved_guides
.retain(|g| in_range(g.pos) && g.artboard.is_none_or(|a| !removed.contains(&a)) && g.layer.is_none_or(|l| !layers.contains(&l)));
self.saved_guides.retain(|g| in_range(g.pos) && not_in(g.artboard, &removed) && not_in(g.layer, &layers));
gone.guides += guides - self.saved_guides.len();
let out = |n: &Node| match n.kind {
NodeKind::RulerGuide { pos, artboard, .. } => !in_range(pos) || artboard.is_some_and(|a| removed.contains(&a)),
NodeKind::RulerGuide { pos, artboard, .. } => !in_range(pos) || !not_in(artboard, &removed),
_ => false,
};
for layer in &mut self.layers {
@@ -392,4 +436,153 @@ mod tests {
assert_eq!(d.assets.iter().map(|a| (a.id, a.nodes.clone())).collect::<Vec<_>>(), [(2, vec![NodeId(10)])]);
assert_eq!(d.variables.bindings.keys().copied().collect::<Vec<_>>(), [NodeId(10)]);
}
#[test]
fn guides_of_many_removed_artboards_and_layers_go_and_the_rest_keep_their_order() {
let probe = Document::new(1.0, 1.0);
// Sublayers 40 to 43 clip by a path beyond the canvas, so they go whole; 50 stays.
let far: Vec<Arc<Node>> = (40..44).map(|id| sublayer(&probe, id, vec![rect(id * 10, 1e17), rect(id * 10 + 1, 0.0)], true)).collect();
let near = sublayer(&probe, 50, vec![rect(500, 0.0)], false);
let mut d = doc(far.into_iter().chain([near, rect(10, 0.0)]).collect());
let kept = d.artboards[0].id;
for id in 9..13 {
d.artboards.push(Artboard { id, rect: Rect::new(0.0, 1e17, 100.0, 1e17 + 100.0), ..d.artboards[0].clone() });
}
let top = d.layers[0].id;
let guide = |pos: f64, artboard: Option<u32>, layer: Option<NodeId>| Guide { artboard, layer, ..Guide::new(false, pos) };
d.saved_guides = vec![
guide(1.0, Some(9), None),
guide(2.0, None, None),
guide(3.0, Some(kept), Some(NodeId(41))),
guide(4.0, Some(kept), None),
guide(5.0, Some(12), None),
guide(6.0, None, Some(NodeId(50))),
guide(7.0, None, Some(NodeId(43))),
guide(8.0, Some(10), Some(top)),
guide(9.0, None, Some(top)),
];
d.saved_selections = vec![crate::records::SavedSelection { name: "s".into(), objects: vec![NodeId(42), NodeId(10), NodeId(500)] }].into();
let mut nodes = d.clone();
assert_eq!(nodes.guides_into_nodes(), 9);
let gone = d.drop_beyond_canvas();
assert_eq!(gone, BeyondCanvas { objects: 4, artboards: 4, guides: 5, ruler_origin: false });
assert_eq!(d.artboards.iter().map(|a| a.id).collect::<Vec<_>>(), [kept]);
let left: Vec<f64> = d.saved_guides.iter().map(|g| g.pos).collect();
assert_eq!(left, [2.0, 4.0, 6.0, 9.0], "the guides that stay keep their order");
assert_eq!(d.saved_selections[0].objects, [NodeId(10), NodeId(500)]);
assert_eq!(nodes.drop_beyond_canvas(), gone, "guide nodes go as saved guides do");
let mut left: Vec<f64> = nodes.ruler_guides().iter().map(|g| g.pos).collect();
left.sort_by(f64::total_cmp);
assert_eq!(left, [2.0, 4.0, 6.0, 9.0]);
assert_eq!(nodes.saved_selections, d.saved_selections);
}
thread_local! {
static COMPARISONS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// An id that counts how often it is compared.
#[derive(Debug)]
struct Counted(u32);
impl Ord for Counted {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
COMPARISONS.with(|c| c.set(c.get() + 1));
self.0.cmp(&other.0)
}
}
impl PartialOrd for Counted {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for Counted {
fn eq(&self, other: &Self) -> bool {
self.cmp(other) == std::cmp::Ordering::Equal
}
}
impl Eq for Counted {}
#[test]
fn a_guide_is_checked_without_scanning_every_removed_id() {
let per_guide = |removed: u32| {
let ids: BTreeSet<Counted> = (0..removed).map(|i| Counted(i * 2)).collect();
COMPARISONS.with(|c| c.set(0));
// Guides on removed ids, on ids between them, on ids past them and on none.
let guides: Vec<Option<Counted>> = (0..64).map(|i| (i % 4 != 3).then(|| Counted(i * 31 % (removed * 2 + 8)))).collect();
let kept = guides.into_iter().filter(|g| not_in(g.as_ref().map(|c| Counted(c.0)), &ids)).count();
assert!(kept > 0 && kept < 64);
COMPARISONS.with(|c| c.get()) as f64 / 64.0
};
let small = per_guide(16);
let large = per_guide(16_384);
// A sorted lookup grows with the depth of the tree; a scan of 16,384 ids compares thousands per guide.
assert!(large < small * 32.0 && large < 256.0, "{small} comparisons per guide among 16 ids, {large} among 16,384");
}
#[test]
fn each_object_is_measured_once_however_deep_the_nesting() {
// 32 groups, each inside the one before and holding an object within the canvas; the
// innermost also holds one beyond it. Beside them, a group with nothing beyond and a clip
// group whose clipping path reaches beyond.
let mut chain = Arc::new(Node::group(NodeId(100), vec![rect(200, 0.0), rect(201, 1e17)]));
for depth in 1..32 {
chain = Arc::new(Node::group(NodeId(100 + depth), vec![rect(300 + depth, 0.0), chain]));
}
let still = Arc::new(Node::group(NodeId(400), vec![rect(401, 0.0), rect(402, 5.0)]));
let clip = Arc::new(Node::new(NodeId(600), NodeKind::Group { children: vec![rect(601, 1e17), rect(602, 0.0), rect(603, 0.0)], clip: true }));
let mut d = doc(vec![chain, Arc::clone(&still), clip]);
let mut whole = d.clone();
let measured = std::cell::Cell::new(0_usize);
let far = |n: &Node| {
measured.set(measured.get() + 1);
beyond(n)
};
let layer = &mut d.layers[0];
let found = reach(layer, &far).unwrap();
assert_eq!(
measured.get(),
36,
"the 33 objects in the groups, the 2 beside them and the clipping path, each measured once; not what the path clips"
);
assert!(!clips_beyond(layer, &found));
let (mut dropped, mut layers, mut guides) = (0, BTreeSet::new(), 0);
drop_children_beyond(layer, found, &mut dropped, &mut layers, &mut guides);
assert_eq!(measured.get(), 36, "removing measures nothing again");
assert_eq!((dropped, layers.len(), guides), (2, 0, 0));
assert!(d.layers[0].children().is_some_and(|c| Arc::ptr_eq(&c[1], &still)), "a group with nothing beyond is not copied");
assert_eq!(whole.drop_beyond_canvas(), BeyondCanvas { objects: 2, ..Default::default() });
assert_eq!(ids(&whole), ids(&d));
assert!(!ids(&d).contains(&201) && !ids(&d).contains(&600) && ids(&d).contains(&200) && ids(&d).contains(&331));
}
#[test]
fn each_object_is_looked_at_once_when_guides_go_from_nested_layers() {
let guide = |id: u64, pos: f64| Arc::new(Node::new(NodeId(id), NodeKind::RulerGuide { vertical: false, pos, artboard: None }));
let probe = Document::new(1.0, 1.0);
// 32 sublayers, each inside the one before, each holding a guide within the canvas and one
// beyond it. Beside them, a sublayer with nothing to remove.
let mut chain = sublayer(&probe, 100, vec![guide(200, 5.0), guide(201, 1e17)], false);
for depth in 1..32 {
chain = sublayer(&probe, 100 + depth, vec![guide(300 + depth * 2, 5.0), guide(301 + depth * 2, 1e17), chain], false);
}
let still = sublayer(&probe, 500, vec![guide(501, 5.0), rect(502, 0.0)], false);
let mut d = doc(vec![chain, Arc::clone(&still)]);
let looked = std::cell::Cell::new(0_usize);
let out = |n: &Node| {
looked.set(looked.get() + 1);
matches!(n.kind, NodeKind::RulerGuide { pos, .. } if !in_range(pos))
};
let mut dropped = 0;
drop_guides(&mut d.layers[0], &out, &mut dropped);
assert_eq!(dropped, 32);
assert_eq!(looked.get(), 2 + 2 + 31 * 3 + 2, "each object in the layers is looked at once");
assert!(d.layers[0].children().is_some_and(|c| Arc::ptr_eq(&c[1], &still)), "a sublayer with nothing to remove is not copied");
let left = d.ruler_guides();
assert_eq!(left.len(), 33);
assert!(left.iter().all(|g| g.pos == 5.0));
}
}
+20 -3
View File
@@ -20,7 +20,9 @@ use vectorcraft_doc::{Node, NodeId, OrientedBox};
use vectorcraft_geom::{Affine, Point, Rect};
use vectorcraft_render::effects;
use super::super::appearance::series_children_in_paint_order;
use super::super::edit::selected_roots;
use super::super::graph::capture_series_object_opacity;
use super::super::menucmds::whole_or;
use super::super::object::{choice, object_bounds_transform, scaling, transform_node, transform_patterns};
use super::super::typecmd::refresh_bounds_of;
@@ -90,7 +92,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Randomize Opacity",
["Object", "Plug-ins", "Arrange Tools"],
None,
"{min?: % 0..100 (30), max?: % 0..100 (100; not less than min), seed?: whole number (0; the same seed, objects and range give the same opacities), ids?: [id…] (default: the selection)} give each selected object (the top-level ones) its own opacity, picked at random and evenly from min to max, as one undo step; it is the object's opacity, as the Transparency panel sets it → {count}",
"{min?: % 0..100 (30), max?: % 0..100 (100; not less than min), seed?: whole number (0; the same seed, objects and range give the same opacities), ids?: [id…] (default: the selection)} give each selected object (the top-level ones) its own opacity, picked at random and evenly from min to max, as one undo step; it is the object's opacity, as the Transparency panel sets it. On paths directly in a graph series whose opacity changes, the graph stores the opacity and blend mode of the frontmost of them for its next redraw (docs/mcp.md) → {count}",
has_selection,
randomize_opacity
),
@@ -99,7 +101,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Sort Objects",
["Object", "Plug-ins", "Arrange Tools"],
None,
"{by?: \"width\" | \"height\" | \"area\" (width × height) | \"x\" (left edge) | \"y\" (top edge) | \"opacity\" (%) | \"stacking\" (stacking order, from the back) (\"area\"), apply?: one of the same (\"stacking\"), order?: \"ascending\" (small to large) | \"descending\" (large to small) | \"random\" (\"ascending\"), distribute?: false (true: the values step evenly from the smallest to the largest; false: the objects trade the values they have), seed?: whole number (0; the order \"random\" picks), scaleStrokes?: the Scale Strokes & Effects preference (width, height and area), ids?: [id…] (default: the selection)} sort the selected objects (the top-level ones, at most 20000) by the attribute `by` and give them the values of `apply` in that order, as one undo step: the first in order gets the smallest value. Sizes and places are measured and set as object.setBounds measures them (Use Preview Bounds), a width, height or area about each object's centre (an area in proportion); stacking order always trades places, and only among the objects in the same layer or group. A run that changes nothing makes no step → {count}",
"{by?: \"width\" | \"height\" | \"area\" (width × height) | \"x\" (left edge) | \"y\" (top edge) | \"opacity\" (%) | \"stacking\" (stacking order, from the back) (\"area\"), apply?: one of the same (\"stacking\"), order?: \"ascending\" (small to large) | \"descending\" (large to small) | \"random\" (\"ascending\"), distribute?: false (true: the values step evenly from the smallest to the largest; false: the objects trade the values they have), seed?: whole number (0; the order \"random\" picks), scaleStrokes?: the Scale Strokes & Effects preference (width, height and area), ids?: [id…] (default: the selection)} sort the selected objects (the top-level ones, at most 20000) by the attribute `by` and give them the values of `apply` in that order, as one undo step: the first in order gets the smallest value. Sizes and places are measured and set as object.setBounds measures them (Use Preview Bounds), a width, height or area about each object's centre (an area in proportion); stacking order always trades places, and only among the objects in the same layer or group. With apply \"opacity\", on paths directly in a graph series whose opacity changes, the graph stores the opacity and blend mode of the frontmost of them for its next redraw (docs/mcp.md). A run that changes nothing makes no step → {count}",
has_multi,
sort
),
@@ -396,17 +398,30 @@ fn randomize_opacity(s: &mut Session, p: &Value) -> Result<Value> {
}
let (lo, hi) = ((min / 100.0) as f32, (max / 100.0) as f32);
s.edit("Randomize Opacity", |d, _| {
let mut changed = vec![];
for id in &ids {
let o = rng.range(lo, hi);
if let Some(n) = d.node_mut(*id) {
if let Some(n) = d.node_mut(*id)
&& n.opacity != o
{
n.opacity = o;
changed.push(*id);
}
}
keep_series_opacity(d, &changed);
Ok(())
})?;
Ok(json!({ "count": ids.len() }))
}
/// Store on their graphs the opacity just given to the paths among `changed` (objects whose opacity changed) that are
/// directly in a graph series, with their blend mode, so that every path of the series has them when the graph is drawn
/// again; the frontmost of them in a series sets them.
fn keep_series_opacity(d: &mut vectorcraft_doc::Document, changed: &[NodeId]) {
let marks = series_children_in_paint_order(d, changed);
capture_series_object_opacity(d, &marks);
}
/// An object Sort Objects sorts: its layer or group, its place in it, its box as
/// `object.setBounds` measures it and its opacity (%).
struct Sorted {
@@ -510,6 +525,8 @@ fn sort(s: &mut Session, p: &Value) -> Result<Value> {
n.opacity = (v / 100.0) as f32;
}
}
let changed: Vec<NodeId> = wanted.iter().filter(|(o, v)| (o.opacity - v).abs() >= 1e-6).map(|(o, _)| o.id).collect();
keep_series_opacity(d, &changed);
Ok(())
})?;
return Ok(count);
+8 -2
View File
@@ -806,12 +806,18 @@ pub(super) fn capture_series_writes(
/// and objects the edit left as they were keep what the graph stores. When the edit changes several marks of one series,
/// the frontmost one sets what the graph stores, whatever order `ids` are in. Returns whether the stored paint changed.
pub(crate) fn capture_series_changes(before: &vectorcraft_doc::Document, d: &mut vectorcraft_doc::Document, ids: &[NodeId]) -> bool {
let marks = series_children_in_paint_order(d, ids);
!marks.is_empty() && capture_series_writes(before, d, &marks, (false, false), (false, false), false, false)
}
/// Each of `ids` directly in a series group, from the back to the front: a later mark's capture replaces an earlier
/// one's, so the frontmost one sets what the graph stores.
pub(crate) fn series_children_in_paint_order(d: &vectorcraft_doc::Document, ids: &[NodeId]) -> Vec<NodeId> {
// Only objects directly in a series group can be marks: other edits skip the search of the document for graphs.
let in_series = |id: &NodeId| d.parent_of(*id).and_then(|p| d.node(p)).is_some_and(|g| g.extras().series_index.is_some());
let mut marks: Vec<NodeId> = ids.iter().copied().filter(in_series).collect();
// A later mark's capture replaces an earlier one's: take them in paint order.
marks.sort_by_cached_key(|id| d.index_path(*id));
!marks.is_empty() && capture_series_writes(before, d, &marks, (false, false), (false, false), false, false)
marks
}
/// Store on the graph the paint that an edit of `ids` (from `before` to `d`) leaves on the topmost visible fill and stroke
+228 -51
View File
@@ -18,7 +18,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Document Info",
["Window", "Document Info"],
None,
"{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts (the type in opacity masks and in the art of symbols and patterns included; with selectionOnly: the selected type's), images, swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the brushes the art's drawn strokes use, each once; with selectionOnly: those the selected objects' strokes use), brushes: [{name, type: calligraphic|scatter|art|pattern|bristle|null}] (those brushes with their types; null: not in the Brushes panel), panelBrushNames (the Brushes panel's brushes), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), spotObjects: [{id, name, spotColors}] (the objects filled or stroked with a spot color swatch, as a solid color or in the stops of a gradient that color a part of it above opacity 0 (a stop at opacity 0 counts only where it mixes with a stop above opacity 0 over a stretch of some width), at a tint above 0, and grayscale images colorized with one, each once, by the rules patternObjects follows, with the spot colors they use; Registration and process colors are not spot colors; objects.spots counts them), spotColorNames and spotColors (the spot colors those objects use), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, fills and strokes at an opacity of 0, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else Linear gradient, Radial gradient or Freeform gradient; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone. brushNames, brushes, spotObjects, patternObjects and gradientObjects leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0 (with selectionOnly too), their characters' paints and colorized images included; objects still counts them as paths, groups and the other kinds",
"{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document: {…, units (English), unitId: the units' Preferences › Units id (points, millimeters, feetInches, …), rasterEffectsPpi}, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts (the type in opacity masks and in the art of symbols and patterns included; with selectionOnly: the selected type's), fontDetails: [{font, match: exact|style|missingWithFallback|missing, family, style, file, embedding: allowed|editing|previewPrint|forbidden|null}] (each font of fonts, in order: how it was found, the face shown (null when none), that face's file name (null for a built-in face) and what its license allows), images, imageObjects: [{name, width, height, linked, file}] (the image objects in the order Linked Images and Embedded Images list them; file: what a linked image's row shows, null for an embedded one), swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the brushes the art's drawn strokes use, each once; with selectionOnly: those the selected objects' strokes use), brushes: [{name, type: calligraphic|scatter|art|pattern|bristle|null}] (those brushes with their types; null: not in the Brushes panel), panelBrushNames (the Brushes panel's brushes), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), spotObjects: [{id, name, spotColors}] (the objects filled or stroked with a spot color swatch, as a solid color or in the stops of a gradient that color a part of it above opacity 0 (a stop at opacity 0 counts only where it mixes with a stop above opacity 0 over a stretch of some width), at a tint above 0, and grayscale images colorized with one, each once, by the rules patternObjects follows, with the spot colors they use; Registration and process colors are not spot colors; objects.spots counts them), spotColorNames and spotColors (the spot colors those objects use), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, fills and strokes at an opacity of 0, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients, kinds}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else its kind's name, such as Linear gradient; kinds gives each one's kind, linear|radial|conic|diamond|freeform, when it is named by its kind, else null; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone. brushNames, brushes, spotObjects, patternObjects and gradientObjects leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0 (with selectionOnly too), their characters' paints and colorized images included; objects still counts them as paths, groups and the other kinds",
has_doc,
info
),
@@ -85,17 +85,65 @@ pub struct Section {
/// What a font's `fsType` lets a copy of it do, read as exports read it ([`Embedding`]): the
/// most permissive usage bit wins, and bitmap-only fonts may not be embedded.
pub fn embedding_label(fs_type: u16) -> &'static str {
if Embedding::from_fs_type(fs_type) == Embedding::Forbidden {
"embedding not allowed"
} else if fs_type & 0x0008 != 0 {
"embedding for editing"
} else if fs_type & 0x0004 != 0 {
"embedding for preview and print"
} else {
"embedding allowed"
match embedding_id(fs_type) {
"forbidden" => "embedding not allowed",
"editing" => "embedding for editing",
"previewPrint" => "embedding for preview and print",
_ => "embedding allowed",
}
}
/// [`embedding_label`] as the `embedding` value of a `fontDetails` entry: `forbidden`, `editing`,
/// `previewPrint` or `allowed`.
pub fn embedding_id(fs_type: u16) -> &'static str {
if Embedding::from_fs_type(fs_type) == Embedding::Forbidden {
"forbidden"
} else if fs_type & 0x0008 != 0 {
"editing"
} else if fs_type & 0x0004 != 0 {
"previewPrint"
} else {
"allowed"
}
}
/// A font as Font Details lists it: its `fontDetails` entry and its row. The row gives the file
/// the font is drawn from (`built in` for a face with no file) and whether its license lets it be
/// embedded; for a style the family lacks, the face shown in its place; for a font that is not
/// installed, the face shown instead, or `missing`. The entry holds the same facts as values
/// (`match`: `exact`, `style`, `missingWithFallback` or `missing`), so the panel can show them in
/// the interface language.
fn font_detail(used: &super::fonts::UsedFont) -> (Value, (String, String)) {
let db = vectorcraft_text::FontDb::global();
let (family, style, version) = used;
let label = super::fonts::font_label(used);
// Found by any of its names (in the version the type names); a style the family lacks shows in
// another.
let resolved = db.resolve(family, style).map(|(f, m)| (db.face_version(family, style, version.as_deref()).unwrap_or(f), m));
let (entry, detail) = match resolved {
Some((f, m)) if m != vectorcraft_text::FontMatch::Missing => {
let file = f.path().and_then(|p| p.file_name()).map(|n| n.to_string_lossy().into_owned());
let found = format!("{}; {}", file.as_deref().unwrap_or("built in"), embedding_label(f.fs_type()));
let substituted = m == vectorcraft_text::FontMatch::Style;
let entry = json!({
"font": label,
"match": if substituted { "style" } else { "exact" },
"family": f.family,
"style": f.style,
"file": file,
"embedding": embedding_id(f.fs_type()),
});
(entry, if substituted { format!("substituted: shown in {} {} ({found})", f.family, f.style) } else { found })
}
Some((f, _)) => (
json!({ "font": label, "match": "missingWithFallback", "family": f.family, "style": f.style, "file": null, "embedding": null }),
format!("missing: shown in {} {}", f.family, f.style),
),
None => (json!({ "font": label, "match": "missing", "family": null, "style": null, "file": null, "embedding": null }), "missing".into()),
};
(entry, (label, detail))
}
/// An image object as Document Info lists it: (name, width, height, linked file).
type ImageRow = (String, u32, u32, Option<String>);
@@ -131,14 +179,15 @@ fn repeat_entry(d: &Document, n: &Node, spec: &RepeatSpec) -> (Value, (String, S
}
/// The Document Info categories of `d` (only `category` when given) from `info` (what
/// `document.info` reports), its fonts, its image objects, the rows of the brushes its art uses, the
/// rows of its Repeat objects and the rows of its objects filled or stroked with a spot color, with a
/// pattern and with a gradient.
/// `document.info` reports), its fonts and their Font Details rows, its image objects, the rows of
/// the brushes its art uses, the rows of its Repeat objects and the rows of its objects filled or
/// stroked with a spot color, with a pattern and with a gradient.
#[allow(clippy::too_many_arguments)]
fn sections(
d: &Document,
info: &Value,
fonts: &BTreeSet<super::fonts::UsedFont>,
font_details: &[(String, String)],
images: &[ImageRow],
brushes: &[(String, String)],
repeats: &[(String, String)],
@@ -192,34 +241,7 @@ fn sections(
"gradients" => gradient_objects.to_vec(),
"symbols" => names("symbols"),
"fonts" => fonts.iter().map(|f| (super::fonts::font_label(f), String::new())).collect(),
"fontDetails" => {
let db = vectorcraft_text::FontDb::global();
fonts
.iter()
.map(|used| {
let (family, style, version) = used;
// Found by any of its names (in the version the type names); a style the
// family lacks shows in another.
let resolved =
db.resolve(family, style).map(|(f, m)| (db.face_version(family, style, version.as_deref()).unwrap_or(f), m));
let detail = match resolved {
Some((f, m)) if m != vectorcraft_text::FontMatch::Missing => {
let file =
f.path().and_then(|p| p.file_name()).map_or_else(|| "built in".into(), |n| n.to_string_lossy().into_owned());
let found = format!("{file}; {}", embedding_label(f.fs_type()));
if m == vectorcraft_text::FontMatch::Style {
format!("substituted: shown in {} {} ({found})", f.family, f.style)
} else {
found
}
}
Some((f, _)) => format!("missing: shown in {} {}", f.family, f.style),
None => "missing".into(),
};
(super::fonts::font_label(used), detail)
})
.collect()
}
"fontDetails" => font_details.to_vec(),
"linkedImages" => {
images.iter().filter_map(|(name, w, h, link)| Some((name.clone(), format!("{w} × {h} px — {}", link.as_ref()?)))).collect()
}
@@ -277,6 +299,39 @@ fn gradient_label(p: &Paint) -> Option<String> {
}
}
/// Where [`gradient_label`]'s name for gradient paint `p` comes from: `swatch:<name>` for a
/// gradient linked to a swatch, else `kind:<kind>` (`linear`, `radial`, `conic`, `diamond` or
/// `freeform`). The two prefixes keep a swatch's name apart from a kind's name it reads like.
fn gradient_source(p: &Paint) -> Option<String> {
match p {
Paint::Gradient(g) => Some(match g.swatch.as_deref().filter(|s| !s.is_empty()) {
Some(swatch) => format!("swatch:{swatch}"),
None => format!("kind:{}", g.gradient.kind.label().to_ascii_lowercase()),
}),
_ => None,
}
}
/// For each of `names` (an object's [`gradient_label`]s), the kind it names when only a kind
/// gives that name: a name one of `sources` (the object's [`gradient_source`]s) gives as a kind's
/// and none gives as a swatch's, else null. A swatch named like a kind keeps its name even where
/// a gradient of that kind is listed under the same name.
fn gradient_kinds(names: &[String], sources: &[String]) -> Vec<Value> {
names
.iter()
.map(|name| {
if sources.iter().any(|s| s.strip_prefix("swatch:") == Some(name.as_str())) {
return Value::Null;
}
sources
.iter()
.filter_map(|s| s.strip_prefix("kind:"))
.find(|k| vectorcraft_color::GradientKind::parse(k).is_some_and(|kind| *name == format!("{} gradient", kind.label())))
.map_or(Value::Null, |k| json!(k))
})
.collect()
}
/// The names of `d`'s spot color swatches: the swatches whose prints go to a plate of their own
/// ([`vectorcraft_doc::inks::inks`]). A name held by several swatches is the first one's, as
/// [`Document::swatch`] finds it, and the Registration swatch prints on every plate, so it is not
@@ -486,9 +541,11 @@ fn node_and_drawn<'a>(d: &'a Document, path: &[usize]) -> Option<(&'a Node, bool
/// The spot colors, the patterns and the gradients (`spots`: [`spot_swatches`]) that object `n`
/// paints, each once: those of its own fills and strokes ([`own_paints`], `members` included), of
/// its drawn characters and, for a grayscale or 1-bit image, of the color it is colorized with.
fn object_paints(d: &Document, spots: &HashSet<&str>, members: &HashSet<*const Node>, n: &Node) -> [Vec<String>; 3] {
/// The fourth list gives where each gradient comes from: a swatch or a kind ([`gradient_source`]).
fn object_paints(d: &Document, spots: &HashSet<&str>, members: &HashSet<*const Node>, n: &Node) -> [Vec<String>; 4] {
let (spot, pattern, gradient) = (|p: &Paint| spot_labels(spots, p), one_label(pattern_label), one_label(gradient_label));
let labels: [&PaintNames<'_>; 3] = [&spot, &pattern, &gradient];
let gradient_from = one_label(gradient_source);
let labels: [&PaintNames<'_>; 4] = [&spot, &pattern, &gradient, &gradient_from];
let painted_runs = painted_runs(d, spots, n);
let mut used = labels.map(|label| own_paints(d, n, members, painted_runs.as_ref(), label));
// The characters' own paints: an inline graphic draws no outline and does not take its run's
@@ -654,8 +711,10 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(k) = k {
*counts.entry(k).or_default() += 1;
}
// The spot colors, the patterns and the gradients this object paints, each once; none when it does not draw.
let [used_spots, used_patterns, used_gradients] = if drawn { object_paints(d, &spot_swatches, &members, n) } else { Default::default() };
// The spot colors, the patterns and the gradients this object paints, each once, and where each gradient comes from;
// none when it does not draw.
let [used_spots, used_patterns, used_gradients, used_sources] =
if drawn { object_paints(d, &spot_swatches, &members, n) } else { Default::default() };
// Objects counts the objects that Spot Color Objects, Pattern Objects and Gradient Objects list.
if !used_spots.is_empty() {
let name = n.display_name();
@@ -675,7 +734,8 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
let name = n.display_name();
gradients.extend(used_gradients.iter().cloned());
gradient_rows.push((name.clone(), used_gradients.join(", ")));
gradient_objects.push(json!({ "id": n.id.0, "name": name, "gradients": used_gradients }));
let kinds = gradient_kinds(&used_gradients, &used_sources);
gradient_objects.push(json!({ "id": n.id.0, "name": name, "gradients": used_gradients, "kinds": kinds }));
*counts.entry("gradients").or_default() += 1;
}
if n.extras().mask.is_some() {
@@ -710,6 +770,14 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
fonts.extend(super::fonts::art_texts_of(d).into_iter().flat_map(|(_, t, _)| t.runs.iter().map(|r| super::fonts::font_of(&r.style))));
}
let font_names: Vec<String> = fonts.iter().map(super::fonts::font_label).collect();
let (font_entries, font_rows): (Vec<Value>, Vec<(String, String)>) = fonts.iter().map(font_detail).unzip();
// The image objects in walk order, as Linked Images and Embedded Images list them: `file` is a
// linked image's row value (its path, or its file name alone when the request may not read it),
// and null for an embedded one.
let image_objects: Vec<Value> = image_rows
.iter()
.map(|(name, w, h, file)| json!({ "name": name, "width": w, "height": h, "linked": file.is_some(), "file": file }))
.collect();
// 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.
@@ -727,7 +795,9 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
"objects": counts,
"pathLength": path_length,
"fonts": font_names,
"fontDetails": font_entries,
"images": images,
"imageObjects": image_objects,
"symbols": symbols,
"spotColors": spot,
"spotColorNames": spot,
@@ -749,7 +819,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
});
// The document's name: its file's, else its title.
out["document"]["name"] = json!(st.title());
let sections = sections(d, &out, &fonts, &image_rows, &brush_rows, &repeat_rows, &spot_rows, &pattern_rows, &gradient_rows, category);
let sections = sections(d, &out, &fonts, &font_rows, &image_rows, &brush_rows, &repeat_rows, &spot_rows, &pattern_rows, &gradient_rows, category);
if text {
return Ok(json!({ "text": report_text(&st.title(), selection_only, &sections) }));
}
@@ -763,6 +833,7 @@ fn document_summary(d: &Document) -> Value {
"title": d.title,
"colorMode": match d.color_mode { ColorMode::Rgb => "RGB", ColorMode::Cmyk => "CMYK" },
"units": d.units.label(),
"unitId": d.units.key(),
"artboards": d.artboards.iter().map(|a| json!({ "name": a.name, "width": a.rect.width() / u, "height": a.rect.height() / u })).collect::<Vec<_>>(),
"rasterEffectsPpi": d.raster_effects_ppi,
})
@@ -1289,11 +1360,11 @@ mod tests {
assert_eq!(
i["gradientObjects"],
json!([
{"id": a, "name": "Both", "gradients": ["Ramp", "Linear gradient"]},
{"id": b, "name": "<Rectangle>", "gradients": ["Radial gradient"]},
{"id": f, "name": "<Rectangle>", "gradients": ["Freeform gradient"]},
{"id": t, "name": "Type", "gradients": ["Ramp"]},
{"id": bar, "name": "Bar", "gradients": ["Ramp"]},
{"id": a, "name": "Both", "gradients": ["Ramp", "Linear gradient"], "kinds": [null, "linear"]},
{"id": b, "name": "<Rectangle>", "gradients": ["Radial gradient"], "kinds": ["radial"]},
{"id": f, "name": "<Rectangle>", "gradients": ["Freeform gradient"], "kinds": ["freeform"]},
{"id": t, "name": "Type", "gradients": ["Ramp"], "kinds": [null]},
{"id": bar, "name": "Bar", "gradients": ["Ramp"], "kinds": [null]},
])
);
assert_eq!(i["gradientNames"], json!(["Freeform gradient", "Linear gradient", "Radial gradient", "Ramp"]));
@@ -1800,6 +1871,112 @@ mod tests {
assert_eq!(embedding_label(0x0003), "embedding not allowed");
assert_eq!(embedding_label(0x0006), "embedding for preview and print");
assert_eq!(embedding_label(0x000c), "embedding for editing");
// `fontDetails` names each permission by id.
assert_eq!(
[0, 0x0002, 0x0104, 0x0008, 0x0200, 0x000c].map(embedding_id),
["allowed", "forbidden", "previewPrint", "editing", "forbidden", "editing"]
);
}
/// `fontDetails` gives each Font Details row's facts as values, in the rows' order: how the
/// font was found, the face shown, its file (null for a built-in face) and its embedding
/// permission. The rows and the report stay in English.
#[test]
fn info_exposes_structured_font_details_without_changing_english_rows() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
s.execute("text.create", &json!({"x": 10, "y": 20, "text": "Hi"})).unwrap();
s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Heavy", "font": "Source Sans 3", "style": "Black Wide"})).unwrap();
s.execute("text.create", &json!({"x": 10, "y": 80, "text": "Gone", "font": "Qx Absent Family"})).unwrap();
let i = s.execute("document.info", &json!({"category": "fontDetails"})).unwrap();
let (entries, rows) = (i["fontDetails"].as_array().unwrap(), i["sections"][0]["rows"].as_array().unwrap());
assert_eq!(entries.iter().map(|e| e["font"].clone()).collect::<Vec<_>>(), rows.iter().map(|r| r[0].clone()).collect::<Vec<_>>());
let at = |prefix: &str| entries.iter().position(|e| e["font"].as_str().unwrap().starts_with(prefix)).unwrap();
let regular = at("Source Sans 3 Regular");
assert_eq!(
entries[regular],
json!({"font": "Source Sans 3 Regular", "match": "exact", "family": "Source Sans 3", "style": "Regular", "file": null, "embedding": "allowed"})
);
assert_eq!(rows[regular][1], "built in; embedding allowed");
let (wide, e) = (at("Source Sans 3 Black Wide"), &entries[at("Source Sans 3 Black Wide")]);
assert_eq!((e["match"].as_str(), e["family"].as_str()), (Some("style"), Some("Source Sans 3")), "{e}");
let file = e["file"].as_str().unwrap_or("built in");
let fs_type = [("allowed", 0), ("forbidden", 0x0002), ("previewPrint", 0x0004), ("editing", 0x0008)]
.into_iter()
.find_map(|(id, bits)| (e["embedding"] == id).then_some(bits))
.unwrap();
let found = format!("{file}; {}", embedding_label(fs_type));
assert_eq!(rows[wide][1], format!("substituted: shown in Source Sans 3 {} ({found})", e["style"].as_str().unwrap()));
let (gone, e) = (at("Qx Absent Family"), &entries[at("Qx Absent Family")]);
assert!(e["file"].is_null() && e["embedding"].is_null(), "{e}");
match e["match"].as_str() {
Some("missingWithFallback") => {
assert_eq!(rows[gone][1], format!("missing: shown in {} {}", e["family"].as_str().unwrap(), e["style"].as_str().unwrap()))
}
Some("missing") => assert_eq!((rows[gone][1].as_str(), e["family"].is_null()), (Some("missing"), true)),
m => panic!("{m:?}"),
}
let text = s.execute("document.info", &json!({"category": "fontDetails", "format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
assert!(text.contains("Source Sans 3 Regular: built in; embedding allowed\n"), "{text}");
}
/// `document.unitId` names the document's units as Preferences › Units does, beside the English
/// `units`, and `imageObjects` lists the image objects in the order Embedded Images and Linked
/// Images list them, with the file a linked one shows (null for an embedded one).
#[test]
fn info_exposes_ordered_images_and_unit_id() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
s.edit("Units", |d, _| {
d.units = vectorcraft_doc::Unit::Millimeters;
Ok(())
})
.unwrap();
for x in [0.0, 50.0] {
let r = s.execute("shape.rectangle", &json!({"x": x, "y": 0, "width": 20, "height": 10})).unwrap()["id"].clone();
s.execute("select.set", &json!({"ids": [r]})).unwrap();
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
}
let i = s.execute("document.info", &json!({})).unwrap();
assert_eq!((i["document"]["units"].as_str(), i["document"]["unitId"].as_str()), (Some("Millimeters"), Some("millimeters")));
let section = |id: &str| i["sections"].as_array().unwrap().iter().find(|s| s["id"] == id).unwrap()["rows"].as_array().unwrap().clone();
assert!(section("document").iter().any(|r| *r == json!(["Units", "Millimeters"])));
let embedded = section("embeddedImages");
let objects = i["imageObjects"].as_array().unwrap();
assert_eq!(objects.len(), 2, "{objects:?}");
for (o, r) in objects.iter().zip(&embedded) {
assert_eq!((o["linked"].clone(), o["file"].clone(), o["name"].clone()), (json!(false), Value::Null, r[0].clone()), "{o}");
assert_eq!(r[1], format!("{} × {} px", o["width"], o["height"]));
}
assert!(section("linkedImages").is_empty());
}
/// A `gradientObjects` entry's `kinds` gives the kind of each gradient listed by its kind
/// rather than by a swatch, and null for a swatch's name, even one that reads like a kind and
/// one an object's gradient of that kind shares; a type object's characters count as its own.
#[test]
fn gradient_kinds_tell_kinds_from_swatch_names() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
let ramp = |kind: &str| json!({"kind": kind, "stops": [{"offset": 0, "color": "#000"}, {"offset": 1, "color": "#fff"}]});
s.execute("swatch.new", &json!({"name": "Radial gradient", "gradient": ramp("linear")})).unwrap();
let r = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"ids": [r], "swatch": "Radial gradient"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [r], "gradient": ramp("conic")})).unwrap();
let t = s.execute("text.create", &json!({"x": 10, "y": 40, "text": "Hi"})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"ids": [t], "gradient": ramp("diamond")})).unwrap();
// The swatch's name and a radial gradient's kind name are listed once, as the name.
let both = s.execute("shape.rectangle", &json!({"x": 20, "y": 0, "width": 10, "height": 10})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"ids": [both], "swatch": "Radial gradient"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [both], "gradient": ramp("radial")})).unwrap();
let i = s.execute("document.info", &json!({})).unwrap();
let entry = |id: &Value| i["gradientObjects"].as_array().unwrap().iter().find(|e| e["id"] == *id).unwrap().clone();
assert_eq!(
(entry(&r)["gradients"].clone(), entry(&r)["kinds"].clone()),
(json!(["Radial gradient", "Conic gradient"]), json!([null, "conic"]))
);
assert_eq!((entry(&t)["gradients"].clone(), entry(&t)["kinds"].clone()), (json!(["Diamond gradient"]), json!(["diamond"])));
assert_eq!((entry(&both)["gradients"].clone(), entry(&both)["kinds"].clone()), (json!(["Radial gradient"]), json!([null])));
}
#[test]
+26 -11
View File
@@ -15,15 +15,27 @@ const SMOOTH_SPREAD: f64 = 1.0 / 3.0;
/// The options the Smooth tool refits with: the path smoothed along its length by a Gaussian of
/// spread `sigma` (none at 0), then refitted within `tol` of that and within twice the distance the
/// smoothing moved it, keeping a corner only where the path turns back on itself.
fn refit_options(tol: f64, sigma: f64) -> SimplifyOptions {
SimplifyOptions { tolerance: tol, corner_angle_deg: 179.0, straight_lines: false, smooth: sigma, smooth_moved_only: true }
/// smoothing moved it, keeping a corner only where the path turns back on itself. `free` says whether
/// the start and the end of the stretch refitted are ends of an open path, whose direction then
/// follows the smoothed path within the reach rather than the first or last segment.
fn refit_options(tol: f64, sigma: f64, free: [bool; 2]) -> SimplifyOptions {
SimplifyOptions {
tolerance: tol,
corner_angle_deg: 179.0,
straight_lines: false,
smooth: sigma,
smooth_moved_only: true,
free_start: free[0],
free_end: free[1],
}
}
/// Smooth and refit the anchors of an open run `a[lo..=hi]` keeping its end points and outer handles.
fn refit_run(anchors: &[Anchor], tol: f64, sigma: f64) -> Vec<Anchor> {
/// `free` says whether its first and last anchors are ends of an open path: the curve leaving or
/// arriving at such an end can turn.
fn refit_run(anchors: &[Anchor], tol: f64, sigma: f64, free: [bool; 2]) -> Vec<Anchor> {
let piece = PathData::single(SubPath::new(anchors.to_vec(), false));
let fitted = po::simplify_with(&piece, &refit_options(tol, sigma));
let fitted = po::simplify_with(&piece, &refit_options(tol, sigma, free));
let Some(mut out) = fitted.subpaths.into_iter().next().map(|s| s.anchors).filter(|a| a.len() >= 2) else { return anchors.to_vec() };
let (f, l) = (anchors[0], anchors[anchors.len() - 1]);
let last = out.len() - 1;
@@ -228,7 +240,7 @@ fn smooth_subpath(sp: &SubPath, pts: &[Point], radius: f64, share: usize, tol: f
if sp.closed {
let Some(k) = marked.iter().position(|m| !m) else {
// Everything is in range: smooth the whole closed path, across its start too.
let f = po::simplify_with(&PathData::single(sp.clone()), &refit_options(tol, sigma));
let f = po::simplify_with(&PathData::single(sp.clone()), &refit_options(tol, sigma, [false; 2]));
return f.subpaths.into_iter().next();
};
// Rotate so an untouched anchor comes first, duplicate it at the end and treat as open.
@@ -239,14 +251,14 @@ fn smooth_subpath(sp: &SubPath, pts: &[Point], radius: f64, share: usize, tol: f
open.anchors.push(open.anchors[0]);
m.push(false);
open.closed = false;
let mut res = smooth_open(&open.anchors, &m, near, tol, sigma);
let mut res = smooth_open(&open.anchors, &m, near, tol, sigma, false);
let l = res.pop()?;
if let Some(r0) = res.first_mut() {
r0.h_in = l.h_in;
}
return Some(SubPath::new(res, true));
}
Some(SubPath::new(smooth_open(&sp.anchors, &marked, near, tol, sigma), false))
Some(SubPath::new(smooth_open(&sp.anchors, &marked, near, tol, sigma, true), false))
}
/// The segment `c`, which ends in the drag's reach (`near`) and starts outside it, split where it
@@ -278,8 +290,10 @@ fn split_at_reach(c: CubicBez, near: &dyn Fn(Point) -> bool) -> Option<(CubicBez
/// `anchors` with each run of `marked` ones smoothed by a Gaussian of spread `sigma` and refitted
/// within `tol`, together with the stretch of the segments leading into the run that is in the
/// drag's reach (`near`): a short drag smooths what is under it, and the rest of a long segment next
/// to it stays as it was (#1512).
fn smooth_open(anchors: &[Anchor], marked: &[bool], near: &dyn Fn(Point) -> bool, tol: f64, sigma: f64) -> Vec<Anchor> {
/// to it stays as it was (#1512). With `open`, `anchors` are an open path, and the curve at its first
/// or last anchor turns with the smoothing when a run's refit reaches that anchor; a run's other ends,
/// and those of the open run a closed path is cut into, keep their direction.
fn smooth_open(anchors: &[Anchor], marked: &[bool], near: &dyn Fn(Point) -> bool, tol: f64, sigma: f64, open: bool) -> Vec<Anchor> {
let n = anchors.len();
let mut runs = vec![];
let mut i = 0;
@@ -319,7 +333,8 @@ fn smooth_open(anchors: &[Anchor], marked: &[bool], near: &dyn Fn(Point) -> bool
head = Some(Anchor { h_out: far.p1, ..*outer });
*outer = Anchor::with_handles(far.p3, far.p2, reach.p1);
}
let new = refit_run(&piece, tol, sigma);
let free = [open && lo == 0 && head.is_none(), open && hi == n - 1 && tail.is_none()];
let new = refit_run(&piece, tol, sigma, free);
out.splice(lo..=hi, head.into_iter().chain(new).chain(tail));
}
out
+17
View File
@@ -49,6 +49,10 @@
//! member with another order, and any other change to the list (items moved, or several added
//! or removed at once), takes the model's whole list of fills and strokes.
//!
//! A path directly in a graph series that takes an edit from another member (a graph's paths are
//! members only while the graph is isolated) also has what changed stored on its graph, so that
//! every path of the series takes it when the graph is drawn again (docs/mcp.md).
//!
//! Members that are hidden or locked at the time are left as they are. An edit that would take any
//! member past the canvas (beyond [`vectorcraft_doc::MAX_COORD`]) is refused whole, as one that
//! takes the selection there is. Whenever the document is put back (Undo, Redo, a cancelled drag
@@ -786,9 +790,22 @@ pub(crate) fn propagate(before: &Document, d: &mut Document, ge: &GlobalEdit, se
}
super::object::keep_compound_aligned(d, *id, Scaling::default());
}
keep_series_changes(before, d, &edited);
edited
}
/// Store on their graphs what the members `edited`, and the objects in them, took on the paths directly in a graph
/// series, for the graph's next redraw. The edited member is left to the edit's own command.
fn keep_series_changes(before: &Document, d: &mut Document, edited: &[NodeId]) {
let mut taken = vec![];
for id in edited {
if let Some(n) = d.node(*id) {
n.walk(&mut |c: &Node| taken.push(c.id));
}
}
super::appearance::capture_series_changes(before, d, &taken);
}
/// The outlines of the members of the active document's Global Edit that are not selected, hold
/// no selected object and sit inside no selected object, in their layer's colour: the canvas
/// highlights them while Global Edit is on. While it is off, with one supported object selected,
+118
View File
@@ -572,6 +572,124 @@ fn an_object_opacity_a_series_mark_already_shows_replaces_the_kept_opacity() {
assert!(spec(&s, id).series_paints.iter().all(|p| p.opacity.is_none()));
}
/// Randomize Opacity on marks of one series stores the opacity of the frontmost of them on the graph in the same undo
/// step, and every mark of the series has it when the graph is drawn again.
#[test]
fn a_random_opacity_on_series_marks_survives_regeneration() {
let (mut s, id, _, marks) = column_marks();
s.execute("addon.arrange.randomizeOpacity", &json!({"ids": [marks[1].0, marks[0].0], "min": 30, "max": 60, "seed": 7})).unwrap();
let front = s.doc().unwrap().doc.node(marks[1]).unwrap().opacity;
assert!(front < 1.0);
assert_eq!(spec(&s, id).series_paints[0].opacity, Some(front));
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
assert!(transparency_of(&s, id, 0).iter().all(|t| t.0 == front), "{:?}", transparency_of(&s, id, 0));
assert!(transparency_of(&s, id, 1).iter().all(|t| t.0 == 1.0), "{:?}", transparency_of(&s, id, 1));
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert!(spec(&s, id).series_paints.is_empty(), "undo takes back the opacities and what the graph stored");
}
/// Sort Objects giving series marks new opacities stores the opacity of the frontmost of them on the graph, in place of
/// the one another mark left there.
#[test]
fn an_opacity_sort_objects_gives_series_marks_survives_regeneration() {
let (mut s, id, _, marks) = column_marks();
s.execute("object.setProps", &json!({"id": marks[2].0, "opacity": 30})).unwrap();
assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.3));
// From left to right the three columns get 30%, 65% and 100%: the frontmost, the rightmost, is fully opaque.
let ids = [marks[0].0, marks[1].0, marks[2].0];
s.execute("addon.arrange.sort", &json!({"ids": ids, "by": "x", "apply": "opacity", "distribute": true})).unwrap();
let opacities: Vec<f32> = marks[..3].iter().map(|m| s.doc().unwrap().doc.node(*m).unwrap().opacity).collect();
assert_eq!(opacities, [0.3, 0.65, 1.0]);
assert_eq!(spec(&s, id).series_paints[0].opacity, None);
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
assert!(transparency_of(&s, id, 0).iter().all(|t| t.0 == 1.0), "{:?}", transparency_of(&s, id, 0));
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.3), "undo takes back the sort and what the graph stored");
}
/// Sort Objects stores the opacity of the frontmost series mark whose opacity it changes: a mark in front that keeps its
/// opacity leaves the stored value to the marks it changed.
#[test]
fn an_opacity_sort_objects_stores_the_frontmost_mark_it_changes() {
let (mut s, id, _, marks) = column_marks();
s.execute("object.setProps", &json!({"id": marks[0].0, "opacity": 60})).unwrap();
s.execute("object.setProps", &json!({"id": marks[1].0, "opacity": 30})).unwrap();
assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.3));
// From left to right the columns trade 60%, 30% and 100% for 30%, 60% and 100%: the frontmost keeps its 100%.
let ids = [marks[0].0, marks[1].0, marks[2].0];
s.execute("addon.arrange.sort", &json!({"ids": ids, "by": "x", "apply": "opacity"})).unwrap();
let opacities: Vec<f32> = marks[..3].iter().map(|m| s.doc().unwrap().doc.node(*m).unwrap().opacity).collect();
assert_eq!(opacities, [0.3, 0.6, 1.0]);
assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.6));
}
/// An object opacity, blend mode, fill, stroke and weight that Global Edit gives a mark of another series from the mark
/// that was edited are stored on the graph for that series in the same undo step, and every mark of the series has them
/// when the graph is drawn again.
#[test]
fn what_global_edit_gives_series_marks_survives_regeneration() {
let (mut s, id, _, _) = column_marks();
// Equal values: the first column of each series has the same shape.
s.execute("graph.setData", &json!({"rows": [[3, 3], [5, 2]]})).unwrap();
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
let (first, other) = (series(&n, 0).children().unwrap()[0].id, series(&n, 1).children().unwrap()[0].id);
s.execute("object.isolate", &json!({"id": id.0})).unwrap();
s.execute("select.set", &json!({"ids": [first.0]})).unwrap();
let r = s.execute("select.globalEdit", &json!({})).unwrap();
assert!(r["ids"].as_array().unwrap().contains(&json!(other.0)), "{r}");
let steps = s.doc().unwrap().history.undo.len();
s.execute("transparency.set", &json!({"ids": [first.0], "opacity": 40, "blend": "multiply"})).unwrap();
s.execute("paint.setFill", &json!({"ids": [first.0], "color": "#e8573f"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [first.0], "color": "#1f4e9c"})).unwrap();
s.execute("stroke.set", &json!({"ids": [first.0], "weight": 5})).unwrap();
let mark = s.doc().unwrap().doc.node(other).unwrap().clone();
assert_eq!((mark.opacity, mark.blend), (0.4, BlendMode::Multiply), "Global Edit reaches the other series' mark");
let kept = spec(&s, id).series_paints[1].clone();
assert_eq!((kept.opacity, kept.blend), (Some(0.4), Some(BlendMode::Multiply)));
assert_eq!(kept.fill, Some(mark.appearance.fill_paint()));
assert_eq!((kept.stroke, kept.stroke_width), (Some(mark.appearance.stroke_paint()), Some(5.0)));
s.execute("object.exitIsolation", &json!({})).unwrap();
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
let normal = BlendMode::Normal;
assert!(transparency_of(&s, id, 1).iter().all(|t| *t == (0.4, BlendMode::Multiply, normal, normal)), "{:?}", transparency_of(&s, id, 1));
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
assert!(series(&n, 1).children().unwrap().iter().all(|m| m.appearance.fill_paint() == mark.appearance.fill_paint()));
while s.doc().unwrap().history.undo.len() > steps {
s.execute("edit.undo", &json!({})).unwrap();
}
assert!(spec(&s, id).series_paints.iter().all(|p| *p == vectorcraft_doc::SeriesPaint::default()), "{:?}", spec(&s, id).series_paints);
}
/// With a whole series group picked and Global Edit on, the other series groups of the same form take the edit of its
/// marks, and the graph stores it for their series too.
#[test]
fn what_global_edit_gives_the_marks_of_another_series_group_survives_regeneration() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
// Series without names draw no legend, so each series group holds only its columns, laid out like the other's.
let csv = ",,\nQ1,3,3\nQ2,5,5";
let made = s.execute("graph.create", &json!({"type": "column", "x": 100, "y": 100, "width": 300, "height": 200, "csv": csv})).unwrap();
let id = NodeId(made["id"].as_u64().unwrap());
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
let (first, other) = (series(&n, 0).clone(), series(&n, 1).id);
s.execute("object.isolate", &json!({"id": id.0})).unwrap();
s.execute("select.set", &json!({"ids": [first.id.0]})).unwrap();
let r = s.execute("select.globalEdit", &json!({})).unwrap();
assert!(r["ids"].as_array().unwrap().contains(&json!(other.0)), "{r}");
let marks: Vec<u64> = first.children().unwrap().iter().map(|m| m.id.0).collect();
s.execute("paint.setFill", &json!({"ids": marks, "color": "#e8573f"})).unwrap();
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
let given = series(&n, 1).children().unwrap()[0].appearance.fill_paint();
assert_eq!(given, series(&n, 0).children().unwrap()[0].appearance.fill_paint(), "Global Edit reaches the other group");
assert_eq!(spec(&s, id).series_paints[1].fill, Some(given.clone()));
s.execute("object.exitIsolation", &json!({})).unwrap();
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
assert!(series(&n, 1).children().unwrap().iter().all(|m| m.appearance.fill_paint() == given));
}
/// A blend mode set on the top fill or stroke row of one series mark is kept by the graph and drawn on every mark of
/// the series again; Normal forgets it.
#[test]
+25
View File
@@ -314,6 +314,15 @@ fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
let out = str_param(p, "which") != Some("in");
let pos = Point::new(f64_req(p, "x", "path.setHandle")?, f64_req(p, "y", "path.setHandle")?);
let independent = switch_or(p, "independent", false, "path.setHandle")?;
// A handle already there, on an anchor already of the kind it would get, changes nothing and
// records no undo step.
if let Some(a) = anchor_of(s, id, si, ai)? {
let mut b = a;
b.set_handle(out, pos, independent);
if b == a {
return ok();
}
}
s.edit("Reshape", |d, _| {
let path = path_mut(d, id)?;
let a = path.anchor_mut(si, ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
@@ -330,6 +339,12 @@ fn move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
let si = usize_opt(p, "subpath", "path.moveAnchor")?.unwrap_or(0);
let ai = p.get("anchor").and_then(Value::as_u64).map(index).ok_or_else(|| bad("path.moveAnchor", "missing anchor"))?;
let pos = Point::new(f64_req(p, "x", "path.moveAnchor")?, f64_req(p, "y", "path.moveAnchor")?);
// An anchor already at (x, y) changes nothing and records no undo step.
if let Some(a) = anchor_of(s, id, si, ai)?
&& a.transform(vectorcraft_geom::Affine::translate(pos - a.p)) == a
{
return ok();
}
s.edit("Move", |d, _| {
let path = path_mut(d, id)?;
let a = path.anchor_mut(si, ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
@@ -345,6 +360,16 @@ fn move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
ok()
}
/// Anchor `ai` of subpath `si` of path `id` in the active document, when `id` is a path that has it.
/// Busy while a script runs, as [`Session::edit`] is.
fn anchor_of(s: &Session, id: NodeId, si: usize, ai: usize) -> Result<Option<Anchor>> {
if s.script_running() {
return Err(EngineError::Busy);
}
let d = &s.doc()?.doc;
Ok(d.node(id).and_then(|n| n.path_data()).and_then(|path| path.subpaths.get(si)).and_then(|sp| sp.anchors.get(ai)).copied())
}
fn set_anchors(s: &mut Session, p: &Value) -> Result<Value> {
let id = object_param(p, "id", "path.setAnchors")?.ok_or_else(|| bad("path.setAnchors", "missing id"))?;
let subs = p.get("subpaths").and_then(Value::as_array).ok_or_else(|| bad("path.setAnchors", "missing subpaths"))?;
+29 -2
View File
@@ -17,7 +17,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Make",
["Object", "Text Wrap"],
None,
"{offset?: pt (6), invert?: bool, ids?} area type below the selected objects (same layer) wraps around them → {ids}",
"{offset?: pt (6), invert?: bool, ids?} area type below the selected objects (same layer) wraps around them; a negative offset (to -1000) lets the text that far into them → {ids}",
has_selection,
make
),
@@ -27,7 +27,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Text Wrap Options…",
["Object", "Text Wrap"],
None,
"{offset?: pt, invert?: bool, ids?} set the options of the selected wrap objects; no options → the current {offset, invert}",
"{offset?: pt, invert?: bool, ids?} set the options of the selected wrap objects (offset -1000 to 1000; a negative one lets text into the objects); no options → the current {offset, invert}",
has_selection,
options
),
@@ -186,6 +186,33 @@ mod tests {
assert_eq!(lines(&s, t), plain);
}
/// A negative offset from Text Wrap Options lets the lines beside a wrap object run that far
/// into it, the options report it, and one undo puts back the offset before it.
#[test]
fn text_wrap_options_negative_offset_reflows_and_round_trips() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 600, "height": 600})).unwrap();
let t = s
.execute("text.create", &json!({"x": 0, "y": 0, "text": "word ".repeat(200), "size": 12, "area": {"width": 400, "height": 400}}))
.unwrap()["id"]
.as_u64()
.unwrap();
let r = s.execute("shape.rectangle", &json!({"x": -50, "y": 50, "width": 250, "height": 100})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [r]})).unwrap();
s.execute("object.textWrap.make", &json!({})).unwrap();
let beside = |s: &Session| lines(s, t).into_iter().filter(|l| l.0 > 1.0).map(|l| l.0).collect::<Vec<_>>();
assert!(!beside(&s).is_empty() && beside(&s).iter().all(|x| (x - 206.0).abs() < 1e-6), "{:?}", beside(&s));
assert_eq!(s.execute("object.textWrap.options", &json!({"offset": -20})).unwrap()["offset"], json!(-20.0));
assert!(!beside(&s).is_empty() && beside(&s).iter().all(|x| (x - 180.0).abs() < 1e-6), "{:?}", beside(&s));
assert_eq!(s.execute("object.textWrap.options", &json!({})).unwrap()["offset"], json!(-20.0));
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(s.execute("object.textWrap.options", &json!({})).unwrap()["offset"], json!(6.0));
assert!(beside(&s).iter().all(|x| (x - 206.0).abs() < 1e-6), "{:?}", beside(&s));
// An offset past -1000 is kept at -1000: the whole object lets text through.
assert_eq!(s.execute("object.textWrap.options", &json!({"offset": -5000})).unwrap()["offset"], json!(-1000.0));
assert!(lines(&s, t).iter().all(|l| l.0 < 1.0 && l.1 > 300.0));
}
#[test]
fn text_flows_on_both_sides_of_a_centred_object() {
let mut s = Session::new();
+47
View File
@@ -395,9 +395,25 @@ pub(crate) fn mark_continued(doc: &mut Document) {
}
}
#[cfg(test)]
thread_local! {
/// Tests: how many times [`story_of`] and [`ThreadIndex::of`] went through the document's
/// threads on this thread.
static THREAD_SCANS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// Tests: how many times [`story_of`] and [`ThreadIndex::of`] have gone through the document's
/// threads on this thread.
#[cfg(test)]
pub(crate) fn thread_scans() -> usize {
THREAD_SCANS.with(std::cell::Cell::get)
}
/// The frames of the thread that `id` is a frame of, in thread order, each area type or type on a
/// path; empty when `id` is in no thread or the thread has fewer than two such frames.
pub(crate) fn story_of(d: &Document, id: NodeId) -> Vec<NodeId> {
#[cfg(test)]
THREAD_SCANS.with(|c| c.set(c.get() + 1));
let Some(thread) = d.text_threads.iter().find(|t| t.contains(&id)) else { return vec![] };
story_in(d, thread, id)
}
@@ -408,6 +424,37 @@ pub(crate) fn story_in(d: &Document, thread: &[NodeId], id: NodeId) -> Vec<NodeI
if frames.len() >= 2 && frames.contains(&id) { frames } else { vec![] }
}
/// A document's text threads looked up by frame, built in one pass over them, for a command that
/// asks [`ThreadIndex::threaded`] of each of many objects.
pub(crate) struct ThreadIndex<'a> {
doc: &'a Document,
/// Each object the threads list, with the index of the first thread that lists it.
first: std::collections::HashMap<NodeId, usize>,
/// Each thread's count of entries that are area type or type on a path.
live: Vec<usize>,
}
impl<'a> ThreadIndex<'a> {
pub(crate) fn of(doc: &'a Document) -> Self {
#[cfg(test)]
THREAD_SCANS.with(|c| c.set(c.get() + 1));
let mut first = std::collections::HashMap::new();
let mut live = Vec::with_capacity(doc.text_threads.len());
for (i, thread) in doc.text_threads.iter().enumerate() {
for id in thread {
first.entry(*id).or_insert(i);
}
live.push(thread.iter().filter(|id| text_of(doc, **id).is_some()).count());
}
Self { doc, first, live }
}
/// Whether `id` is a frame of a thread: [`story_of`] is not empty for it.
pub(crate) fn threaded(&self, id: NodeId) -> bool {
self.first.get(&id).and_then(|i| self.live.get(*i)).is_some_and(|n| *n >= 2) && text_of(self.doc, id).is_some()
}
}
/// `ids` followed by the other frames of the threads they are in, each once, in thread order.
pub(crate) fn with_threads(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
let given: Ids = ids.iter().copied().collect();
+22
View File
@@ -245,6 +245,28 @@ fn a_frame_left_alone_by_a_dropped_repeat_stops_continuing() {
assert_eq!(t.plain_text(), "Tail");
}
/// [`ThreadIndex::threaded`] answers as [`story_of`] does, by the first thread that lists an
/// object, also for threads listed more than once, with point type, other art and missing ids.
#[test]
fn thread_index_matches_story_of() {
let (mut s, a, b) = setup();
s.execute("text.thread.create", &json!({})).unwrap();
let c = s.execute("text.create", &json!({"x": 400, "y": 10, "text": "C", "area": {"width": 150, "height": 60}})).unwrap()["id"].as_u64().unwrap();
let p = s.execute("text.create", &json!({"x": 10, "y": 250, "text": "Point"})).unwrap()["id"].as_u64().unwrap();
let r = s.execute("shape.rectangle", &json!({"x": 400, "y": 200, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
let mut d = (*s.doc().unwrap().doc).clone();
let [fa, fb, fc, fp, fr, fx] = [a, b, c, p, r, 9_999_999].map(NodeId);
// a's first thread has one frame beside point type, c's has one beside a rectangle, and b's
// lists a twice.
d.text_threads = vec![vec![fp, fa], vec![fa, fb, fa], vec![fc, fr], vec![fc, fb], vec![fx, fb]];
let index = ThreadIndex::of(&d);
let got: Vec<(bool, bool)> = [fa, fb, fc, fp, fr, fx].iter().map(|id| (index.threaded(*id), !story_of(&d, *id).is_empty())).collect();
let want: Vec<(bool, bool)> = [false, true, false, false, false, false].iter().map(|t| (*t, *t)).collect();
assert_eq!(got, want);
d.text_threads.clear();
assert!(!ThreadIndex::of(&d).threaded(fb));
}
#[test]
fn edits_copy_only_the_stories_of_threads_whose_frames_changed() {
let (mut s, a, b) = setup();
+2 -2
View File
@@ -1225,8 +1225,8 @@ fn area_options(s: &mut Session, p: &Value) -> Result<Value> {
.map(|(id, t)| merged(&t.area, t.dynamic_text).map(|o| (id, o)))
.collect::<Result<_>>()?;
// Dynamic Text's Block is refused for threaded frames, as `type.dynamicText` refuses it.
let frames: Vec<String> =
planned.iter().filter(|(id, (_, block))| *block && !super::threads::story_of(d, *id).is_empty()).map(|(id, _)| id.0.to_string()).collect();
let threads = super::threads::ThreadIndex::of(d);
let frames: Vec<String> = planned.iter().filter(|(id, (_, block))| *block && threads.threaded(*id)).map(|(id, _)| id.0.to_string()).collect();
if !frames.is_empty() {
let frames = frames.join(", ");
return Err(bad(C, format!("area type in a thread cannot use Dynamic Text: {frames}")));
+10 -13
View File
@@ -7,6 +7,7 @@ use vectorcraft_doc::{AreaFit, CharStyle, Document, Justify, LockedArtboards, No
use vectorcraft_geom::{Affine, Rect, shapes};
use super::object::choice;
use super::threads::ThreadIndex;
use super::typecmd::{area_text, block_gaps, needed_room, refresh_bounds};
use super::{
CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, number_or,
@@ -556,7 +557,7 @@ fn path_center_refusal(d: &Document, ids: &[NodeId]) -> Option<String> {
let open = open.join(", ");
return Some(format!("type on an open or compound path cannot be centered on its top or bottom: {open}"));
}
let frames = threaded_ids(d, ids);
let frames = threaded_ids(&ThreadIndex::of(d), ids);
(!frames.is_empty()).then(|| format!("type on a path in a thread cannot be centered on its top or bottom: {frames}"))
}
@@ -783,11 +784,6 @@ fn path_options(s: &mut Session, p: &Value) -> Result<Value> {
options(s)
}
/// Whether type `id` is a frame of a thread.
fn threaded(d: &Document, id: NodeId) -> bool {
!super::threads::story_of(d, id).is_empty()
}
/// Type on a path or area type: the type Dynamic Text works on.
fn dynamic_type(n: Option<&Node>) -> Option<&TextObject> {
path_text(n).or_else(|| area_text(n))
@@ -820,17 +816,18 @@ fn has_dynamic_type(s: &Session) -> std::result::Result<(), String> {
/// path first; None when none is.
fn threaded_refusal(d: &Document, ids: &[NodeId]) -> Option<String> {
let (paths, areas): (Vec<NodeId>, Vec<NodeId>) = ids.iter().copied().partition(|id| path_text(d.node(*id)).is_some());
let frames = threaded_ids(d, &paths);
let threads = ThreadIndex::of(d);
let frames = threaded_ids(&threads, &paths);
if !frames.is_empty() {
return Some(format!("type on a path in a thread cannot use Dynamic Text: {frames}"));
}
let frames = threaded_ids(d, &areas);
let frames = threaded_ids(&threads, &areas);
(!frames.is_empty()).then(|| format!("area type in a thread cannot use Dynamic Text: {frames}"))
}
/// The ids among `ids` of frames of threads, as a list for a message; empty when there are none.
fn threaded_ids(d: &Document, ids: &[NodeId]) -> String {
ids.iter().filter(|id| threaded(d, **id)).map(|id| id.0.to_string()).collect::<Vec<_>>().join(", ")
/// The ids among `ids` of frames of `threads`, as a list for a message; empty when there are none.
fn threaded_ids(threads: &ThreadIndex, ids: &[NodeId]) -> String {
ids.iter().filter(|id| threads.threaded(**id)).map(|id| id.0.to_string()).collect::<Vec<_>>().join(", ")
}
/// Type › Dynamic Text: set `on` (without it, the opposite of the first object's setting, or on
@@ -969,7 +966,7 @@ fn has_preset_type(s: &Session) -> std::result::Result<(), String> {
if ids.is_empty() {
return Err("select point type or type on a path".into());
}
let frames = threaded_ids(d, &ids);
let frames = threaded_ids(&ThreadIndex::of(d), &ids);
if !frames.is_empty() {
return Err(format!("type on a path in a thread cannot use Dynamic Text: {frames}"));
}
@@ -1108,7 +1105,7 @@ fn dynamic_text_preset(s: &mut Session, p: &Value) -> Result<Value> {
if ids.is_empty() {
return Err(bad(C, "select point type or type on a path"));
}
let frames = threaded_ids(d, &ids);
let frames = threaded_ids(&ThreadIndex::of(d), &ids);
if !frames.is_empty() {
return Err(bad(C, format!("type on a path in a thread cannot use Dynamic Text: {frames}")));
}
+20 -1
View File
@@ -54,7 +54,26 @@ fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {
}
/// Do the objects `ids` have finite geometry within [`MAX_COORD`] (the ones not there pass)?
///
/// A path or compound path whose anchors and handles are all finite and inside the range by a
/// margin passes without being measured: its curves stay inside their control points. Any other
/// object, and a path with a point outside that margin, is measured.
pub(crate) fn objects_in_range(d: &Document, ids: &[NodeId]) -> bool {
let paths = d.index_paths(ids.iter().copied());
ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).and_then(|n| n.geometric_bounds()).is_none_or(rect_in_range))
ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).is_none_or(|n| points_in_range(n) || n.geometric_bounds().is_none_or(rect_in_range)))
}
/// Coordinates at most this far from 0 keep a curve's measured bounds within [`MAX_COORD`]
/// whatever the rounding of its extrema.
const POINTS_LIMIT: f64 = MAX_COORD * (1.0 - 1e-9);
/// Whether every anchor and handle of path `n`, or of each path of compound path `n`, is finite and
/// within [`POINTS_LIMIT`]. `false` for any other object.
fn points_in_range(n: &vectorcraft_doc::Node) -> bool {
let near = |p: vectorcraft_geom::Point| p.x.is_finite() && p.y.is_finite() && p.x.abs() <= POINTS_LIMIT && p.y.abs() <= POINTS_LIMIT;
match &n.kind {
NodeKind::Path { path, .. } => path.subpaths.iter().flat_map(|s| &s.anchors).all(|a| near(a.p) && near(a.h_in) && near(a.h_out)),
NodeKind::Compound { .. } => n.editing_children().iter().all(|c| points_in_range(c)),
_ => false,
}
}
+1
View File
@@ -7,6 +7,7 @@ use vectorcraft_tools::{PointerEvent, PointerKind, ToolKey};
mod actionset;
pub(super) mod adjust;
mod ai_open_path;
mod anchor_edit_work;
mod appearance;
mod areafit;
mod arrowheads;
+111
View File
@@ -0,0 +1,111 @@
//! An edit of one anchor of a long selected path does not measure the path's segments
//! ([`vectorcraft_geom::path::measured_segments`]) to check that it stays within the canvas, and
//! an edit that leaves the anchor as it was records no undo step.
use std::collections::BTreeSet;
use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_doc::{Appearance, Document, Node, NodeId};
use vectorcraft_geom::path::measured_segments;
use vectorcraft_geom::{Anchor, PathData, Point, SubPath};
use crate::*;
/// Most segments one anchor edit may measure, however many anchors the path has.
const MOST_MEASURED: u64 = 16;
/// A session whose document holds one open zigzag path of `n` anchors, selected, with its anchor 5
/// direct-selected.
fn long_path(n: usize) -> (Session, NodeId) {
let mut d = Document::new(2000.0, 1000.0);
let anchors = (0..n).map(|i| Anchor::corner(Point::new(i as f64 * 0.1, if i % 2 == 0 { 100.0 } else { 110.0 }))).collect();
let id = d.alloc_id();
let node = Node::path(id, PathData::single(SubPath::new(anchors, false)), Appearance::default_art());
if let Some(ch) = Arc::make_mut(&mut d.layers[0]).children_mut() {
ch.push(Arc::new(node));
}
let mut s = Session::new();
s.add_document(d, None);
let st = s.doc_mut().unwrap();
st.selection.set([id]);
st.selection.anchors.insert(id, BTreeSet::from([(0, 5)]));
(s, id)
}
fn anchor(s: &Session, id: NodeId, ai: usize) -> Anchor {
s.doc().unwrap().doc.node(id).unwrap().path_data().unwrap().subpaths[0].anchors[ai]
}
fn undo_steps(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
/// Runs `cmd` with `p` and returns how many segments it measured.
fn measured(s: &mut Session, cmd: &str, p: Value) -> u64 {
let before = measured_segments();
s.execute(cmd, &p).unwrap();
measured_segments() - before
}
#[test]
fn one_anchor_edit_of_a_long_path_measures_few_segments() {
for n in [100, 10_000] {
let (mut s, id) = long_path(n);
let a = anchor(&s, id, 5);
let m = measured(&mut s, "path.moveAnchor", json!({"id": id.0, "anchor": 5, "x": 3, "y": 50}));
assert!(m <= MOST_MEASURED, "path.moveAnchor on {n} anchors measured {m} segments");
assert_eq!(anchor(&s, id, 5).p, Point::new(3.0, 50.0));
let m = measured(&mut s, "path.setHandle", json!({"id": id.0, "anchor": 5, "which": "out", "x": 4, "y": 40}));
assert!(m <= MOST_MEASURED, "path.setHandle on {n} anchors measured {m} segments");
assert_eq!(anchor(&s, id, 5).h_out, Point::new(4.0, 40.0));
let m = measured(&mut s, "path.moveAnchors", json!({"dx": 1, "dy": 0}));
assert!(m <= MOST_MEASURED, "path.moveAnchors on {n} anchors measured {m} segments");
let m = measured(&mut s, "object.nudge", json!({"dx": 1, "dy": 0}));
assert!(m <= MOST_MEASURED, "object.nudge on {n} anchors measured {m} segments");
assert_eq!(anchor(&s, id, 5).p, Point::new(5.0, 50.0));
// Only anchor 5 moved, and undoing the four edits gives it back.
assert_eq!(anchor(&s, id, 4), Anchor::corner(Point::new(4.0 * 0.1, 100.0)));
assert_eq!(anchor(&s, id, 6), Anchor::corner(Point::new(6.0 * 0.1, 100.0)));
for _ in 0..4 {
s.execute("edit.undo", &json!({})).unwrap();
}
assert_eq!(anchor(&s, id, 5), a);
}
}
/// A handle past the canvas is measured: the edit stands while the curve stays within the canvas,
/// and is refused once the curve leaves it.
#[test]
fn a_handle_past_the_canvas_is_measured() {
let (mut s, id) = long_path(10_000);
// The curve from anchor 5 reaches 4/9 of the way to its outgoing handle.
let x = 2.0 * MAX_COORD;
s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": x, "y": 110})).unwrap();
assert_eq!(anchor(&s, id, 5).h_out, Point::new(x, 110.0));
let before = s.doc().unwrap().doc.clone();
let undo = undo_steps(&s);
let x = 3.0 * MAX_COORD;
assert!(s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": x, "y": 110})).is_err());
assert!(s.doc().unwrap().doc == before, "the refused edit changed the document");
assert_eq!(undo_steps(&s), undo);
}
/// `path.moveAnchor` to where the anchor is and `path.setHandle` to where the handle is change
/// nothing and record no undo step.
#[test]
fn an_anchor_edit_that_changes_nothing_records_no_undo_step() {
let (mut s, id) = long_path(100);
let a = anchor(&s, id, 5);
s.execute("path.moveAnchor", &json!({"id": id.0, "anchor": 5, "x": a.p.x, "y": a.p.y})).unwrap();
assert_eq!(undo_steps(&s), 0, "path.moveAnchor recorded an undo step");
s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": a.h_out.x, "y": a.h_out.y})).unwrap();
assert_eq!(undo_steps(&s), 0, "path.setHandle recorded an undo step");
assert_eq!(anchor(&s, id, 5), a);
// An anchor that is not there is still refused.
assert!(s.execute("path.moveAnchor", &json!({"id": id.0, "anchor": 100, "x": 0, "y": 0})).is_err());
assert!(s.execute("path.setHandle", &json!({"id": id.0, "anchor": 100, "which": "out", "x": 0, "y": 0})).is_err());
// A change still records one.
s.execute("path.moveAnchor", &json!({"id": id.0, "anchor": 5, "x": a.p.x + 1.0, "y": a.p.y})).unwrap();
assert_eq!(undo_steps(&s), 1);
}
+77
View File
@@ -1632,6 +1632,83 @@ fn smoothing_a_whole_closed_path_smooths_a_bump_at_its_start() {
assert!(start <= far + 0.5, "the bump at the start stays {start} pt high, the far one {far} pt");
}
/// A straight line along y = 200 from x = 100 to 400, one anchor every 5 pt, whose second and
/// second-to-last anchors are 1.5 pt off the line: its first and last segments leave and arrive at
/// 16.7° to it.
fn smooth_jagged_ends(s: &mut Session) -> NodeId {
let anchors: Vec<_> = (0..=60).map(|i| json!({"x": 100.0 + 5.0 * f64::from(i), "y": if i == 1 || i == 59 { 201.5 } else { 200.0 }})).collect();
smooth_test_path(s, &anchors, false)
}
/// The degrees between the direction `sp` leaves its first anchor along (`at_end` false), or arrives
/// at its last anchor along, and the x axis.
fn smooth_end_angle(sp: &vectorcraft_geom::SubPath, at_end: bool) -> f64 {
let c = sp.segment(if at_end { sp.segment_count() - 1 } else { 0 });
let d = if at_end {
[c.p3 - c.p2, c.p3 - c.p1, c.p3 - c.p0].into_iter().find(|d| d.hypot() > 1e-9)
} else {
[c.p1 - c.p0, c.p2 - c.p0, c.p3 - c.p0].into_iter().find(|d| d.hypot() > 1e-9)
};
d.map_or(f64::NAN, |d| d.y.atan2(d.x).to_degrees().abs())
}
/// The largest turn, in degrees, at any anchor of `sp` (other than its ends) whose x is in `xs`.
fn smooth_largest_turn(sp: &vectorcraft_geom::SubPath, xs: std::ops::Range<f64>) -> f64 {
let dir = |v: kurbo::Vec2, w: kurbo::Vec2, chord: kurbo::Vec2| [v, w, chord].into_iter().find(|d| d.hypot() > 1e-9).unwrap_or(chord);
(1..sp.segment_count())
.filter(|&i| xs.contains(&sp.anchors[i].p.x))
.map(|i| {
let (prev, next) = (sp.segment(i - 1), sp.segment(i));
let arrive = dir(prev.p3 - prev.p2, prev.p3 - prev.p1, prev.p3 - prev.p0);
let leave = dir(next.p1 - next.p0, next.p2 - next.p0, next.p3 - next.p0);
arrive.cross(leave).atan2(arrive.dot(leave)).abs().to_degrees()
})
.fold(0.0, f64::max)
}
/// A Smooth drag over the whole of an open path turns the curve at each end to follow the smoothed
/// path rather than the jag of its first or last segment, and leaves both end points where they were.
#[test]
fn smoothing_an_open_path_turns_its_jagged_ends_with_the_path() {
let mut s = session();
let id = smooth_jagged_ends(&mut s);
let before = path(&s, id);
assert!(smooth_end_angle(&before.subpaths[0], false) > 16.0 && smooth_end_angle(&before.subpaths[0], true) > 16.0);
smooth_pass(&mut s, &smooth_drag_along(200.0, 90.0, 410.0));
let p = path(&s, id);
assert_ne!(p, before, "the path is smoothed");
let sp = &p.subpaths[0];
let (first, last) = (sp.anchors[0].p, sp.anchors[sp.anchors.len() - 1].p);
assert!(first == Point::new(100.0, 200.0) && last == Point::new(400.0, 200.0), "the ends stay: {first:?} {last:?}");
let (start, end) = (smooth_end_angle(sp, false), smooth_end_angle(sp, true));
assert!(start <= 5.0, "the path leaves its start at {start}° to the line");
assert!(end <= 5.0, "and arrives at its end at {end}°");
let off = smooth_test_samples(&p).iter().map(|q| (q.y - 200.0).abs()).fold(0.0, f64::max);
assert!(off <= 1.5, "the path stays within {off} pt of the line");
}
/// A Smooth drag that reaches only the start of an open path turns the curve there, and the rest of
/// the path, its far end with its jag included, stays as it was, joining the refitted part without a
/// corner.
#[test]
fn a_smooth_drag_turns_only_the_end_it_reaches() {
let mut s = session();
let id = smooth_jagged_ends(&mut s);
let before = path(&s, id);
smooth_pass(&mut s, &smooth_drag_along(200.0, 90.0, 200.0));
let p = path(&s, id);
assert_ne!(p, before, "the start is smoothed");
let sp = &p.subpaths[0];
assert_eq!(sp.anchors[0].p, Point::new(100.0, 200.0), "the start stays");
let start = smooth_end_angle(sp, false);
assert!(start <= 5.0, "the path leaves its start at {start}° to the line");
let kept = |sp: &vectorcraft_geom::SubPath| sp.anchors.iter().filter(|a| a.p.x >= 215.0).copied().collect::<Vec<_>>();
assert_eq!(kept(sp), kept(&before.subpaths[0]), "the anchors out of reach stay as they were");
assert!(smooth_end_angle(sp, true) > 16.0, "the far end keeps its jag");
let turn = smooth_largest_turn(sp, 101.0..300.0);
assert!(turn <= 1.0, "the refitted part joins the rest with a {turn}° turn");
}
/// `path.smoothRegion` along `drag` with the Smooth tool's reach and default Fidelity → the ids changed.
fn smooth_pass_ids(s: &mut Session, drag: &[Point]) -> serde_json::Value {
let pts: Vec<_> = drag.iter().map(|p| json!([p.x, p.y])).collect();
+113
View File
@@ -456,3 +456,116 @@ fn first_text(s: &Session) -> NodeId {
});
found.unwrap()
}
/// Whether command `id` is enabled for `s`'s selection, with the reason when it is not.
fn enabled(s: &Session, id: &str) -> std::result::Result<(), String> {
command_specs().iter().find(|c| c.id == id).map_or_else(|| Err(format!("no command {id}")), |c| (c.enabled)(s))
}
/// What `f` returned, and how many times it went through the document's text threads to tell
/// which objects are frames of one.
fn scans<T>(f: impl FnOnce() -> T) -> (T, usize) {
let before = crate::cmd::threads::thread_scans();
let out = f();
(out, crate::cmd::threads::thread_scans() - before)
}
/// Threads `a` with a new 100 pt square frame at (`x`, `y`); the thread's frames.
fn thread_with_frame(s: &mut Session, a: NodeId, x: f64, y: f64) -> Vec<u64> {
let frame = s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [a.0, frame]})).unwrap();
let r = s.execute("text.thread.create", &json!({})).unwrap();
r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect()
}
/// `ids` as a type command's refusal lists them.
fn listed(ids: &[u64]) -> String {
ids.iter().map(u64::to_string).collect::<Vec<_>>().join(", ")
}
/// Dynamic Text, its presets, Center on Top and Bottom and Area Type Options look up the threads
/// once for a whole selection, not once for each object, and refuse the same frames in the same
/// order.
#[test]
fn type_commands_look_up_threads_once_for_the_whole_selection() {
const N: usize = 24;
let mut s = session();
let area = |s: &mut Session, i: usize| {
let x = 10.0 + 30.0 * i as f64;
let r = s.execute("text.create", &json!({"x": x, "y": 10, "text": format!("Area {i}"), "area": {"width": 25, "height": 40}})).unwrap();
NodeId(r["id"].as_u64().unwrap())
};
// Area type: every other one is the first frame of a thread of two.
let (mut areas, mut threaded) = (vec![], vec![]);
for i in 0..N {
let a = area(&mut s, i);
areas.push(a.0);
if i % 2 == 0 {
let frames = thread_with_frame(&mut s, a, 10.0 + 30.0 * i as f64, 500.0);
assert_eq!(frames.len(), 2, "{frames:?}");
areas.push(frames[1]);
threaded.extend(frames);
}
}
// The refusal lists the threaded frames in the order the objects are given.
areas.reverse();
let refused: Vec<u64> = areas.iter().copied().filter(|id| threaded.contains(id)).collect();
let before = undo_len(&s);
s.execute("select.set", &json!({ "ids": areas })).unwrap();
let why = format!("area type in a thread cannot use Dynamic Text: {}", listed(&refused));
let (e, n) = scans(|| enabled(&s, "type.dynamicText"));
assert_eq!((e, n), (Err(why.clone()), 1));
let (e, n) = scans(|| err(s.execute("type.dynamicText", &json!({"on": true, "ids": areas}))));
assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
let (e, n) = scans(|| err(s.execute("text.areaOptions", &json!({"fit": "block", "ids": areas}))));
assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
assert_eq!(undo_len(&s), before);
// Type on a path in a thread comes first, before the area type.
let path = on_line(&mut s, "Threaded path");
let path_frames = thread_with_frame(&mut s, path, 700.0, 500.0);
let mut mixed = areas.clone();
mixed.push(path.0);
s.execute("select.set", &json!({ "ids": mixed })).unwrap();
let why = format!("type on a path in a thread cannot use Dynamic Text: {}", path.0);
let (e, n) = scans(|| enabled(&s, "type.dynamicText"));
assert_eq!((e, n), (Err(why.clone()), 1));
let (e, n) = scans(|| err(s.execute("type.dynamicText", &json!({"on": true, "ids": mixed}))));
assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
// Presets: point type beside type on a path in a thread.
let mut points: Vec<u64> = (0..N)
.map(|i| s.execute("text.create", &json!({"x": 10.0 + 30.0 * i as f64, "y": 300, "text": "P"})).unwrap()["id"].as_u64().unwrap())
.collect();
points.insert(N / 2, path.0);
s.execute("select.set", &json!({ "ids": points })).unwrap();
let (e, n) = scans(|| enabled(&s, "type.dynamicTextPreset"));
assert_eq!((e, n), (Err(why.clone()), 1));
let (e, n) = scans(|| err(s.execute("type.dynamicTextPreset", &json!({"preset": "arch", "ids": points}))));
assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
// Center on Top and Bottom: type on closed paths, some of it in threads.
let mut circles = vec![];
let mut in_threads = vec![];
for i in 0..N {
let (x, y) = (60.0 + 30.0 * i as f64, 200.0);
let d = format!("M{} {y} A12 12 0 1 1 {} {y} A12 12 0 1 1 {} {y} Z", x - 12.0, x + 12.0, x - 12.0);
let pid = s.execute("path.create", &json!({ "d": d })).unwrap()["id"].as_u64().unwrap();
let r = s.execute("text.createInPath", &json!({"path": pid, "mode": "onPath", "text": "O", "size": 6, "at": [x - 12.0, y]})).unwrap();
let id = NodeId(r["id"].as_u64().unwrap());
if i % 3 == 0 {
thread_with_frame(&mut s, id, x, 650.0);
in_threads.push(id.0);
}
circles.push(id.0);
}
s.execute("select.set", &json!({ "ids": circles })).unwrap();
let why = format!("type on a path in a thread cannot be centered on its top or bottom: {}", listed(&in_threads));
for c in ["type.pathCenter.top", "type.pathCenter.bottom"] {
let (e, n) = scans(|| enabled(&s, c));
assert_eq!((e, n), (Err(why.clone()), 1), "{c}");
let (e, n) = scans(|| err(s.execute(c, &json!({ "ids": circles }))));
assert!(e.ends_with(&why) && n == 1, "{c} {n}: {e}");
}
assert_eq!(path_frames.len(), 2);
}
+10
View File
@@ -534,6 +534,16 @@ fn the_document_info_report_has_every_category() {
let i = run(&mut s, "document.info", json!({"category": "linkedImages"}));
assert_eq!((i["sections"].as_array().unwrap().len(), i["sections"][0]["id"].as_str()), (1, Some("linkedImages")));
assert_eq!(i["sections"][0]["rows"].as_array().unwrap().len(), 2);
// `imageObjects` lists the linked images in the rows' order with the files they show, and the
// embedded one with no file.
let linked: Vec<Value> = i["imageObjects"].as_array().unwrap().iter().filter(|o| o["linked"] == true).cloned().collect();
for (o, r) in linked.iter().zip(i["sections"][0]["rows"].as_array().unwrap()) {
let shown = format!("{} × {} px — {}", o["width"], o["height"], o["file"].as_str().unwrap());
assert_eq!((&o["name"], shown.as_str()), (&r[0], r[1].as_str().unwrap()));
}
assert_eq!(linked.len(), 2);
let embedded: Vec<&Value> = i["imageObjects"].as_array().unwrap().iter().filter(|o| o["linked"] == false).collect();
assert_eq!((embedded.len(), &embedded[0]["file"], &embedded[0]["width"]), (1, &Value::Null, &json!(600)));
let all = run(&mut s, "document.info", json!({}));
assert_eq!(all["sections"].as_array().unwrap().len(), 13);
let i = run(&mut s, "document.info", json!({"category": "brushes"}));
+11
View File
@@ -248,6 +248,16 @@ fn anchors_within<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<Anchor>,
d.deserialize_seq(V)
}
thread_local! {
/// [`measured_segments`] of this thread.
static MEASURED_SEGMENTS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
/// How many segments [`PathData::bounds`] has measured on this thread.
pub fn measured_segments() -> u64 {
MEASURED_SEGMENTS.get()
}
/// An open or closed run of anchors.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct SubPath {
@@ -568,6 +578,7 @@ impl PathData {
}
let mut bbox: Option<Rect> = None;
for sp in &self.subpaths {
MEASURED_SEGMENTS.set(MEASURED_SEGMENTS.get().saturating_add(sp.segment_count() as u64));
for i in 0..sp.segment_count() {
let c = sp.segment(i);
// `to_bezpath_into` writes a line where neither handle is out, else a cubic.
+1 -1
View File
@@ -511,7 +511,7 @@ pub fn tool_definitions() -> Vec<Value> {
obj(
json!({
"ids": {"type": "array", "items": {"type": "integer"}},
"offset": num("Gap between text and object (default 6 pt)"),
"offset": num("Gap between text and object in pt, -1000 to 1000 (default 6 pt); a negative gap lets text that far into the object"),
"invert": {"type": "boolean"},
"release": {"type": "boolean"},
}),
+109 -7
View File
@@ -28,11 +28,26 @@ pub struct SimplifyOptions {
/// keeps its shape. The limit is the same along the whole stretch, so where smoothing moves some of
/// its points far, all of it is refitted within up to `tolerance`, as without this option.
pub smooth_moved_only: bool,
/// With [`smooth`](Self::smooth), the curve at an open subpath's first anchor leaves it along the
/// direction of the smoothed path over the 3 spreads next to it rather than along its first
/// segment. The anchor stays where it is. A closed subpath has no such end, and [`simplify_part`]
/// ignores this.
pub free_start: bool,
/// [`free_start`](Self::free_start) for an open subpath's last anchor.
pub free_end: bool,
}
impl Default for SimplifyOptions {
fn default() -> Self {
Self { tolerance: 0.5, corner_angle_deg: 30.0, straight_lines: false, smooth: 0.0, smooth_moved_only: false }
Self {
tolerance: 0.5,
corner_angle_deg: 30.0,
straight_lines: false,
smooth: 0.0,
smooth_moved_only: false,
free_start: false,
free_end: false,
}
}
}
@@ -107,6 +122,8 @@ fn simplify_subpath(sp: &SubPath, opts: &SimplifyOptions) -> Option<SubPath> {
if n == 0 || sp.closed && n < 2 {
return Some(sp.clone());
}
let closed_opts = SimplifyOptions { free_start: false, free_end: false, ..*opts };
let opts = if sp.closed { &closed_opts } else { opts };
if sp.closed {
// Start the loop at its first corner, so no fit runs across one.
let k = (0..n).find(|&i| turn_deg(&segs[(i + n - 1) % n], &segs[i]) > opts.corner_angle_deg).unwrap_or(0);
@@ -282,6 +299,12 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
cuts.insert(0, 0);
cuts.push(run.len());
let mut result: Vec<Seg> = Vec::new();
// Whether `part` starts where `run` does and whether it ends where `run` does, for the free ends.
let free = |part: &[(&Seg, usize)]| {
let starts = part.first().zip(run.first()).is_some_and(|((s, _), r)| std::ptr::eq(*s, r));
let ends = part.last().zip(run.last()).is_some_and(|((s, _), r)| std::ptr::eq(*s, r));
[opts.free_start && starts, opts.free_end && ends]
};
for w in cuts.windows(2) {
let piece = &run[w[0]..w[1]];
let mut part: Vec<(&Seg, usize)> = Vec::new();
@@ -290,7 +313,7 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
let steps = sample_steps(&s.c, tol);
if steps <= budget.min(MAX_SEGMENT_SAMPLES) && result.len() < MAX_RUN_RESULT {
if part_samples + steps > MAX_FIT_SAMPLES {
refit_part(&part, opts, tol, None, &mut result);
refit_part(&part, opts, tol, None, free(&part), &mut result);
part.clear();
part_samples = 0;
}
@@ -299,7 +322,7 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
part.push((s, steps));
} else {
part_samples = 0;
refit_part(&part, opts, tol, None, &mut result);
refit_part(&part, opts, tol, None, free(&part), &mut result);
part.clear();
if opts.straight_lines {
let room = MAX_RUN_RESULT.saturating_sub(result.len());
@@ -313,7 +336,7 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
}
}
}
refit_part(&part, opts, tol, ends.filter(|_| part.len() == run.len()), &mut result);
refit_part(&part, opts, tol, ends.filter(|_| part.len() == run.len()), free(&part), &mut result);
}
result
}
@@ -321,14 +344,18 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
/// Adds the refit of `part`, consecutive segments with no corner between them and the steps to
/// sample each one with, to `result`. `ends`, given only when `part` is a whole closed loop, is the
/// direction it leaves and arrives along; when the loop is smoothed, the smoothing runs across its
/// start and the direction comes from the smoothed samples there.
fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends: Option<Vec2>, result: &mut Vec<Seg>) {
/// start and the direction comes from the smoothed samples there. `free` says whether the start and
/// the end of `part` are free ends of an open subpath: when it is smoothed, the refit leaves such a
/// start and arrives at such an end along [`free_end_direction`], or along its first or last segment
/// when that gives none or turns from the segment by 90° or more.
fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends: Option<Vec2>, free: [bool; 2], result: &mut Vec<Seg>) {
let (Some((first, _)), Some((last, _))) = (part.first(), part.last()) else { return };
let mut pts = Vec::new();
for (k, (s, steps)) in part.iter().enumerate() {
sample(&s.c, *steps, &mut pts, k == 0);
}
let mut tol = tol;
let (mut t0, mut t1) = (start_tangent(&first.c), end_tangent(&last.c));
if opts.smooth > 0.0 {
let smoothed = if ends.is_some() { smooth_loop_points(&pts, opts.smooth) } else { smooth_points(&pts, opts.smooth) };
if ends.is_some()
@@ -336,6 +363,18 @@ fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends
{
ends = unit(next - prev).or(ends);
}
if ends.is_none() {
if free[0]
&& let Some(d) = free_end_direction(&smoothed, opts.smooth, false).filter(|d| d.dot(t0) > 0.0)
{
t0 = d;
}
if free[1]
&& let Some(d) = free_end_direction(&smoothed, opts.smooth, true).filter(|d| d.dot(t1) > 0.0)
{
t1 = d;
}
}
if opts.smooth_moved_only {
tol = tol.min((2.0 * smoothing_moved(&pts, &smoothed)).max(tol * SMOOTH_MOVED_FLOOR));
}
@@ -351,7 +390,7 @@ fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends
// to 1.5% of `tol`: 3/4 of how far its handles may be from the line. The fitted curves join
// smoothly, so a curve becomes a line only when the line keeps both of its joins smooth. The last
// curve of a loop fitted across its start leaves along the loop's first segment.
let (t0, t1) = ends.map_or((start_tangent(&first.c), end_tangent(&last.c)), |d| (d, d));
let (t0, t1) = ends.map_or((t0, t1), |d| (d, d));
let fitted = fit_cubics(&pts, t0, t1, tol * 0.98);
let from = result.len();
let mut arrive = t0;
@@ -451,6 +490,66 @@ fn smoothing_moved(pts: &[Point], smoothed: &[Point]) -> f64 {
.fold(0.0, f64::max)
}
/// How far along the path, in spreads of the smoothing, [`free_end_direction`] looks from the end:
/// as far as the Gaussian reaches. VectorCraft's own value.
const FREE_END_SPREADS: f64 = 3.0;
/// [`free_end_direction`] gives no direction when the path near the end spreads out from it more
/// evenly than this: the ratio of the least to the most squared distance from a line through the end,
/// over all such lines. VectorCraft's own value.
const FREE_END_MAX_SPREAD: f64 = 1.0 / 3.0;
/// The direction the samples `pts` of an open run leave their first point along, or with `at_end`
/// arrive at their last point along: the direction of the line through that point that the path
/// within [`FREE_END_SPREADS`] spreads `sigma` of it along its length, and at most half its length,
/// lies closest to by the least sum of squared distances, pointing along the path. `None` when the
/// path there has no length or is not finite, when its mean point is within a tenth of its length
/// there of that point (it doubles back), or when it spreads from that point more evenly than
/// [`FREE_END_MAX_SPREAD`].
fn free_end_direction(pts: &[Point], sigma: f64, at_end: bool) -> Option<Vec2> {
let n = pts.len();
let total: f64 = pts.windows(2).map(|w| w[0].distance(w[1])).sum();
let reach = (FREE_END_SPREADS * sigma).min(total / 2.0);
if !(reach.is_finite() && reach > 0.0) {
return None;
}
let at = |i: usize| pts.get(if at_end { n - 1 - i } else { i }).copied();
let origin = at(0)?;
// The integrals along the path of v vᵀ and of v, for v from the end to each point.
let (mut sxx, mut sxy, mut syy, mut sum, mut along) = (0.0, 0.0, 0.0, Vec2::ZERO, 0.0);
let mut a = Vec2::ZERO;
for i in 1..n {
let Some(p) = at(i) else { break };
let mut b = p - origin;
let mut len = (b - a).hypot();
if along + len > reach {
b = a.lerp(b, (reach - along) / len);
len = reach - along;
}
sxx += len * (a.x * a.x + a.x * b.x + b.x * b.x) / 3.0;
syy += len * (a.y * a.y + a.y * b.y + b.y * b.y) / 3.0;
sxy += len * (2.0 * a.x * a.y + a.x * b.y + b.x * a.y + 2.0 * b.x * b.y) / 6.0;
sum += (a + b) * (len / 2.0);
along += len;
a = b;
if along >= reach {
break;
}
}
let (trace, apart) = (sxx + syy, (sxx - syy).hypot(2.0 * sxy));
// The two principal values are (trace ± apart) / 2.
if !(trace.is_finite() && apart.is_finite() && trace > 0.0) || trace - apart > FREE_END_MAX_SPREAD * (trace + apart) {
return None;
}
let mean = sum / along;
if !mean.hypot().is_finite() || mean.hypot() < 0.1 * along {
return None;
}
let d = Vec2::from_angle(0.5 * (2.0 * sxy).atan2(sxx - syy));
let d = if d.dot(mean) >= 0.0 { d } else { -d };
unit(if at_end { -d } else { d })
}
/// How many groups of samples a spread holds at most in [`smooth_points`]. Weighing them in groups
/// leaves each smoothed point within a thousandth of a spread of the mean of its samples weighed one
/// by one.
@@ -597,6 +696,7 @@ pub struct SimplifiedPart {
/// `segments` is simplified whole, as [`simplify_with`] does. A run whose refit would have more
/// segments than it had is left as it is (except with Convert to Straight Lines).
pub fn simplify_part(path: &PathData, segments: &BTreeSet<(usize, usize)>, opts: &SimplifyOptions) -> SimplifiedPart {
let opts = &SimplifyOptions { free_start: false, free_end: false, ..*opts };
let (mut runs, mut anchors) = (BTreeSet::new(), BTreeMap::new());
let mut subpaths = Vec::with_capacity(path.subpaths.len());
for (si, sp) in path.subpaths.iter().enumerate() {
@@ -784,6 +884,8 @@ pub fn smooth_options(path: &PathData, level: f64) -> SimplifyOptions {
straight_lines: false,
smooth: size * 0.05 * level / 100.0,
smooth_moved_only: false,
free_start: false,
free_end: false,
}
}
+55
View File
@@ -488,6 +488,61 @@ fn simplify_keeps_the_join_at_the_start_of_a_smoothed_loop_smooth() {
}
}
/// The degrees between the x axis and the direction `sp` leaves its first anchor along.
fn start_angle(sp: &SubPath) -> f64 {
let c = sp.segment(0);
let d = [c.p1 - c.p0, c.p2 - c.p0, c.p3 - c.p0].into_iter().find(|d| d.hypot() > 1e-9).unwrap_or_default();
d.y.atan2(d.x).to_degrees()
}
/// With `free_start` and `free_end`, a smoothed open subpath leaves its first anchor and arrives at
/// its last one along the smoothed path, not along a jagged first or last segment, and its end points
/// stay. Only a flagged end turns, and a closed subpath, Object › Path › Smooth's selected segments
/// (`simplify_part`) and a refit without smoothing give the same result with the flags as without.
#[test]
fn free_ends_turn_only_open_smoothed_ends() {
let pts: Vec<Point> = (0..=40).map(|i| Point::new(5.0 * f64::from(i), if i == 1 || i == 39 { 1.5 } else { 0.0 })).collect();
let path = PathData::single(SubPath::polyline(&pts, false));
let base = SimplifyOptions { tolerance: 2.5, corner_angle_deg: 179.0, smooth: 4.0, smooth_moved_only: true, ..Default::default() };
let both = SimplifyOptions { free_start: true, free_end: true, ..base };
let s = simplify_with(&path, &both);
let sp = &s.subpaths[0];
assert_eq!((sp.anchors[0].p, sp.anchors[sp.anchors.len() - 1].p), (pts[0], pts[40]), "{s:?}");
let mut back = sp.clone();
back.reverse();
assert!(start_angle(sp).abs() <= 5.0 && (start_angle(&back).abs() - 180.0).abs() <= 5.0, "{s:?}");
let start_only = simplify_with(&path, &SimplifyOptions { free_start: true, ..base });
let plain = simplify_with(&path, &base);
assert!(start_angle(&start_only.subpaths[0]).abs() <= 5.0, "{start_only:?}");
assert!(start_angle(&plain.subpaths[0]) > 16.0, "{plain:?}");
let (mut a, mut b) = (start_only.subpaths[0].clone(), plain.subpaths[0].clone());
a.reverse();
b.reverse();
assert!((start_angle(&a) - start_angle(&b)).abs() <= 1e-9, "the last anchor keeps its direction: {start_only:?}");
// Flags that must have no effect.
let ring = PathData::single(SubPath::polyline(&pts[..39], true));
assert_eq!(simplify_with(&ring, &both), simplify_with(&ring, &base));
let unsmoothed = SimplifyOptions { smooth: 0.0, ..base };
assert_eq!(simplify_with(&path, &SimplifyOptions { free_start: true, free_end: true, ..unsmoothed }), simplify_with(&path, &unsmoothed));
let picked: std::collections::BTreeSet<(usize, usize)> = (0..20).map(|i| (0, i)).collect();
assert_eq!(simplify_part(&path, &picked, &both).path, simplify_part(&path, &picked, &base).path);
}
/// A free end whose smoothed path turns back by more than 90° from its first segment keeps that
/// segment's direction: a path that leaves its start along x for 2 pt, then turns by 170°.
#[test]
fn a_free_end_that_turns_back_keeps_its_first_direction() {
let back = kurbo::Vec2::from_angle(170f64.to_radians());
let mut pts = vec![Point::ORIGIN, Point::new(2.0, 0.0)];
pts.extend((1..=10).map(|i| Point::new(2.0, 0.0) + back * (3.0 * f64::from(i))));
let path = PathData::single(SubPath::polyline(&pts, false));
let opts =
SimplifyOptions { tolerance: 2.5, corner_angle_deg: 179.0, smooth: 4.0, smooth_moved_only: true, free_start: true, ..Default::default() };
let s = simplify_with(&path, &opts);
let angle = start_angle(&s.subpaths[0]);
assert!(angle.abs() <= 1.0, "the path leaves its start at {angle}°: {s:?}");
}
#[test]
fn simplify_straight_lines_option() {
let c = dense_circle(50.0, 200);
+2
View File
@@ -42,6 +42,8 @@ use breaking::{break_line, candidates};
pub use driver::{decorations, drawn, fit_first_line, fit_source_lines, layout, layout_with, scaled};
#[cfg(test)]
pub(crate) use driver::{fit_passes, layout_faces_per_call};
#[cfg(test)]
pub(crate) use on_path::{layout_trying_each_start, path_arrangements};
use vertical::{TcyStyle, stands_upright, tate_chu_yoko, upright_cell, upright_centre, upright_extent, whole_character_widths};
#[cfg(test)]
+334 -28
View File
@@ -7,6 +7,7 @@ use super::{
SGlyph, Shape, TextObject, Vec2, style_metrics,
};
use crate::fontdb::PathAlignHeights;
use unicode_bidi::{BidiClass, BidiInfo};
/// The distance along type on a path each glyph takes: its advance measured `spacing` points above
/// the path (Type on a Path Options › Spacing), so glyphs close up round the outside of a curve and
@@ -132,6 +133,253 @@ fn bend_outline(outline: &BezPath, pre: Affine, ap: &ArcPath, bend: &GlyphBend)
.then_some(out)
}
/// Glyphs in a row, each taking its step: how far the row takes the line (`sum`), and how far past
/// where its first glyph starts the farthest of their ends is (`far`).
#[derive(Clone, Copy)]
struct Reach {
sum: f64,
far: f64,
}
impl Reach {
/// No glyphs.
const NONE: Self = Self { sum: 0.0, far: f64::NEG_INFINITY };
/// One glyph.
fn step(step: f64) -> Self {
Self { sum: step, far: step }
}
/// The glyphs of `self` followed by those of `next`.
fn then(self, next: Self) -> Self {
Self { sum: self.sum + next.sum, far: self.far.max(self.sum + next.far) }
}
}
/// The reach of the glyphs at some of `n` positions in a row (a segment tree): a glyph is put at
/// its position in O(log n), and the reach of the glyphs in a range of positions is found in O(log n).
struct Reaches {
size: usize,
nodes: Vec<Reach>,
}
impl Reaches {
fn new(n: usize) -> Self {
let size = n.next_power_of_two();
Self { size, nodes: vec![Reach::NONE; 2 * size] }
}
fn node(&self, k: usize) -> Reach {
self.nodes.get(k).copied().unwrap_or(Reach::NONE)
}
/// Puts a glyph that takes `step` at position `at`.
fn put(&mut self, at: usize, step: f64) {
let mut k = self.size + at;
let Some(leaf) = self.nodes.get_mut(k) else { return };
*leaf = Reach::step(step);
while k > 1 {
k /= 2;
let joined = self.node(2 * k).then(self.node(2 * k + 1));
if let Some(node) = self.nodes.get_mut(k) {
*node = joined;
}
}
}
/// The reach of the glyphs put at positions `range`, in order.
fn of(&self, range: Range<usize>) -> Reach {
let (mut left, mut right) = (Reach::NONE, Reach::NONE);
let (mut a, mut b) = (range.start.min(self.size) + self.size, range.end.min(self.size) + self.size);
while a < b {
if a % 2 == 1 {
left = left.then(self.node(a));
a += 1;
}
if b % 2 == 1 {
b -= 1;
right = self.node(b).then(right);
}
(a, b) = (a / 2, b / 2);
}
left.then(right)
}
}
/// Whether a glyph whose character has bidi class `class` goes to its paragraph's level when the
/// line ends with it and the characters after it like it (UAX #9 L1): whitespace and isolate
/// controls, and the embedding controls and boundary neutrals, which `unicode_bidi` treats the same.
fn trails(class: BidiClass) -> bool {
use unicode_bidi::BidiClass::{BN, FSI, LRE, LRI, LRO, PDF, PDI, RLE, RLI, RLO, WS};
matches!(class, WS | FSI | LRI | RLI | PDI | RLE | LRE | RLO | LRO | PDF | BN)
}
/// Measures every start of the text in reading order, shortest first, in O(n log n) for n glyphs:
/// `visit(end, reach)` gets the byte each start ends at (a glyph's byte; the whole text is not
/// visited) and the reach of its glyphs in its own visual order when each glyph `g` takes `step(g)`.
///
/// The visual order of a start of a paragraph keeps the order its glyphs have in the whole
/// paragraph (UAX #9 L2 reorders by the levels between two glyphs only), except for the glyphs
/// that L1 sets to the paragraph's level at the end of the start: those come after the rest in a
/// left-to-right paragraph and before it, last first, in a right-to-left one. The glyphs are put at
/// their positions in the whole text's visual order one start after another.
fn each_start(shaped: &[(Range<usize>, Option<BidiInfo<'_>>, Vec<SGlyph>)], step: impl Fn(&SGlyph) -> f64, mut visit: impl FnMut(usize, Reach)) {
let total = shaped.iter().map(|(_, _, glyphs)| glyphs.len()).sum();
let mut reaches = Reaches::new(total);
let mut last_byte = None;
let mut para_at = 0;
for (pr, bidi, glyphs) in shaped {
// Where each glyph of the paragraph is in the whole text's visual order.
let mut at = vec![para_at; glyphs.len()];
for (v, i) in visual_order(bidi.as_ref(), pr.start, pr.clone(), glyphs).into_iter().enumerate() {
if let Some(p) = at.get_mut(i) {
*p = para_at + v;
}
}
let para_rtl = bidi.as_ref().and_then(|b| b.paragraphs.first()).map(|p| p.level.is_rtl());
// The glyphs at the end of the start so far that L1 sets to the paragraph's level, their
// reach in visual order, and the reach of the cluster being added to them.
let mut held: Vec<(usize, f64)> = Vec::new();
let (mut trailing, mut cluster) = (Reach::NONE, Reach::NONE);
let mut prev: Option<&SGlyph> = None;
for (g, &p) in glyphs.iter().zip(&at) {
// A cluster is a glyph and those after it at its byte (a list marker's apart).
let joins = prev.is_some_and(|q| q.byte == g.byte && (q.len == 0) == (g.len == 0));
if !joins {
trailing = match para_rtl {
Some(true) => cluster.then(trailing),
_ => trailing.then(cluster),
};
cluster = Reach::NONE;
}
if last_byte != Some(g.byte) {
// The start that ends before this glyph.
let reach = match para_rtl {
_ if held.is_empty() => reaches.of(0..total),
Some(true) => reaches.of(0..para_at).then(trailing).then(reaches.of(para_at..total)),
_ => reaches.of(0..total).then(trailing),
};
visit(g.byte, reach);
last_byte = Some(g.byte);
}
let s = step(g);
// Every character of the glyph's cluster is one that trails.
let from = g.byte.saturating_sub(pr.start);
let classes = bidi.as_ref().and_then(|b| b.original_classes.get(from..from + g.len));
if para_rtl.is_some() && g.len > 0 && classes.is_some_and(|c| c.iter().copied().all(trails)) {
held.push((p, s));
cluster = cluster.then(Reach::step(s));
} else {
for (q, s) in held.drain(..) {
reaches.put(q, s);
}
(trailing, cluster) = (Reach::NONE, Reach::NONE);
reaches.put(p, s);
}
prev = Some(g);
}
// The whole paragraph is in its own visual order.
for (q, s) in held.drain(..) {
reaches.put(q, s);
}
para_at += glyphs.len();
}
}
/// The end (a byte) of the longest start of the text, in reading order, whose glyphs fit when each
/// takes its advance: `fits(w, far)` says whether glyphs in visual order that take `w` along the
/// path, the farthest of their ends `far` past where the first starts, fit. `first` is the first
/// glyph's byte, where nothing is laid out. A start can fit where a shorter one doesn't, after a
/// glyph that takes the line back, so every start is measured ([`each_start`]).
fn longest_fitting_start(shaped: &[(Range<usize>, Option<BidiInfo<'_>>, Vec<SGlyph>)], first: usize, fits: impl Fn(f64, f64) -> bool) -> usize {
let mut longest = first;
each_start(
shaped,
|g| g.adv,
|byte, reach| {
if fits(reach.sum, reach.far) {
longest = byte;
}
},
);
longest
}
/// The ends (bytes) of the starts of the text, in reading order, shortest first, that can fit on a
/// path of length `len` with `spacing`: those whose glyphs, in their own visual order, reach at most
/// `len` past where the first starts when each takes the least step it can. A glyph's step is at
/// least a quarter of its advance with spacing, and its advance otherwise ([`path_steps`]); a line
/// starts no earlier than its span with the hang at its start, and every glyph that fits ends within
/// that span with both hangs, which is no longer than the path. The start before the first glyph,
/// where nothing is laid out, is always one of them.
fn starts_that_can_fit(shaped: &[(Range<usize>, Option<BidiInfo<'_>>, Vec<SGlyph>)], spacing: f64, len: f64) -> Vec<usize> {
let least = |g: &SGlyph| if spacing != 0.0 && g.adv > 1e-9 { g.adv * 0.25 } else { g.adv };
let mut starts = Vec::new();
each_start(shaped, least, |byte, reach| {
// A little room for sums added in another order than where the glyphs are placed.
if reach.far <= len + 1e-5 || reach.far.is_nan() {
starts.push(byte);
}
});
starts
}
/// The most starts of overflowing right-to-left type on a path that are arranged one by one, from
/// the longest, when a glyph takes the line back ([`longest_start_tried`]).
const PATH_START_TRIES: usize = 32;
/// The longest of `starts` (ends of starts, shortest first, the first of which fits) for which
/// `fits` holds, arranging at most `tries` of them one by one, from the longest. When none of those
/// fits, a binary search among the rest finds one that fits with O(log n) more arrangements; as a
/// longer start can fit where a shorter one doesn't, that one is not always the longest that fits.
/// `None` when there are no starts.
fn longest_start_tried(starts: &[usize], tries: usize, mut fits: impl FnMut(usize) -> bool) -> Option<usize> {
let rest = starts.len().saturating_sub(tries);
if let Some(&byte) = starts.get(rest..).unwrap_or_default().iter().rev().find(|&&byte| fits(byte)) {
return Some(byte);
}
// `starts[fit]` fits; `starts[over]` was tried or doesn't.
let (mut fit, mut over) = (0, rest);
while over > fit + 1 {
let mid = fit + (over - fit) / 2;
if starts.get(mid).is_some_and(|&byte| fits(byte)) {
fit = mid;
} else {
over = mid;
}
}
starts.get(fit).copied()
}
#[cfg(test)]
thread_local! {
/// How many times type on a path arranged glyphs on its path on this thread ([`path_arrangements`]).
static ARRANGEMENTS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// How many times type on a path arranged glyphs on its path on this thread.
#[cfg(test)]
pub(crate) fn path_arrangements() -> usize {
ARRANGEMENTS.get()
}
#[cfg(test)]
thread_local! {
/// Set while [`layout_trying_each_start`] lays text out.
static EACH_START: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
/// [`layout`](super::layout) arranging every start of overflowing right-to-left type on a path in
/// turn, from the longest, until one fits: the reference the search for the longest start is
/// compared with.
#[cfg(test)]
pub(crate) fn layout_trying_each_start(db: &crate::fontdb::FontDb, t: &TextObject) -> crate::TextLayout {
EACH_START.set(true);
let l = super::layout(db, t);
EACH_START.set(false);
l
}
/// Lay type on a path out along `path` (text space), between its brackets.
pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &PathData) {
cx.out.on_path = true;
@@ -247,29 +495,33 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
};
(l, r, hung_r)
};
// Where a line that takes `w` along the path starts, aligned in the span with the hangs.
let align = |w: f64, (l, r, _): (f64, f64, usize)| {
let (lo, room) = (s_start - l, avail + l + r);
match para.justify {
Justify::Auto if rtl => lo + (room - w).max(0.0),
Justify::Center | Justify::JustifyCenter => lo + ((room - w) * 0.5).max(0.0),
Justify::Right | Justify::JustifyRight => lo + (room - w).max(0.0),
_ => lo,
}
};
// The glyphs `sg` arranged on the path: their steps, where the first starts, and the hangs.
let arrange = |sg: &[SGlyph]| {
#[cfg(test)]
ARRANGEMENTS.set(ARRANGEMENTS.get() + 1);
let mut steps = path_steps(&ap, sg, s_start, spacing);
let w: f64 = steps.iter().sum();
let place = |(l, r, _): (f64, f64, usize)| {
let (lo, room) = (s_start - l, avail + l + r);
match para.justify {
Justify::Auto if rtl => lo + (room - w).max(0.0),
Justify::Center | Justify::JustifyCenter => lo + ((room - w) * 0.5).max(0.0),
Justify::Right | Justify::JustifyRight => lo + (room - w).max(0.0),
_ => lo,
}
};
// Where the line starts when its glyphs take `steps`.
let place = |steps: &[f64], hung| align(steps.iter().sum(), hung);
let mut hung = hangs(sg, &steps);
let mut s0 = place(hung);
let mut s0 = place(&steps, hung);
if spacing != 0.0 && s0 != s_start {
// Spaced from where the alignment puts them, the curve under them is another. That
// changes the hanging glyphs' steps, so the line is placed again from the new steps
// until it stays where it is (at most 8 times).
// changes the glyphs' steps, so what the line takes and what hangs, and the line is
// placed again from the new steps until it stays where it is (at most 8 times).
steps = path_steps(&ap, sg, s0, spacing);
for _ in 0..8 {
hung = hangs(sg, &steps);
let moved = place(hung);
let moved = place(&steps, hung);
if (moved - s0).abs() < 1e-9 {
break;
}
@@ -303,23 +555,47 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
// Right-to-left text that overflows keeps the start of its text, not what comes first in visual
// order: the longest start, in reading order, whose glyphs fit in visual order is laid out.
if shaped.iter().any(|(_, bidi, _)| bidi.is_some()) && fitting(&steps, s0, hung) < sg.len() {
let mut starts: Vec<usize> = shaped.iter().flat_map(|(_, _, glyphs)| glyphs.iter().map(|g| g.byte)).collect();
starts.dedup();
// The text before `starts[fit]` fits; before `starts[over]` (the whole text at the end) it
// doesn't.
let (mut fit, mut over) = (0, starts.len());
while over - fit > 1 {
let mid = (fit + over) / 2;
let sg = visual(starts.get(mid).copied().unwrap_or(text_len));
// Whether the text before byte `cut` fits, arranged as it would be laid out.
let fits_before = |cut: usize| {
let sg = visual(cut);
let (steps, s0, hung) = arrange(&sg);
if fitting(&steps, s0, hung) == sg.len() {
fit = mid;
} else {
over = mid;
fitting(&steps, s0, hung) == sg.len()
};
// The byte at which each start of the text ends, in reading order.
let mut starts: Vec<usize> = shaped.iter().flat_map(|(_, _, glyphs)| glyphs).map(|g| g.byte).collect();
starts.dedup();
let first = starts.first().copied().unwrap_or(text_len);
// On one straight segment the path doesn't turn, so spacing changes no step.
let straight = matches!(path.to_bezpath().elements(), [PathEl::MoveTo(_), PathEl::LineTo(_)]);
#[cfg(test)]
let each_start = EACH_START.get();
#[cfg(not(test))]
let each_start = false;
fits = if each_start {
starts.iter().rev().copied().find(|&byte| fits_before(byte)).unwrap_or(first)
} else if (spacing == 0.0 || straight) && !hanging {
// Each glyph takes its advance wherever the line is placed.
longest_fitting_start(&shaped, first, |w, far| align(w, (0.0, 0.0, 0)) - s_start + far <= avail + 1e-6)
} else if sg.iter().all(|g| g.adv >= 0.0) {
// No glyph takes the line back: a start fits when a longer one does. The text before
// `starts[fit]` fits; before `starts[over]` (the whole text at the end) it doesn't.
let (mut fit, mut over) = (0, starts.len());
while over - fit > 1 {
let mid = (fit + over) / 2;
if fits_before(starts.get(mid).copied().unwrap_or(text_len)) {
fit = mid;
} else {
over = mid;
}
}
}
starts.get(fit).copied().unwrap_or(text_len)
} else {
// A glyph that takes the line back can make a start fit where a shorter one doesn't:
// the starts that can fit the path however their glyphs are spaced are tried from the
// longest, at most `PATH_START_TRIES` of them before a binary search over the rest.
longest_start_tried(&starts_that_can_fit(&shaped, spacing, ap.len()), PATH_START_TRIES, &fits_before).unwrap_or(first)
};
cx.out.overflow = true;
fits = starts.get(fit).copied().unwrap_or(text_len);
sg = visual(fits);
(steps, s0, hung) = arrange(&sg);
}
@@ -432,3 +708,33 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
region: 0,
});
}
#[cfg(test)]
mod tests {
use super::longest_start_tried;
/// The longest start that fits is found among the ones tried; past the tries, a binary search
/// finds one that fits, with as many more tries as halvings of the rest.
#[test]
fn starts_are_tried_from_the_longest_then_searched() {
let starts: Vec<usize> = (0..1000).collect();
// Every start up to 600 fits, and so does 990.
let fits = |byte: usize| byte <= 600 || byte == 990;
let mut tried = 0;
let found = longest_start_tried(&starts, 32, |byte| {
tried += 1;
fits(byte)
});
assert_eq!((found, tried), (Some(990), 10));
tried = 0;
let found = longest_start_tried(&starts, 8, |byte| {
tried += 1;
fits(byte)
});
assert_eq!(found, Some(600));
assert!(tried <= 8 + 10, "{tried} tries");
// With fewer starts than tries, each is tried.
assert_eq!(longest_start_tried(&starts[..5], 32, |byte| byte == 0), Some(0));
assert_eq!(longest_start_tried(&[], 32, |_| true), None);
}
}
+179 -6
View File
@@ -384,6 +384,80 @@ fn band_boundaries(polys: &[Vec<Point>], top: f64, bottom: f64) -> (Vec<(f64, f6
(union_intervals(edges), paired)
}
/// The largest magnitude a text wrap offset may have (points), the bound the Text Wrap commands
/// and `.ai` import keep too.
const MAX_WRAP_OFFSET: f64 = 1000.0;
/// A wrap object's offset as layout uses it: within [`MAX_WRAP_OFFSET`] either way, and 0 when it
/// is not a number.
fn wrap_offset(offset: f64) -> f64 {
if offset.is_nan() { 0.0 } else { offset.clamp(-MAX_WRAP_OFFSET, MAX_WRAP_OFFSET) }
}
/// The x at which some point of the band `top..bottom` (`top <= bottom`) is inside `polys`
/// (even-odd) and farther than `d` (> 0) from every edge of it, holes included: the cover of the
/// shape shrunk by `d`. The band is cut into pieces (at most [`INVERT_WRAP_PIECES`] even ones, and
/// at every anchor's height and `d` above and below it when there are at most that many of those);
/// in each piece, an x is left out when the shape is nowhere in the piece there, or when the whole
/// piece there lies within `d` of one edge. A piece where several edges together cover it keeps
/// its x, so the result can be wider than the shrunk shape, never narrower, and never wider than
/// the shape's own cover of the band.
fn eroded_cover(polys: &[Vec<Point>], top: f64, bottom: f64, d: f64) -> Vec<(f64, f64)> {
// A point `d` from an edge, up to rounding, counts as near it, so a band that only touches the
// shrunk shape is left whole.
let r = d * (1.0 + 1e-12);
let span = |p: &[Point]| p.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), q| (lo.min(q.y), hi.max(q.y)));
// The shrunk shape lies more than `d` below the shape's top and above its bottom, so a band
// outside that holds none of it; within it, only contours that come within `d` of the band
// count (the others neither cross it nor bound the shape near it).
let (lo, hi) = polys.iter().map(|p| span(p)).fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), (c, e)| (a.min(c), b.max(e)));
if bottom <= lo + r || top >= hi - r {
return vec![];
}
let near_band: Vec<Vec<Point>> = polys
.iter()
.filter(|p| {
let (lo, hi) = span(p);
hi >= top - r && lo <= bottom + r
})
.cloned()
.collect();
let polys = near_band.as_slice();
let pieces = ((bottom - top) * 4.0 / d).ceil().clamp(1.0, INVERT_WRAP_PIECES);
let mut cuts: Vec<f64> = (0..=pieces as usize).map(|k| top + (bottom - top) * k as f64 / pieces).collect();
if bottom > top {
let mut anchors: Vec<f64> = polys.iter().flatten().flat_map(|p| [p.y - d, p.y, p.y + d]).filter(|&y| y > top && y < bottom).collect();
anchors.sort_by(f64::total_cmp);
anchors.dedup();
if anchors.len() <= INVERT_WRAP_PIECES as usize {
cuts.extend(anchors);
cuts.sort_by(f64::total_cmp);
cuts.dedup();
}
}
let mut out = Vec::new();
// A band of no height keeps its two equal cuts: one piece of no height, measured at its y.
for w in cuts.windows(2) {
let (a, b) = (w[0], w[1]);
let cover = band_cover(polys, a, b, false);
if cover.is_empty() {
continue;
}
// The points closer than `d` to an edge make a convex shape, so a vertical line within
// the piece lies in it when both its ends do.
let near = polys.iter().flat_map(|p| {
(0..p.len()).filter_map(move |i| {
let (s, t) = (p[i], p[(i + 1) % p.len()]);
let (u, v) = (near_segment(s, t, a, r)?, near_segment(s, t, b, r)?);
let (x, y) = (u.0.max(v.0), u.1.min(v.1));
(y > x).then_some((x, y))
})
});
out.extend(subtract_intervals(&cover, &union_intervals(near.collect())));
}
union_intervals(out)
}
impl Region {
pub(super) fn cells(path: &BezPath, opts: &LayoutOptions, wrap: &[vectorcraft_doc::WrapShape]) -> Vec<Region> {
// A frame out of range has no cells, and a wrap shape out of range is left out.
@@ -392,7 +466,7 @@ impl Region {
let polys: std::sync::Arc<[Vec<Point>]> = polys.into();
let wraps: std::sync::Arc<[FlatWrap]> = wrap
.iter()
.filter_map(|w| Some((polygons(&w.path.to_bezpath())?, w.wrap.offset.max(0.0), w.wrap.invert)))
.filter_map(|w| Some((polygons(&w.path.to_bezpath())?, wrap_offset(w.wrap.offset), w.wrap.invert)))
.filter(|w| !w.0.is_empty())
.collect();
let bbox = path.bounding_box();
@@ -431,8 +505,10 @@ impl Region {
}
/// `iv` minus every x at which a wrap object lies somewhere in the band `top..bottom` (or the x
/// inside it over the whole band, for Invert Wrap). Offsets grow each wrap shape vertically
/// and horizontally. Along the line, the text also keeps the inset beside each wrap object
/// inside it over the whole band, for Invert Wrap). A positive offset grows each wrap shape
/// vertically and horizontally; a negative one shrinks it by that distance from its edges
/// (holes included), so text runs that far into the object, or stays that far inside it for
/// Invert Wrap. Along the line, the text also keeps the inset beside each wrap object
/// (outside it, or inside it for Invert Wrap); above and below a wrap object only its offset
/// applies.
fn wrapped(&self, mut iv: Vec<(f64, f64)>, top: f64, bottom: f64) -> Vec<(f64, f64)> {
@@ -444,7 +520,17 @@ impl Region {
}
let grow = |v: Vec<(f64, f64)>| union_intervals(v.into_iter().map(|(a, b)| (a - off, b + off)).collect());
let shrink = |v: Vec<(f64, f64)>| v.into_iter().map(|(a, b)| (a + inset, b - inset)).filter(|(a, b)| b > a).collect::<Vec<_>>();
iv = if *invert {
let pad = |v: Vec<(f64, f64)>| union_intervals(v.into_iter().map(|(a, b)| (a - inset, b + inset)).collect());
iv = if *off < 0.0 {
// Invert Wrap keeps the x at which the shape shrunk by the offset holds the whole
// band; otherwise the text leaves out the x at which the shrunk shape lies
// somewhere in the band.
if *invert {
intersect_intervals(&iv, &shrink(band_inset_intervals(polys, top, bottom, -off)))
} else {
subtract_intervals(&iv, &pad(eroded_cover(polys, top, bottom, -off)))
}
} else if *invert {
// The band is cut into pieces. Each height of a piece `y0..y1` is within the offset
// of some height from `y0` plus the offset to `y1` less the offset, so an x the
// shape holds at all of those heights is inside the grown shape over the piece. In
@@ -485,8 +571,7 @@ impl Region {
}
iv
} else {
let w = grow(band_cover(polys, top - off, bottom + off, false));
subtract_intervals(&iv, &union_intervals(w.into_iter().map(|(a, b)| (a - inset, b + inset)).collect()))
subtract_intervals(&iv, &pad(grow(band_cover(polys, top - off, bottom + off, false))))
};
}
iv
@@ -640,6 +725,94 @@ fn a_line_stays_clear_of_a_wrap_object_that_reaches_into_its_band() {
assert_spans(&Region::cells(&frame, &LayoutOptions::default(), &[wrap])[0].spans(50.0, 50.0), &[(15.0, 45.0)]);
}
/// The spans of a 100 pt square frame over the band `top..bottom` with one wrap object through
/// `contours` (even-odd).
#[cfg(test)]
fn wrap_spans(contours: &[&[(f64, f64)]], offset: f64, invert: bool, top: f64, bottom: f64) -> Vec<(f64, f64)> {
let frame = Rect::new(0.0, 0.0, 100.0, 100.0).to_path(0.1);
let wrap = vectorcraft_doc::WrapShape { path: PathData::from_bezpath(&closed(contours)), wrap: vectorcraft_doc::TextWrap { offset, invert } };
Region::cells(&frame, &LayoutOptions::default(), &[wrap])[0].spans(top, bottom)
}
/// A negative offset lets text run into a wrap object by that distance, across and along the
/// line: beside a square, the line reaches 5 pt into it, and a line whose band reaches no more than
/// 5 pt into its top or bottom runs across it.
#[cfg(test)]
#[test]
fn negative_wrap_offset_insets_rectangle_on_both_axes() {
let square: &[(f64, f64)] = &[(40.0, 40.0), (60.0, 40.0), (60.0, 60.0), (40.0, 60.0)];
assert_spans(&wrap_spans(&[square], -5.0, false, 44.0, 50.0), &[(0.0, 45.0), (55.0, 100.0)]);
assert_spans(&wrap_spans(&[square], -5.0, false, 30.0, 45.0), &[(0.0, 100.0)]);
assert_spans(&wrap_spans(&[square], -5.0, false, 55.0, 70.0), &[(0.0, 100.0)]);
assert_spans(&wrap_spans(&[square], -5.0, false, 30.0, 46.0), &[(0.0, 45.0), (55.0, 100.0)]);
// The most an offset may take away is 1000 pt, and an offset that is not a number is 0.
assert_spans(&wrap_spans(&[square], f64::NEG_INFINITY, false, 44.0, 50.0), &[(0.0, 100.0)]);
assert_spans(&wrap_spans(&[square], f64::NAN, false, 44.0, 50.0), &[(0.0, 40.0), (60.0, 100.0)]);
}
/// A negative offset is measured from a sloped edge itself (10 pt across the edge of a triangle is
/// 10√2 pt along the line), and from the edges of a hole too.
#[cfg(test)]
#[test]
fn negative_wrap_offset_insets_sloped_shape_and_hole() {
let triangle: &[(f64, f64)] = &[(0.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
assert_spans(&wrap_spans(&[triangle], -10.0, false, 40.0, 60.0), &[(0.0, 10.0), (60.0 - 10.0 * std::f64::consts::SQRT_2, 100.0)]);
let outer: &[(f64, f64)] = &[(20.0, 20.0), (80.0, 20.0), (80.0, 80.0), (20.0, 80.0)];
let hole: &[(f64, f64)] = &[(40.0, 40.0), (60.0, 40.0), (60.0, 60.0), (40.0, 60.0)];
assert_spans(&wrap_spans(&[outer, hole], -5.0, false, 48.0, 52.0), &[(0.0, 25.0), (35.0, 65.0), (75.0, 100.0)]);
}
/// With Invert Wrap, a negative offset keeps the text that far inside the object, along and across
/// the line.
#[cfg(test)]
#[test]
fn negative_invert_wrap_keeps_only_eroded_interior() {
let square: &[(f64, f64)] = &[(40.0, 40.0), (60.0, 40.0), (60.0, 60.0), (40.0, 60.0)];
assert_spans(&wrap_spans(&[square], -5.0, true, 46.0, 54.0), &[(45.0, 55.0)]);
assert!(wrap_spans(&[square], -5.0, true, 42.0, 48.0).is_empty());
let triangle: &[(f64, f64)] = &[(0.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
assert_spans(&wrap_spans(&[triangle], -10.0, true, 40.0, 60.0), &[(10.0, 40.0 - 10.0 * std::f64::consts::SQRT_2)]);
}
/// A negative offset at least half as large as a wrap object is wide leaves nothing of it: text
/// runs across it, and with Invert Wrap no text fits inside it.
#[cfg(test)]
#[test]
fn negative_offset_erases_narrow_wrap_shape() {
let strip: &[(f64, f64)] = &[(40.0, 0.0), (48.0, 0.0), (48.0, 100.0), (40.0, 100.0)];
for offset in [-4.0, -5.0, -1000.0] {
assert_spans(&wrap_spans(&[strip], offset, false, 40.0, 60.0), &[(0.0, 100.0)]);
assert!(wrap_spans(&[strip], offset, true, 40.0, 60.0).is_empty(), "offset {offset}");
}
// A band of no height.
assert_spans(&wrap_spans(&[strip], -1.0, false, 50.0, 50.0), &[(0.0, 41.0), (47.0, 100.0)]);
}
/// A negative offset never keeps text farther from a wrap object than an offset of 0 does, on a
/// shape whose edges meet at many angles.
#[cfg(test)]
#[test]
fn negative_offset_never_wraps_more_than_no_offset() {
let star: Vec<(f64, f64)> = (0..40)
.map(|k| {
let (r, a) = (if k % 2 == 0 { 40.0 } else { 15.0 }, f64::from(k) * std::f64::consts::PI / 20.0);
(50.0 + r * a.cos(), 50.0 + r * a.sin())
})
.collect();
for (top, bottom) in [(10.0, 22.0), (44.0, 56.0), (30.0, 31.0), (70.0, 90.0)] {
for invert in [false, true] {
let zero = wrap_spans(&[star.as_slice()], 0.0, invert, top, bottom);
let neg = wrap_spans(&[star.as_slice()], -3.0, invert, top, bottom);
let width = |v: &[(f64, f64)]| v.iter().map(|(a, b)| b - a).sum::<f64>();
if invert {
assert!(width(&neg) <= width(&zero) + 1e-9, "{top}..{bottom}: {neg:?} {zero:?}");
} else {
assert!(width(&neg) >= width(&zero) - 1e-9, "{top}..{bottom}: {neg:?} {zero:?}");
}
}
}
}
/// A hole that starts and ends inside a line's band splits the line, and a band below the hole, or
/// one that only touches it, keeps the whole width.
#[cfg(test)]
+23
View File
@@ -835,6 +835,29 @@ fn on_path_circle_and_overflow() {
assert!(l.overflow && l.glyphs.len() < t.plain_text().len());
}
/// Type on a curve with Spacing, aligned right or centered, is placed by what its glyphs take where
/// it ends up, which differs from what they take at the start bracket: text that fits shows whole.
#[test]
fn on_path_aligned_spaced_text_that_fits_shows_whole() {
let circle = PathData::from_bezpath(&kurbo::Circle::new((0.0, 0.0), 200.0).to_path(0.1));
for text in ["Hi", "Around"] {
for justify in [Justify::Right, Justify::Center] {
for spacing in [20.0, -20.0] {
for (start, end) in [(0.0, Some(0.05)), (0.3, Some(0.4)), (0.0, None)] {
let mut t = point(text, style(12.0));
t.para.justify = justify;
t.path_spacing = spacing;
t.kind = TextKind::OnPath { path: circle.clone(), start, end };
let l = layout(db(), &t);
let case = format!("{text} {justify:?} {spacing} {start} {end:?}");
assert!(!l.overflow, "{case}");
assert_eq!(l.glyphs.len(), text.len(), "{case}");
}
}
}
}
}
#[test]
fn fallback_font_per_character() {
let primary = db().face("Source Sans 3", "Regular").unwrap();
+167
View File
@@ -698,3 +698,170 @@ fn mixed_type_on_a_path_hangs_its_final_period() {
assert!(l.glyphs.iter().any(|g| g.byte == s.len() - 1), "the period shows");
assert!(!l.overflow, "all of it fits");
}
/// `n` Hebrew letters on `path` from `start` to `end` (fractions of its length), one run each, the
/// letter at `i` tracked so that it takes `steps[i % steps.len()]` points: what each takes with no
/// tracking is measured first, and what each takes when tracked is checked.
fn stepped_hebrew(db: &FontDb, n: usize, steps: &[f64], path: &BezPath, (start, end): (f64, Option<f64>)) -> TextObject {
let letters = ['א', 'ב', 'ג', 'ד'];
let style = CharStyle::default();
let mut t = TextObject::point(Point::ZERO, "", style.clone());
t.runs = (0..n).map(|i| TextRun { text: letters[i % letters.len()].to_string(), style: style.clone(), inline: None }).collect();
let long = kurbo::Line::new((0.0, 0.0), (100_000.0, 0.0)).to_path(0.1);
t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&long), start: 0.0, end: None };
let advances = |t: &TextObject| {
let l = layout(db, t);
assert!(!l.overflow);
let mut a: Vec<(usize, f64)> = l.glyphs.iter().map(|g| (g.byte, g.advance)).collect();
a.sort_by_key(|&(byte, _)| byte);
assert_eq!(a.len(), n, "one glyph per letter");
a.into_iter().map(|(_, adv)| adv).collect::<Vec<_>>()
};
let plain = advances(&t);
for (i, (run, adv)) in t.runs.iter_mut().zip(&plain).enumerate() {
run.style.tracking = (steps[i % steps.len()] - adv) / style.size * 1000.0;
assert!((-1000.0..=10000.0).contains(&run.style.tracking), "tracking {} is in the range commands allow", run.style.tracking);
}
for (i, adv) in advances(&t).into_iter().enumerate() {
assert!((adv - steps[i % steps.len()]).abs() < 1e-9, "letter {i} takes {adv}");
}
t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(path), start, end };
t
}
/// Right-to-left type on a path that overflows shows the longest start of its text whose glyphs
/// fit, even where a shorter start doesn't fit: a letter tracked to take the line back (a negative
/// step) lets a longer start fit than the one before it.
#[test]
fn overflowing_rtl_type_on_a_path_shows_the_longest_start_that_fits() {
use vectorcraft_doc::Justify;
let db = FontDb::with_font_dirs(vec![]);
// The span runs from x = 0 to x = 10, with path on both sides of it.
let line = kurbo::Line::new((-100.0, 0.0), (100.0, 0.0)).to_path(0.1);
let t = stepped_hebrew(&db, 4, &[6.0, 6.0, -3.0, 6.0], &line, (0.5, Some(0.55)));
// Letters 0 and 1 take 12 points, more than the span holds; letters 0 to 2 take 9 and fit:
// in visual order letter 2 (-3), then 1 and 0 (6 each). All four take 15.
for (justify, s0) in [(Justify::Right, 1.0), (Justify::Auto, 1.0), (Justify::Center, 0.5), (Justify::Left, 0.0)] {
let mut t = t.clone();
t.para.justify = justify;
let l = layout(&db, &t);
assert!(l.overflow, "{justify:?}");
assert_eq!(l.lines.first().map(|line| line.end), Some(6), "{justify:?}: the first three letters show");
assert_eq!(l.glyphs.len(), 3, "{justify:?}");
let x = |byte: usize| l.glyphs.iter().find(|g| g.byte == byte).map(|g| g.origin.x);
for (byte, at) in [(4, s0), (2, s0 - 3.0), (0, s0 + 3.0)] {
assert!(x(byte).is_some_and(|x| (x - at).abs() < 1e-6), "{justify:?}: letter at byte {byte} at {:?}, not {at}", x(byte));
}
}
}
/// The longest start that fits is the one found by arranging every start in turn, in mixed text
/// whose letters take the line forward and back: with spaces and controls at the end of a start
/// (UAX #9 L1), isolates, embeddings, several paragraphs and either base direction.
#[test]
fn the_longest_rtl_start_on_a_path_is_the_one_each_start_gives() {
use vectorcraft_doc::Justify;
let db = FontDb::with_font_dirs(vec![]);
let texts = [
"abc אבג de שלום ",
"שלום עולם, hello world 123 שלום ",
"a \u{2067}אב \u{2069} cd אב \u{2066}x ",
"אב גד\nef גה \nשלום ab ",
"\u{202B}abc \u{202C} אב \u{200B} cd\u{0301} ",
];
let tracking = [-900.0, 300.0, -400.0, 0.0, 800.0, -1000.0, 150.0];
let line = kurbo::Line::new((0.0, 0.0), (200.0, 0.0)).to_path(0.1);
let mut overflowed = 0;
for s in texts {
let style = CharStyle::default();
let mut t = TextObject::point(Point::ZERO, "", style.clone());
t.runs = s
.chars()
.enumerate()
.map(|(i, c)| TextRun { text: c.to_string(), style: CharStyle { tracking: tracking[i % tracking.len()], ..style.clone() }, inline: None })
.collect();
for direction in [None, Some(ParaDirection::RightToLeft), Some(ParaDirection::LeftToRight)] {
for justify in [Justify::Right, Justify::Center, Justify::Left, Justify::Auto] {
for end in (1..=25).map(|i| f64::from(i) * 0.02) {
t.para.direction = direction;
t.para.justify = justify;
t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&line), start: 0.0, end: Some(end) };
let (found, each) = (layout(&db, &t), crate::layout::layout_trying_each_start(&db, &t));
let case = format!("{s:?} {direction:?} {justify:?} {end}");
overflowed += usize::from(found.overflow);
assert_eq!(found.overflow, each.overflow, "{case}");
assert_eq!(found.lines.first().map(|l| l.end), each.lines.first().map(|l| l.end), "{case}");
let placed = |l: &TextLayout| l.glyphs.iter().map(|g| (g.byte, g.origin.x)).collect::<Vec<_>>();
assert_eq!(placed(&found), placed(&each), "{case}");
}
}
}
}
assert!(overflowed > 500, "{overflowed} of the layouts overflow");
}
/// Finding the longest start that fits in a long right-to-left text whose letters take the line
/// back does not arrange the glyphs again for every start, nor for a search over them.
#[test]
fn the_longest_rtl_start_on_a_path_is_found_without_arranging_each_start() {
use vectorcraft_doc::Justify;
let db = FontDb::with_font_dirs(vec![]);
// Every 4 letters take 15 points, but 2 letters into a group the line is 3 points longer than
// after 3: with 940 points, 251 letters (939 points) fit and 250 (942) don't.
let line = kurbo::Line::new((0.0, 0.0), (940.0, 0.0)).to_path(0.1);
let t = stepped_hebrew(&db, 2000, &[6.0, 6.0, -3.0, 6.0], &line, (0.0, None));
let mut cases = Vec::new();
for justify in [Justify::Right, Justify::Center, Justify::Left] {
let mut t = t.clone();
t.para.justify = justify;
cases.push((format!("{justify:?}"), t.clone(), 2));
// Spacing on a straight path changes no step.
t.path_spacing = 5.0;
cases.push((format!("{justify:?} spaced"), t.clone(), 2));
// Hanging punctuation: starts are arranged one by one, from the longest that could fit.
t.path_spacing = 0.0;
t.para.roman_hanging = true;
cases.push((format!("{justify:?} hanging"), t, 3));
}
for (case, t, most) in cases {
let before = crate::layout::path_arrangements();
let l = layout(&db, &t);
let arrangements = crate::layout::path_arrangements() - before;
assert!(l.overflow, "{case}");
assert_eq!(l.lines.first().map(|line| line.end), Some(251 * 'א'.len_utf8()), "{case}: 251 letters show");
assert_eq!(l.glyphs.len(), 251, "{case}");
assert!(arrangements <= most, "{case}: {arrangements} arrangements");
}
}
/// Long right-to-left type on a curved, spaced path with hanging punctuation, whose letters take the
/// line forward and back in turn, is arranged a bounded number of times however long the text is,
/// and the start it shows fits.
#[test]
fn rtl_type_on_a_curve_whose_letters_take_the_line_back_is_arranged_a_bounded_number_of_times() {
use vectorcraft_doc::Justify;
let db = FontDb::with_font_dirs(vec![]);
let n = 600;
let circle = kurbo::Circle::new((0.0, 0.0), 200.0).to_path(0.1);
let t = stepped_hebrew(&db, n, &[6.0, -4.0], &circle, (0.0, Some(0.05)));
for justify in [Justify::Right, Justify::Left] {
for spacing in [20.0, -20.0] {
let mut t = t.clone();
t.para.justify = justify;
t.para.roman_hanging = true;
t.path_spacing = spacing;
let case = format!("{justify:?} spacing {spacing}");
let before = crate::layout::path_arrangements();
let l = layout(&db, &t);
let arrangements = crate::layout::path_arrangements() - before;
let end = l.lines.first().map_or(0, |line| line.end);
// The whole text, at most 32 starts one by one, a binary search over 600, and the start shown.
assert!(arrangements <= 44, "{case}: {arrangements} arrangements, overflow {}, end {end}", l.overflow);
assert!(l.overflow, "{case}");
assert!(end > 0, "{case}: some letters show");
assert_eq!(l.glyphs.len(), end / 'א'.len_utf8(), "{case}: every letter of the start shows");
let each = crate::layout::layout_trying_each_start(&db, &t);
assert!(end <= each.lines.first().map_or(0, |line| line.end), "{case}: no start longer than the longest that fits");
}
}
}
+4 -2
View File
@@ -568,8 +568,10 @@ impl Targets {
}
/// View → Snap to Point: only these targets' anchors pull, and the ruler guides (shown and
/// unlocked, as the selection tools pick them) pull the pointer into line where they run.
pub(super) fn for_snap_to_point(self, cx: &ToolContext) -> Self {
/// unlocked, as the selection tools pick them) pull the pointer into line where they run. It
/// snaps without Smart Guides, so it draws none of their labels and lines.
pub(super) fn for_snap_to_point(mut self, cx: &ToolContext) -> Self {
self.style = GuideStyle { lines: false, labels: false, ..GuideStyle::of(cx) };
self.anchors_only().with_rulers(cx)
}
+23
View File
@@ -952,3 +952,26 @@ fn a_drawn_point_lands_on_a_corner_of_a_glyphs_bounds() {
assert!((q - tr).cross(dir).abs() < 1e-6, "angle {angle}: {q:?} is off the right edge");
}
}
/// With Smart Guides off, View → Snap to Point still pulls a drawn point onto an anchor, but
/// draws no Smart Guides: no "anchor" label, no lines.
#[test]
fn snap_to_point_without_smart_guides_shows_no_guides() {
let (d, _) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
// Within Snap to Point's 2 px of the anchor at (200, 200).
let at = Point::new(201.0, 199.0);
let off = ToolContext { smart_guides: false, snap_to_point: true, ..cx(&d, &s, &p) };
let mut snap = DrawSnap::default();
assert_eq!(snap.hover(&off, at, &[], None), Point::new(200.0, 200.0));
assert!(snap.guides().is_empty(), "{:?}", snap.guides());
assert_eq!(snap.press(&off, at, &[], None), Point::new(200.0, 200.0));
assert!(snap.guides().is_empty(), "{:?}", snap.guides());
// A dragged selection's grabbed point too.
let (q, ov) = Targets::snap_to_point(&off, &[]).unwrap().snap_point(at, 4.0);
assert_eq!((q, ov.len()), (Point::new(200.0, 200.0), 0), "{ov:?}");
// Smart Guides on: the same point says "anchor".
let mut snap = DrawSnap::default();
assert_eq!(snap.hover(&cx(&d, &s, &p), at, &[], None), Point::new(200.0, 200.0));
assert_eq!(labels(snap.guides()), ["anchor"]);
}
+1 -1
View File
@@ -688,7 +688,7 @@ fn message_at(lang: Lang, s: &str, depth: usize) -> String {
/// Fill `{name}` placeholders in one pass: a value that holds `{name}` text stays as it is.
/// Unknown placeholders are left as written. `{{` and `}}` are a literal `{` and `}`.
fn fill_once(template: &str, args: &[(&str, &str)]) -> String {
pub(crate) fn fill_once(template: &str, args: &[(&str, &str)]) -> String {
let mut rest = template;
let mut out = String::with_capacity(rest.len());
while let Some(open) = rest.find(['{', '}']) {
+23
View File
@@ -2120,6 +2120,29 @@ font-technology Variable Променливи
Bristle Brush Четка с косъм
Pattern Brush Четка с мостра
missing from the Brushes panel липсва в панела „Четки“
built in вграден
embedding not allowed вграждането не е разрешено
embedding for editing вграждане за редактиране
embedding for preview and print вграждане за преглед и печат
embedding allowed вграждането е разрешено
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) заместен: показан с {family} {style} ({detail})
missing: shown in {family} {style} липсва: показан с {family} {style}
missing липсва
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Линеен градиент
Radial gradient Радиален градиент
Conic gradient Конусен градиент
Diamond gradient Ромбовиден градиент
Freeform gradient Градиент със свободна форма
@plural {n} instance|{n} instances {n} екземпляр|{n} екземпляра
@plural {n} row|{n} rows {n} ред|{n} реда
@plural {n} column|{n} columns {n} колона|{n} колони
Select art to make a scatter, art or pattern brush. Изберете графика, за да създадете разпръсната четка, артистична четка или четка с мостра.
Brush Art Графика на четка
New Calligraphic Brush Нова калиграфска четка
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3356,6 +3356,29 @@ theme Appearance Izgled
Bristle Brush Četkica s čekinjama
Pattern Brush Četkica uzorka
missing from the Brushes panel nedostaje u panelu Četkice
built in ugrađen
embedding not allowed ugrađivanje nije dozvoljeno
embedding for editing ugrađivanje za uređivanje
embedding for preview and print ugrađivanje za pregled i štampu
embedding allowed ugrađivanje dozvoljeno
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) zamijenjen: prikazan fontom {family} {style} ({detail})
missing: shown in {family} {style} nedostaje: prikazan fontom {family} {style}
missing nedostaje
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Linearni gradijent
Radial gradient Radijalni gradijent
Conic gradient Konusni gradijent
Diamond gradient Rombni gradijent
Freeform gradient Gradijent slobodnog oblika
@plural {n} instance|{n} instances {n} instanca|{n} instance|{n} instanci
@plural {n} row|{n} rows {n} red|{n} reda|{n} redova
@plural {n} column|{n} columns {n} kolona|{n} kolone|{n} kolona
Select art to make a scatter, art or pattern brush. Odaberite crtež da napravite raspršenu, umjetničku četkicu ili četkicu uzorka.
Brush Art Crtež četkice
New Symbol Novi simbol
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3115,6 +3115,29 @@ digits Malayalam Malaiàlam
Pattern Borders Vores de motiu
Pattern Brush Pinzell de motiu
missing from the Brushes panel absent del tauler Pinzells
built in integrat
embedding not allowed incrustació no permesa
embedding for editing incrustació per a l’edició
embedding for preview and print incrustació per a la visualització i la impressió
embedding allowed incrustació permesa
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) substituït: es mostra amb {family} {style} ({detail})
missing: shown in {family} {style} absent: es mostra amb {family} {style}
missing absent
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppp
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Degradat lineal
Radial gradient Degradat radial
Conic gradient Degradat cònic
Diamond gradient Degradat de rombe
Freeform gradient Degradat de forma lliure
@plural {n} instance|{n} instances {n} instància|{n} instàncies
@plural {n} row|{n} rows {n} fila|{n} files
@plural {n} column|{n} columns {n} columna|{n} columnes
Pattern Brush Options Opcions del pinzell de motiu
Pattern Editing Edició de motius
Pattern Options Opcions del motiu
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3406,6 +3406,29 @@ theme Appearance Motiv
Bristle Brush Štětinový štětec
Pattern Brush Vzorkový štětec
missing from the Brushes panel chybí v panelu Štětce
built in vestavěné
embedding not allowed vkládání není povoleno
embedding for editing vkládání pro úpravy
embedding for preview and print vkládání pro náhled a tisk
embedding allowed vkládání povoleno
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) nahrazeno: zobrazeno písmem {family} {style} ({detail})
missing: shown in {family} {style} chybí: zobrazeno písmem {family} {style}
missing chybí
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Lineární přechod
Radial gradient Kruhový přechod
Conic gradient Kuželový přechod
Diamond gradient Kosočtverečný přechod
Freeform gradient Volný přechod
@plural {n} instance|{n} instances {n} instance|{n} instance|{n} instancí
@plural {n} row|{n} rows {n} řádek|{n} řádky|{n} řádků
@plural {n} column|{n} columns {n} sloupec|{n} sloupce|{n} sloupců
Select art to make a scatter, art or pattern brush. Vyberte kresbu, abyste mohli vytvořit rozptylový, obrazový nebo vzorkový štětec.
Brush Art Kresba štětce
New Symbol Nový symbol
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3139,6 +3139,29 @@ theme Appearance Udseende
Bristle Brush Børstepensel
Pattern Brush Mønsterpensel
missing from the Brushes panel mangler i panelet Pensler
built in indbygget
embedding not allowed indlejring ikke tilladt
embedding for editing indlejring til redigering
embedding for preview and print indlejring til visning og udskrivning
embedding allowed indlejring tilladt
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) erstattet: vist med {family} {style} ({detail})
missing: shown in {family} {style} mangler: vist med {family} {style}
missing mangler
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Lineær gradient
Radial gradient Radial gradient
Conic gradient Konisk gradient
Diamond gradient Diamantgradient
Freeform gradient Freeform-gradient
@plural {n} instance|{n} instances {n} forekomst|{n} forekomster
@plural {n} row|{n} rows {n} række|{n} rækker
@plural {n} column|{n} columns {n} kolonne|{n} kolonner
Select art to make a scatter, art or pattern brush. Markér grafik for at oprette en spredningspensel, grafikpensel eller mønsterpensel.
Brush Art Penselgrafik
New Symbol Nyt symbol
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -2154,6 +2154,29 @@ file-filter Templates Vorlagen
Bristle Brush Borstenpinsel
Pattern Brush Musterpinsel
missing from the Brushes panel fehlt im Bedienfeld „Pinsel“
built in integriert
embedding not allowed Einbetten nicht erlaubt
embedding for editing Einbetten zum Bearbeiten
embedding for preview and print Einbetten für Vorschau und Druck
embedding allowed Einbetten erlaubt
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) ersetzt: angezeigt in {family} {style} ({detail})
missing: shown in {family} {style} fehlt: angezeigt in {family} {style}
missing fehlt
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Linearer Verlauf
Radial gradient Radialer Verlauf
Conic gradient Konischer Verlauf
Diamond gradient Rautenverlauf
Freeform gradient Freiformverlauf
@plural {n} instance|{n} instances {n} Instanz|{n} Instanzen
@plural {n} row|{n} rows {n} Zeile|{n} Zeilen
@plural {n} column|{n} columns {n} Spalte|{n} Spalten
Select art to make a scatter, art or pattern brush. Wählen Sie eine Grafik aus, um einen Spezial-, Bild- oder Musterpinsel zu erstellen.
Brush Art Pinselgrafik
New Calligraphic Brush Neuer Kalligrafiepinsel
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -1827,6 +1827,29 @@ font-technology Variable Μεταβλητές
Bristle Brush Πινέλο με τρίχες
Pattern Brush Πινέλο μοτίβου
missing from the Brushes panel λείπει από τον πίνακα Πινέλα
built in ενσωματωμένη
embedding not allowed η ενσωμάτωση δεν επιτρέπεται
embedding for editing ενσωμάτωση για επεξεργασία
embedding for preview and print ενσωμάτωση για προεπισκόπηση και εκτύπωση
embedding allowed η ενσωμάτωση επιτρέπεται
{file}; {embedding} {file}· {embedding}
substituted: shown in {family} {style} ({detail}) αντικαταστάθηκε: εμφανίζεται με {family} {style} ({detail})
missing: shown in {family} {style} λείπει: εμφανίζεται με {family} {style}
missing λείπει
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Γραμμικό ντεγκραντέ
Radial gradient Ακτινικό ντεγκραντέ
Conic gradient Κωνικό ντεγκραντέ
Diamond gradient Ρομβοειδές ντεγκραντέ
Freeform gradient Ντεγκραντέ ελεύθερης μορφής
@plural {n} instance|{n} instances {n} παρουσία|{n} παρουσίες
@plural {n} row|{n} rows {n} γραμμή|{n} γραμμές
@plural {n} column|{n} columns {n} στήλη|{n} στήλες
Select art to make a scatter, art or pattern brush. Επιλέξτε σχέδιο για να δημιουργήσετε πινέλο διασποράς, σχεδίου ή μοτίβου.
Brush Art Σχέδιο πινέλου
New Layer… Νέο επίπεδο…
Can't render this file because it is too large.
+23
View File
@@ -2192,6 +2192,29 @@ font-technology Variable Variables
Bristle Brush Pincel de cerdas
Pattern Brush Pincel de motivo
missing from the Brushes panel falta en el panel Pinceles
built in integrada
embedding not allowed incrustación no permitida
embedding for editing incrustación para edición
embedding for preview and print incrustación para vista previa e impresión
embedding allowed incrustación permitida
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) sustituida: se muestra con {family} {style} ({detail})
missing: shown in {family} {style} falta: se muestra con {family} {style}
missing falta
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppp
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Degradado lineal
Radial gradient Degradado radial
Conic gradient Degradado cónico
Diamond gradient Degradado de rombo
Freeform gradient Degradado libre
@plural {n} instance|{n} instances {n} instancia|{n} instancias
@plural {n} row|{n} rows {n} fila|{n} filas
@plural {n} column|{n} columns {n} columna|{n} columnas
Select art to make a scatter, art or pattern brush. Selecciona una ilustración para crear un pincel de dispersión, de arte o de motivo.
Brush Art Ilustración del pincel
New Calligraphic Brush Nuevo pincel caligráfico
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3345,6 +3345,29 @@ theme Appearance Ulkoasu
Bristle Brush Harjassivellin
Pattern Brush Kuviosivellin
missing from the Brushes panel puuttuu Siveltimet-paneelista
built in sisäänrakennettu
embedding not allowed upottaminen ei sallittu
embedding for editing upottaminen muokkausta varten
embedding for preview and print upottaminen esikatselua ja tulostusta varten
embedding allowed upottaminen sallittu
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) korvattu: näytetään fontilla {family} {style} ({detail})
missing: shown in {family} {style} puuttuu: näytetään fontilla {family} {style}
missing puuttuu
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Lineaarinen liukuväri
Radial gradient Säteittäinen liukuväri
Conic gradient Kartiomainen liukuväri
Diamond gradient Vinoneliöliukuväri
Freeform gradient Vapaamuotoinen liukuväri
@plural {n} instance|{n} instances {n} esiintymä|{n} esiintymää
@plural {n} row|{n} rows {n} rivi|{n} riviä
@plural {n} column|{n} columns {n} sarake|{n} saraketta
Select art to make a scatter, art or pattern brush. Valitse kuvitus, jotta voit luoda sirote-, taide- tai kuviosiveltimen.
Brush Art Siveltimen kuvitus
New Symbol Uusi symboli
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -2184,6 +2184,29 @@ font-technology Variable Variables
Bristle Brush Forme Soies
Pattern Brush Forme de motif
missing from the Brushes panel absente du panneau Formes
built in intégrée
embedding not allowed incorporation interdite
embedding for editing incorporation pour la modification
embedding for preview and print incorporation pour l’aperçu et l’impression
embedding allowed incorporation autorisée
{file}; {embedding} {file}, {embedding}
substituted: shown in {family} {style} ({detail}) remplacée, affichée en {family} {style} ({detail})
missing: shown in {family} {style} absente, affichée en {family} {style}
missing absente
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppp
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Dégradé linéaire
Radial gradient Dégradé radial
Conic gradient Dégradé conique
Diamond gradient Dégradé en losange
Freeform gradient Dégradé de forme libre
@plural {n} instance|{n} instances {n} occurrence|{n} occurrences
@plural {n} row|{n} rows {n} ligne|{n} lignes
@plural {n} column|{n} columns {n} colonne|{n} colonnes
Select art to make a scatter, art or pattern brush. Sélectionnez une illustration pour créer une forme diffuse, artistique ou de motif.
Brush Art Illustration de la forme
New Calligraphic Brush Nouvelle forme calligraphique
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3397,6 +3397,29 @@ antiAlias Sharp शार्प
Pattern Borders पैटर्न सीमा
Pattern Brush पैटर्न ब्रश
missing from the Brushes panel ब्रश पैनल में अनुपलब्ध
built in अंतर्निहित
embedding not allowed एम्बेडिंग की अनुमति नहीं
embedding for editing संपादन के लिए एम्बेडिंग
embedding for preview and print पूर्वावलोकन और प्रिंट के लिए एम्बेडिंग
embedding allowed एम्बेडिंग की अनुमति है
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) प्रतिस्थापित: {family} {style} में दिखाया गया ({detail})
missing: shown in {family} {style} अनुपलब्ध: {family} {style} में दिखाया गया
missing अनुपलब्ध
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient लीनियर ग्रेडिएंट
Radial gradient रेडियल ग्रेडिएंट
Conic gradient कोनिक ग्रेडिएंट
Diamond gradient डायमंड ग्रेडिएंट
Freeform gradient फ्रीफॉर्म ग्रेडिएंट
@plural {n} instance|{n} instances {n} इंस्टेंस|{n} इंस्टेंस
@plural {n} row|{n} rows {n} पंक्ति|{n} पंक्तियाँ
@plural {n} column|{n} columns {n} कॉलम|{n} कॉलम
Pattern Brush Options पैटर्न ब्रश ऑप्शन्स
Pattern Editing पैटर्न संपादन
Pattern Options पैटर्न ऑप्शन्स
Can't render this file because it is too large.
+23
View File
@@ -3009,6 +3009,29 @@ file-filter Templates Sablonok
Pattern Mintázat
Pattern Brush Mintázatecset
missing from the Brushes panel hiányzik az Ecsetek panelről
built in beépített
embedding not allowed beágyazás nem engedélyezett
embedding for editing beágyazás szerkesztéshez
embedding for preview and print beágyazás előnézethez és nyomtatáshoz
embedding allowed beágyazás engedélyezett
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) helyettesítve: megjelenítés ezzel: {family} {style} ({detail})
missing: shown in {family} {style} hiányzik: megjelenítés ezzel: {family} {style}
missing hiányzik
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Lineáris színátmenet
Radial gradient Körkörös színátmenet
Conic gradient Kúpos színátmenet
Diamond gradient Rombusz színátmenet
Freeform gradient Szabad formájú színátmenet
@plural {n} instance|{n} instances {n} példány
@plural {n} row|{n} rows {n} sor
@plural {n} column|{n} columns {n} oszlop
Pattern Brush Options Mintázatecset beállításai
Pattern Editing Mintázatszerkesztés
Pattern Options Mintázat beállításai
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3139,6 +3139,29 @@ theme Appearance Tampilan
Bristle Brush Kuas bristle
Pattern Brush Kuas pola
missing from the Brushes panel tidak ada di panel Kuas
built in bawaan
embedding not allowed penyematan tidak diizinkan
embedding for editing penyematan untuk pengeditan
embedding for preview and print penyematan untuk pratinjau dan cetak
embedding allowed penyematan diizinkan
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) diganti: ditampilkan dengan {family} {style} ({detail})
missing: shown in {family} {style} tidak ada: ditampilkan dengan {family} {style}
missing tidak ada
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Gradien linear
Radial gradient Gradien radial
Conic gradient Gradien kerucut
Diamond gradient Gradien wajik
Freeform gradient Gradien bentuk bebas
@plural {n} instance|{n} instances {n} instans
@plural {n} row|{n} rows {n} baris
@plural {n} column|{n} columns {n} kolom
Select art to make a scatter, art or pattern brush. Pilih karya seni untuk membuat kuas sebar, seni, atau pola.
Brush Art Karya seni kuas
New Symbol Simbol baru
Can't render this file because it contains an unexpected character in line 2429 and column 5.
+23
View File
@@ -2230,6 +2230,29 @@ file-filter Templates Modelli
Bristle Brush Pennello a setole
Pattern Brush Pennello motivo
missing from the Brushes panel mancante nel pannello Pennelli
built in integrato
embedding not allowed incorporamento non consentito
embedding for editing incorporamento per la modifica
embedding for preview and print incorporamento per anteprima e stampa
embedding allowed incorporamento consentito
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) sostituito: mostrato con {family} {style} ({detail})
missing: shown in {family} {style} mancante: mostrato con {family} {style}
missing mancante
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Sfumatura lineare
Radial gradient Sfumatura radiale
Conic gradient Sfumatura conica
Diamond gradient Sfumatura a rombo
Freeform gradient Sfumatura libera
@plural {n} instance|{n} instances {n} istanza|{n} istanze
@plural {n} row|{n} rows {n} riga|{n} righe
@plural {n} column|{n} columns {n} colonna|{n} colonne
Select art to make a scatter, art or pattern brush. Seleziona la grafica per creare un pennello a dispersione, artistico o motivo.
Brush Art Grafica del pennello
New Calligraphic Brush Nuovo pennello calligrafico
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -2439,6 +2439,29 @@ antiAlias Sharp シャープ
Bristle Brush 剛毛ブラシ
Pattern Brush パターンブラシ
missing from the Brushes panel ブラシパネルにありません
built in 内蔵
embedding not allowed 埋め込み不可
embedding for editing 編集用に埋め込み可
embedding for preview and print プレビューと印刷用に埋め込み可
embedding allowed 埋め込み可
{file}; {embedding} {file}、{embedding}
substituted: shown in {family} {style} ({detail}) 代替: {family} {style} で表示 ({detail})
missing: shown in {family} {style} 見つかりません: {family} {style} で表示
missing 見つかりません
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}、{instances}
{kind}, {rows} × {cols} {kind}、{rows} × {cols}
{grid}, {instances} {grid}、{instances}
Linear gradient 線形グラデーション
Radial gradient 円形グラデーション
Conic gradient 円錐グラデーション
Diamond gradient ひし形グラデーション
Freeform gradient フリーグラデーション
@plural {n} instance|{n} instances インスタンス {n} 個
@plural {n} row|{n} rows {n} 行
@plural {n} column|{n} columns {n} 列
Select art to make a scatter, art or pattern brush. 散布ブラシ、アートブラシ、パターンブラシを作成するには、アートを選択します。
Brush Art ブラシのアート
New Calligraphic Brush 新規絵筆ブラシ
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -2982,6 +2982,29 @@ theme Appearance იერსახე
Bristle Brush ჯაგრის ფუნჯი
Pattern Brush პატერნის ფუნჯი
missing from the Brushes panel ფუნჯების პანელში არ არის
built in ჩაშენებული
embedding not allowed ჩაშენება არ არის დაშვებული
embedding for editing ჩაშენება რედაქტირებისთვის
embedding for preview and print ჩაშენება გადახედვისა და ბეჭდვისთვის
embedding allowed ჩაშენება დაშვებულია
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) ჩანაცვლებულია: ნაჩვენებია შრიფტით {family} {style} ({detail})
missing: shown in {family} {style} აკლია: ნაჩვენებია შრიფტით {family} {style}
missing აკლია
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient წრფივი გრადიენტი
Radial gradient რადიალური გრადიენტი
Conic gradient კონუსური გრადიენტი
Diamond gradient რომბისებრი გრადიენტი
Freeform gradient თავისუფალი ფორმის გრადიენტი
@plural {n} instance|{n} instances {n} ეგზემპლარი
@plural {n} row|{n} rows {n} მწკრივი
@plural {n} column|{n} columns {n} სვეტი
Select art to make a scatter, art or pattern brush. მონიშნეთ ნახატი გაფანტვის, მხატვრული ან პატერნის ფუნჯის შესაქმნელად.
Brush Art ფუნჯის ნახატი
New Symbol ახალი სიმბოლო
Can't render this file because it is too large.
+23
View File
@@ -2429,6 +2429,29 @@ antiAlias Sharp 날카롭게
Bristle Brush 강모 브러시
Pattern Brush 패턴 브러시
missing from the Brushes panel 브러시 패널에 없음
built in 내장
embedding not allowed 포함 허용 안 됨
embedding for editing 편집용 포함
embedding for preview and print 미리 보기 및 인쇄용 포함
embedding allowed 포함 허용
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) 대체됨: {family} {style}(으)로 표시({detail})
missing: shown in {family} {style} 없음: {family} {style}(으)로 표시
missing 없음
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient 선형 그레이디언트
Radial gradient 방사형 그레이디언트
Conic gradient 원뿔형 그레이디언트
Diamond gradient 다이아몬드 그레이디언트
Freeform gradient 자유 형태 그레이디언트
@plural {n} instance|{n} instances 인스턴스 {n}개
@plural {n} row|{n} rows {n}행
@plural {n} column|{n} columns {n}열
Select art to make a scatter, art or pattern brush. 흩뿌리기, 아트 또는 패턴 브러시를 만들려면 아트웍을 선택하세요.
Brush Art 브러시 아트
New Calligraphic Brush 새 캘리그래피 브러시
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3656,6 +3656,29 @@ theme Appearance Vormgeving
Bristle Brush Borstelpenseel
Pattern Brush Patroonpenseel
missing from the Brushes panel ontbreekt in het deelvenster Penselen
built in ingebouwd
embedding not allowed insluiten niet toegestaan
embedding for editing insluiten voor bewerken
embedding for preview and print insluiten voor voorvertoning en afdrukken
embedding allowed insluiten toegestaan
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) vervangen: weergegeven in {family} {style} ({detail})
missing: shown in {family} {style} ontbreekt: weergegeven in {family} {style}
missing ontbreekt
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Lineair verloop
Radial gradient Radiaal verloop
Conic gradient Conisch verloop
Diamond gradient Ruitverloop
Freeform gradient Vrijvormverloop
@plural {n} instance|{n} instances {n} exemplaar|{n} exemplaren
@plural {n} row|{n} rows {n} rij|{n} rijen
@plural {n} column|{n} columns {n} kolom|{n} kolommen
Select art to make a scatter, art or pattern brush. Selecteer illustratie om een verspreidings-, art- of patroonpenseel te maken.
Brush Art Penseelillustratie
New Symbol Nieuw symbool
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3285,6 +3285,29 @@ theme Appearance Wygląd
Bristle Brush Pędzel włosiankowy
Pattern Brush Pędzel wzorka
missing from the Brushes panel brak w panelu Pędzle
built in wbudowany
embedding not allowed osadzanie niedozwolone
embedding for editing osadzanie do edycji
embedding for preview and print osadzanie do podglądu i drukowania
embedding allowed osadzanie dozwolone
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) zastąpiony: wyświetlany krojem {family} {style} ({detail})
missing: shown in {family} {style} brak: wyświetlany krojem {family} {style}
missing brak
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Gradient liniowy
Radial gradient Gradient promienisty
Conic gradient Gradient stożkowy
Diamond gradient Gradient rombowy
Freeform gradient Gradient dowolny
@plural {n} instance|{n} instances {n} wystąpienie|{n} wystąpienia|{n} wystąpień
@plural {n} row|{n} rows {n} wiersz|{n} wiersze|{n} wierszy
@plural {n} column|{n} columns {n} kolumna|{n} kolumny|{n} kolumn
Select art to make a scatter, art or pattern brush. Zaznacz kompozycję, aby utworzyć pędzel rozproszony, artystyczny lub wzorka.
Brush Art Kompozycja pędzla
New Symbol Nowy symbol
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -1801,6 +1801,29 @@ antiAlias Sharp Nítido
Bristle Brush Pincel de Cerdas
Pattern Brush Pincel de Padrão
missing from the Brushes panel ausente do painel Pincéis
built in integrada
embedding not allowed incorporação não permitida
embedding for editing incorporação para edição
embedding for preview and print incorporação para visualização e impressão
embedding allowed incorporação permitida
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) substituída: exibida em {family} {style} ({detail})
missing: shown in {family} {style} ausente: exibida em {family} {style}
missing ausente
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppp
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Gradiente linear
Radial gradient Gradiente radial
Conic gradient Gradiente cônico
Diamond gradient Gradiente losango
Freeform gradient Gradiente de forma livre
@plural {n} instance|{n} instances {n} instância|{n} instâncias
@plural {n} row|{n} rows {n} linha|{n} linhas
@plural {n} column|{n} columns {n} coluna|{n} colunas
Select art to make a scatter, art or pattern brush. Selecione arte para criar um pincel de dispersão, de arte ou de padrão.
Brush Art Arte do Pincel
New Calligraphic Brush Novo Pincel Caligráfico
Can't render this file because it contains an unexpected character in line 6 and column 47.
+23
View File
@@ -2217,6 +2217,29 @@ file-filter Templates Шаблоны
Bristle Brush Щетинная кисть
Pattern Brush Узорная кисть
missing from the Brushes panel отсутствует в панели «Кисти»
built in встроенный
embedding not allowed внедрение запрещено
embedding for editing внедрение для редактирования
embedding for preview and print внедрение для просмотра и печати
embedding allowed внедрение разрешено
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) заменен: показан шрифтом {family} {style} ({detail})
missing: shown in {family} {style} отсутствует: показан шрифтом {family} {style}
missing отсутствует
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Линейный градиент
Radial gradient Радиальный градиент
Conic gradient Конический градиент
Diamond gradient Ромбовидный градиент
Freeform gradient Произвольный градиент
@plural {n} instance|{n} instances {n} экземпляр|{n} экземпляра|{n} экземпляров
@plural {n} row|{n} rows {n} строка|{n} строки|{n} строк
@plural {n} column|{n} columns {n} столбец|{n} столбца|{n} столбцов
Select art to make a scatter, art or pattern brush. Выделите рисунок, чтобы создать кисть-распыление, художественную или узорную кисть.
Brush Art Рисунок кисти
New Calligraphic Brush Новая каллиграфическая кисть
Can't render this file because it is too large.
+23
View File
@@ -2131,6 +2131,29 @@ font-technology Variable Variabla
Bristle Brush Borstpensel
Pattern Brush Mönsterpensel
missing from the Brushes panel saknas i panelen Penslar
built in inbyggt
embedding not allowed inbäddning inte tillåten
embedding for editing inbäddning för redigering
embedding for preview and print inbäddning för förhandsvisning och utskrift
embedding allowed inbäddning tillåten
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) ersatt: visas med {family} {style} ({detail})
missing: shown in {family} {style} saknas: visas med {family} {style}
missing saknas
{width} × {height} px {width} × {height} px
{size} — {file} {size} – {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Linjär gradient
Radial gradient Radiell gradient
Conic gradient Konisk gradient
Diamond gradient Rombgradient
Freeform gradient Fri gradient
@plural {n} instance|{n} instances {n} instans|{n} instanser
@plural {n} row|{n} rows {n} rad|{n} rader
@plural {n} column|{n} columns {n} kolumn|{n} kolumner
Select art to make a scatter, art or pattern brush. Markera grafik för att skapa en spridnings-, konst- eller mönsterpensel.
Brush Art Penselgrafik
New Calligraphic Brush Ny kalligrafisk pensel
Can't render this file because it is too large.
+40
View File
@@ -463,6 +463,46 @@ fn document_info_labels_are_in_complete_catalogs() {
}
}
/// The values Document Info makes and shows in the interface language: the font states and
/// embedding permissions, the templates of the font, image, raster effects and Repeat object
/// values, the names of gradients named by their kind, and the counted instances, rows and columns.
#[test]
fn document_info_values_are_in_complete_catalogs() {
const VALUES: [&str; 20] = [
"built in",
"embedding not allowed",
"embedding for editing",
"embedding for preview and print",
"embedding allowed",
"{file}; {embedding}",
"substituted: shown in {family} {style} ({detail})",
"missing: shown in {family} {style}",
"missing",
"{width} × {height} px",
"{size} — {file}",
"{n} ppi",
"{kind}, {instances}",
"{kind}, {rows} × {cols}",
"{grid}, {instances}",
"Linear gradient",
"Radial gradient",
"Conic gradient",
"Diamond gradient",
"Freeform gradient",
];
const COUNTED: [(&str, &str); 3] = [("{n} instance", "{n} instances"), ("{n} row", "{n} rows"), ("{n} column", "{n} columns")];
let gradient_kinds: Vec<String> = vectorcraft_color::GradientKind::ALL.iter().map(|k| format!("{} gradient", k.label())).collect();
assert!(gradient_kinds.iter().all(|k| VALUES.contains(&k.as_str())), "{gradient_kinds:?}");
for lang in LANGUAGES.iter().filter(|lang| lang.complete_menus) {
for value in VALUES {
assert!(lang.catalog().plain(value).is_some(), "{} is missing {value}", lang.code);
}
for (one, other) in COUNTED {
assert!(lang.catalog().plural(one, other, 0).is_some(), "{} is missing the row for {other}", lang.code);
}
}
}
/// The Character panel's Anti-aliasing Method label and its choices, with the Sharp method's
/// own `antiAlias` row apart from the plain "Sharp" corner row.
#[test]
+23
View File
@@ -6137,6 +6137,29 @@ theme Appearance Görünüm
New Brush Yeni Fırça
Pattern Brush Desen Fırçası
missing from the Brushes panel Fırçalar panelinde yok
built in yerleşik
embedding not allowed gömmeye izin verilmiyor
embedding for editing düzenleme için gömme
embedding for preview and print önizleme ve yazdırma için gömme
embedding allowed gömmeye izin veriliyor
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) yerine konan: {family} {style} ile gösteriliyor ({detail})
missing: shown in {family} {style} eksik: {family} {style} ile gösteriliyor
missing eksik
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Doğrusal degrade
Radial gradient Radyal degrade
Conic gradient Konik degrade
Diamond gradient Elmas degrade
Freeform gradient Serbest biçimli degrade
@plural {n} instance|{n} instances {n} örnek
@plural {n} row|{n} rows {n} satır
@plural {n} column|{n} columns {n} sütun
Pick Color From: Rengi Buradan Al:
Scatter Brush Serpme Fırçası
Select art to make a scatter, art or pattern brush. Bir serpme, resim veya desen fırçası oluşturmak için çizim seçin.
Can't render this file because it contains an unexpected character in line 5 and column 25.
+23
View File
@@ -2222,6 +2222,29 @@ file-filter Templates Шаблони
Bristle Brush Щетинний пензель
Pattern Brush Візерунковий пензель
missing from the Brushes panel відсутній у панелі «Пензлі»
built in вбудований
embedding not allowed вбудовування заборонено
embedding for editing вбудовування для редагування
embedding for preview and print вбудовування для перегляду й друку
embedding allowed вбудовування дозволено
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) замінено: показано шрифтом {family} {style} ({detail})
missing: shown in {family} {style} відсутній: показано шрифтом {family} {style}
missing відсутній
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Лінійний градієнт
Radial gradient Радіальний градієнт
Conic gradient Конічний градієнт
Diamond gradient Ромбоподібний градієнт
Freeform gradient Довільний градієнт
@plural {n} instance|{n} instances {n} екземпляр|{n} екземпляри|{n} екземплярів
@plural {n} row|{n} rows {n} рядок|{n} рядки|{n} рядків
@plural {n} column|{n} columns {n} стовпець|{n} стовпці|{n} стовпців
Select art to make a scatter, art or pattern brush. Виділіть малюнок, щоб створити пензель-розпорошення, художній або візерунковий пензель.
Brush Art Малюнок пензля
New Calligraphic Brush Новий каліграфічний пензель
Can't render this file because it is too large.
+23
View File
@@ -2826,6 +2826,29 @@ digits Hindi Hindi
Pattern Họa tiết
Pattern Brush Cọ họa tiết
missing from the Brushes panel không có trong bảng Cọ
built in tích hợp sẵn
embedding not allowed không cho phép nhúng
embedding for editing nhúng để chỉnh sửa
embedding for preview and print nhúng để xem trước và in
embedding allowed cho phép nhúng
{file}; {embedding} {file}; {embedding}
substituted: shown in {family} {style} ({detail}) đã thay thế: hiển thị bằng {family} {style} ({detail})
missing: shown in {family} {style} thiếu: hiển thị bằng {family} {style}
missing thiếu
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind}, {instances}
{kind}, {rows} × {cols} {kind}, {rows} × {cols}
{grid}, {instances} {grid}, {instances}
Linear gradient Chuyển sắc tuyến tính
Radial gradient Chuyển sắc hướng tâm
Conic gradient Chuyển sắc hình nón
Diamond gradient Chuyển sắc hình thoi
Freeform gradient Chuyển sắc tự do
@plural {n} instance|{n} instances {n} phiên bản
@plural {n} row|{n} rows {n} hàng
@plural {n} column|{n} columns {n} cột
Pattern Brush Options Tùy chọn cọ họa tiết
Pattern Editing Chỉnh sửa họa tiết
Pattern Options Tùy chọn họa tiết
Can't render this file because it contains an unexpected character in line 204 and column 5.
+23
View File
@@ -2087,6 +2087,29 @@ file-filter Templates 模板
Bristle Brush 鬃毛画笔
Pattern Brush 图案画笔
missing from the Brushes panel “画笔”面板中没有
built in 内置
embedding not allowed 不允许嵌入
embedding for editing 允许嵌入以供编辑
embedding for preview and print 允许嵌入以供预览和打印
embedding allowed 允许嵌入
{file}; {embedding} {file};{embedding}
substituted: shown in {family} {style} ({detail}) 已替换:以 {family} {style} 显示 ({detail})
missing: shown in {family} {style} 缺失:以 {family} {style} 显示
missing 缺失
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind},{instances}
{kind}, {rows} × {cols} {kind},{rows} × {cols}
{grid}, {instances} {grid},{instances}
Linear gradient 线性渐变
Radial gradient 径向渐变
Conic gradient 锥形渐变
Diamond gradient 菱形渐变
Freeform gradient 自由渐变
@plural {n} instance|{n} instances {n} 个实例
@plural {n} row|{n} rows {n} 行
@plural {n} column|{n} columns {n} 列
Select art to make a scatter, art or pattern brush. 选择图稿以创建散布画笔、艺术画笔或图案画笔。
Brush Art 画笔图稿
New Calligraphic Brush 新建书法画笔
Can't render this file because it contains an unexpected character in line 2 and column 73.
+23
View File
@@ -3295,6 +3295,29 @@ file-filter Templates 範本
Bristle Brush 鬃毛筆刷
Pattern Brush 圖樣筆刷
missing from the Brushes panel 「筆刷」面板中沒有
built in 內建
embedding not allowed 不允許內嵌
embedding for editing 允許內嵌以供編輯
embedding for preview and print 允許內嵌以供預覽和列印
embedding allowed 允許內嵌
{file}; {embedding} {file};{embedding}
substituted: shown in {family} {style} ({detail}) 已替代:以 {family} {style} 顯示 ({detail})
missing: shown in {family} {style} 遺失:以 {family} {style} 顯示
missing 遺失
{width} × {height} px {width} × {height} px
{size} — {file} {size} — {file}
{n} ppi {n} ppi
{kind}, {instances} {kind},{instances}
{kind}, {rows} × {cols} {kind},{rows} × {cols}
{grid}, {instances} {grid},{instances}
Linear gradient 線性漸層
Radial gradient 放射狀漸層
Conic gradient 錐形漸層
Diamond gradient 菱形漸層
Freeform gradient 自由漸層
@plural {n} instance|{n} instances {n} 個實例
@plural {n} row|{n} rows {n} 列
@plural {n} column|{n} columns {n} 欄
Select art to make a scatter, art or pattern brush. 選取圖稿以製作散佈筆刷、藝術筆刷或圖樣筆刷。
Brush Art 筆刷圖稿
New Calligraphic Brush 新增書法筆刷
Can't render this file because it contains an unexpected character in line 6 and column 47.
+252 -6
View File
@@ -72,16 +72,15 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
if rows.is_empty() {
widgets::dim_label(ui, tl!("None"));
}
let named = named_rows(s["id"].as_str().unwrap_or_default(), rows);
let id = s["id"].as_str().unwrap_or_default();
let named = named_rows(id, rows);
for (k, r) in rows.iter().enumerate() {
let (label, value) = (r[0].as_str().unwrap_or_default(), r[1].as_str().unwrap_or_default());
let label = super::label_or_name(label, !named.contains(&k));
if value.is_empty() {
widgets::dim_name(ui, label);
} else if s["id"] == "brushes" {
row(ui, label, brush_value(value).into());
widgets::dim_name(ui, super::label_or_name(label, !named.contains(&k)));
} else {
row(ui, label, value.into());
let shown = shown_value(&i, id, k, (label, value), named.contains(&k)).unwrap_or_else(|| value.to_string());
row(ui, super::label_or_name(label, !named.contains(&k)), shown);
}
}
}
@@ -102,6 +101,127 @@ fn brush_value(value: &str) -> &str {
}
}
/// Row `k` of Document Info section `id` (`label` and `value` as `document.info` gives them, the
/// label a name when `named`) with its value in the interface language, built from what
/// `document.info` (`info`) gives as values: the
/// units, the raster effects resolution, each brush's type, each font's file, match and
/// embedding permission, each image's size and file, each Repeat object's kind and counts, and the
/// kinds of the gradients no swatch names. Names (fonts, files, faces, swatches) stay as they are.
/// None when the row's value is shown as `document.info` gives it, or the values do not match the
/// row.
fn shown_value(info: &Value, id: &str, k: usize, (label, value): (&str, &str), named: bool) -> Option<String> {
let entry = |list: &str| info[list].get(k).filter(|e| e["name"] == label || e["font"] == label);
match id {
"document" if !named => match label {
"Units" => {
let unit = info["document"]["unitId"].as_str()?;
vectorcraft_doc::Unit::EAST_ASIAN.into_iter().find(|u| u.key() == unit).map(|u| tl!(u.label()).to_string())
}
"Raster Effects" => {
let ppi = info["document"]["rasterEffectsPpi"].as_f64()?;
Some(fill(tl!("{n} ppi"), &[("n", &ppi.to_string())]))
}
_ => None,
},
"brushes" => Some(brush_value(value).to_string()),
"fontDetails" => font_detail_value(entry("fontDetails")?),
"linkedImages" | "embeddedImages" => {
let linked = id == "linkedImages";
let image = info["imageObjects"].as_array()?.iter().filter(|o| o["linked"] == linked).nth(k).filter(|o| o["name"] == label)?;
image_value(image)
}
"repeats" => repeat_value(entry("repeatObjects")?),
"gradients" => gradient_value(entry("gradientObjects")?),
_ => None,
}
}
/// [`crate::i18n::fill_once`]: a name that holds `{…}` text stays as it is.
fn fill(template: &str, args: &[(&str, &str)]) -> String {
crate::i18n::fill_once(template, args)
}
/// A `fontDetails` entry as Font Details shows it: the font's file (or that it is built in) and
/// what its license allows, the face shown in place of a style the family lacks, the face shown in
/// place of a font that is not installed, or that it is missing.
fn font_detail_value(e: &Value) -> Option<String> {
let found = || {
let embedding = match e["embedding"].as_str()? {
"forbidden" => tl!("embedding not allowed"),
"editing" => tl!("embedding for editing"),
"previewPrint" => tl!("embedding for preview and print"),
"allowed" => tl!("embedding allowed"),
_ => return None,
};
let file = e["file"].as_str().unwrap_or(tl!("built in"));
Some(fill(tl!("{file}; {embedding}"), &[("file", file), ("embedding", embedding)]))
};
let face = || Some((e["family"].as_str()?, e["style"].as_str()?));
match e["match"].as_str()? {
"exact" => found(),
"style" => {
let ((family, style), detail) = (face()?, found()?);
Some(fill(tl!("substituted: shown in {family} {style} ({detail})"), &[("family", family), ("style", style), ("detail", &detail)]))
}
"missingWithFallback" => {
let (family, style) = face()?;
Some(fill(tl!("missing: shown in {family} {style}"), &[("family", family), ("style", style)]))
}
"missing" => Some(tl!("missing").to_string()),
_ => None,
}
}
/// An `imageObjects` entry as Linked Images and Embedded Images show it: its size in pixels, and
/// for a linked image the file it shows.
fn image_value(o: &Value) -> Option<String> {
let size = fill(tl!("{width} × {height} px"), &[("width", &o["width"].as_u64()?.to_string()), ("height", &o["height"].as_u64()?.to_string())]);
if o["linked"] == true { Some(fill(tl!("{size} — {file}"), &[("size", &size), ("file", o["file"].as_str()?)])) } else { Some(size) }
}
/// A `repeatObjects` entry as Repeat Objects shows it: its kind and the number of instances it
/// draws, or for a grid its rows and columns, followed by the number it draws when that is fewer.
fn repeat_value(e: &Value) -> Option<String> {
let kind = match e["type"].as_str()? {
"radial" => tl!("Radial Repeat"),
"grid" => tl!("Grid Repeat"),
"mirror" => tl!("Mirror Repeat"),
_ => return None,
};
let n = e["instances"].as_u64()?;
let instances = crate::i18n::tn(n, "{n} instance", "{n} instances");
if e["type"] != "grid" {
return Some(fill(tl!("{kind}, {instances}"), &[("kind", kind), ("instances", &instances)]));
}
let (rows, cols) = (e["rows"].as_u64()?, e["cols"].as_u64()?);
let (shown_rows, shown_cols) = (crate::i18n::tn(rows, "{n} row", "{n} rows"), crate::i18n::tn(cols, "{n} column", "{n} columns"));
let grid = fill(tl!("{kind}, {rows} × {cols}"), &[("kind", kind), ("rows", &shown_rows), ("cols", &shown_cols)]);
Some(if n < rows.saturating_mul(cols) { fill(tl!("{grid}, {instances}"), &[("grid", &grid), ("instances", &instances)]) } else { grid })
}
/// A `gradientObjects` entry as Gradient Objects shows it: its gradients, a swatch's name as it
/// is and a gradient named by its kind in the interface language.
fn gradient_value(e: &Value) -> Option<String> {
let (names, kinds) = (e["gradients"].as_array()?, e["kinds"].as_array()?);
if names.len() != kinds.len() {
return None;
}
let shown: Option<Vec<&str>> = names
.iter()
.zip(kinds)
.map(|(name, kind)| match kind.as_str() {
None => name.as_str(),
Some("linear") => Some(tl!("Linear gradient")),
Some("radial") => Some(tl!("Radial gradient")),
Some("conic") => Some(tl!("Conic gradient")),
Some("diamond") => Some(tl!("Diamond gradient")),
Some("freeform") => Some(tl!("Freeform gradient")),
Some(_) => name.as_str(),
})
.collect();
Some(shown?.join(", "))
}
/// The rows of Document Info section `id` labelled by a name (an artboard, a style, a swatch, a
/// font, an image, a repeat object) rather than an interface label: every row of the lists, and in Document the
/// artboards, which follow the Artboards count. Names are shown as they are.
@@ -337,4 +457,130 @@ mod tests {
let report = app.session.execute("document.info", &json!({"category": "brushes", "format": "text"})).unwrap()["text"].to_string();
assert!(report.contains("Charcoal: Art Brush"), "{report}");
}
/// Section `id`'s rows as the panel shows them for `info`: each label and its shown value.
fn shown_rows(info: &Value, id: &str) -> Vec<(String, String)> {
let section = info["sections"].as_array().unwrap().iter().find(|s| s["id"] == id).unwrap_or_else(|| panic!("no {id}"));
let rows = section["rows"].as_array().unwrap();
let named = named_rows(id, rows);
rows.iter()
.enumerate()
.map(|(k, r)| {
let (label, value) = (r[0].as_str().unwrap(), r[1].as_str().unwrap());
(label.to_string(), shown_value(info, id, k, (label, value), named.contains(&k)).unwrap_or_else(|| value.to_string()))
})
.collect()
}
/// The values Document Info makes (the units, the raster effects resolution, each font's file
/// and state, each image's size, each Repeat object's kind and counts, and gradients named by
/// their kind) show in the interface language, from the same `document.info` after a language
/// change; font, face, file and swatch names stay as they are, also with Selection Only, and
/// `document.info` and the saved report stay in English.
#[test]
fn values_follow_interface_language_and_keep_names() {
let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
app.session.execute("file.new", &json!({"width": 400, "height": 400, "units": "Millimeters"})).unwrap();
app.session.execute("text.create", &json!({"x": 10, "y": 40, "text": "Hi"})).unwrap();
app.session.execute("text.create", &json!({"x": 10, "y": 80, "text": "Heavy", "font": "Source Sans 3", "style": "Black Wide"})).unwrap();
app.session.execute("text.create", &json!({"x": 10, "y": 120, "text": "Gone", "font": "Qx Absent Family"})).unwrap();
let rect = |app: &mut VectorcraftApp, x: f64| {
app.session.execute("shape.rectangle", &json!({"x": x, "y": 200, "width": 20, "height": 10})).unwrap()["id"].clone()
};
let ramp = |kind: &str| json!({"kind": kind, "stops": [{"offset": 0, "color": "#000"}, {"offset": 1, "color": "#fff"}]});
app.session.execute("swatch.new", &json!({"name": "Linear gradient", "gradient": ramp("radial")})).unwrap();
let glow = rect(&mut app, 0.0);
app.session.execute("paint.setFill", &json!({"ids": [glow], "swatch": "Linear gradient"})).unwrap();
app.session.execute("paint.setStroke", &json!({"ids": [glow], "gradient": ramp("radial")})).unwrap();
app.session.execute("layer.setProps", &json!({"id": glow, "name": "Glow"})).unwrap();
let star = rect(&mut app, 50.0);
app.session.execute("object.repeat.radial", &json!({"ids": [star], "instances": 6})).unwrap();
let tile = rect(&mut app, 100.0);
app.session.execute("object.repeat.grid", &json!({"ids": [tile], "rows": 2, "cols": 1})).unwrap();
let pic = rect(&mut app, 150.0);
app.session.execute("select.set", &json!({"ids": [pic]})).unwrap();
app.session.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
app.session.execute("select.set", &json!({"ids": []})).unwrap();
let info = app.session.execute("document.info", &json!({})).unwrap();
let value = |rows: &[(String, String)], label: &str| {
rows.iter().find(|(l, _)| l == label).unwrap_or_else(|| panic!("no {label} in {rows:?}")).1.clone()
};
let english = |id: &str| shown_rows(&info, id);
assert_eq!((value(&english("document"), "Units"), value(&english("document"), "Raster Effects")), ("Millimeters".into(), "72 ppi".into()));
assert_eq!(value(&english("fontDetails"), "Source Sans 3 Regular"), "built in; embedding allowed");
assert_eq!(value(&english("gradients"), "Glow"), "Linear gradient, Radial gradient");
let repeats = english("repeats");
assert_eq!((repeats[0].1.as_str(), repeats[1].1.as_str()), ("Radial Repeat, 6 instances", "Grid Repeat, 2 rows × 1 column"));
// Every value the panel builds reads as `document.info`'s English row.
for s in info["sections"].as_array().unwrap() {
let id = s["id"].as_str().unwrap();
let rows: Vec<(String, String)> =
s["rows"].as_array().unwrap().iter().map(|r| (r[0].as_str().unwrap().into(), r[1].as_str().unwrap().into())).collect();
assert_eq!(shown_rows(&info, id), rows, "{id}");
}
let Some(de) = crate::i18n::Lang::from_code("de") else { panic!("no German catalog") };
crate::i18n::set_current(de);
let german = |id: &str| shown_rows(&info, id);
let (document, fonts, images, gradients, repeats) =
(german("document"), german("fontDetails"), german("embeddedImages"), german("gradients"), german("repeats"));
let painted = crate::tests_labels::painted_text(&mut app, show);
app.session.execute("select.set", &json!({"ids": [glow]})).unwrap();
let selected = shown_rows(&app.session.execute("document.info", &json!({"selectionOnly": true})).unwrap(), "gradients");
let written: std::rc::Rc<std::cell::RefCell<Vec<u8>>> = Default::default();
let w = written.clone();
app.services.write = Some(Box::new(move |_: &str, b: &[u8]| {
w.borrow_mut().extend_from_slice(b);
Ok(())
}));
app.run("docInfo.save", json!({"path": "/tmp/info.txt", "category": "gradients", "selectionOnly": true})).unwrap();
crate::i18n::set_current(crate::i18n::Lang::EN);
let saved = String::from_utf8(written.borrow().clone()).unwrap();
assert_eq!((value(&document, "Units"), value(&document, "Raster Effects")), ("Millimeter".into(), "72 ppi".into()));
assert!(painted.contains("Millimeter") && !painted.contains("Millimeters"), "{painted}");
assert_eq!(value(&fonts, "Source Sans 3 Regular"), "integriert; Einbetten erlaubt");
let wide = value(&fonts, "Source Sans 3 Black Wide");
assert!(wide.starts_with("ersetzt: angezeigt in Source Sans 3 ") && wide.ends_with("Einbetten erlaubt)"), "{wide}");
let gone = fonts.iter().find(|(l, _)| l.starts_with("Qx Absent Family")).unwrap_or_else(|| panic!("{fonts:?}")).1.clone();
assert!(gone == "fehlt" || gone.starts_with("fehlt: angezeigt in "), "{gone}");
assert_eq!(images.len(), 1);
assert!(images[0].1.ends_with(" px") && images[0].1.contains(" × "), "{images:?}");
// A swatch named like a kind keeps its name; the gradient named by its kind is translated.
assert_eq!(value(&gradients, "Glow"), "Linear gradient, Radialer Verlauf");
assert_eq!(value(&selected, "Glow"), "Linear gradient, Radialer Verlauf");
assert_eq!((repeats[0].1.as_str(), repeats[1].1.as_str()), ("Radiale Wiederholung, 6 Instanzen", "Rasterwiederholung, 2 Zeilen × 1 Spalte"));
assert!(saved.contains("(the selection only)") && saved.contains("\nGRADIENT OBJECTS\nGlow: Linear gradient, Radial gradient\n"), "{saved}");
let report = app.session.execute("document.info", &json!({"format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
assert!(report.contains("Units: Millimeters\n") && report.contains("Radial Repeat, 6 instances"), "{report}");
}
/// A Repeat object's counts take each language's plural forms, and a grid that draws fewer
/// instances than its rows and columns give is followed by the number it draws.
#[test]
fn repeat_value_uses_locale_plural_forms_and_drawn_count() {
let radial = |n: u64| json!({"name": "R", "type": "radial", "instances": n});
let grid = json!({"name": "G", "type": "grid", "rows": 500, "cols": 500, "instances": 125_000});
let in_lang = |code: &str, e: &Value| {
let Some(lang) = crate::i18n::Lang::from_code(code) else { panic!("no {code} catalog") };
crate::i18n::set_current(lang);
let shown = repeat_value(e);
crate::i18n::set_current(crate::i18n::Lang::EN);
shown.unwrap_or_else(|| panic!("{e}"))
};
assert_eq!(in_lang("en", &radial(1)), "Radial Repeat, 1 instance");
assert_eq!(in_lang("en", &grid), "Grid Repeat, 500 rows × 500 columns, 125000 instances");
assert_eq!(
[1, 3, 5, 21].map(|n| in_lang("ru", &radial(n))),
[
"Радиальный повтор, 1 экземпляр",
"Радиальный повтор, 3 экземпляра",
"Радиальный повтор, 5 экземпляров",
"Радиальный повтор, 21 экземпляр"
]
);
assert_eq!(in_lang("ru", &grid), "Повтор сеткой, 500 строк × 500 столбцов, 125000 экземпляров");
assert_eq!([1, 2].map(|n| in_lang("ja", &radial(n))), ["ラジアルリピート、インスタンス 1 個", "ラジアルリピート、インスタンス 2 個"]);
// A full grid shows its rows and columns alone; an unknown kind is shown as `document.info` gives it.
assert_eq!(in_lang("de", &json!({"type": "grid", "rows": 1, "cols": 3, "instances": 3})), "Rasterwiederholung, 1 Zeile × 3 Spalten");
assert_eq!(repeat_value(&json!({"type": "spiral", "instances": 2})), None);
}
}
+35 -12
View File
@@ -1,6 +1,6 @@
# VectorCraft MCP server
> **Last updated:** 2026-11-13 · **Change:** Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097); existing response shapes retained. Previously: Save location-refusal error (#6146); existing response shapes retained.
> **Last updated:** 2026-11-13 · **Change:** Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; no response-shape change. Previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097); existing response shapes retained.
`vectorcraft-cli mcp` runs a [Model Context Protocol](https://modelcontextprotocol.io) server on stdio
(newline-delimited JSON-RPC 2.0; see [Protocol](#protocol) for version negotiation). Agents use it to
@@ -805,13 +805,17 @@ color changed by `paint.invert`, `paint.complement`, `edit.colors.invert`, `edit
`addon.color.filter`, `addon.color.applyNearestSwatch` or the ink limit of `addon.color.printFixes`. The recolor
commands store it too when they are given a series group, the graph or a group that holds the graph. A row a command
leaves as it was keeps what the graph stores. When one command changes several paths of a series, the frontmost of
them sets what the graph stores. A gradient is stored with its placement relative to the box of the path it was stored
from (a stroke's box is the path's bounds grown by half the weight), and every path of the series, the legend swatch
included, takes it at the same place on its own box when the graph is drawn again, also after the data changes or the
graph moves. The graph saves this as `fillUnitBox` and `strokeUnitBox` in its series paints. A gradient stored from a
path with no width or no height is drawn at the place in the document where it was stored. So is a gradient a graph
stored without these flags. The graph does not store a stroke's dashes, caps, joins, arrowheads, width
profile or brush. These commands do not store the colors they give a graph's axes and labels, which are drawn again
them sets what the graph stores. While Global Edit is on, a path directly in a series that takes an edit from another
match (a graph's paths are matches only while the graph is isolated) has what changed on it stored for its series: the
paint, weight, opacity and blend mode of the topmost visible fill and stroke, and the object's opacity and blend mode.
`addon.arrange.randomizeOpacity` and `addon.arrange.sort` with `apply: "opacity"` store the object opacity, with the
blend mode, of the frontmost path of a series whose opacity they change. A gradient is stored with its placement relative
to the box of the path it was stored from (a stroke's box is the path's bounds grown by half the weight), and every path
of the series, the legend swatch included, takes it at the same place on its own box when the graph is drawn again, also
after the data changes or the graph moves. The graph saves this as `fillUnitBox` and `strokeUnitBox` in its series
paints. A gradient stored from a path with no width or no height is drawn at the place in the document where it was
stored. So is a gradient a graph stored without these flags. The graph does not store a stroke's dashes, caps, joins,
arrowheads, width profile or brush. These commands do not store the colors they give a graph's axes and labels, which are drawn again
with the paint they had.
`text.setFormat` without `start` and `end`, on a graph or on its labels, stores the character and paragraph attributes
@@ -5094,6 +5098,8 @@ the canvas (coordinates out of range)".
`path.setHandle`, `path.moveAnchor` and `path.insertAnchor` edit subpath 0 when `subpath` is absent or null, and refuse a `subpath` that
is not a whole number of 0 or more, such as 1.5, -1 or "1" ("missing integer `subpath`"); `path.split` refuses such
an `anchor` or `segment` in the same way. The document does not change and no undo step is recorded.
`path.moveAnchor` to the point the anchor is at, and `path.setHandle` to the point the handle is at on an anchor that
keeps its kind, leave the document as it is and record no undo step.
`path.insertAnchor` keeps the direct-selected anchors and selected segments of the path on the same points: those
after the new anchor on its subpath are numbered one higher, and a selected segment that the new anchor splits stays
selected as its two halves, with the new anchor as an end of both that moves with them. Undo restores the path and
@@ -5236,6 +5242,13 @@ round, such as a rectangle, stays as it is. Closed paths stay closed and open pa
{"name":"run_command","arguments":{"command":"object.path.smooth","params":{"level":80}}}
```
`path.smoothRegion` (the Smooth tool) keeps the end points of an open path where they are. When the stretch it refits
reaches the first or last anchor of an open path, the curve there leaves or arrives along the smoothed path within
`radius` of that end rather than along the first or last segment, so a jagged end turns with the rest of the path; it
keeps the segment's direction when the smoothed path there turns back by 90° or more. Where the stretch ends inside a
path, the curve keeps the direction of the part outside the drag. `object.path.smooth` and Simplify keep each end's
direction.
In the desktop app, Object › Path › Smooth and the canvas context menu's Smooth… (listed while the selection holds a
path) open the slider (`ui.menuDialog {command: "object.path.smooth"}`, dialog `smoothSlider` with field `level`) at
the Auto-Smooth level, and the slider previews the result until `ui.dialog.confirm`; `ui.smoothAuto` moves the open
@@ -5813,7 +5826,7 @@ The Selection & Anchor Display and General preferences apply to `pointer_gesture
- `usePreciseCursors`: the Pen, Eyedropper, Slice and Blend tools' pointers are a crosshair.
- `snapToPointTolerance` (1–8 px, 2 by default): with View › Snap to Point on and Smart Guides off (desktop app), the
point a selection is dragged by, a drawn point and a transform tool's reference point land on an anchor or a ruler
guide that near.
guide that near, showing none of the Smart Guides labels or lines.
- `moveLockedWithArtboard`: `artboard.move {moveArt: true}`, the Artboard tool and `artboard.rearrange` move locked and
hidden art, and art that is also on a locked artboard, with the artboard too, and `artboard.setProps {scaleArt: true}`
scales it too; off (the default) it stays where it is. `artboard.duplicate`, `artboard.copy` and `artboard.cut` copy or
@@ -7240,7 +7253,14 @@ result carries the same files as a zip (`{name: "<name>.zip", dataBase64}`, entr
document, objects, graphicStyles, brushes, spotColors, patterns, gradients, symbols, fonts, fontDetails, linkedImages,
embeddedImages, repeats), `fonts` (the fonts the document's type uses, the type in opacity masks and in the art of
its symbols and pattern swatches included, which the fonts and fontDetails categories list; with `selectionOnly`, the
fonts of the selected type), `brushNames` (the brushes the art's strokes use, each once, hidden strokes, strokes at an opacity of 0, strokes with no
fonts of the selected type), `fontDetails` (`[{font, match, family, style, file, embedding}]`: each font of `fonts`,
in order, as the fontDetails category's rows give it: `match` is `exact`, `style` (a style the family lacks, shown in
`family` `style`), `missingWithFallback` (not installed, shown in `family` `style`) or `missing`; `file` is the face's
file name, null for a built-in face; `embedding` is `allowed`, `editing`, `previewPrint` or `forbidden`, null when no
face is found), `imageObjects` (`[{name, width, height, linked, file}]`: the image objects in the order the
linkedImages and embeddedImages categories list them, with the file a linked image's row shows and null for an
embedded one), `document.unitId` (the document's units as Preferences › Units names them, such as `millimeters`, beside
the English `document.units`), `brushNames` (the brushes the art's strokes use, each once, hidden strokes, strokes at an opacity of 0, strokes with no
paint or width, guides, paths with no segment, type that draws no characters, a group's or layer's own strokes, a compound path member's own strokes and an image's strokes without a
shape left out; with `selectionOnly`, the brushes the selected
objects' strokes use), `brushes` (`[{name, type}]`: those brushes with their types, `calligraphic`, `scatter`, `art`,
@@ -7253,9 +7273,11 @@ whose drawn characters use a pattern included, hidden fills and strokes, fills a
member's own fills and strokes, an image's fills and strokes that no Convert to Shape or Outline Object effect gives a
shape, and characters that draw nothing (spaces and line breaks without an underline or strikethrough) left out, with
the patterns it uses, which the patterns category lists as Pattern Objects and `objects.patterns` counts; with `selectionOnly`, those in the selection),
`patternNames` (the patterns those objects use), `gradientObjects` (`[{id, name, gradients}]`: every object filled or
`patternNames` (the patterns those objects use), `gradientObjects` (`[{id, name, gradients, kinds}]`: every object filled or
stroked with a gradient, by the same rules as `patternObjects`, with the gradients it uses: the name of the gradient
swatch a gradient is linked to, else `Linear gradient`, `Radial gradient` or `Freeform gradient`; the gradients category
swatch a gradient is linked to, else its kind's name, such as `Linear gradient`, `Radial gradient` or `Freeform gradient`;
`kinds` gives, for each of `gradients`, the kind (`linear`, `radial`, `conic`, `diamond` or `freeform`) of a gradient
named by its kind and null for a swatch's name; the gradients category
lists them as Gradient Objects and `objects.gradients` counts them; gradient swatches no art uses are not listed; with
`selectionOnly`, those in the selection), `gradientNames` (the gradients those objects use), `spotObjects`
(`[{id, name, spotColors}]`: every object filled or stroked with a spot color swatch, as a solid color or in the
@@ -11524,5 +11546,6 @@ the error text. The interactive fallback applies only to ordinary File > Save, n
| Date | Change |
|---|---|
| 2026-11-13 | Snap to Point with Smart Guides off draws no Smart Guides labels or lines (#7250). |
| 2026-11-13 | Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097). |
| 2026-11-11 | Document READ_ONLY_LOCATION for saves (#6146); no response-shape change. |
+8 -1
View File
@@ -1,6 +1,6 @@
# Parity with Adobe Illustrator
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-13 · **Change:** minor (3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlines at their own weight, as users' `.ai` files draw them, which changes how VectorCraft's own envelopes of stroked type draw (#6644; scores and estimates unchanged); previously minor: G5: Energy Beams brush library; bundled content ~44% → ~46%; previously minor: G5: Skill Icons symbol library; bundled content ~42% → ~44%; previously minor: `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art (#6570; scores and estimates unchanged); previously minor: ruler double-click adds a guide at the pointer, #5239; G5: Status Effects graphic style library; bundled content ~40% → ~42%; MCP symbol libraries list UI Frames and Map Markers; previously minor: G5: Inventory Icons built-in symbol library; bundled content ~38% → ~40%; previously minor: `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke (#3179; scores and estimates unchanged); previously minor: `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid where VectorCraft's warp doesn't draw as their drawn art (#3179; scores and estimates unchanged); G5: Game Trails brush library; bundled content ~36% → ~38%; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page (#3179; scores and estimates unchanged); G5: Game HUD graphic style library; bundled content ~34% → ~36%; previously minor: Line Arrow arrowhead (#5421; scores and estimates unchanged); G5: Map Markers built-in symbol library; bundled content ~32% → ~34%; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Canvas: a 3D effect changed on type or a group redraws where its solid was; Fit to Artwork Bounds and per-artboard SVG expLine truncated
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-13 · **Change:** minor (Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; previously: 3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlines at their own weight, as users' `.ai` files draw them, which changes how VectorCraft's own envelopes of stroked type draw (#6644; scores and estimates unchanged); previously minor: G5: Energy Beams brush library; bundled content ~44% → ~46%; previously minor: G5: Skill Icons symbol library; bundled content ~42% → ~44%; previously minor: `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art (#6570; scores and estimates unchanged); previously minor: ruler double-click adds a guide at the pointer, #5239; G5: Status Effects graphic style library; bundled content ~40% → ~42%; MCP symbol libraries list UI Frames and Map Markers; previously minor: G5: Inventory Icons built-in symbol library; bundled content ~38% → ~40%; previously minor: `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke (#3179; scores and estimates unchanged); previously minor: `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid where VectorCraft's warp doesn't draw as their drawn art (#3179; scores and estimates unchanged); G5: Game Trails brush library; bundled content ~36% → ~38%; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page (#3179; scores and estimates unchanged); G5: Game HUD graphic style library; bundled content ~34% → ~36%; previously minor: Line Arrow arrowhead (#5421; scores and estimates unchanged); G5: Map Markers built-in symbol library; bundled content ~32% → ~34%; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Canvas: a 3D effect changed Line truncated
>
> Oversized artboard import update (2026-11-12): Explicit editing-data import retains a single artboard beyond a capped 14,400 pt PDF page (#6865).
>
@@ -54,6 +54,7 @@ Artboard Options forwards the active Artboard tool's Scale Artwork with Artboard
| Date | Change | Summary |
|---|---|---|
| 2026-11-13 | minor | Snap to Point: with Smart Guides off it still pulls drawn and dragged points onto anchors and ruler guides, but draws none of the Smart Guides labels ("anchor") or lines (#7250; `guides::tests::snap_to_point_without_smart_guides_shows_no_guides`). Scores and estimates unchanged. |
| 2026-11-13 | minor | Graphic Styles: in a panel made taller the list fills the space above the footer instead of stopping at 220 pt (#2992; `the_list_fills_a_tall_panel_above_its_footer` in `crates/ui-egui/src/panels/graphic_styles.rs`). Scores and estimates unchanged. |
| 2026-11-13 | minor | PDF import: glyphs inside a marked-content span with an empty `ActualText` come in as outlines in their fill and stroke instead of being left out, adding no text (#6971; `empty_actual_text_keeps_the_glyphs_art` in `crates/pdf/src/tests/actual_text.rs`). Scores and estimates unchanged. |
| 2026-11-13 | minor | Library panels (swatch, Color Book, brush, symbol and graphic style libraries): in a panel made taller the list fills the space above the footer instead of scrolling inside 220 or 280 pt (#2992; `the_list_fills_a_tall_panel_above_its_footer` in `crates/ui-egui/src/panels/library_panel/tests.rs`). Scores and estimates unchanged. |
@@ -1100,6 +1101,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type. A series starts in greyscale; Group Selection's fill and stroke, the paint, weight, opacity and blend mode of a mark's top visible fill or stroke row after an Appearance command or a graphic style (each given a mark or its series picked with Group Selection), the Eyedropper, Default Fill and Stroke or Swap Fill and Stroke, the paint or stroke weight a stroke weight, gradient or recolor command changes there, and a mark's object opacity and blend mode, are kept separately on the graph and reapplied when its data, type or size changes, and through save, open and undo; a kept gradient takes the same place on each mark's own box. Graph Type's Override Calculated Values (both `axisMin` and `axisMax`) uses exactly that value-axis range, split into the tick count (5 when automatic). Line graphs take Edge-to-Edge Lines (off by default: the points sit at the centres of their categories; graphs saved before the option keep their edge-to-edge lines), and radar graphs follow Mark Data Points and Connect Data Points. Blank cells (an empty CSV cell or `null`) are values left out, not zeros: columns, bars and stacked segments skip them, lines and scatter lines break around them and the value axis ignores them, while area, pie and radar draw them as 0; a number in straight quotes is a label, and the data window writes it back quoted. Graph types combine: Graph Type on series picked with Group Selection (or `series` indexes) draws them as their own type, with column, stacked column, line and area mixing on the vertical value axis and bar and stacked bar on the horizontal one; stacked columns take one slot of the cluster, lines draw in front of columns and areas behind. The value axis goes on the left, the right or both sides (column, stacked column, line, area and scatter graphs; bar graphs keep theirs along the bottom), and Separate Scales gives the series assigned to the right axis a scale of their own with its own tick values. Each value axis takes tick marks of no, short or full (across the plot) length and a count per division, and a prefix and suffix for its numbers; the category axis takes tick marks too (none by default), at or between its labels. Graph designs: Object › Graph › Design lists the designs with a preview of the selected one, and New Design (the selected art), Rename, Delete Design, Paste Design (a copy back to edit) and Select Unused, and Marker draws the data points and legend swatches of line, scatter and radar series with a design, scaled so its backmost object fills the default marker's square. Graph Data transposes rows and columns and switches a scatter graph's x and y, and a `|` in a category or series label starts a new line. Pie graphs take Legends in Wedges, Position (Even, Ratio sized by area, Stacked on one centre) and Sort (None, All, First). Graph Type takes column and cluster widths up to 1000% (overlapping past 100%) with First Row and First Column in Front (First Row orders each series' categories; across series the series order decides, so series stay one group each for Group Selection), draws filled lines, adds drop shadows behind columns, bars, lines and wedges, and puts the legend in rows across the top. Text formatted with the Character, Paragraph, Appearance, Transparency or Graphic Styles controls or the Eyedropper, on the whole graph or on labels picked with Group Selection, is kept per kind of label (value axis numbers, category labels, legend labels) through the graph being drawn again, the paint, weight, opacity and blend mode of a label's topmost visible fill and stroke rows and its object opacity and blend mode included. Object › Graph › Data opens a worksheet: cells picked with a click and edited above the sheet (Tab moves right, Enter down, the arrows between cells), Import Data from a tab-separated text file, Transpose, Switch x/y, Cell Style (decimals shown, column width), Revert and Apply. `graph.setData` returns and takes the data as CSV with each value written exactly, not rounded to two decimals, so applying the returned CSV changes nothing (#1485).
A series that draws Filled Lines bands keeps no stroke paint or weight: its bands are drawn again with their 0.25 pt black outline.
An Eyedropper pick that includes transparency and leaves a mark's top fill or stroke row without paint, or removes that row when the source has no row of that kind, where that row had paint before, also replaces the opacity and blend mode the graph keeps for that kind of row in the series; a row that had no paint before the pick leaves them as they are.
What Global Edit gives a mark from another match (in an isolated graph) is kept on the graph the same way, and so is the object opacity, with its blend mode, that Randomize Opacity and Sort Objects change on marks.
- **Graph column designs:** Object › Graph › Column (`graph.column`) draws the columns, bars or stacked segments and the legend swatch of the series picked with Group Selection with a graph design: Vertically Scaled stretches it to each column's length, Uniformly Scaled scales it both ways and centers it, Repeating stacks a copy for each Each Design Represents value and chops or scales the last one (For Fractions), and Sliding keeps the part above the design's guide line in proportion and stretches the part below. The dialog lists the designs with a preview; the choice is saved with the graph and follows the design's rename and delete.
Type in a column design that holds a `%` followed by two digits shows each column's value in place of the `%` and the digits: the first digit is the least number of places before the decimal point (zeros are added in front; 0 gives as many as the value needs), and the second digit sets the places after it, rounded. Unless it is inside a group that clips or has its own opacity or appearance, or inside a blend, compound shape, envelope, repeat or intertwined objects, the type keeps its size and is drawn once per column in a repeating design. The legend swatch leaves it out.
- **Other:** Eyedropper, Gradient annotator, Artboard (Alt-drag duplicates an artboard, and its art with Move/Copy Artwork with Artboard on; Copy, Cut and Paste take the artboard with its art, Paste right of the last artboard, Paste in Place where it was, into this or another document, #446; Object › Artboards › Rearrange All Artboards lays them out in a grid by row or by column, in one row or one column, left to right or right to left, from the menu, the Artboards panel or Properties' Rearrange All, #681; Scale Artwork with Artboard, in the Control bar and Properties beside Move Artwork with Artboard, resizes the artboard proportionally with the art fully inside it and its guides, strokes and corners per the Scale preferences, #602), Measure, Type, Hand, Zoom, Rotate View.
@@ -1131,6 +1133,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
The Pencil's and the Paintbrush's Fidelity is in screen pixels, the same at any zoom: their Tool Options give it in px, from 0.01 px on the logarithmic slider to 20 px and up to 100 px in the field, and the tool sends `path.freehand` the value in points at the current zoom (#5729). The Smooth tool's and the Blob Brush's Fidelity stays in points.
`path.freehand` and `brush.freehand` take a Fidelity of up to 100 / 0.0313 pt (about 3194.89 pt), the 100 px field maximum at the lowest zoom (3.13 %), and reject a value outside their range with an error, so a Pencil or Paintbrush stroke drawn zoomed out keeps the Fidelity set in pixels (engine tests `pencil_fit_keeps_its_anchors_on_a_stroke_drawn_zoomed_out` and `pencil_takes_fidelity_within_its_range_and_rejects_the_rest`).
Each drag of the Smooth tool smooths the stretch of a selected path in its reach along its length before refitting it within Fidelity, so a wobble wider than Fidelity is smoothed out and another drag over the same place smooths it further, as [the help page](https://helpx.adobe.com/illustrator/using/tool-techniques/smooth-tool.html) describes (`path.smoothRegion`). The smoothing spread (a third of the reach) and the rule that each refit stays within twice the distance the smoothing moved the path, so repeated drags do not drift from it, are VectorCraft's own. A drag over the whole of a closed path smooths it across its first anchor too, so a bump there is smoothed like any other and no corner is left; Object › Path › Smooth smooths a closed path across its first anchor the same way.
When a Smooth tool drag reaches the first or last anchor of an open path, that anchor stays where it is and the curve there leaves or arrives along the smoothed path within the reach, so a jagged first or last segment no longer sets the end's direction; an end where the smoothed path turns back by 90° or more keeps its segment's direction, and where the refitted stretch ends inside the path the curve keeps the direction of the part outside the drag. This rule is VectorCraft's own (`tests/draw2.rs`, `smoothing_an_open_path_turns_its_jagged_ends_with_the_path` and `a_smooth_drag_turns_only_the_end_it_reaches`).
A Smooth drag along a curved segment smooths the stretch of it in the drag's reach even when neither of the segment's anchors is in reach, as [the help page](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/refine-paths.html) describes dragging along the path segment; the segment is cut where the drag enters and leaves the reach, and the parts outside keep their shape (`path.smoothRegion`). Paths of two anchors are smoothed too, and Alt with the Paintbrush smooths a selected two-anchor curve; a two-anchor straight line still gets the closed stroke. How the reach is found on a segment (samples no more than half the reach apart) is VectorCraft's own, and a straight segment is left as it is.
Before a press that draws a new path, the Pencil cursor shows a small star, as [Draw freeform paths with the Pencil tool](https://web.archive.org/web/20260926095638/https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-freeform-paths-with-the-pencil-tool.html) describes; over a selected path within Edit selected paths' distance, which the press continues from an end or redraws, the star is not shown ([Reshape paths with the Pencil tool](https://web.archive.org/web/20260106004407/https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/reshape-paths-with-the-pencil-tool.html)).
Keep selected in the Pencil and Paintbrush Tool Options is on by default: while it is on, a stroke selects the path it draws or continues and replaces the earlier selection. While it is off, a new stroke leaves nothing selected, the earlier selection included, as the reference application starts the stroke by dropping it (#5752); a continued or redrawn path is deselected while the rest of the selection stays (`path.freehand` `keepSelected`).
@@ -1281,6 +1284,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- **Type:** Character size, leading, baseline shift and horizontal-scale controls account for object/group transforms (#1034): exact document-point sizes, mixed-value display and keyboard increments, range edits, resettable horizontal stretch, undo/redo and native save/reopen (`tests_typescale`, Character panel tests). Point size is the transformed em-height axis, independent of glyph ink bounds; affine rotation, reflection and shear are retained. Group scaling still scales text; preserving font sizes is a separate enhancement. Behaviour reference: [Transform text](https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/transform-text.html) (public documentation). Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), paragraph attributes per paragraph (alignment, indents, spacing, hyphenation, hanging punctuation, tab stops, paragraph style, direction, mojikumi and leading model; the Paragraph, Tabs and Paragraph Styles panels act on the paragraphs the Type tool's selection or caret touches, Return continues the paragraph's style, threads and SVG keep them), Area Type Options (rows/columns/inset/first baseline, Text Flow by rows or by columns (#4978), vertical Align Top/Center/Bottom/Justify per row/column, reflowing non-rectangular frames and text wrap), threaded text across any closed shapes, Fit Headline, the Every-line Composer for justified and ragged text (paragraph-wide breaks for an even rag, Single-line per object from the Paragraph panel menu or `text.setFormat {composer}`). Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`), and an anchor of the path of type on a path outside perspective, the type reflowing along it (`text.reshapePath`, #3980). Point type still scales. Auto Size: the frame height follows the text after every edit, in the same undo step (rectangular frames of horizontal type in one row; columns get the least height that holds them; a height set by hand or threading turns it off), and the "Auto Size New Area Type" preference gives it to new area type. Shrink Text to Fit (beyond Illustrator): overflowing area type scales its sizes, leading and baseline shifts down by the largest factor (in 0.1 pt steps of the first run, down to a minimum percentage) that fits, at layout time so every export sees it. `text.areaOptions` and `document.inspect` report overflow and the shrink factor. The Selection tool shows the type widget beside selected type's bounding box (hollow on point type, filled on area type); double-clicking it converts between them (Type › Convert To Area Type / Convert To Point Type), keeping the text and its styles in place. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. The Character panel's Variable Font sliders set each axis (see Fonts). Beyond Illustrator: inline graphics (`text.insertInline`, Type ▸ Insert Inline Symbol) set a document symbol in a run of type as one character that flows, wraps and justifies like a glyph (InDesign-style inline objects, e.g. mana symbols in card rules text): sized to a multiple of the font size, centred on the cap height, opening up tall lines, following Redefine Symbol; a character of its run's size for Character Alignment and Top-to-Top leading, placed by the bidi reordering in right-to-left text (a neutral U+FFFC); drawn on the canvas, kept as live text plus a `<use>` in SVG and as vector art in PDF; Backspace removes it whole. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text. Arabic typefaces: builds made with a craft-fonts checkout that holds its Arabic families (Noto Sans Arabic, the Arabic fallback, plus Cairo, Tajawal, Almarai, IBM Plex Sans Arabic, Noto Kufi Arabic, Amiri, Alexandria, Fustat, Reem Kufi, Aref Ruqaa and Gulzar once craft-fonts adds them, storytold/craft-fonts#11; reLine truncated
The Character panel menu's Show Font Height Options shows a Set Font Height Reference dropdown under Font Size (`text.setFormat` or `text.setRangeStyle` `{fontHeightReference}`). Each reference shows an icon of the height it measures before its name, in the open list and in the closed field (#6304): a frame around a letter for Em Box, a bar from the baseline to the top of a capital for Cap Height and of a lowercase x for x-Height, and a frame inset in the em square for ICF Box. With Em Box, the default, the font size is the size of the em square; with Cap Height, x-Height or ICF Box, the characters are set at the em size at which the font's OS/2 cap height, its x height or the height of its ideographic character face equals the font size. With a font that has no such value, or one outside 0.1 to 2 em, the size measures the em box. SVG, PDF and legacy `.ai` export and the CSS Properties rules write the em size the characters are drawn at, and DXF export writes 0.7 times that em size as each TEXT entity's height (group 40, the height of its capitals). Behavior reference: [Vary font height](https://web.archive.org/web/20251118174722/https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/vary-font-height.html).
The Every-line Composer composes a paragraph whose characters differ in line metrics (type size, font, leading or vertical scale, or an inline graphic taller than the text) in area type of any shape, rows, columns and text wrap included. In a frame that is not a rectangle, or with text wrap, each line it tries is measured where the lines above it put it, across the line's own height, so a taller line gets the room of the narrower part of the frame, or of the span beside a wrap object, that it reaches. Such a paragraph is broken with the Single-line Composer when the frame has no room for all of it or when the search passes VectorCraft's own limits. Behavior reference: [the help page](https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/set-hyphenation-and-line-breaks.html).
A text wrap object's Offset may be negative as well as positive ([the help page](https://help.adobe.com/archive/en_US/illustrator/cs4/illustrator_cs4_help.pdf#page=307)). A negative Offset (to -1000 pt) shrinks the wrap object by that distance, measured from each edge itself and from the edges of its holes, so lines beside it, above it and below it run that far into it, and an object narrower than twice the distance no longer moves text aside. With Invert Wrap, a negative Offset keeps the text that far inside the object. These are VectorCraft's own rules for the shape of the shrunk object. Text Wrap Options, `object.textWrap.make` and `object.textWrap.options` and the MCP `text_wrap` tool take the negative value, and layout uses it (`crates/text/src/layout/region.rs` tests, `cmd::textwrap::tests::text_wrap_options_negative_offset_reflows_and_round_trips`).
In area type of a shape other than a rectangle, each line's whole band, ascent to descent, stays inside the frame: where an edge pinches in within the band, the line ends at the narrowest point, and a line runs beside a hole that starts and ends within its band, not across it. In area type of any shape, a line also stays clear of a text wrap object that reaches into any part of its band, and inside an Invert Wrap object over its whole band (`crates/text/src/layout/region.rs` tests).
With Invert Wrap, the spans a line keeps inside a wrap shape of many parts (a comb of 500 teeth) are found by stepping through the line's spans and the shape's spans once for each piece of the band, so the work grows with the number of spans, not with its square (`crates/text/src/layout/region.rs` tests).
The Character panel's Small Caps, Superscript and Subscript buttons and the panel menu's items of the same names turn small caps and the superscript or subscript position on and off for the selected type, or for the text the Type tool has selected (`text.setFormat` or `text.setRangeStyle` `{smallCaps, position}`), in Document Setup's proportions. Turning Superscript on turns Subscript off, and turning Subscript on turns Superscript off. A button or item shows as on when the first selected character (at a caret, the character before it) has its attribute.
@@ -1323,6 +1327,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
The frames of threaded text share one writing direction: Type › Type Orientation (`type.orientation.vertical`, `type.orientation.horizontal`) in one frame sets every frame, threading frames gives the thread its first frame's direction, frames taken out of a thread keep theirs, and the story flows through every frame in the thread's direction.
Type › Optical Margin Alignment (`type.opticalMarginAlignment`) hangs the punctuation and letter edges at the ends of a type object's lines outside its margins: at the left of left-aligned lines, at the right of right-aligned lines, and at both ends of centered and justified lines, in point and area type of left-to-right paragraphs. Quotation marks, hyphens, full stops and commas hang wholly; asterisks, tildes, ellipses, en and em dashes, colons and semicolons hang by half; and A, V, W, Y, v, w and y hang by a tenth of their width. It is off by default and saved with the type object. Justification's Glyph Scaling leaves the glyphs that hang at their width, so they hang exactly their share, and Standard burasagari counts what hangs at a line's start as room before hanging a comma; `crates/text/src/tests/hang.rs` checks whole paragraphs with both composers, ragged, centred and justified, with Line-end Punctuation Half Width and bidirectional lines.
Optical Margin Alignment and Roman Hanging Punctuation hang right-to-left paragraphs of point and area type, and type on a path whose first paragraph runs right to left, too. Auto aligns a right-to-left line at its right, or at the end bracket of a path, so it hangs there. A right-to-left line is read from right to left: where it hangs at its left margin, `."` ending it hangs both glyphs.
Type on a path with right-to-left text that does not fit shows the longest start of its text whose glyphs fit, also where tracking gives a letter a negative advance and a shorter start does not fit; the rest overflows or flows to the next threaded object (VectorCraft's own rule). Without hanging punctuation, and on a straight path or with no spacing, every start is measured without arranging it on the path again. With hanging punctuation, or spacing on a curve, when a letter has a negative advance, at most 32 of the starts that could fit are arranged one by one from the longest; when none of them fits, a binary search over the rest shows a start that fits, which is not always the longest (`overflowing_rtl_type_on_a_path_shows_the_longest_start_that_fits`, `the_longest_rtl_start_on_a_path_is_found_without_arranging_each_start`, `the_longest_rtl_start_on_a_path_is_the_one_each_start_gives` and `rtl_type_on_a_curve_whose_letters_take_the_line_back_is_arranged_a_bounded_number_of_times` in `crates/text/src/tests/bidi.rs`). Right-aligned and centered type on a curve with Spacing is placed by what its glyphs take where the line ends up, so text that fits is not cut off at the end bracket (`on_path_aligned_spaced_text_that_fits_shows_whole` in `crates/text/src/tests.rs`).
The Paragraph panel menu's Kinsoku Shori Type (`text.setFormat {kinsokuType}`, with the East Asian options) picks Push In First, Push Out First or Push Out Only for each paragraph: a character the Kinsoku Set keeps off a line's start or end is set on the line, with the line's gaps next to CJK characters closed by at most a tenth of an em each to fit, or moved to the next line with the character before it. Push Out First pushes in only when pushing out would leave the line more than an em short. Push Out Only is the default, the setting is saved only when it is not, and paragraph styles carry it.
The Paragraph panel menu's Bunri-Kinshi (`text.setFormat {bunriKinshi}`, with the East Asian options, and the East Asian Composition Settings section of Paragraph Style Options) keeps inseparable pairs on one line in each paragraph that has it: two em dashes, two ellipses, two two-dot leaders and the two halves of a vertical kana repeat mark (the pairs of W3C JLREQ's class cl-08, VectorCraft's set). Both composers and vertical type follow it, and justification adds no space inside a pair. It works with a Kinsoku Set only, is off by default and is saved only when on; editing the set of pairs is not available.
The Paragraph panel menu's Korean Line Break Anywhere (`text.setFormat {koreanLineBreakAnywhere}`, with the East Asian options, and the East Asian Composition Settings section of Paragraph Style Options) sets for each paragraph whether a line may break between any two Hangul syllables. When it is off, a word that contains Hangul breaks only at its spaces and after punctuation, or where the word is wider than the line, and takes no hyphen. New type has it off; paragraphs saved before the option read as on, so their lines do not move.
@@ -1509,6 +1514,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
Document Info's Brushes, Spot Color Objects, Pattern Objects and Gradient Objects categories leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0, their characters' paints and colorized images included. With Selection Only an object selected inside such a group or layer is left out too, and Objects still counts every object as before. This is VectorCraft's own rule. Test: `cmd::docinfo::tests::info_skips_paints_on_hidden_and_clear_objects_and_their_members` (vectorcraft-engine).
Document Info's Save… writes the category the panel shows, with Selection Only applied, as the [Document Info panel](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/document-info-panel.html) page describes ("Exports the selected category's visible information to a text file"). With All Categories shown it writes every category, which is VectorCraft's own rule (`docInfo.save {category}`). Test: `panels::doc_info::tests::save_writes_the_category_the_panel_shows`.
Document Info's category menu and headings show every category title in the interface language, Font Details, Linked Images and Embedded Images included, and the Objects category shows every count label in it too: Compound Paths, Text Objects, Placed Documents, Symbol Instances, Gradient Meshes, Blends, Envelopes, Intertwine Groups, Opacity Masks and Objects with Effects. The Document category's Pattern Swatches row and the Objects category's Path Length row are translated in every catalog that has every menu label. `document.info` and the saved report keep the English labels. Showing these labels in the interface language is VectorCraft's own rule. Test: `i18n::tests::document_info_labels_are_in_complete_catalogs` (vectorcraft-ui-egui).
Document Info shows the values it makes in the interface language too: the Units, the Raster Effects resolution, each font's file, substitution and embedding permission (or that it is built in or missing), each image's size and linked file, each Repeat object's kind with its instances, rows and columns in the language's plural forms, and gradients named by their kind. Font, face, file, swatch and other names stay as they are, a gradient swatch named like a kind included, and `document.info`, Save… and Package's report keep the English values (`document.unitId`, `fontDetails`, `imageObjects`, `gradientObjects` `kinds`). Showing these values in the interface language is VectorCraft's own rule. Tests: `panels::doc_info::tests::values_follow_interface_language_and_keep_names`, `repeat_value_uses_locale_plural_forms_and_drawn_count`, `i18n::tests::document_info_values_are_in_complete_catalogs` (vectorcraft-ui-egui), `cmd::docinfo::tests::info_exposes_structured_font_details_without_changing_english_rows`, `info_exposes_ordered_images_and_unit_id` and `gradient_kinds_tell_kinds_from_swatch_names` (vectorcraft-engine).
The Brushes panel menu's Select All Unused selects the brushes that are not used in the document, as the [Brushes](https://web.archive.org/web/20241230205225/https://helpx.adobe.com/illustrator/using/brushes.html) page (archived copy) describes. A brush counts as used when a stroke paints with it in the art (opacity masks included), in symbols, graph designs, pattern tiles or graphic styles, or in the art of a used brush (`brush.unused`).
A rename in Brush Options and Delete Brush change every stroke that paints with the brush: in the layers and opacity masks, symbols, graph designs, pattern tiles, graphic styles and the art of other brushes. A rename gives those strokes the new name, and Delete Brush makes them plain strokes, in one undo step.
A scatter, art or pattern brush dragged from the Brushes panel onto an empty part of the canvas places a copy of its art there to edit, as the [Modify brushes](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/apply-and-edit-strokes/modify-brushes.html) page describes (`brush.placeArt`). The copy is centered where it is dropped. A pattern brush comes out as its tiles in a row, 10 pt apart, each in a group named for its tile, with an unpainted rectangle at the back of a tile that has a repeat frame. The centering and the tile layout are VectorCraft's own rules. Evidence: `tests::brushsym::place_art_puts_a_copy_of_the_brush_art_where_it_is_dropped`, `tests::brushsym::pattern_brushes_place_their_tiles_in_a_row` (vectorcraft-engine), `canvas::tests::a_brush_with_art_dropped_off_the_art_places_a_copy_of_its_art_there` (vectorcraft-ui-egui).
@@ -1784,6 +1790,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
When the stroke of a path moved this way has a gradient along or across it, the renderer also draws the gradient from the slices it made before the move, moved by the same offset. It makes the slices again when the path is scaled, rotated or edited, and when the stroke or its gradient changes. The pixels are the same. On Windows at 1600 × 1000, the frame after a 1 pt nudge of an open path of 200,000 anchors takes 75 ms instead of 1,237 ms with the gradient along the stroke and 69 ms instead of 1,420 ms with it across, and with an open path of 50,000 anchors 22 ms instead of 313 ms and 21 ms instead of 352 ms (medians of five interleaved runs).
When an edit changes a 3D effect (Extrude & Bevel, Inflate, Rotate, Revolve), the canvas draws again where its art was and is, measured by that art: type and groups were measured by their letters or members, so a shallower or turned solid left pieces of the old one on the canvas. When the canvas draws the part on its own thread, it measures through its renderer and draws the part with the art it made to measure it. Exports and Object › Rasterize take the solid of 3D type, where they cropped it to the letters, and Fit to Artwork Bounds and per-artboard SVG export measure every artboard through one renderer, building each solid once unless the object has brushed strokes: 30 extruded type objects measured over 30 artboards take about 2 ms in a release build, where measuring their letters took under 1 ms. A document's first frame builds every 3D object's solid, off the view too, to know whether it reaches into the view.
When only anchors of a path or compound path move, the canvas draws again only around the segments that start or end at a moved anchor, grown by the farthest its strokes reach, instead of the whole object before and after. This holds while every fill and stroke is a solid color, and the strokes have no dashes, width profile, arrowheads or brush, and the object has no effects or opacity mask; any other object still counts whole. On a loaded Windows machine at 1600 × 1200, single-threaded in a development build, the frame after one anchor of a filled closed path moves takes 16.6 million CPU cycles instead of 56.4 million with 50,000 anchors and 65.6 million instead of 180.0 million with 200,000 anchors (medians of 15 edits, the two builds run in turn three times).
The check after an edit that a selected path or compound path stays within the canvas passes without measuring the path when every anchor and handle of it is within the canvas, and measures it only when one is not. Moving one anchor of a selected open path of 10,000 anchors (`path.moveAnchor`, `path.setHandle`, `path.moveAnchors` or a nudge) measured all 9,999 segments of the path and now measures at most 16 (counted in the engine's tests). The edit still copies the path's anchors for undo, and the renderer still compares every anchor of the path to find the moved ones.
Opening a document keeps the layouts it makes for its type objects, up to 128 MiB, and the first frame uses them instead of laying those objects out again. It does not keep a layout with bitmap or color glyphs or a text object with a gradient. The frame uses a layout only for a text object equal to the one laid out, and only while the fonts and the hyphenation exceptions have not changed. It uses each layout once. The renderer drops the rest when a frame that used one ends, and all of them after eight frames that use none. The frames of a threaded story are laid out while the file is read, and the first frame lays them out again. The pixels are the same. On Windows at 1600 × 1200, in medians of seven interleaved rounds of a local example, counted in the main thread's CPU cycles because other builds were running: with 5,000 point type objects in view the first frame takes 409 million cycles instead of 894 million and the open 816 million instead of 665 million, so the two together take 1,225 million instead of 1,559 million; with one area type object of 500 paragraphs the first frame takes 697 million instead of 1,193 million and the open 535 million instead of 568 million.
Type › Show Hidden Characters keeps the marks it places on each text object from one frame to the next. The canvas lays a text object out again when an edit changes it or its threaded story, or when the last frame that showed the marks did not draw it, and it lays out all type in view again when the fonts or the hyphenation exceptions change. With 1,000 two-line labels in view, drawing the marks takes 0.8 ms per frame in a release build instead of 19.7 ms.
A selection with more than 100,000 points to outline shows its bounds instead of each object's outline and anchors. Paths count their anchors. Area type and type on a path count the anchors of their frame or path, and point type counts six: its box's corners and the ends of its baseline marker. Images, symbol instances, placed documents, and area type or type on a path in perspective count the four corners of their box, and gradient meshes and envelopes count their points and the ends of their mesh lines. The hover highlight leaves out an object past that count, and such an object shows its bounds as the key object. With 32,768 type objects, images, symbol instances, gradient meshes or envelopes selected, the selection's outlines and anchors add fewer than 100 vertices to the canvas's mesh (#2460).