mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-17 09:36:45 +00:00
Task bar: the Recolor check stops at the first color
The Contextual Task Bar and the Control bar check, each time they are drawn, whether the selection holds a color that Recolor Artwork can change. The check walked the whole subtree of each selected object even after the first color, so with one large group selected, the check read every paint in the group. - Node::try_walk visits in walk's order and ends at a ControlFlow::Break. - swatches::node_has_colors stops at the first color node_colors would visit; node_colors now runs the same visitor without stopping, so the two read the same nodes and paints in the same order. - has_colors in the task bar uses node_has_colors. The result is the same for every selection. On one group of 100,000 paths, the check takes 16 ns instead of 14.5 ms when the first path is filled; when only the last path is filled, or none is, it costs about what the full walk costs.
This commit is contained in:
@@ -608,6 +608,18 @@ impl Node {
|
||||
}
|
||||
}
|
||||
|
||||
/// [`Self::walk`] that ends at the first node for which `f` returns [`std::ops::ControlFlow::Break`]: no
|
||||
/// node after it is visited, and the break is returned.
|
||||
pub fn try_walk<'a, B>(&'a self, f: &mut impl FnMut(&'a Node) -> std::ops::ControlFlow<B>) -> std::ops::ControlFlow<B> {
|
||||
f(self)?;
|
||||
if let Some(ch) = self.children() {
|
||||
for c in ch {
|
||||
c.try_walk(f)?;
|
||||
}
|
||||
}
|
||||
std::ops::ControlFlow::Continue(())
|
||||
}
|
||||
|
||||
/// Count of nodes in this subtree, ruler guides left out.
|
||||
pub fn count(&self) -> usize {
|
||||
let mut n = 0;
|
||||
|
||||
@@ -805,3 +805,31 @@ fn mapping_ruler_guide_positions_looks_at_each_child_of_nested_layers_once() {
|
||||
assert!(Arc::ptr_eq(&group.children().unwrap()[0], &twice));
|
||||
assert_eq!(calls, 0);
|
||||
}
|
||||
|
||||
/// `try_walk` visits in `walk`'s order and visits nothing after the node that breaks it: not its
|
||||
/// children, its later siblings or its ancestors' later siblings.
|
||||
#[test]
|
||||
fn try_walk_ends_at_the_break() {
|
||||
use std::ops::ControlFlow;
|
||||
let leaf = |id| Arc::new(Node::group(NodeId(id), vec![]));
|
||||
let inner = Node::group(NodeId(2), vec![leaf(3), leaf(4), leaf(5)]);
|
||||
let root = Node::group(NodeId(1), vec![Arc::new(inner), leaf(6), leaf(7)]);
|
||||
let mut all = vec![];
|
||||
root.walk(&mut |n| all.push(n.id));
|
||||
let mut seen = vec![];
|
||||
assert_eq!(
|
||||
root.try_walk(&mut |n| {
|
||||
seen.push(n.id);
|
||||
ControlFlow::<()>::Continue(())
|
||||
}),
|
||||
ControlFlow::Continue(())
|
||||
);
|
||||
assert_eq!(seen, all, "without a break it visits what walk visits, in the same order");
|
||||
seen.clear();
|
||||
let flow = root.try_walk(&mut |n| {
|
||||
seen.push(n.id);
|
||||
if n.id == NodeId(3) { ControlFlow::Break(n.id) } else { ControlFlow::Continue(()) }
|
||||
});
|
||||
assert_eq!(flow, ControlFlow::Break(NodeId(3)));
|
||||
assert_eq!(seen, [NodeId(1), NodeId(2), NodeId(3)]);
|
||||
}
|
||||
|
||||
+239
-5
@@ -8,6 +8,7 @@
|
||||
//! change; [`Document::map_paints`] replaces whole paints of any kind in the same places.
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::ops::ControlFlow;
|
||||
use std::sync::Arc;
|
||||
|
||||
use vectorcraft_color::swatch::REGISTRATION;
|
||||
@@ -340,18 +341,39 @@ fn map_style_paint(attrs: &mut serde_json::Map<String, serde_json::Value>, key:
|
||||
/// and gradient stops (with their link), a dynamic symbol instance's own paints
|
||||
/// ([`override_paints`]), then mesh points (unlinked), in paint order.
|
||||
pub fn node_colors(n: &Node, f: &mut dyn FnMut(&Color, Option<&str>)) {
|
||||
n.walk(&mut |m| {
|
||||
let _ = try_node_colors::<()>(n, &mut |c, s| {
|
||||
f(c, s);
|
||||
ControlFlow::Continue(())
|
||||
});
|
||||
}
|
||||
|
||||
/// Whether the subtree of `n` holds any color [`node_colors`] visits. It stops at the first one.
|
||||
pub fn node_has_colors(n: &Node) -> bool {
|
||||
try_node_colors(n, &mut |_, _| ControlFlow::Break(())).is_break()
|
||||
}
|
||||
|
||||
/// [`node_colors`] that ends at the first color for which `f` returns [`ControlFlow::Break`]: no
|
||||
/// paint or node after it is visited.
|
||||
fn try_node_colors<B>(n: &Node, f: &mut dyn FnMut(&Color, Option<&str>) -> ControlFlow<B>) -> ControlFlow<B> {
|
||||
n.try_walk(&mut |m| {
|
||||
for p in node_paints(m).chain(override_paints(m)) {
|
||||
match p {
|
||||
Paint::Solid { color, swatch, .. } => f(color, swatch.as_deref()),
|
||||
Paint::Gradient(g) => g.gradient.stops.iter().for_each(|s| f(&s.color, s.swatch.as_deref())),
|
||||
Paint::Solid { color, swatch, .. } => f(color, swatch.as_deref())?,
|
||||
Paint::Gradient(g) => {
|
||||
for s in &g.gradient.stops {
|
||||
f(&s.color, s.swatch.as_deref())?;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if let NodeKind::Mesh(mesh) = &m.kind {
|
||||
mesh.points.iter().for_each(|p| f(&p.color, None));
|
||||
for p in &mesh.points {
|
||||
f(&p.color, None)?;
|
||||
}
|
||||
}
|
||||
});
|
||||
ControlFlow::Continue(())
|
||||
})
|
||||
}
|
||||
|
||||
fn item_paint(it: &AppearanceItem) -> &Paint {
|
||||
@@ -821,4 +843,216 @@ mod tests {
|
||||
node_colors(d.node(b).unwrap(), &mut |c, s| colors.push((*c, s.map(str::to_string))));
|
||||
assert_eq!(colors, [(Color::rgb(1.0, 0.0, 0.0), None)]);
|
||||
}
|
||||
|
||||
/// The colors [`node_colors`] visits, in its order, by a [`Node::walk`] that reads the whole subtree.
|
||||
fn full_walk(n: &Node, f: &mut dyn FnMut(&Color, Option<&str>)) {
|
||||
n.walk(&mut |m| {
|
||||
for p in node_paints(m).chain(override_paints(m)) {
|
||||
match p {
|
||||
Paint::Solid { color, swatch, .. } => f(color, swatch.as_deref()),
|
||||
Paint::Gradient(g) => g.gradient.stops.iter().for_each(|s| f(&s.color, s.swatch.as_deref())),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if let NodeKind::Mesh(mesh) = &m.kind {
|
||||
mesh.points.iter().for_each(|p| f(&p.color, None));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Whether [`full_walk`] finds a color in `n`.
|
||||
fn full_walk_has_colors(n: &Node) -> bool {
|
||||
let mut found = false;
|
||||
full_walk(n, &mut |_, _| found = true);
|
||||
found
|
||||
}
|
||||
|
||||
/// The colors of `n` by [`full_walk`], in order.
|
||||
fn full_walk_colors(n: &Node) -> Vec<(Color, Option<String>)> {
|
||||
let mut out = vec![];
|
||||
full_walk(n, &mut |c, s| out.push((*c, s.map(str::to_string))));
|
||||
out
|
||||
}
|
||||
|
||||
fn square(id: u64, fill: Paint, stroke: Paint) -> Node {
|
||||
Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::basic(fill, stroke, 1.0))
|
||||
}
|
||||
|
||||
fn holder(id: u64, kind: fn(Vec<Arc<Node>>) -> NodeKind, children: Vec<Node>) -> Node {
|
||||
Node::new(NodeId(id), kind(children.into_iter().map(Arc::new).collect()))
|
||||
}
|
||||
|
||||
/// One node of each kind of paint [`node_colors`] reads or skips, with whether it shows a color.
|
||||
fn color_cases() -> Vec<(&'static str, Node, bool)> {
|
||||
let red = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
|
||||
let gradient = |stops: usize| {
|
||||
let mut g = vectorcraft_color::Gradient::default();
|
||||
g.stops.truncate(stops);
|
||||
Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(g)))
|
||||
};
|
||||
let pattern = Paint::Pattern { pattern: "Dots".into(), xf: vectorcraft_geom::Affine::IDENTITY };
|
||||
let area = shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0));
|
||||
let mesh = crate::GradientMesh::for_path_with(&area, 2, 2, &|_| (Color::BLACK, 1.0)).unwrap();
|
||||
let mut empty_mesh = mesh.clone();
|
||||
empty_mesh.points.clear();
|
||||
let text = |fill: Paint| {
|
||||
let style = crate::CharStyle { fill, stroke: Paint::None, ..Default::default() };
|
||||
let mut n =
|
||||
Node::new(NodeId(20), NodeKind::Text(Box::new(crate::TextObject::point(vectorcraft_geom::Point::new(0.0, 0.0), "Hi", style))));
|
||||
n.appearance = Appearance::basic(Paint::None, Paint::None, 0.0).into();
|
||||
n
|
||||
};
|
||||
let image = |colorize: Option<Paint>| {
|
||||
let im = crate::ImageObject {
|
||||
key: "k".into(),
|
||||
width: 2,
|
||||
height: 2,
|
||||
xf: vectorcraft_geom::Affine::IDENTITY,
|
||||
link: None,
|
||||
placement: Default::default(),
|
||||
pixels: None,
|
||||
};
|
||||
let mut n = Node::new(NodeId(21), NodeKind::Image(Box::new(im)));
|
||||
n.appearance = Appearance::basic(Paint::None, Paint::None, 0.0).into();
|
||||
n.extras_mut().colorize = colorize.map(Box::new);
|
||||
n
|
||||
};
|
||||
let overridden = |fill: Option<Paint>| {
|
||||
let mut n = square(22, Paint::None, Paint::None);
|
||||
n.extras_mut().symbol_overrides = vec![crate::SymbolOverride { path: vec![0], fill, ..Default::default() }];
|
||||
n
|
||||
};
|
||||
let masked = {
|
||||
let mut n = square(23, Paint::None, Paint::None);
|
||||
n.extras_mut().mask = Some(Box::new(crate::OpacityMask::new(square(24, red.clone(), Paint::None), true)));
|
||||
n
|
||||
};
|
||||
let group = |children| NodeKind::Group { children, clip: false };
|
||||
let clip = |children| NodeKind::Group { children, clip: true };
|
||||
let compound = |children| NodeKind::Compound { children, rule: Default::default() };
|
||||
let blend = |children| NodeKind::Blend { children, spec: Default::default() };
|
||||
let blank = |id| square(id, Paint::None, Paint::None);
|
||||
vec![
|
||||
("no paint", blank(1), false),
|
||||
("solid fill", square(2, red.clone(), Paint::None), true),
|
||||
("solid stroke", square(3, Paint::None, red.clone()), true),
|
||||
("pattern only", square(4, pattern.clone(), pattern.clone()), false),
|
||||
("gradient without stops", square(5, gradient(0), Paint::None), false),
|
||||
("gradient with stops", square(6, gradient(2), Paint::None), true),
|
||||
("mesh with points", Node::new(NodeId(7), NodeKind::Mesh(mesh)), true),
|
||||
("mesh without points", Node::new(NodeId(8), NodeKind::Mesh(empty_mesh)), false),
|
||||
("text run fill", text(red.clone()), true),
|
||||
("text without paint", text(Paint::None), false),
|
||||
("image colorize", image(Some(red.clone())), true),
|
||||
("image without colorize", image(None), false),
|
||||
("image with a pattern colorize", image(Some(pattern.clone())), false),
|
||||
("symbol override fill", overridden(Some(red.clone())), true),
|
||||
("symbol override without paint", overridden(None), false),
|
||||
("color only in the opacity mask", masked, false),
|
||||
("group, color first", holder(30, group, vec![square(31, red.clone(), Paint::None), blank(32), blank(33)]), true),
|
||||
("group, color last", holder(34, group, vec![blank(35), blank(36), square(37, red.clone(), Paint::None)]), true),
|
||||
("group without color", holder(38, group, vec![blank(39), blank(40)]), false),
|
||||
("clip group", holder(41, clip, vec![blank(42), square(43, red.clone(), Paint::None)]), true),
|
||||
("compound shape", holder(44, compound, vec![blank(45), square(46, gradient(3), Paint::None)]), true),
|
||||
("blend", holder(47, blend, vec![blank(48), blank(49)]), false),
|
||||
(
|
||||
"nested groups, color deepest",
|
||||
holder(50, group, vec![blank(51), holder(52, group, vec![holder(53, group, vec![blank(54), square(55, red.clone(), Paint::None)])])]),
|
||||
true,
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn has_colors_matches_the_full_walk() {
|
||||
for (label, n, expected) in color_cases() {
|
||||
let all = full_walk_colors(&n);
|
||||
assert_eq!(node_has_colors(&n), full_walk_has_colors(&n), "{label}");
|
||||
assert_eq!(full_walk_has_colors(&n), !all.is_empty(), "{label}");
|
||||
assert_eq!(node_has_colors(&n), expected, "{label}");
|
||||
let mut listed = vec![];
|
||||
node_colors(&n, &mut |c, s| listed.push((*c, s.map(str::to_string))));
|
||||
assert_eq!(listed, all, "{label}: node_colors lists the same colors in the same order");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn has_colors_stops_at_the_first_color() {
|
||||
let red = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
|
||||
let mut stops = vectorcraft_color::Gradient::default();
|
||||
stops.stops.push(stops.stops[0].clone());
|
||||
let gradient = Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(stops)));
|
||||
let mut later = vec![square(2, gradient, red.clone())];
|
||||
later.extend((3..100).map(|id| square(id, red.clone(), red.clone())));
|
||||
let n = holder(1, |children| NodeKind::Group { children, clip: false }, later);
|
||||
let (mut colors, mut nodes) = (0, 0);
|
||||
let flow = try_node_colors(&n, &mut |_, _| {
|
||||
colors += 1;
|
||||
ControlFlow::Break(())
|
||||
});
|
||||
assert!(flow.is_break());
|
||||
assert_eq!(colors, 1, "the first gradient stop ends the walk: no later stop, stroke or object is read");
|
||||
let flow = n.try_walk(&mut |m| {
|
||||
nodes += 1;
|
||||
if node_paints(m).next().is_some() { ControlFlow::Break(()) } else { ControlFlow::Continue(()) }
|
||||
});
|
||||
assert!(flow.is_break());
|
||||
assert_eq!(nodes, 2, "the group, then its first member: none of the 97 after it");
|
||||
}
|
||||
|
||||
/// Times [`node_has_colors`] against the full walk it replaces on one group of 100,000 paths, alternating the two in
|
||||
/// one process: `cargo test --release -p vectorcraft-doc --lib -- --ignored --nocapture has_colors_timing`.
|
||||
#[test]
|
||||
#[ignore = "a timing, not a check"]
|
||||
fn has_colors_timing() {
|
||||
/// This thread's CPU time in nanoseconds on Linux; the elapsed time since `start` elsewhere.
|
||||
fn clock(start: std::time::Instant) -> u128 {
|
||||
let cpu = std::fs::read_to_string("/proc/thread-self/schedstat").ok();
|
||||
cpu.and_then(|s| s.split_whitespace().next()?.parse().ok()).unwrap_or_else(|| start.elapsed().as_nanos())
|
||||
}
|
||||
let red = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
|
||||
let count = 100_000u64;
|
||||
let group = |colored: &dyn Fn(u64) -> bool| {
|
||||
let children =
|
||||
(0..count).map(|i| if colored(i) { square(i + 1, red.clone(), Paint::None) } else { square(i + 1, Paint::None, Paint::None) });
|
||||
holder(0, |children| NodeKind::Group { children, clip: false }, children.collect())
|
||||
};
|
||||
let cases = [
|
||||
("every path filled", group(&|_| true)),
|
||||
("only the last path filled", group(&|i| i == count - 1)),
|
||||
("no path filled", group(&|_| false)),
|
||||
];
|
||||
let start = std::time::Instant::now();
|
||||
println!("clock: {}", if std::fs::metadata("/proc/thread-self/schedstat").is_ok() { "thread CPU time" } else { "wall clock" });
|
||||
// The time per call of `f` on `n`: batches of calls double until one takes at least 100 ms.
|
||||
let per_call = |f: fn(&Node) -> bool, n: &Node| {
|
||||
let mut calls = 1u32;
|
||||
loop {
|
||||
let t = clock(start);
|
||||
for _ in 0..calls {
|
||||
std::hint::black_box(f(std::hint::black_box(n)));
|
||||
}
|
||||
let spent = clock(start) - t;
|
||||
if spent >= 100_000_000 || calls >= 1 << 30 {
|
||||
return (spent as f64 / f64::from(calls), calls);
|
||||
}
|
||||
calls *= 2;
|
||||
}
|
||||
};
|
||||
for (label, n) in &cases {
|
||||
assert_eq!(full_walk_has_colors(n), node_has_colors(n), "{label}");
|
||||
let (mut old, mut new) = (vec![], vec![]);
|
||||
for _ in 0..7 {
|
||||
old.push(per_call(full_walk_has_colors, n));
|
||||
new.push(per_call(node_has_colors, n));
|
||||
}
|
||||
old.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||||
new.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||||
let (o, nw) = (old[3], new[3]);
|
||||
println!(
|
||||
"{label}: full walk {:.1} ns per call ({} calls), node_has_colors {:.1} ns per call ({} calls), median of 7 runs",
|
||||
o.0, o.1, nw.0, nw.1
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,11 +22,7 @@ pub(crate) fn task_bar_shows_fonts(ctx: &egui::Context) -> bool {
|
||||
/// Whether the objects `ids` (or anything inside them) are painted with a colour: a solid colour,
|
||||
/// a gradient's stops or a mesh's points, which Recolor Artwork can change.
|
||||
pub(crate) fn has_colors(doc: &vectorcraft_doc::Document, ids: &[vectorcraft_doc::NodeId]) -> bool {
|
||||
ids.iter().filter_map(|id| doc.node(*id)).any(|n| {
|
||||
let mut found = false;
|
||||
vectorcraft_doc::swatches::node_colors(n, &mut |_, _| found = true);
|
||||
found
|
||||
})
|
||||
ids.iter().filter_map(|id| doc.node(*id)).any(vectorcraft_doc::swatches::node_has_colors)
|
||||
}
|
||||
|
||||
/// The bounds of the artboards the Artboard tool has selected ([`crate::panels::artboards::picked`]).
|
||||
|
||||
@@ -11045,6 +11045,28 @@ fn the_task_bar_recolors_coloured_art() {
|
||||
assert!(app.ui.dialog.is_none(), "no Recolor button without colours");
|
||||
}
|
||||
|
||||
/// Recolor Artwork shows in the bars when any selected object has a color, whichever of them it is,
|
||||
/// and not for an empty selection or ids that are gone.
|
||||
#[test]
|
||||
fn has_colors_looks_at_every_selected_object() {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
||||
let mut rect = |x: i32| {
|
||||
vectorcraft_doc::NodeId(s.execute("shape.rectangle", &json!({"x": x, "y": 10, "width": 40, "height": 40})).unwrap()["id"].as_u64().unwrap())
|
||||
};
|
||||
let (blank, colored) = (rect(10), rect(80));
|
||||
s.execute("paint.setFill", &json!({"ids": [blank.0], "none": true})).unwrap();
|
||||
s.execute("paint.setStroke", &json!({"ids": [blank.0], "none": true})).unwrap();
|
||||
s.execute("paint.setFill", &json!({"ids": [colored.0], "color": "#cc3322"})).unwrap();
|
||||
let doc = &s.active().unwrap().doc;
|
||||
let gone = vectorcraft_doc::NodeId(u64::MAX);
|
||||
assert!(!has_colors(doc, &[]), "nothing selected");
|
||||
assert!(!has_colors(doc, &[gone]), "an id that is gone");
|
||||
assert!(!has_colors(doc, &[blank, gone]));
|
||||
assert!(has_colors(doc, &[blank, colored]), "the color is on the second object");
|
||||
assert!(has_colors(doc, &[colored, blank, gone]), "the color is on the first object");
|
||||
}
|
||||
|
||||
/// The Contextual Task Bar's Lock button locks the selected member in isolation mode and the
|
||||
/// selected group outside isolation mode.
|
||||
#[test]
|
||||
|
||||
Reference in New Issue
Block a user