VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Select: Same commands for paint, appearance and shape select compound paths
dotCooCooa272d49ea7e9
diff --git a/crates/engine/src/cmd/select.rs b/crates/engine/src/cmd/select.rsindex 8a7d220e3..6d8d7c4a5 100644--- a/crates/engine/src/cmd/select.rs+++ b/crates/engine/src/cmd/select.rs@@ -8,6 +8,7 @@ use vectorcraft_doc::{Document, Node, NodeId, NodeKind};use super::wand::{fill_of, stroke_of};use super::*;+use crate::DocState;pub fn specs() -> Vec<CommandSpec> {vec![@@ -663,10 +664,27 @@ fn paint_reported(d: &Document, n: &Node) -> bool {compound(n) || (!n.is_container() && !d.parent_of(n.id).and_then(|p| d.node(p)).is_some_and(compound))}+/// The object Select > Same compares the others with, and whether isolation mode is inside a+/// compound path. The object is the first selected one, or its compound path when it is a member+/// of one; in isolation mode inside a compound path it is the member path itself.+fn same_reference<'a>(st: &'a DocState, cmd: &str) -> Result<(&'a Node, bool)> {+ let compound = |n: &Node| matches!(n.kind, NodeKind::Compound { .. });+ let members = st.isolation.and_then(|i| st.doc.ancestry(i)).is_some_and(|a| a.iter().any(|i| st.doc.node(*i).is_some_and(compound)));+ let first = st.selection.objects.first().and_then(|id| st.doc.node(*id)).ok_or_else(|| bad(cmd, "nothing selected"))?;+ let refn = match st.doc.parent_of(first.id).and_then(|p| st.doc.node(p)) {+ Some(p) if !members && compound(p) => p,+ _ => first,+ };+ Ok((refn, members))+}++/// Select > Same: the objects `eq` matches with the object [`same_reference`] returns, among those+/// [`paint_reported`] accepts. A compound path matches as a whole. In isolation mode inside a+/// compound path, its member paths are matched instead.fn same(s: &mut Session, cmd: &str, eq: impl Fn(&Node, &Node) -> bool) -> Result<Value> {- let st = s.doc()?;- let refn = st.selection.objects.first().and_then(|id| st.doc.node(*id)).cloned().ok_or_else(|| bad(cmd, "nothing selected"))?;- select_where(s, cmd, &json!({}), |_, n| !n.is_container() && eq(n, &refn))+ let (refn, members) = same_reference(s.doc()?, cmd)?;+ let refn = refn.clone();+ select_where(s, cmd, &json!({}), |d, n| (if members { !n.is_container() } else { paint_reported(d, n) }) && eq(n, &refn))}/// Select the objects [`walk_selectable`] visits that `f` accepts (not looking inside accepted@@ -690,13 +708,8 @@ fn select_where(s: &mut Session, cmd: &str, p: &Value, f: impl Fn(&Document, &Nofn same_graphic_style(s: &mut Session, _: &Value) -> Result<Value> {let cmd = "select.same.graphicStyle";let st = s.doc()?;- let id = st- .selection- .objects- .first()- .and_then(|id| super::style::linked_style(&st.doc, st.doc.node(*id)?))- .map(|g| g.id)- .ok_or_else(|| bad(cmd, "the selection has no graphic style"))?;+ let (refn, _) = same_reference(st, cmd)?;+ let id = super::style::linked_style(&st.doc, refn).map(|g| g.id).ok_or_else(|| bad(cmd, "the selection has no graphic style"))?;select_where(s, cmd, &json!({}), |d, n| n.extras().graphic_style == Some(id) && super::style::linked_style(d, n).is_some())}@@ -709,7 +722,7 @@ enum Attribute {fn same_attribute(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "select.same.appearanceAttribute";let st = s.doc()?;- let refn = st.selection.objects.first().and_then(|id| st.doc.node(*id)).ok_or_else(|| bad(cmd, "nothing selected"))?;+ let (refn, _) = same_reference(st, cmd)?;let ap = &refn.appearance;let item = p.get("item").and_then(Value::as_u64).map(index).or(s.appearance_item());let attr = match (item.and_then(|i| ap.items.get(i)), ap.effects.first()) {diff --git a/crates/engine/src/tests_menucmds.rs b/crates/engine/src/tests_menucmds.rsindex c0fb6de45..8e57771b0 100644--- a/crates/engine/src/tests_menucmds.rs+++ b/crates/engine/src/tests_menucmds.rs@@ -1303,6 +1303,40 @@ fn select_same_paint_reads_type_characters() {assert_eq!(same(&mut s, t1, "select.same.fillAndStroke"), vec![t1, r]);}+/// Select > Same matches a compound path on its own paint, as a whole: never its member paths.+/// When a member path is selected first, the other objects are compared with its compound path.+#[test]+fn select_same_matches_compound_paths_on_their_own_paint() {+ let mut s = session();+ let [a, b] = [0.0, 20.0].map(|x| rect(&mut s, x, 0.0, 10.0, 10.0));+ let outer = rect(&mut s, 100.0, 0.0, 50.0, 50.0);+ let inner = rect(&mut s, 110.0, 10.0, 20.0, 20.0);+ let r = rect(&mut s, 40.0, 0.0, 10.0, 10.0);+ for id in [a, b, outer, inner] {+ fill(&mut s, id, "#000000");+ }+ fill(&mut s, r, "#ff0000");+ sel(&mut s, &[outer, inner]);+ let c = id_of(&s.execute("object.compoundPath.make", &json!({})).unwrap());+ let same = |s: &mut Session, from: NodeId, cmd: &str| {+ sel(s, &[from]);+ s.execute(cmd, &json!({})).unwrap();+ let mut v = selected(s);+ v.sort();+ v+ };+ for from in [a, c, outer] {+ assert_eq!(same(&mut s, from, "select.same.fillColor"), vec![a, b, c], "from {from:?}");+ }+ assert_eq!(same(&mut s, inner, "select.same.shapeType"), vec![c]);+ fill(&mut s, c, "#ff0000");+ assert_eq!(same(&mut s, a, "select.same.fillColor"), vec![a, b]);+ assert_eq!(same(&mut s, r, "select.same.fillColor"), vec![r, c]);+ // Isolated in the compound path, its member paths are the objects to match.+ s.execute("object.isolate", &json!({"id": c.0})).unwrap();+ assert_eq!(same(&mut s, outer, "select.same.shapeType"), vec![outer, inner]);+}+/// Select by Color needs no object to start from: it matches fills and strokes as/// `document.inspect` reports them, `#rrggbb`.#[test]diff --git a/crates/engine/src/tests_styles.rs b/crates/engine/src/tests_styles.rsindex 1b464d564..2a8a379c8 100644--- a/crates/engine/src/tests_styles.rs+++ b/crates/engine/src/tests_styles.rs@@ -256,6 +256,36 @@ fn select_same_appearance_attribute() {assert_eq!(s.doc().unwrap().selection.objects, vec![a, b]);}+/// With a member path of a compound path selected first, Select > Same > Graphic Style and+/// Appearance Attribute compare the other objects with the compound path, except in isolation mode+/// inside it.+#[test]+fn select_same_style_and_attribute_from_a_compound_path_member() {+ let mut s = session();+ let a = rect(&mut s, 10.0);+ set_fill(&mut s, a, "#ff0000");+ run(&mut s, "effect.apply", json!({"effect": "distort.roughen"}));+ run(&mut s, "graphicStyle.new", json!({"name": "Rough"}));+ run(&mut s, "graphicStyle.apply", json!({"name": "Rough"}));+ let outer = rect(&mut s, 100.0);+ let inner = rect(&mut s, 120.0);+ run(&mut s, "select.set", json!({"ids": [outer.0, inner.0]}));+ let c = NodeId(run(&mut s, "object.compoundPath.make", json!({}))["id"].as_u64().unwrap());+ run(&mut s, "graphicStyle.apply", json!({"name": "Rough"}));+ rect(&mut s, 300.0);+ for cmd in ["select.same.graphicStyle", "select.same.appearanceAttribute"] {+ for from in [c, outer] {+ run(&mut s, "select.set", json!({"ids": [from.0]}));+ run(&mut s, cmd, json!({}));+ assert_eq!(s.doc().unwrap().selection.objects, vec![a, c], "{cmd} from {from:?}");+ }+ }+ // Isolated in the compound path, its member paths are compared, and they carry no style.+ run(&mut s, "object.isolate", json!({"id": c.0}));+ run(&mut s, "select.set", json!({"ids": [outer.0]}));+ assert!(s.execute("select.same.graphicStyle", &json!({})).is_err());+}+#[test]fn document_info_lists_style_names() {let mut s = session();