diff --git a/crates/engine/src/cmd/clipboard/resources.rs b/crates/engine/src/cmd/clipboard/resources.rs index de626e514b..ab99a0f1e4 100644 --- a/crates/engine/src/cmd/clipboard/resources.rs +++ b/crates/engine/src/cmd/clipboard/resources.rs @@ -762,6 +762,22 @@ fn same_art(r: &Relink, ours: &[Arc], theirs: &[Arc]) -> bool { ours.len() == theirs.len() && ours.iter().zip(theirs).all(|(a, b)| relinked(&unlinked, a) == relinked(r, b)) } +/// `n` with the ids of its objects, those of opacity-mask art included, all 0: art drawn again +/// compares equal to art drawn the same way, whatever ids each drawing gave it. +fn without_ids(n: &Node) -> Node { + let mut n = n.clone(); + n.id = vectorcraft_doc::NodeId(0); + if let Some(mask) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()) { + mask.art = Arc::new(without_ids(&mask.art)); + } + if let Some(children) = n.children_mut() { + for c in children.iter_mut() { + *c = Arc::new(without_ids(c)); + } + } + n +} + /// Is `ours` (a document brush) brush `theirs` (a pasted one) once the art of that is relinked by /// `r`? Graphic style links don't count, as in [`same_art`]. fn same_brush(r: &Relink, ours: &Brush, theirs: &Brush) -> bool { @@ -1051,6 +1067,8 @@ pub(crate) struct Imported { /// The names of the symbols added to the document, whose art may hold graphs that draw with /// [`Self::kept_designs`]. pub added_symbols: BTreeSet, + /// The names of the graph designs added to the document. + pub added_designs: BTreeSet, /// The global and spot colors that took the document's color (merged). merged_swatches: BTreeSet, } @@ -1275,11 +1293,18 @@ impl Clipboard { .collect(), None => HashMap::new(), }; + // A symbol whose graphs the paste draws again with the document's designs is + // also the document's one that holds its art drawn that way (an earlier paste + // added it). + let redrawn = (!fresh && d.symbols.iter().any(|s| copy_of(&def.name, &s.name))) + .then(|| self.redrawn_art(d, &def.art, &out.relink)) + .flatten(); let r = &out.relink; let p = place(&mut d.symbols, def, same_doc, |a, b| { !fresh && options.is_none_or(|o| theirs.get(&a.name) == Some(o)) - && same_art(r, std::slice::from_ref(&a.art), std::slice::from_ref(&b.art)) + && (same_art(r, std::slice::from_ref(&a.art), std::slice::from_ref(&b.art)) + || redrawn.as_ref().is_some_and(|art| without_ids(&a.art) == *art)) }); if let Some(name) = p.new_name(&def.name) { if let Some(o) = options { @@ -1499,6 +1524,27 @@ impl Clipboard { } } + /// Symbol art `art` relinked by `relink` with its graphs drawn again with the designs `d` holds + /// under a name whose design the clipboard lacks or holds with other art, as a paste that adds + /// the symbol draws it, its ids left out ([`without_ids`]). `None` when no graph of it draws + /// with such a design. + fn redrawn_art(&self, d: &mut Document, art: &Arc, relink: &Relink) -> Option { + let theirs = |n: &str| self.graph_designs.iter().find(|g| g.name == n); + let differs: BTreeSet = d + .graph_designs + .iter() + .filter(|x| theirs(&x.name).is_none_or(|g| !Arc::ptr_eq(&g.art, &x.art) && g.art != x.art)) + .map(|x| x.name.clone()) + .collect(); + if differs.is_empty() || !crate::cmd::graph::holds_designs(art, &differs) { + return None; + } + let mut n = (**art).clone(); + relink.node(&mut n); + crate::cmd::graph::redraw_detached(d, &mut n, &differs); + Some(without_ids(&n)) + } + /// Graph designs: the document's design of a name stays as it is and the pasted graphs draw /// with it ([`Imported::kept_designs`]); a design the document lacks is added under its name, its art following the /// resources placed above, with fresh ids. Called once every other resource is placed. @@ -1538,6 +1584,7 @@ impl Clipboard { let art = d.reid(&art); d.graph_designs.push(GraphDesign { name: g.name.clone(), art: Arc::new(art) }); out.placed(Res::GraphDesign, &g.name, &Placed::Added); + out.added_designs.insert(g.name.clone()); } Ok(()) } @@ -1632,15 +1679,16 @@ pub(crate) fn graph_design_library(src: &Document) -> Option { /// Add graph designs `names` of `src` to `d`, with the swatches, patterns, symbols, styles, /// brushes and images their art uses, placed as Paste places them ([`Clipboard::import_into`]; a /// global or spot color whose name `d` gives another color is `d`'s). A design `d` has under the -/// same name stays as it is. → each name, and whether its design was added. An error, with `d` -/// unchanged, when `d` would hold more than [`GraphDesign::MAX`] designs. -pub(crate) fn import_graph_designs(src: &Document, d: &mut Document, names: &[String]) -> Result> { +/// same name stays as it is, and the art of `src`'s design of that name is not followed. → the +/// names of the designs added: those of `names` `d` lacked, and those their art uses. An error, +/// with `d` unchanged, when `d` would hold more than [`GraphDesign::MAX`] designs. +pub(crate) fn import_graph_designs(src: &Document, d: &mut Document, names: &[String]) -> Result> { let library = OnceCell::new(); - let used = designs_used(&Defs::of(src, &library), names); + let held = |n: &str| d.graph_designs.iter().any(|x| x.name == n); + let followed: Vec = src.graph_designs.iter().filter(|g| names.contains(&g.name) || !held(&g.name)).cloned().collect(); + let used = designs_used(&Defs { graph_designs: &followed, ..Defs::of(src, &library) }, names); let clip = Clipboard::with_used(src, &used, &library, vec![]); - let before: HashSet = d.graph_designs.iter().map(|g| g.name.clone()).collect(); - clip.import_used(d, &used, &SwatchChoices::default(), false)?; - Ok(names.iter().map(|n| (n.clone(), !before.contains(n))).collect()) + Ok(clip.import_used(d, &used, &SwatchChoices::default(), false)?.added_designs) } /// Swatch `w` in `d` ([`existing`]), else added under a free name (swatches and colour groups diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index b707a8367a..259bcc48a8 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -1625,6 +1625,11 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho super::graph::redraw_with_designs(d, &new_ids, &imported.kept_designs)?; super::graph::redraw_symbols_with_designs(d, &imported.added_symbols, &imported.kept_designs); } + // The graphs already in the document that draw with a design the paste added are drawn + // again with it; the pasted ones already draw with it. + if !imported.added_designs.is_empty() { + super::graph::refresh_graphs(d, &imported.added_designs, &new_ids, &imported.added_symbols)?; + } sel.set(new_ids.iter().copied()); // Copied ruler guides (#3226): on the layer new art goes to, moved as the objects are (a // paste of guides alone keeps them where they were, but onto another artboard or every diff --git a/crates/engine/src/cmd/graph.rs b/crates/engine/src/cmd/graph.rs index 13c34deb28..06fb062e50 100644 --- a/crates/engine/src/cmd/graph.rs +++ b/crates/engine/src/cmd/graph.rs @@ -41,7 +41,7 @@ pub use data::{MAX_GRAPH_DATA_FILE, graph_cell_text, graph_data_from_grid, graph pub(crate) use data::{apply_csv, graph_csv_from_file, parse_csv}; #[cfg(test)] use data::{fmt_value, to_csv}; -pub(crate) use designs::{redraw_symbols_with_designs, redraw_with_designs}; +pub(crate) use designs::{holds_designs, redraw_detached, redraw_symbols_with_designs, redraw_with_designs, refresh_graphs}; pub use edit::{GraphTypeSubject, graph_type_subject}; pub(crate) use edit::{edit_graph_art, graphs_holding, keep_placed}; pub use generate::calculated_axes; diff --git a/crates/engine/src/cmd/graph/designs.rs b/crates/engine/src/cmd/graph/designs.rs index 1b7d89a8c5..d0807df3f1 100644 --- a/crates/engine/src/cmd/graph/designs.rs +++ b/crates/engine/src/cmd/graph/designs.rs @@ -1,5 +1,7 @@ use super::edit::{regenerate, regenerate_detached}; -use super::{Arc, Document, GraphDesign, GraphSpec, Node, Result, Session, Value, bad, json, ok, str_param}; +use std::collections::BTreeSet; + +use super::{Arc, Document, GraphDesign, GraphKind, GraphSpec, Node, Result, Session, Value, bad, json, ok, str_param}; use crate::cmd::clipboard::resources::import_graph_designs; use crate::cmd::swatchlib::{concealed_library_id, shown_library_id}; @@ -57,12 +59,11 @@ pub(super) fn from_library(s: &Session, p: &Value, cmd: &str) -> Result Result<()> { - for (name, added) in import_graph_designs(lib, d, names)? { - if added { - refresh_graphs_using(d, &name)?; - } + let added = import_graph_designs(lib, d, names)?; + if !added.is_empty() { + refresh_graphs(d, &added, &[], &BTreeSet::new())?; } Ok(()) } @@ -78,21 +79,58 @@ pub(super) fn bring_in_for(d: &mut Document, lib: &Document, name: &str, id: sup Ok(()) } -/// Whether graph `g` draws a series with design `name`, as its marker or its columns. +/// Whether graph `g` draws a series with design `name`: as the marker of a series drawn with +/// markers (every series of a scatter or radar graph, and line series) while Mark Data Points is +/// on or the legend has an entry for the series, or as the columns of a series drawn as columns or +/// bars. fn draws_with(g: &GraphSpec, name: &str) -> bool { + let scatter = g.kind == GraphKind::Scatter; + let nser = g.rows.iter().map(Vec::len).max().unwrap_or(0).clamp(1, vectorcraft_doc::MAX_GRAPH_SERIES); + // The legend draws entry `s` with marker design `s`, and leaves out an entry whose label is blank + // (a scatter graph's entries are its pairs of series, labeled by the first of each pair). + let in_legend = |s: usize| { + let entries = if scatter { nser.div_ceil(2) } else { nser }; + let label = g.series.get(if scatter { s * 2 } else { s }).map_or("", String::as_str); + g.legend && !g.series.is_empty() && s < entries && !super::labels::blank_label(label) + }; + let shown = |s: usize| g.mark_points || in_legend(s); + let marked = |s: usize| shown(s) && (matches!(g.kind, GraphKind::Scatter | GraphKind::Radar) || g.series_kind(s) == GraphKind::Line); + let columnar = |s: usize| matches!(g.series_kind(s), GraphKind::Column | GraphKind::StackedColumn | GraphKind::Bar | GraphKind::StackedBar); + g.series_markers.iter().enumerate().any(|(s, m)| m.as_deref() == Some(name) && marked(s)) + || g.series_columns.iter().enumerate().any(|(s, c)| c.as_ref().is_some_and(|c| c.design == name) && columnar(s)) +} + +/// Whether graph `g` names design `name` for a series, as its marker or its columns, whether or +/// not the series draws with it. +fn names_design(g: &GraphSpec, name: &str) -> bool { g.series_markers.iter().flatten().any(|m| m == name) || g.series_columns.iter().flatten().any(|c| c.design == name) } /// Regenerate the graphs whose series use design `name` (it was added or removed), in the layers, /// in opacity-mask art and in symbols' art. fn refresh_graphs_using(d: &mut Document, name: &str) -> Result<()> { - let names = std::collections::BTreeSet::from([name.to_string()]); + refresh_graphs(d, &BTreeSet::from([name.to_string()]), &[], &BTreeSet::new()) +} + +/// Regenerate the graphs that draw a series with one of the designs `names`, in the layers, in +/// opacity-mask art and in symbols' art, except those in the subtrees of `skip` and in the art of +/// symbols `skip_symbols`. +pub(crate) fn refresh_graphs(d: &mut Document, names: &BTreeSet, skip: &[super::NodeId], skip_symbols: &BTreeSet) -> Result<()> { + let mut skipped = std::collections::HashSet::new(); + for n in skip.iter().filter_map(|id| d.node(*id)) { + n.walk(&mut |m| { + skipped.insert(m.id); + }); + } let (mut ids, mut masked) = (vec![], vec![]); d.walk(|n| { - if n.extras().graph.as_deref().is_some_and(|g| draws_with(g, name)) { + if skipped.contains(&n.id) { + return; + } + if n.extras().graph.as_deref().is_some_and(|g| names.iter().any(|name| draws_with(g, name))) { ids.push(n.id); } - if n.extras().mask.as_deref().is_some_and(|m| holds(&m.art, &names)) { + if n.extras().mask.as_deref().is_some_and(|m| holds(&m.art, names)) { masked.push(n.id); } }); @@ -104,17 +142,31 @@ fn refresh_graphs_using(d: &mut Document, name: &str) -> Result<()> { // The graphs in objects' opacity-mask art. for id in masked { let Some(mut art) = d.node(id).and_then(|n| n.extras().mask.as_deref()).map(|m| (*m.art).clone()) else { continue }; - redraw_in(d, &mut art, &names); + redraw_in(d, &mut art, names); if let Some(mask) = d.node_mut(id).and_then(|n| n.extras_if_any()).and_then(|e| e.mask.as_deref_mut()) { mask.art = Arc::new(art); } } // And the graphs in symbols' art, which instances draw. - let symbols: std::collections::BTreeSet = d.symbols.iter().map(|s| s.name.clone()).collect(); - redraw_symbols_with_designs(d, &symbols, &names); + let symbols: BTreeSet = d.symbols.iter().map(|s| s.name.clone()).filter(|s| !skip_symbols.contains(s)).collect(); + redraw_symbols_with_designs(d, &symbols, names); Ok(()) } +/// [`redraw_in`] for the clipboard: graph art `n`, outside the document, drawn again with `d`'s +/// designs `names`. +pub(crate) fn redraw_detached(d: &mut Document, n: &mut Node, names: &BTreeSet) { + if holds(n, names) { + redraw_in(d, n, names); + } +} + +/// Whether `n`'s subtree, the art of opacity masks included, holds a graph that draws a series +/// with one of the designs `names`. +pub(crate) fn holds_designs(n: &Node, names: &BTreeSet) -> bool { + holds(n, names) +} + /// Draw the graphs in the subtrees of `ids` again that draw a series with one of the designs /// `names`: pasted graphs, after the paste kept the document's own designs of those names. pub(crate) fn redraw_with_designs(d: &mut Document, ids: &[super::NodeId], names: &std::collections::BTreeSet) -> Result<()> { @@ -177,18 +229,57 @@ fn redraw_in(d: &mut Document, n: &mut Node, names: &std::collections::BTreeSet< } } -/// The designs no graph's series draw with (Select Unused). +/// The designs no graph's series draw with (Select Unused): graphs in the layers, in opacity-mask +/// art and in symbols' art count. fn unused_designs(d: &Document) -> Vec { let mut used = std::collections::HashSet::new(); - d.walk(|n| { + let mut note = |n: &Node| { if let Some(g) = n.extras().graph.as_deref() { used.extend(g.series_markers.iter().flatten().cloned()); used.extend(g.series_columns.iter().flatten().map(|c| c.design.clone())); } - }); + }; + for art in d.layers.iter().chain(d.symbols.iter().map(|s| &s.art)) { + vectorcraft_doc::swatches::walk_with_masks(art, &mut note); + } d.graph_designs.iter().map(|x| x.name.clone()).filter(|n| !used.contains(n)).collect() } +/// Whether `n`'s subtree, the art of opacity masks included, holds a graph that names design +/// `name` for a series ([`names_design`]). +fn names_in(n: &Node, name: &str) -> bool { + let mut found = false; + vectorcraft_doc::swatches::walk_with_masks(n, &mut |m| { + found |= m.extras().graph.as_deref().is_some_and(|g| names_design(g, name)); + }); + found +} + +/// Graph `g`'s series that name design `old` name `new` instead. +fn rename_series(g: &mut GraphSpec, old: &str, new: &str) { + for m in g.series_markers.iter_mut().flatten().filter(|m| **m == old) { + *m = new.to_string(); + } + for c in g.series_columns.iter_mut().flatten().filter(|c| c.design == old) { + c.design = new.to_string(); + } +} + +/// [`rename_series`] for the graphs of `n`'s subtree, the art of opacity masks included. +fn rename_in(n: &mut Node, old: &str, new: &str) { + if let Some(mask) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()).filter(|m| names_in(&m.art, old)) { + rename_in(Arc::make_mut(&mut mask.art), old, new); + } + if let Some(g) = n.extras_if_any().and_then(|e| e.graph.as_deref_mut()) { + rename_series(g, old, new); + } + if let Some(children) = n.children_mut() { + for c in children.iter_mut().filter(|c| names_in(c, old)) { + rename_in(Arc::make_mut(c), old, new); + } + } +} + /// Design names from param `key`: one name or a list of names. fn names_param(p: &Value, key: &str, cmd: &str) -> Result>> { match p.get(key) { @@ -255,22 +346,29 @@ pub(super) fn design(s: &mut Session, p: &Value) -> Result { if let Some(x) = d.graph_designs.iter_mut().find(|x| x.name == old) { x.name = new.clone(); } - let mut graphs = vec![]; + let (mut graphs, mut masked) = (vec![], vec![]); d.walk(|n| { - if n.extras().graph.as_deref().is_some_and(|g| draws_with(g, &old)) { + if n.extras().graph.as_deref().is_some_and(|g| names_design(g, &old)) { graphs.push(n.id); } + if n.extras().mask.as_deref().is_some_and(|m| names_in(&m.art, &old)) { + masked.push(n.id); + } }); for id in graphs { if let Some(g) = d.node_mut(id).and_then(|n| n.extras_if_any().and_then(|e| e.graph.as_deref_mut())) { - for m in g.series_markers.iter_mut().flatten().filter(|m| **m == old) { - *m = new.clone(); - } - for c in g.series_columns.iter_mut().flatten().filter(|c| c.design == old) { - c.design = new.clone(); - } + rename_series(g, &old, &new); } } + // The graphs in opacity-mask art and in symbols' art follow too, their art as it is. + for id in masked { + if let Some(mask) = d.node_mut(id).and_then(|n| n.extras_if_any()).and_then(|e| e.mask.as_deref_mut()) { + rename_in(Arc::make_mut(&mut mask.art), &old, &new); + } + } + for s in d.symbols.iter_mut().filter(|s| names_in(&s.art, &old)) { + rename_in(Arc::make_mut(&mut s.art), &old, &new); + } Ok(()) })?; return Ok(json!({ "name": to })); diff --git a/crates/engine/src/cmd/graph/tests.rs b/crates/engine/src/cmd/graph/tests.rs index c1230301bb..a254f71ccc 100644 --- a/crates/engine/src/cmd/graph/tests.rs +++ b/crates/engine/src/cmd/graph/tests.rs @@ -5713,7 +5713,9 @@ fn a_pasted_graph_keeps_its_art_when_only_a_resource_its_design_does_not_use_com s.execute("swatch.edit", &json!({"name": "Ink", "color": "#0000ff"})).unwrap(); for conflict in ["merge", "add"] { let r = s.execute("edit.paste", &json!({"swatchConflict": conflict})).unwrap(); - assert!(r["merged"] == 1 || r["renamed"].as_array().is_some_and(|a| !a.is_empty()), "{conflict}: {r}"); + let ink_renamed = r["renamed"].as_array().is_some_and(|a| a.iter().any(|x| x["from"] == "Ink")); + let expected = if conflict == "merge" { (json!(1), false) } else { (json!(0), true) }; + assert_eq!((r["merged"].clone(), ink_renamed), expected, "{conflict}: {r}"); let st = s.doc().unwrap(); let d = &st.doc; let pasted = st.selection.objects.iter().copied().find(|i| d.node(*i).is_some_and(|n| n.extras().graph.is_some())).unwrap(); @@ -5937,6 +5939,276 @@ fn a_graph_pasted_back_after_its_design_was_made_again_draws_with_the_new_design assert_eq!(columns, [2, 2, 2, 2], "drawn with the design the document has now"); } +/// The graphs in `n`'s subtree, those in opacity-mask art included. +fn graphs_in(n: &vectorcraft_doc::Node) -> Vec { + let mut graphs = vec![]; + vectorcraft_doc::swatches::walk_with_masks(n, &mut |m| { + if m.extras().graph.is_some() { + graphs.push(m.clone()); + } + }); + graphs +} + +/// Load a saved document holding [`save_coin_design`]'s "Coin" and design "Chart", an instance of +/// symbol "Plot" whose column graph names "Coin" as its columns (`columns`) or only as a marker +/// its columns do not draw, as a swatch library → its id. +fn load_chart_library(s: &mut Session, columns: bool) -> String { + let mut src = Session::new(); + src.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_coin_design(&mut src); + let id = graph(&mut src, "column"); + src.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + src.execute(if columns { "graph.column" } else { "graph.marker" }, &json!({"design": "Coin"})).unwrap(); + let instance = src.execute("symbol.new", &json!({"name": "Plot", "ids": [id.0]})).unwrap()["id"].as_u64().unwrap(); + src.execute("select.set", &json!({"ids": [instance]})).unwrap(); + src.execute("graph.design", &json!({"new": "Chart"})).unwrap(); + let bytes = vectorcraft_format::save_file(&src.doc().unwrap().doc); + let p = json!({"dataBase64": vectorcraft_format::base64_encode(&bytes), "name": "Charts.vectorcraft"}); + s.execute("swatch.library.load", &p).unwrap()["library"].as_str().unwrap().to_string() +} + +#[test] +fn a_library_design_brings_none_of_the_resources_of_a_design_the_document_keeps() { + let mut s = Session::new(); + let lib = load_chart_library(&mut s, false); + // The document keeps its own "Coin": nothing the library's "Coin" uses comes in. + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_design(&mut s, "Coin"); + s.execute("graph.design", &json!({"library": lib, "add": "Chart"})).unwrap(); + let d = &s.doc().unwrap().doc; + assert!(d.symbols.iter().any(|x| x.name == "Plot"), "the design's symbol came in"); + assert!(d.swatch("Gold").is_none()); + // A document without one takes the design and its swatch. + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + s.execute("graph.design", &json!({"library": lib, "add": "Chart"})).unwrap(); + let d = &s.doc().unwrap().doc; + assert!(d.graph_designs.iter().any(|x| x.name == "Coin") && d.swatch("Gold").is_some()); +} + +#[test] +fn a_design_a_library_design_brings_along_redraws_the_graphs_that_name_it() { + let mut s = Session::new(); + let lib = load_chart_library(&mut s, true); + // A graph that names "Coin", which the document no longer has. + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_design(&mut s, "Coin"); + let id = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + s.execute("graph.design", &json!({"delete": "Coin"})).unwrap(); + let r = s.execute("graph.design", &json!({"library": lib, "add": "Chart"})).unwrap(); + assert_eq!(r, json!({"added": ["Chart"], "existing": []})); + let d = &s.doc().unwrap().doc; + assert!(paints_with_swatch(series(d.node(id).unwrap(), 0), "Gold"), "drawn with the library's Coin"); +} + +#[test] +fn a_paste_that_adds_a_design_redraws_the_documents_graphs_that_name_it_and_not_the_pasted_ones() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_coin_design(&mut s); + let id = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + // An edit of the copied graph's art that drawing it again would not keep. + let mark = series(s.doc().unwrap().doc.node(id).unwrap(), 0).children().unwrap()[0].id; + s.edit("Name", |d, _| { + if let Some(n) = d.node_mut(mark) { + n.name = Some("Mine".into()); + } + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("edit.copy", &json!({})).unwrap(); + // A document whose graph names "Coin", which it no longer has. + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_design(&mut s, "Coin"); + let own = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [own.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + s.execute("graph.design", &json!({"delete": "Coin"})).unwrap(); + s.execute("edit.paste", &json!({})).unwrap(); + let st = s.doc().unwrap(); + assert!(paints_with_swatch(series(st.doc.node(own).unwrap(), 0), "Gold"), "drawn with the pasted Coin"); + let pasted = st.selection.objects.to_vec()[0]; + let first = series(st.doc.node(pasted).unwrap(), 0).children().unwrap()[0].name.clone(); + assert_eq!(first.as_deref(), Some("Mine"), "the pasted graph is not drawn again"); +} + +#[test] +fn a_paste_that_adds_a_marker_design_a_graph_does_not_show_leaves_that_graph_as_it_is() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_coin_design(&mut s); + let id = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("edit.copy", &json!({})).unwrap(); + // A line graph whose series name "Coin", which the document no longer has, as a marker that + // Mark Data Points does not show, with no legend or with a legend that has no entry for them. + for (legend, csv) in [(false, ",2024,2025\nQ1,3,2\nQ2,5,4"), (true, ",,\nQ1,3,2\nQ2,5,4")] { + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_design(&mut s, "Coin"); + let p = json!({"type": "line", "x": 100, "y": 100, "width": 300, "height": 200, "csv": csv}); + let own = NodeId(s.execute("graph.create", &p).unwrap()["id"].as_u64().unwrap()); + s.execute("select.set", &json!({"ids": [own.0]})).unwrap(); + s.execute("graph.marker", &json!({"design": "Coin"})).unwrap(); + s.execute("graph.setType", &json!({"id": own.0, "markPoints": false, "legend": legend})).unwrap(); + s.execute("graph.design", &json!({"delete": "Coin"})).unwrap(); + let mark = series(s.doc().unwrap().doc.node(own).unwrap(), 0).children().unwrap()[0].id; + s.edit("Name", |d, _| { + if let Some(n) = d.node_mut(mark) { + n.name = Some("Mine".into()); + } + Ok(()) + }) + .unwrap(); + s.execute("edit.paste", &json!({})).unwrap(); + let d = &s.doc().unwrap().doc; + assert!(d.graph_designs.iter().any(|x| x.name == "Coin"), "legend {legend}: the paste added Coin"); + let first = series(d.node(own).unwrap(), 0).children().unwrap()[0].name.clone(); + assert_eq!(first.as_deref(), Some("Mine"), "legend {legend}: not drawn again"); + } +} + +#[test] +fn a_symbol_pasted_twice_with_a_graph_the_document_draws_again_is_added_once() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_coin_design(&mut s); + let id = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + let instance = s.execute("symbol.new", &json!({"name": "Chart", "ids": [id.0]})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [instance]})).unwrap(); + s.execute("edit.copy", &json!({})).unwrap(); + // A document whose "Coin" is other art: the first paste draws the symbol's graph with it. + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_design(&mut s, "Coin"); + // The paths of each column of the symbol's graph: 2 for the document's Coin, 1 for the copied one. + let columns = |s: &Session| { + let art = s.doc().unwrap().doc.symbols.iter().find(|x| x.name == "Chart").unwrap().art.clone(); + let graph = graphs_in(&art).remove(0); + let paths = |n: &vectorcraft_doc::Node| { + let mut count = 0; + n.walk(&mut |m| count += usize::from(matches!(m.kind, NodeKind::Path { .. }))); + count + }; + series(&graph, 0).children().unwrap().iter().map(|n| paths(n)).collect::>() + }; + s.execute("edit.paste", &json!({})).unwrap(); + assert_eq!(columns(&s), [2, 2, 2, 2], "the first paste draws with the document's Coin"); + s.execute("edit.paste", &json!({})).unwrap(); + let d = &s.doc().unwrap().doc; + let names: Vec<&str> = d.symbols.iter().map(|x| x.name.as_str()).filter(|n| n.starts_with("Chart")).collect(); + assert_eq!(names, ["Chart"]); + assert_eq!(columns(&s), [2, 2, 2, 2], "drawn with the document's Coin"); +} + +#[test] +fn a_symbol_pasted_twice_whose_designs_swatch_takes_the_documents_color_is_added_once() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_coin_design(&mut s); + // A copy of the document holds the same "Coin"; its "Gold" is another color. + let saved = vectorcraft_format::base64_encode(&vectorcraft_format::save_file(&s.doc().unwrap().doc)); + let id = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + let instance = s.execute("symbol.new", &json!({"name": "Chart", "ids": [id.0]})).unwrap()["id"].as_u64().unwrap(); + s.execute("select.set", &json!({"ids": [instance]})).unwrap(); + s.execute("edit.copy", &json!({})).unwrap(); + for conflict in ["merge", "add"] { + s.execute("document.open", &json!({"name": format!("{conflict}.vectorcraft"), "dataBase64": saved})).unwrap(); + s.execute("swatch.edit", &json!({"name": "Gold", "color": "#0000ff"})).unwrap(); + let r = s.execute("edit.paste", &json!({"swatchConflict": conflict})).unwrap(); + let gold_renamed = r["renamed"].as_array().is_some_and(|a| a.iter().any(|x| x["from"] == "Gold")); + let expected = if conflict == "merge" { (json!(1), false) } else { (json!(0), true) }; + assert_eq!((r["merged"].clone(), gold_renamed), expected, "{conflict}: {r}"); + s.execute("edit.paste", &json!({"swatchConflict": conflict})).unwrap(); + let d = &s.doc().unwrap().doc; + let names: Vec<&str> = d.symbols.iter().map(|x| x.name.as_str()).filter(|n| n.starts_with("Chart")).collect(); + assert_eq!(names, ["Chart"], "{conflict}"); + } +} + +#[test] +fn a_pasted_graph_that_only_names_a_kept_design_as_an_undrawn_marker_keeps_its_art() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_coin_design(&mut s); + // A column graph whose series name "Coin" as a marker, which columns do not draw. + let id = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("graph.marker", &json!({"design": "Coin"})).unwrap(); + let mark = series(s.doc().unwrap().doc.node(id).unwrap(), 0).children().unwrap()[0].id; + s.edit("Name", |d, _| { + if let Some(n) = d.node_mut(mark) { + n.name = Some("Mine".into()); + } + Ok(()) + }) + .unwrap(); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("edit.copy", &json!({})).unwrap(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_design(&mut s, "Coin"); + s.execute("edit.paste", &json!({})).unwrap(); + let st = s.doc().unwrap(); + let pasted = st.selection.objects.to_vec()[0]; + let first = series(st.doc.node(pasted).unwrap(), 0).children().unwrap()[0].name.clone(); + assert_eq!(first.as_deref(), Some("Mine"), "not drawn again"); +} + +#[test] +fn renaming_a_design_renames_it_in_the_graphs_of_symbols_and_opacity_masks() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_coin_design(&mut s); + let in_symbol = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [in_symbol.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + s.execute("symbol.new", &json!({"name": "Chart", "ids": [in_symbol.0]})).unwrap(); + let r = s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 300, "height": 200})).unwrap()["id"].as_u64().unwrap(); + let masked = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [masked.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + s.execute("select.set", &json!({"ids": [r, masked.0]})).unwrap(); + s.execute("transparency.makeOpacityMask", &json!({})).unwrap(); + let before = graphs_in(&s.doc().unwrap().doc.symbols.iter().find(|x| x.name == "Chart").unwrap().art); + s.execute("graph.design", &json!({"rename": "Coin", "to": "Medal"})).unwrap(); + let d = &s.doc().unwrap().doc; + let symbol = graphs_in(&d.symbols.iter().find(|x| x.name == "Chart").unwrap().art); + let mask = graphs_in(d.node(NodeId(r)).unwrap()); + for (where_, g) in [("symbol", &symbol[0]), ("mask", &mask[0])] { + let designs: Vec = g.extras().graph.as_deref().unwrap().series_columns.iter().flatten().map(|c| c.design.clone()).collect(); + assert!(!designs.is_empty() && designs.iter().all(|n| n == "Medal"), "{where_}: {designs:?}"); + } + assert_eq!(symbol[0].children(), before[0].children(), "the symbol's graph keeps its art"); +} + +#[test] +fn a_design_only_a_graph_in_a_symbol_or_a_mask_draws_with_is_not_unused() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap(); + save_design(&mut s, "Coin"); + save_design(&mut s, "Pill"); + let id = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Coin"})).unwrap(); + s.execute("symbol.new", &json!({"name": "Chart", "ids": [id.0]})).unwrap(); + let r = s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 300, "height": 200})).unwrap()["id"].as_u64().unwrap(); + let masked = graph(&mut s, "column"); + s.execute("select.set", &json!({"ids": [masked.0]})).unwrap(); + s.execute("graph.column", &json!({"design": "Pill"})).unwrap(); + s.execute("select.set", &json!({"ids": [r, masked.0]})).unwrap(); + s.execute("transparency.makeOpacityMask", &json!({})).unwrap(); + assert_eq!(s.execute("graph.design", &json!({})).unwrap()["unused"], json!([])); +} + #[test] fn a_library_copied_to_user_defined_keeps_its_graph_designs_under_the_loaded_id() { let dir = vectorcraft_testkit::TempDir::new("graph-design-library-user"); @@ -6029,18 +6301,28 @@ fn a_design_library_keeps_the_sources_color_for_a_default_swatch_name() { #[test] fn inline_swatch_library_data_over_the_size_limit_is_refused_before_it_is_read() { - let max = crate::cmd::place::document::MAX_FILE; + // With a limit of 3 bytes: text and base64 of 3 bytes pass, and of 4 bytes are refused. + let too_big = |p: serde_json::Value| crate::cmd::swatchlib::library_too_big(&p, "swatch.library.load", 3).unwrap(); + assert!(!too_big(json!({"data": "abc"}))); + assert!(too_big(json!({"data": "abcd"}))); + let b64 = |n: usize| vectorcraft_format::base64_encode(&vec![7u8; n]); + assert!(!too_big(json!({"dataBase64": b64(3)}))); + assert!(too_big(json!({"dataBase64": b64(4)}))); +} + +#[test] +fn a_swatch_library_file_is_read_no_further_than_the_size_limit() { + let dir = vectorcraft_testkit::TempDir::new("graph-design-library-bound"); + let path = dir.join("grown.gpl"); + std::fs::write(&path, [b'a'; 9]).unwrap(); let mut s = Session::new(); - // Text one byte over the limit, and base64 that decodes to one byte over it. - let chars = (max + 1) * 4 / 3 + 1; - // Each input is made in turn, so only one is held at a time. - for key in ["data", "dataBase64"] { - let value = if key == "data" { "a".repeat(max + 1) } else { "A".repeat(chars) }; - let mut p = serde_json::Map::new(); - p.insert(key.into(), serde_json::Value::String(value)); - let e = s.execute("swatch.library.load", &serde_json::Value::Object(p)).unwrap_err().to_string(); - assert!(e.contains("larger than 256 MB"), "{key}: {e}"); - } + let p = json!({"path": path}); + let parsed = |_: &[u8], _: &str| Err(crate::EngineError::Other("parsed".into())); + // A file that grew past the limit after the size check is refused when it is read. + let e = s.swatch_libraries.load_within(&p, "swatch.library.load", Some(8), parsed).unwrap_err().to_string(); + assert!(e.contains("larger than"), "{e}"); + let e = s.swatch_libraries.load_within(&p, "swatch.library.load", Some(9), parsed).unwrap_err().to_string(); + assert!(e.contains("parsed"), "{e}"); } #[test] diff --git a/crates/engine/src/cmd/swatchlib.rs b/crates/engine/src/cmd/swatchlib.rs index b16f743367..e4d89b9c13 100644 --- a/crates/engine/src/cmd/swatchlib.rs +++ b/crates/engine/src/cmd/swatchlib.rs @@ -17,7 +17,7 @@ use vectorcraft_color::swatch::REGISTRATION; use vectorcraft_color::{Paint, Swatch, SwatchGroup, SwatchLibrary, default_swatches}; use vectorcraft_doc::pattern::pattern_paint; -use super::fileio::{create_dir, extension, read_file, write_file, write_new_file}; +use super::fileio::{create_dir, extension, read_file, read_file_head, write_file, write_new_file}; use super::menucmds::squash; use super::package::free_name; use super::patternlib; @@ -393,12 +393,32 @@ impl Libraries { /// or a file with the same extension and bytes as one there, is that User Defined library; /// others are listed as loaded until the app quits. pub(crate) fn load(&mut self, p: &Value, cmd: &str, parse: impl FnOnce(&[u8], &str) -> Result) -> Result<(LibraryInfo, Arc)> { + self.load_within(p, cmd, None, parse) + } + + /// [`Self::load`], with a file at `path` read up to `max` bytes and refused when it is longer. + pub(crate) fn load_within( + &mut self, + p: &Value, + cmd: &str, + max: Option, + parse: impl FnOnce(&[u8], &str) -> Result, + ) -> Result<(LibraryInfo, Arc)> { let path = text_param(p, "path", cmd)?; let data = text_param(p, "data", cmd)?; let data_base64 = text_param(p, "dataBase64", cmd)?; let name = text_param(p, "name", cmd)?; let bytes = match (path, data, data_base64) { - (Some(path), ..) => read_file(path)?, + (Some(path), ..) => match max { + Some(max) => { + let bytes = read_file_head(path, max.saturating_add(1))?; + if bytes.len() > max { + return Err(bad(cmd, too_big_message(max))); + } + bytes + } + None => read_file(path)?, + }, (None, Some(text), _) => text.as_bytes().to_vec(), (None, None, Some(b64)) => vectorcraft_format::base64_decode(b64).ok_or_else(|| bad(cmd, "bad dataBase64"))?, _ => return Err(bad(cmd, "give `path`, `data` or `dataBase64`")), @@ -816,27 +836,38 @@ fn save(s: &mut Session, p: &Value) -> Result { Ok(out) } -fn load(s: &mut Session, p: &Value) -> Result { - const C: &str = "swatch.library.load"; - // The size is checked before the file is read, copied or decoded. - let max = super::place::document::MAX_FILE; - let too_big = match text_param(p, "path", C)? { +/// The error for a library file larger than `max` bytes. +fn too_big_message(max: usize) -> String { + format!("the file is larger than {} MB", max >> 20) +} + +/// Whether the library `p` gives (`path`, `data` or `dataBase64`) is larger than `max` bytes, +/// checked before the file is read, copied or decoded. +pub(crate) fn library_too_big(p: &Value, cmd: &str, max: usize) -> Result { + Ok(match text_param(p, "path", cmd)? { Some(path) => super::fileio::file_stamp(path).is_some_and(|(len, _)| len > max as u64), - None => match text_param(p, "data", C)? { + None => match text_param(p, "data", cmd)? { Some(text) => text.len() > max, // Base64 holds 3 bytes in every 4 characters (padding and white space hold none). None => { - text_param(p, "dataBase64", C)?.is_some_and(|b| b.bytes().filter(|c| *c != b'=' && !c.is_ascii_whitespace()).count() * 3 / 4 > max) + text_param(p, "dataBase64", cmd)?.is_some_and(|b| b.bytes().filter(|c| *c != b'=' && !c.is_ascii_whitespace()).count() * 3 / 4 > max) } }, - }; - if too_big { - return Err(bad(C, format!("the file is larger than {} MB", max >> 20))); + }) +} + +fn load(s: &mut Session, p: &Value) -> Result { + const C: &str = "swatch.library.load"; + let max = super::place::document::MAX_FILE; + if library_too_big(p, C, max)? { + return Err(bad(C, too_big_message(max))); } let mut designs = None; // The document a library with pattern swatches was read from, which holds their patterns. let mut patterns = None; - let (info, lib) = s.swatch_libraries.load(p, C, |bytes, file| { + // The file is read no further than the limit, so a file that grew since it was checked is + // refused too. + let (info, lib) = s.swatch_libraries.load_within(p, C, Some(max), |bytes, file| { // A library file, or a document whose swatches become the library and whose graph // designs the Graph Column and Graph Marker dialogs offer. if palette_io::sniff_bytes(bytes) { diff --git a/docs/mcp.md b/docs/mcp.md index e59eecb22b..6ab12c046e 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -5409,10 +5409,11 @@ Defined copy made with `swatch.library.copyToUser` holds the swatches alone, so swatches, patterns, symbols, styles, brushes and images its art uses, in the same undo step as the graph change. `graph.design {library, add: name | [names]}` copies designs without applying them and returns `{added, existing}`, and `graph.design {library}` lists the library's designs. A design the document already has under the same name stays as it -is. With no `design`, `graph.column`, `graph.marker` and `graph.design` list the loaded libraries that hold designs as -`libraries: [{library, name, designs}]`. Copying a graph and pasting it into another document brings the designs its series +is. `graph.column` and `graph.marker` with no `design`, and `graph.design {}`, list the loaded libraries that hold +designs as `libraries: [{library, name, designs}]`. Copying a graph and pasting it into another document brings the designs its series draw with in the same way; a pasted graph is drawn again with the document's design of that name when that design -would draw it otherwise. +would draw it otherwise. The graphs already in the document that draw with a design the copy or paste adds, one a copied +design's art uses included, are drawn again with it. `swatch.library.copyToUser {library}` copies a loaded library into the user library folder of the desktop app (a library file as it is; a document's swatches or a library loaded from `data` or `dataBase64` as `.vcswatches`; a library with pattern swatches is refused) under a name no file there has, and lists it as User