//! Copy and paste between documents (resources, swatch conflicts) and paste placement (M4.22, //! M4.23). use serde_json::{Value, json}; use vectorcraft_color::{Color, Paint}; use vectorcraft_doc::{Document, Node, NodeKind}; use vectorcraft_geom::{Point, Rect}; use crate::*; fn session() -> Session { let mut s = Session::new(); s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap(); s } /// A second document in the same session (as when copying between windows); it becomes active. fn new_doc(s: &mut Session) { s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap(); } fn id_of(v: &Value) -> NodeId { NodeId(v["id"].as_u64().unwrap()) } fn ids_of(v: &Value) -> Vec { v["ids"].as_array().unwrap().iter().map(|i| NodeId(i.as_u64().unwrap())).collect() } fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64) -> NodeId { id_of(&s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": w, "height": h})).unwrap()) } fn ellipse(s: &mut Session) -> NodeId { id_of(&s.execute("shape.ellipse", &json!({"x": 300, "y": 200, "width": 40, "height": 20})).unwrap()) } fn sel(s: &mut Session, ids: &[NodeId]) { s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::>()})).unwrap(); } fn copy(s: &mut Session, ids: &[NodeId]) { sel(s, ids); s.execute("edit.copy", &json!({})).unwrap(); } fn doc(s: &Session) -> &Document { &s.doc().unwrap().doc } fn node(s: &Session, id: NodeId) -> Node { doc(s).node(id).unwrap().clone() } fn fill(s: &Session, id: NodeId) -> Paint { node(s, id).appearance.fill_paint() } fn linked(color: Color, swatch: &str, tint: f32) -> Paint { Paint::Solid { color, swatch: Some(swatch.into()), tint } } fn hex(h: &str) -> Color { Color::from_hex(h).unwrap() } fn render(s: &Session) -> Vec { vectorcraft_render::Renderer::new().render_region(doc(s), Rect::new(0.0, 0.0, 400.0, 300.0), 1.0, true).pixels } /// A global swatch `name` of `hex` and a rectangle filled with it. fn swatched_rect(s: &mut Session, name: &str, hex: &str) -> NodeId { s.execute("swatch.new", &json!({"name": name, "color": hex, "global": true})).unwrap(); let r = rect(s, 20.0, 20.0, 40.0, 40.0); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": name})).unwrap(); r } fn renamed(v: &Value) -> Vec<(String, String, String)> { let s = |r: &Value, k: &str| r[k].as_str().unwrap().to_string(); v["renamed"].as_array().unwrap().iter().map(|r| (s(r, "kind"), s(r, "from"), s(r, "to"))).collect() } // ---------- M4.22: resources ---------- /// Verify ordinary paste retains image, symbol and pattern resources and their rendered appearance. #[test] fn an_image_symbol_and_pattern_rect_pasted_into_a_new_document_render_the_same() { resource_transfer(false); } /// Verify a translated artwork drop preserves editable resources, pattern phase, opacity and clipboard contents. #[test] fn dropped_artwork_preserves_editable_images_symbols_patterns_and_clipboard() { resource_transfer(true); } /// Exercise paste or tab-drop resource transfer and compare source and destination rendering. fn resource_transfer(drag: bool) { let mut s = session(); // Pattern "Dots" painting a rectangle. let dot = rect(&mut s, 0.0, 0.0, 10.0, 10.0); s.execute("paint.setFill", &json!({"ids": [dot.0], "color": "#ff0000"})).unwrap(); sel(&mut s, &[dot]); s.execute("object.pattern.make", &json!({"name": "Dots", "width": 20, "height": 20})).unwrap(); s.execute("object.pattern.done", &json!({})).unwrap(); sel(&mut s, &[dot]); s.execute("edit.clear", &json!({})).unwrap(); let patterned = rect(&mut s, 20.0, 20.0, 100.0, 80.0); s.execute("paint.setFill", &json!({"ids": [patterned.0], "swatch": "Dots"})).unwrap(); // Symbol "Badge" (a green square) placed once. let badge = rect(&mut s, 150.0, 20.0, 50.0, 50.0); s.execute("paint.setFill", &json!({"ids": [badge.0], "color": "#00aa44"})).unwrap(); sel(&mut s, &[badge]); s.execute("symbol.new", &json!({"name": "Badge"})).unwrap(); // An embedded image (a rasterized blue ellipse). let e = id_of(&s.execute("shape.ellipse", &json!({"x": 240, "y": 40, "width": 90, "height": 60})).unwrap()); s.execute("paint.setFill", &json!({"ids": [e.0], "color": "#2040ff"})).unwrap(); sel(&mut s, &[e]); s.execute("object.rasterize", &json!({"ppi": 72})).unwrap(); s.execute("select.all", &json!({})).unwrap(); s.execute("transparency.set", &json!({"opacity":45})).unwrap(); s.execute("edit.copy", &json!({})).unwrap(); assert_eq!(s.clipboard.nodes.len(), 3); assert_eq!((s.clipboard.symbols.len(), s.clipboard.patterns.len(), s.clipboard.images.len()), (1, 1, 1)); let before = render(&s); let source = s.doc().unwrap().clone(); let ids = source.selection.objects.clone(); new_doc(&mut s); assert!(before != render(&s)); let r = if drag { s.clipboard = Clipboard::default(); s.execute("edit.dropSelection", &json!({"sourceDocument": source.uid, "ids": ids, "grab": [0,0], "at": [13,17]})).unwrap() } else { s.execute("edit.pasteInPlace", &json!({})).unwrap() }; if drag { assert_eq!(s.clipboard, Clipboard::default()); } assert_eq!(s.documents()[0].doc, source.doc); // The pattern (its swatch comes along), the symbol and the image blob. assert_eq!((r["added"].as_u64(), r["merged"].as_u64()), (Some(3), Some(0)), "{r}"); let d = doc(&s); assert!(d.pattern("Dots").is_some() && d.swatch("Dots").is_some()); assert!(d.symbols.iter().any(|x| x.name == "Badge")); assert_eq!(d.images.len(), 1); let after = if drag { vectorcraft_render::Renderer::new().render_region(doc(&s), Rect::new(13.0, 17.0, 413.0, 317.0), 1.0, true).pixels } else { render(&s) }; assert!(before == after, "the transferred art, its transparency and pattern alignment render as in the source"); } #[test] fn a_spot_swatch_brings_its_plate() { let mut s = session(); let r = swatched_rect(&mut s, "Spot Teal", "#008080"); s.execute("swatch.setSpot", &json!({"name": "Spot Teal"})).unwrap(); copy(&mut s, &[r]); new_doc(&mut s); let plates = |s: &Session| vectorcraft_render::proof::plates(doc(s)).iter().filter(|p| p.spot).map(|p| p.name.clone()).collect::>(); assert!(plates(&s).is_empty()); s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(plates(&s), ["Spot Teal"]); let sw = doc(&s).swatch("Spot Teal").unwrap(); assert!(sw.spot && sw.global); } #[test] fn swatch_conflicts_merge_relinks_and_add_renames() { let mut s = session(); let r = swatched_rect(&mut s, "Brand", "#ff0000"); copy(&mut s, &[r]); new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Brand", "color": "#0000ff", "global": true})).unwrap(); let c = s.execute("clipboard.conflicts", &json!({})).unwrap(); assert_eq!(c["swatches"], json!([{"name": "Brand", "document": "#0000ff", "clipboard": "#ff0000", "spot": false}])); let swatches = doc(&s).swatches.len(); // Merge (the default): the pasted object takes the document's Brand. let v = s.execute("edit.pasteInPlace", &json!({"swatchConflict": "merge"})).unwrap(); assert_eq!((v["merged"].as_u64(), v["added"].as_u64()), (Some(1), Some(0))); assert_eq!(fill(&s, ids_of(&v)[0]), linked(hex("#0000ff"), "Brand", 1.0)); assert_eq!(doc(&s).swatches.len(), swatches); s.execute("edit.undo", &json!({})).unwrap(); // Add: the pasted swatch joins under a new name and the object follows it. let v = s.execute("edit.pasteInPlace", &json!({"swatchConflict": "add"})).unwrap(); assert_eq!(v["renamed"], json!([{"kind": "swatch", "from": "Brand", "to": "Brand 2"}])); assert_eq!(fill(&s, ids_of(&v)[0]), linked(hex("#ff0000"), "Brand 2", 1.0)); let added = doc(&s).swatch("Brand 2").unwrap(); assert!(added.global && added.paint.color() == Some(hex("#ff0000"))); s.execute("edit.undo", &json!({})).unwrap(); // Per swatch name; the others merge. let v = s.execute("edit.paste", &json!({"swatchConflict": {"Other": "add"}})).unwrap(); assert_eq!(v["merged"], 1); assert!(s.execute("edit.paste", &json!({"swatchConflict": "keep"})).is_err()); assert!(s.execute("edit.paste", &json!({"swatchConflict": {"Brand": 1}})).is_err()); } #[test] fn tints_and_their_tint_swatches_follow_the_base() { let mut s = session(); s.execute("swatch.new", &json!({"name": "Ink", "color": {"c": 0, "m": 100, "y": 100, "k": 0}, "spot": true})).unwrap(); let r = rect(&mut s, 0.0, 0.0, 10.0, 10.0); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Ink", "tint": 40})).unwrap(); // The 40% tint swatch, and one of another tint the art doesn't use. assert_eq!(s.execute("swatch.new", &json!({})).unwrap()["name"], "Ink 40%"); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Ink", "tint": 70})).unwrap(); s.execute("swatch.new", &json!({})).unwrap(); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Ink", "tint": 40})).unwrap(); copy(&mut s, &[r]); assert_eq!(s.clipboard.swatches.iter().map(|w| w.name.as_str()).collect::>(), ["Ink", "Ink 40%"]); // Into a document whose Ink is cyan: merged, the tint is 40% of the document's Ink. new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Ink", "color": {"c": 100, "m": 0, "y": 0, "k": 0}, "spot": true})).unwrap(); let v = s.execute("edit.pasteInPlace", &json!({})).unwrap(); let cyan = Color::cmyk(1.0, 0.0, 0.0, 0.0); assert_eq!(fill(&s, ids_of(&v)[0]), linked(cyan.tinted(0.4), "Ink", 0.4)); let tint = doc(&s).swatch("Ink 40%").unwrap(); assert_eq!(tint.paint, linked(cyan.tinted(0.4), "Ink", 0.4), "the tint swatch links to the document's Ink"); assert!(doc(&s).swatch("Ink 70%").is_none(), "unused tints stay behind"); s.execute("edit.undo", &json!({})).unwrap(); // Added: the tint and its tint swatch follow the renamed base. let v = s.execute("edit.pasteInPlace", &json!({"swatchConflict": "add"})).unwrap(); let magenta = Color::cmyk(0.0, 1.0, 1.0, 0.0); assert_eq!(fill(&s, ids_of(&v)[0]), linked(magenta.tinted(0.4), "Ink 2", 0.4)); assert_eq!(doc(&s).swatch("Ink 40%").unwrap().paint, linked(magenta.tinted(0.4), "Ink 2", 0.4)); } #[test] fn gradient_stops_stay_linked_to_their_swatches() { let mut s = session(); s.execute("swatch.new", &json!({"name": "Sky", "color": "#3080ff", "global": true})).unwrap(); let r = rect(&mut s, 0.0, 0.0, 50.0, 50.0); s.execute("paint.setFill", &json!({"ids": [r.0], "gradient": {"kind": "linear"}})).unwrap(); s.edit("link stop", |d, _| { let n = d.node_mut(r).unwrap(); let Paint::Gradient(mut g) = n.appearance.fill_paint() else { panic!() }; g.gradient.stops[0].set_color(Color::from_hex("#3080ff").unwrap(), Some(("Sky".into(), 1.0))); n.appearance.set_fill(Paint::Gradient(g)); Ok(()) }) .unwrap(); copy(&mut s, &[r]); assert!(s.clipboard.swatches.iter().any(|w| w.name == "Sky")); new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Sky", "color": "#000080", "global": true})).unwrap(); let v = s.execute("edit.paste", &json!({"swatchConflict": "add"})).unwrap(); let Paint::Gradient(g) = fill(&s, ids_of(&v)[0]) else { panic!() }; assert_eq!((g.gradient.stops[0].swatch.as_deref(), g.gradient.stops[0].color), (Some("Sky 2"), hex("#3080ff"))); assert!(doc(&s).swatch("Sky 2").is_some()); } #[test] fn gradient_swatches_come_along_with_their_stop_links() { let mut s = session(); s.execute("swatch.new", &json!({"name": "Sky", "color": "#3080ff", "global": true})).unwrap(); let glow = json!({"stops": [{"offset": 0, "swatch": "Sky"}, {"offset": 1, "color": "#ffffff"}]}); s.execute("swatch.new", &json!({"name": "Glow", "gradient": glow})).unwrap(); let r = rect(&mut s, 0.0, 0.0, 50.0, 50.0); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Glow"})).unwrap(); copy(&mut s, &[r]); assert_eq!(s.clipboard.swatches.iter().map(|w| w.name.as_str()).collect::>(), ["Sky", "Glow"]); // A document with another Glow and another Sky. new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Sky", "color": "#000080", "global": true})).unwrap(); s.execute("swatch.new", &json!({"name": "Glow", "gradient": {"stops": [{"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#000000"}]}})) .unwrap(); let v = s.execute("edit.paste", &json!({"swatchConflict": "add"})).unwrap(); let Paint::Gradient(g) = fill(&s, ids_of(&v)[0]) else { panic!() }; assert_eq!((g.swatch.as_deref(), g.gradient.stops[0].swatch.as_deref()), (Some("Glow 2"), Some("Sky 2"))); let Paint::Gradient(sw) = doc(&s).swatch("Glow 2").unwrap().paint.clone() else { panic!() }; assert_eq!(sw.gradient, g.gradient, "the added gradient swatch links its stop to the added Sky too"); } /// A gradient swatch made from another one (by name, from a fill linked to it, or from a gradient /// that names it, placed or not) holds the gradient alone, so copying art that uses it brings only /// that swatch. A placed gradient keeps its aspect, and the swatch still fits each object it is /// applied to. #[test] fn a_gradient_swatch_made_from_another_holds_no_link_to_it() { let mut s = session(); let glow = json!({"kind": "radial", "stops": [{"offset": 0, "color": "#3080ff"}, {"offset": 1, "color": "#ffffff"}]}); s.execute("swatch.new", &json!({"name": "Glow", "gradient": glow})).unwrap(); let r = rect(&mut s, 0.0, 0.0, 50.0, 50.0); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Glow"})).unwrap(); let Paint::Gradient(applied) = fill(&s, r) else { panic!("a gradient fill") }; assert_eq!(applied.swatch.as_deref(), Some("Glow")); let mut by_gradient = vectorcraft_tools::params::gradient_params(&applied); by_gradient["swatch"] = json!("Glow"); let mut placed = by_gradient.clone(); placed["start"] = json!([25, 25]); placed["end"] = json!([50, 25]); placed["aspect"] = json!(50); let made = [ ("By Name", json!({"name": "By Name", "swatch": "Glow"})), ("From Fill", json!({"name": "From Fill"})), ("From Gradient", json!({"name": "From Gradient", "gradient": by_gradient})), ("Placed", json!({"name": "Placed", "gradient": placed})), ]; let mut links = vec![]; for (name, p) in &made { s.execute("swatch.new", p).unwrap(); let Paint::Gradient(sw) = doc(&s).swatch(name).unwrap().paint.clone() else { panic!("{name}: a gradient swatch") }; assert_eq!(sw.gradient, applied.gradient, "{name}: Glow's gradient"); links.push(sw.swatch.clone()); } assert_eq!(links, [None, None, None, None], "no swatch links to Glow"); let Paint::Gradient(sw) = doc(&s).swatch("Placed").unwrap().paint.clone() else { panic!("a gradient swatch") }; assert!(sw.geom.is_some_and(|g| (g.aspect - 0.5).abs() < 1e-9), "the placed gradient keeps its aspect: {:?}", sw.geom); for (name, _) in &made { let t = rect(&mut s, 100.0, 0.0, 100.0, 60.0); s.execute("paint.setFill", &json!({"ids": [t.0], "swatch": name})).unwrap(); if *name == "Placed" { let Paint::Gradient(g) = fill(&s, t) else { panic!("a gradient fill") }; let geom = g.geom.unwrap(); assert!(geom.start.distance(Point::new(150.0, 30.0)) < 1e-9 && (geom.aspect - 0.5).abs() < 1e-9, "{geom:?}"); } copy(&mut s, &[t]); assert_eq!(s.clipboard.swatches.iter().map(|w| w.name.as_str()).collect::>(), [*name], "Glow stays behind"); } } #[test] fn lab_spot_colours_show_as_the_target_documents_spot_option_says() { let mut s = session(); let lab = Color::lab(60.0, 50.0, 20.0); s.execute("swatch.new", &json!({"name": "Lab Ink", "color": {"l": 60, "a": 50, "b": 20}, "spot": true})).unwrap(); let r = rect(&mut s, 0.0, 0.0, 10.0, 10.0); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Lab Ink"})).unwrap(); assert_eq!(fill(&s, r).color(), Some(lab)); copy(&mut s, &[r]); new_doc(&mut s); s.execute("swatch.spotOptions", &json!({"useLab": false})).unwrap(); let id = ids_of(&s.execute("edit.paste", &json!({})).unwrap())[0]; let cmyk = doc(&s).global_color("Lab Ink").unwrap(); assert!(matches!(cmyk, Color::Cmyk { .. })); assert_eq!(fill(&s, id), linked(cmyk, "Lab Ink", 1.0), "the CMYK equivalent, still linked"); assert_eq!(doc(&s).swatch("Lab Ink").unwrap().paint.color(), Some(lab), "the swatch keeps its Lab definition"); } #[test] fn registration_is_never_copied_as_a_swatch() { let mut s = session(); let r = rect(&mut s, 0.0, 0.0, 10.0, 10.0); s.edit("registration", |d, _| { d.node_mut(r).unwrap().appearance.set_fill(Paint::registration()); Ok(()) }) .unwrap(); copy(&mut s, &[r]); assert!(s.clipboard.swatches.is_empty()); new_doc(&mut s); let swatches = doc(&s).swatches.len(); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["added"], 0); assert_eq!(doc(&s).swatches.len(), swatches); assert!(fill(&s, ids_of(&v)[0]).is_registration()); } #[test] fn graphic_style_links_follow_the_style_into_the_document() { let mut s = session(); let a = rect(&mut s, 0.0, 0.0, 30.0, 30.0); s.execute("paint.setFill", &json!({"ids": [a.0], "color": "#ffcc00"})).unwrap(); sel(&mut s, &[a]); s.execute("graphicStyle.new", &json!({"name": "Sun"})).unwrap(); let src_id = node(&s, a).extras().graphic_style.unwrap(); copy(&mut s, &[a]); assert_eq!(s.clipboard.graphic_styles.iter().map(|g| g.name.as_str()).collect::>(), ["Sun"]); // A document with another "Sun" and styles taking up the source id. new_doc(&mut s); let b = rect(&mut s, 0.0, 0.0, 10.0, 10.0); s.execute("paint.setFill", &json!({"ids": [b.0], "color": "#0000ff"})).unwrap(); sel(&mut s, &[b]); s.execute("graphicStyle.new", &json!({"name": "Sun"})).unwrap(); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(renamed(&v), [("graphicStyle".to_string(), "Sun".to_string(), "Sun 2".to_string())]); let d = doc(&s); let linked_to = d.graphic_style_by_id(node(&s, ids_of(&v)[0]).extras().graphic_style.unwrap()).unwrap().clone(); assert_eq!(linked_to.name, "Sun 2"); assert_eq!(linked_to.appearance.fill_paint(), Paint::solid(hex("#ffcc00"))); assert!(d.graphic_styles.iter().filter(|g| g.id == linked_to.id).count() == 1, "a fresh id"); // Pasting again finds the same style. let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!((v["added"].as_u64(), node(&s, ids_of(&v)[0]).extras().graphic_style), (Some(0), Some(linked_to.id))); // Back in the source document the link is kept as it was. s.execute("document.activate", &json!({"index": 0})).unwrap(); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(node(&s, ids_of(&v)[0]).extras().graphic_style, Some(src_id)); } #[test] fn undo_removes_everything_the_paste_added() { let mut s = session(); let r = swatched_rect(&mut s, "Brand", "#ff0000"); sel(&mut s, &[r]); s.execute("symbol.new", &json!({"name": "Mark"})).unwrap(); s.execute("select.all", &json!({})).unwrap(); s.execute("edit.copy", &json!({})).unwrap(); new_doc(&mut s); let before = doc(&s).clone(); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["added"], 2, "{v}"); assert!(doc(&s).swatch("Brand").is_some() && !doc(&s).symbols.is_empty()); s.execute("edit.undo", &json!({})).unwrap(); assert!(*doc(&s) == before); } #[test] fn styles_symbols_and_images_of_the_same_name_are_renamed() { let mut s = session(); // A character style, a symbol and an image named like the target's own. let t = id_of(&s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Hello"})).unwrap()); s.execute("charStyle.new", &json!({"name": "Emphasis", "attrs": {"size": 24.0}})).unwrap(); s.execute("charStyle.apply", &json!({"name": "Emphasis", "id": t.0})).unwrap(); let m = rect(&mut s, 200.0, 100.0, 30.0, 30.0); sel(&mut s, &[m]); let mark = id_of(&s.execute("symbol.new", &json!({"name": "Mark"})).unwrap()); let e = rect(&mut s, 300.0, 100.0, 20.0, 20.0); sel(&mut s, &[e]); let img = id_of(&s.execute("object.rasterize", &json!({"ppi": 72})).unwrap()); let key = |s: &Session, id: NodeId| match node(s, id).kind { NodeKind::Image(im) => im.key, _ => panic!("not an image"), }; let src_key = key(&s, img); copy(&mut s, &[t, mark, img]); new_doc(&mut s); s.execute("charStyle.new", &json!({"name": "Emphasis", "attrs": {"size": 8.0}})).unwrap(); let m2 = ellipse(&mut s); sel(&mut s, &[m2]); s.execute("symbol.new", &json!({"name": "Mark"})).unwrap(); // Another image under the same key. let e2 = ellipse(&mut s); sel(&mut s, &[e2]); let img2 = id_of(&s.execute("object.rasterize", &json!({"ppi": 72})).unwrap()); let other_key = key(&s, img2); s.edit("same key", |d, _| { let blob = d.images.remove(&other_key).unwrap(); d.images.insert(src_key.clone(), blob); let NodeKind::Image(im) = &mut d.node_mut(img2).unwrap().kind else { panic!() }; im.key = src_key.clone(); Ok(()) }) .unwrap(); let v = s.execute("edit.pasteInPlace", &json!({})).unwrap(); let kinds: Vec<(String, String)> = renamed(&v).into_iter().map(|(k, _, to)| (k, to)).collect(); for want in [("charStyle", "Emphasis 2"), ("symbol", "Mark 2"), ("image", &*format!("{src_key} 2"))] { assert!(kinds.contains(&(want.0.to_string(), want.1.to_string())), "{want:?} in {kinds:?}"); } let ids = ids_of(&v); let NodeKind::Text(tx) = node(&s, ids[0]).kind else { panic!() }; assert_eq!(tx.runs[0].style.style_name.as_deref(), Some("Emphasis 2")); assert!(matches!(node(&s, ids[1]).kind, NodeKind::SymbolInstance { ref symbol, .. } if symbol == "Mark 2")); let new_key = key(&s, ids[2]); assert_ne!(new_key, src_key, "a different image under the same key is re-keyed"); assert!(doc(&s).images[&new_key].bytes != doc(&s).images[&src_key].bytes); // Their own objects are untouched. assert_eq!(key(&s, img2), src_key); } /// A graph whose series fill, value labels, legend rows and axis and ring line rows paint with global swatch "Brand" and /// whose value labels are set in character style "Emphasis" and paragraph style "Body", as a /// later redraw would give them to its marks and labels. fn styled_graph(s: &mut Session) -> NodeId { s.execute("swatch.new", &json!({"name": "Brand", "color": "#ff0000", "global": true})).unwrap(); s.execute("charStyle.new", &json!({"name": "Emphasis", "attrs": {"size": 24.0}})).unwrap(); s.execute("paraStyle.new", &json!({"name": "Body", "attrs": {"space_after": 8.0}})).unwrap(); let v = s.execute("graph.create", &json!({"type": "column", "x": 200, "y": 200, "width": 60, "height": 40, "csv": ",2024\nQ1,3\nQ2,5"})); let id = id_of(&v.unwrap()); let brand = linked(hex("#ff0000"), "Brand", 1.0); let mut extras = doc_mut(s).node_mut(id).unwrap().extras_mut(); let g = extras.graph.as_mut().unwrap(); g.series_paints = vec![vectorcraft_doc::SeriesPaint { fill: Some(brand.clone()), ..Default::default() }]; let l = &mut g.label_styles; l.values = Some(vectorcraft_doc::CharStyle { fill: brand.clone(), style_name: Some("Emphasis".into()), ..Default::default() }); l.values_para = Some(vectorcraft_doc::ParaStyle { style_name: Some("Body".into()), ..Default::default() }); let paint = vectorcraft_doc::SeriesPaint { stroke: Some(brand), ..Default::default() }; let rows = vectorcraft_doc::graph::LabelRows { paint, ..Default::default() }; (l.legend_rows, l.axis_rows, l.ring_rows) = (Some(rows.clone()), Some(rows.clone()), Some(rows)); id } /// The swatch names a graph's stored paints link to, and its value labels' character and /// paragraph style names. fn graph_links(s: &Session, id: NodeId) -> (Vec, Option, Option) { let n = node(s, id); let swatches = vectorcraft_doc::swatches::graph_paints(&n).filter_map(|p| match p { Paint::Solid { swatch: Some(w), .. } => Some(w.clone()), _ => None, }); let l = &n.extras().graph.as_deref().unwrap().label_styles; let values = l.values.as_ref().and_then(|st| st.style_name.clone()); (swatches.collect(), values, l.values_para.as_ref().and_then(|pa| pa.style_name.clone())) } /// A pasted graph brings the swatches and text styles its series and labels keep, and follows /// them when they come in under new names. #[test] fn a_pasted_graph_brings_and_follows_its_label_styles_and_paints() { let mut s = session(); let g = styled_graph(&mut s); copy(&mut s, &[g]); new_doc(&mut s); let v = s.execute("edit.pasteInPlace", &json!({})).unwrap(); let d = doc(&s); assert!(d.swatch("Brand").is_some(), "{v}"); assert!(d.char_styles.iter().any(|x| x.name == "Emphasis") && d.para_styles.iter().any(|x| x.name == "Body"), "{v}"); let brand = vec!["Brand".to_string(); 5]; assert_eq!(graph_links(&s, ids_of(&v)[0]), (brand.clone(), Some("Emphasis".into()), Some("Body".into()))); // Into a document that gives each name something else: they come in renamed. new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Brand", "color": "#0000ff", "global": true})).unwrap(); s.execute("charStyle.new", &json!({"name": "Emphasis", "attrs": {"size": 8.0}})).unwrap(); s.execute("paraStyle.new", &json!({"name": "Body", "attrs": {"space_after": 2.0}})).unwrap(); let v = s.execute("edit.pasteInPlace", &json!({"swatchConflict": "add"})).unwrap(); let brand2 = vec!["Brand 2".to_string(); 5]; assert_eq!(graph_links(&s, ids_of(&v)[0]), (brand2, Some("Emphasis 2".into()), Some("Body 2".into())), "{v}"); // Without formatting: the labels' text styles stay behind. new_doc(&mut s); let v = s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap(); assert!(doc(&s).char_styles.is_empty() && doc(&s).para_styles.is_empty(), "{v}"); // The value labels' red characters stay behind too; the series fill, the legend rows and the line rows keep Brand. assert_eq!(graph_links(&s, ids_of(&v)[0]), (vec!["Brand".to_string(); 4], None, None)); } /// Each label of graph `id` (the text of its Axes and Legend groups) with its size and its first paragraph's format. fn graph_label_looks(s: &Session, id: NodeId) -> Vec<(String, f64, vectorcraft_doc::ParaStyle)> { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind { out.push((t.plain_text(), t.first_style().size, t.para_at(0).clone())); } }); out } /// Paste without Formatting sets a pasted graph's labels in a new graph's label size and paragraph attributes, and the /// graph keeps them when it is drawn again: the character and paragraph formats its labels keep stay behind with their /// text formatting. #[test] fn a_graph_pasted_without_formatting_keeps_plain_labels_when_drawn_again() { let mut s = session(); let csv = ",2024,2025\nQ1,3,2\nQ2,5,4"; let g = id_of(&s.execute("graph.create", &json!({"type": "column", "x": 100, "y": 100, "width": 120, "height": 80, "csv": csv})).unwrap()); let fresh = graph_label_looks(&s, g); sel(&mut s, &[g]); s.execute("text.setStyle", &json!({"size": 14})).unwrap(); s.execute("text.setFormat", &json!({"spaceAfter": 6})).unwrap(); assert!(graph_label_looks(&s, g).iter().all(|(_, size, para)| *size == 14.0 && para.space_after == 6.0)); // The labels as drawn are also set in a character style. s.execute("charStyle.new", &json!({"name": "Emphasis", "attrs": {"size": 14.0}})).unwrap(); let mut labels = vec![]; node(&s, g).walk(&mut |n| { if matches!(n.kind, NodeKind::Text(_)) { labels.push(n.id); } }); for id in labels { if let Some(NodeKind::Text(t)) = doc_mut(&mut s).node_mut(id).map(|n| &mut n.kind) { t.runs.iter_mut().for_each(|r| r.style.style_name = Some("Emphasis".into())); } } copy(&mut s, &[g]); assert_eq!(s.clipboard.char_styles.iter().map(|c| c.name.as_str()).collect::>(), ["Emphasis"]); // Where a redraw of the copied graph puts its plot. s.execute("graph.setData", &json!({"id": g.0, "csv": csv})).unwrap(); let plot = node(&s, g).extras().graph.as_deref().unwrap().rect; new_doc(&mut s); let steps = s.doc().unwrap().history.undo.len(); let v = s.execute("edit.pasteWithoutFormatting", &json!({"dx": 10, "dy": 20})).unwrap(); let p = ids_of(&v)[0]; assert!(doc(&s).char_styles.is_empty(), "the labels' character style stays behind: {v}"); assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "one undo step"); assert_eq!(s.doc().unwrap().history.undo.last().map(|e| e.label.as_str()), Some("Paste without Formatting")); let l = node(&s, p).extras().graph.as_deref().unwrap().label_styles.clone(); assert_eq!((l.values, l.categories, l.legend), (None, None, None)); assert_eq!((l.values_para, l.categories_para, l.legend_para), (None, None, None)); let pasted = graph_label_looks(&s, p); assert_eq!(pasted, fresh, "the labels are set as a new graph's are"); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert_eq!(graph_label_looks(&s, p), pasted, "and stay so when the graph is drawn again"); let r = node(&s, p).extras().graph.as_deref().unwrap().rect; let off = [r.x0 - plot.x0 - 10.0, r.y0 - plot.y0 - 20.0, r.x1 - plot.x1 - 10.0, r.y1 - plot.y1 - 20.0]; assert!(off.iter().all(|d| d.abs() < 1e-6), "the plot moves by the offset and keeps its size: {plot:?} → {r:?}"); s.execute("graph.setType", &json!({"id": p.0, "type": "column", "dropShadow": true})).unwrap(); assert_eq!(graph_label_looks(&s, p), pasted, "a change of graph type options draws them the same way"); s.execute("edit.undo", &json!({})).unwrap(); s.execute("edit.undo", &json!({})).unwrap(); s.execute("edit.undo", &json!({})).unwrap(); assert!(doc(&s).node(p).is_none(), "one undo takes the paste back"); } /// Paste without Formatting leaves the rest of a pasted graph's art as it was copied: a column painted by hand keeps its /// paint, and nothing is drawn again. #[test] fn a_graph_pasted_without_formatting_keeps_its_art() { let mut s = session(); let csv = ",2024,2025\nQ1,3,2\nQ2,5,4"; let g = id_of(&s.execute("graph.create", &json!({"type": "column", "x": 100, "y": 100, "width": 120, "height": 80, "csv": csv})).unwrap()); let red = Paint::solid(hex("ff0000")); let mut column = None; node(&s, g).walk(&mut |n| { if column.is_none() && matches!(n.kind, NodeKind::Path { .. }) && n.appearance.fill_paint() != Paint::None { column = Some(n.id); } }); let column = column.unwrap(); let n = doc_mut(&mut s).node_mut(column).unwrap(); n.appearance = vectorcraft_doc::Appearance::basic(red.clone(), Paint::None, 0.0).into(); /// Every object of graph `id` that is not type: its kind's name, its fill and its bounds. fn art(s: &Session, id: NodeId) -> Vec<(String, Paint, Option)> { let mut out = vec![]; node(s, id).walk(&mut |n| { if !matches!(n.kind, NodeKind::Text(_)) { out.push((format!("{:?}", std::mem::discriminant(&n.kind)), n.appearance.fill_paint(), n.geometric_bounds())); } }); out } let copied = art(&s, g); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({"dx": 15, "dy": 25})).unwrap())[0]; let pasted = art(&s, p); let dx = pasted[0].2.unwrap().x0 - copied[0].2.unwrap().x0; let dy = pasted[0].2.unwrap().y0 - copied[0].2.unwrap().y0; let moved: Vec<_> = copied.into_iter().map(|(k, f, b)| (k, f, b.map(|b| b + vectorcraft_geom::Vec2::new(dx, dy)))).collect(); assert_eq!(pasted.len(), moved.len()); for (a, b) in pasted.iter().zip(&moved) { assert_eq!((&a.0, &a.1), (&b.0, &b.1)); let (a, b) = (a.2.unwrap(), b.2.unwrap()); assert!((a.x0 - b.x0).abs() + (a.y0 - b.y0).abs() + (a.x1 - b.x1).abs() + (a.y1 - b.y1).abs() < 1e-6, "{a:?} {b:?}"); } assert!(pasted.iter().any(|(_, f, _)| *f == red), "the column keeps the paint it was given"); } /// The labels of a scaled graph pasted without formatting are set at a new graph's label size, unscaled, as a redraw /// sets them. #[test] fn a_scaled_graph_pasted_without_formatting_gets_unscaled_labels() { let mut s = session(); let csv = ",2024\nQ1,3\nQ2,5"; let g = id_of(&s.execute("graph.create", &json!({"type": "column", "x": 50, "y": 50, "width": 120, "height": 80, "csv": csv})).unwrap()); let fresh = graph_label_looks(&s, g)[0].1; sel(&mut s, &[g]); s.execute("object.scale", &json!({"sx": 200, "sy": 200})).unwrap(); /// Each label's size as drawn: its character size times the scale of its transform. fn drawn_sizes(s: &Session, id: NodeId) -> Vec { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind { out.push(t.first_style().size * t.xf.determinant().abs().sqrt()); } }); out } assert!(drawn_sizes(&s, g).iter().all(|z| (z - fresh * 2.0).abs() < 1e-6), "{:?}", drawn_sizes(&s, g)); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert!(drawn_sizes(&s, p).iter().all(|z| (z - fresh).abs() < 1e-6), "{:?}", drawn_sizes(&s, p)); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert!(drawn_sizes(&s, p).iter().all(|z| (z - fresh).abs() < 1e-6), "{:?}", drawn_sizes(&s, p)); // A rotated graph's labels keep their rotation, so they stay turned with the rest of its art. /// Each label's rotation in degrees: the angle of its transform's x axis. fn angles(s: &Session, id: NodeId) -> Vec { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind { let [a, b, ..] = t.xf.as_coeffs(); out.push(b.atan2(a).to_degrees()); } }); out } let r = id_of(&s.execute("graph.create", &json!({"type": "column", "x": 300, "y": 50, "width": 120, "height": 80, "csv": csv})).unwrap()); sel(&mut s, &[r]); s.execute("object.scale", &json!({"sx": 200, "sy": 200})).unwrap(); s.execute("object.rotate", &json!({"angle": 30})).unwrap(); let turned = angles(&s, r); assert!(turned.iter().all(|a| (a.abs() - 30.0).abs() < 1e-6), "{turned:?}"); copy(&mut s, &[r]); new_doc(&mut s); let q = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(angles(&s, q).len(), turned.len()); assert!(angles(&s, q).iter().zip(&turned).all(|(a, b)| (a - b).abs() < 1e-6), "{:?} against {turned:?}", angles(&s, q)); assert!(drawn_sizes(&s, q).iter().all(|z| (z - fresh).abs() < 1e-6), "{:?}", drawn_sizes(&s, q)); } /// A pie's legend labels in their wedges keep a redraw's contrast when pasted without formatting: white on a dark /// wedge, black on a light one. #[test] fn pie_labels_in_wedges_pasted_without_formatting_stay_readable() { let mut s = session(); let csv = ",North,South\nP,1,1"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); /// Each text of graph `id` with its characters' fill. fn fills(s: &Session, id: NodeId) -> Vec<(String, Paint)> { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind { out.push((t.plain_text(), t.first_style().fill.clone())); } }); out } let drawn = fills(&s, g); assert!(drawn.contains(&("North".into(), Paint::solid(Color::WHITE))), "the first wedge is black: {drawn:?}"); sel(&mut s, &[g]); s.execute("text.setStyle", &json!({"size": 14})).unwrap(); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(fills(&s, p), drawn); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert_eq!(fills(&s, p), drawn); } /// A pie whose legend labels were given a black fill of their own loses that mark when pasted without formatting, so a /// later change to a legend label's size does not bring the black fill back on the dark wedge. #[test] fn a_legend_fill_of_its_own_stays_behind_when_pasted_without_formatting() { let mut s = session(); let csv = ",North,South\nP,1,1"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); /// The legend label of graph `id` that says `name`. fn label(s: &Session, id: NodeId, name: &str) -> (NodeId, Paint) { let mut out = None; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text() == name { out = Some((n.id, t.first_style().fill.clone())); } }); out.unwrap() } let (north, fill) = label(&s, g, "North"); assert_eq!(fill, Paint::solid(Color::WHITE), "white on the black wedge"); s.execute("text.setStyle", &json!({"ids": [north.0], "fill": "#000000"})).unwrap(); assert!(node(&s, g).extras().graph.as_deref().unwrap().label_styles.legend_fill_set); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert!(!node(&s, p).extras().graph.as_deref().unwrap().label_styles.legend_fill_set); assert_eq!(label(&s, p, "North").1, Paint::solid(Color::WHITE), "pasted as a redraw sets it"); let (north, _) = label(&s, p, "North"); s.execute("text.setStyle", &json!({"ids": [north.0], "size": 11})).unwrap(); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert_eq!(label(&s, p, "North").1, Paint::solid(Color::WHITE), "still white when the pie is drawn again"); } /// A pie pasted into a document whose swatch of the same name is another color takes that color on its linked wedges /// (Merge), and its legend labels in those wedges take the contrast a redraw gives them there: white on a wedge that /// turned dark. Pasting with Add, which keeps the copied color, keeps the labels as they were. #[test] fn pie_legend_labels_follow_wedges_that_take_the_documents_swatch() { let mut s = session(); let csv = ",North,South\nP,1,1"; s.execute("swatch.new", &json!({"name": "Brand", "color": "#ffff66", "global": true})).unwrap(); let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); /// The fill of the legend label of graph `id` that says `name`. fn label(s: &Session, id: NodeId, name: &str) -> Paint { let mut out = None; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text() == name { out = Some(t.first_style().fill.clone()); } }); out.unwrap() } // The North wedge, black when drawn, takes the light Brand swatch, and a redraw sets its label black. let mut wedges = vec![]; for c in node(&s, g).children().unwrap().iter().filter(|c| c.extras().series_index == Some(0)) { c.walk(&mut |m| { if matches!(m.kind, NodeKind::Path { .. }) { wedges.push(m.id.0); } }); } assert!(!wedges.is_empty()); s.execute("paint.setFill", &json!({"ids": wedges, "swatch": "Brand"})).unwrap(); s.execute("graph.setData", &json!({"id": g.0, "csv": csv})).unwrap(); assert_eq!(label(&s, g, "North"), Paint::solid(Color::BLACK), "black on the light wedge"); assert_eq!(label(&s, g, "South"), Paint::solid(Color::BLACK)); copy(&mut s, &[g]); for (cmd, choice, north) in [ ("edit.pasteWithoutFormatting", "merge", Color::WHITE), ("edit.paste", "merge", Color::WHITE), ("edit.pasteWithoutFormatting", "add", Color::BLACK), ("edit.paste", "add", Color::BLACK), ] { new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Brand", "color": "#202020", "global": true})).unwrap(); let p = ids_of(&s.execute(cmd, &json!({"swatchConflict": choice})).unwrap())[0]; assert_eq!(label(&s, p, "North"), Paint::solid(north), "{cmd} {choice}"); assert_eq!(label(&s, p, "South"), Paint::solid(Color::BLACK), "{cmd} {choice}"); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert_eq!(label(&s, p, "North"), Paint::solid(north), "{cmd} {choice}: as a redraw sets it"); } // A copy of the pie in the opacity mask of a rectangle follows the same way. s.execute("document.activate", &json!({"index": 0})).unwrap(); let r = rect(&mut s, 10.0, 10.0, 300.0, 300.0); let art = { let d = doc_mut(&mut s); let pie = d.node(g).unwrap().clone(); d.reid(&pie) }; doc_mut(&mut s).node_mut(r).unwrap().extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(art, true))); copy(&mut s, &[r]); new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Brand", "color": "#202020", "global": true})).unwrap(); let p = ids_of(&s.execute("edit.paste", &json!({"swatchConflict": "merge"})).unwrap())[0]; let mask = node(&s, p).extras().mask.as_deref().unwrap().art.clone(); let mut north = None; mask.walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text() == "North" { north = Some(t.first_style().fill.clone()); } }); assert_eq!(north, Some(Paint::solid(Color::WHITE)), "in an opacity mask"); } /// A two-line legend label in a narrow dark wedge, whose text sits off the wedge's middle line, stays white when its graph /// is pasted without formatting. #[test] fn a_legend_label_in_a_narrow_wedge_pasted_without_formatting_stays_readable() { let mut s = session(); // The first wedge fills a quarter from the top; the dark fourth series ("Narrow", series 3) follows it for 0.2 degrees, // narrower than the label's distance from the wedge's middle line. let csv = ",A,B,C,Narrow|,E\nP,9,0,0,0.02,26.98"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); fn narrow(s: &Session, id: NodeId) -> Paint { let mut out = None; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text().starts_with("Narrow") { out = Some(t.first_style().fill.clone()); } }); out.unwrap() } assert_eq!(narrow(&s, g), Paint::solid(Color::WHITE)); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(narrow(&s, p), Paint::solid(Color::WHITE)); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert_eq!(narrow(&s, p), Paint::solid(Color::WHITE)); // A standard legend beside the pie stays black. let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "standard"})).unwrap(); assert_eq!(narrow(&s, g), Paint::solid(Color::BLACK)); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(narrow(&s, p), Paint::solid(Color::BLACK)); // Two series with one name: each label keeps its own wedge's contrast, though the second label lies nearer the // middle of the first (dark) wedge's bounds than of its own. fn xs(s: &Session, id: NodeId) -> Vec { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text() == "X" { out.push(t.first_style().fill.clone()); } }); out } let csv = ",X,X,Y\nP,8,1,89"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 0, "y": 0, "width": 2000, "height": 2000, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); let drawn = xs(&s, g); assert_eq!(drawn, vec![Paint::solid(Color::WHITE), Paint::solid(Color::BLACK)]); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(xs(&s, p), drawn); } /// Two-line legend labels of a light and a dark series with one name keep a redraw's colors when pasted without /// formatting, though the narrow light wedge's label reaches into the dark wedge after it. #[test] fn shared_name_labels_in_a_narrow_wedge_pasted_without_formatting_keep_their_colors() { let mut s = session(); let csv = ",A,B,Q|,Q|\nP,9,0,0.02,26.98"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); fn qs(s: &Session, id: NodeId) -> Vec { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text().starts_with('Q') { out.push(t.first_style().fill.clone()); } }); out } let drawn = qs(&s, g); assert_eq!(drawn.len(), 2); assert_ne!(drawn[0], drawn[1], "one light and one dark series"); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(qs(&s, p), drawn); // Names that hold a line break of their own (a redraw sets them on lines centered on the point, as it sets `|`) keep // them too. for name in ["Q\nQ", "Q\nQ\nQ\nQ\nQ\nQ\nQ\nQ\nQ"] { new_doc(&mut s); let named = json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "series": ["A", "B", name, name], "categories": ["P"], "rows": [[9, 0, 0.02, 26.98]]}); let g = id_of(&s.execute("graph.create", &named).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); let broken = qs(&s, g); assert_eq!(broken.len(), 2); assert_ne!(broken[0], broken[1], "names with line breaks"); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(qs(&s, p), broken, "names with {} line breaks", name.matches('\n').count()); } // So do labels whose names show the same text, one with a line break of its own and one with `|`. new_doc(&mut s); let named = json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "series": ["Q\n", "B", "Q|", "Q|"], "categories": ["P"], "rows": [[9, 0, 0.02, 26.98]]}); let g = id_of(&s.execute("graph.create", &named).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); // The fills of the Q labels by their place from left to right and top to bottom. fn placed(s: &Session, id: NodeId) -> Vec { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text().starts_with('Q') { let o = t.xf.translation(); out.push((o.x, o.y, t.first_style().fill.clone())); } }); out.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.total_cmp(&b.1))); out.into_iter().map(|(_, _, f)| f).collect() } let alike = placed(&s, g); assert_eq!(alike.len(), 3); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(placed(&s, p), alike, "names that show the same text"); // The narrow light wedge's label (the second) brought to the front keeps them too. new_doc(&mut s); let g = id_of(&s.execute("graph.create", &named).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); let legend = node(&s, g).children().unwrap().iter().find(|c| c.name.as_deref() == Some("Legend")).unwrap().clone(); let labels = legend.children().unwrap(); assert_eq!(labels.len(), 3); s.execute("object.arrange.bringToFront", &json!({"ids": [labels[1].id.0]})).unwrap(); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(placed(&s, p), alike, "names that show the same text, labels reordered"); // Labels given another size, which leaves them where they were drawn, keep them too. new_doc(&mut s); let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); sel(&mut s, &[g]); s.execute("text.setStyle", &json!({"size": 14})).unwrap(); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(qs(&s, p), drawn, "resized labels"); // Large labels of four series of one name, drawn again at that size, keep the colors that drawing gave them. new_doc(&mut s); let four = ",Q|,Q|,Q|,Q|\nP,1,1,1,1"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": four})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); sel(&mut s, &[g]); s.execute("text.setStyle", &json!({"size": 200})).unwrap(); s.execute("graph.setData", &json!({"id": g.0, "csv": four})).unwrap(); let large = placed(&s, g); assert_eq!(large.len(), 4); assert!(large.contains(&Paint::solid(Color::WHITE)) && large.contains(&Paint::solid(Color::BLACK)), "{large:?}"); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(placed(&s, p), large, "large labels drawn again"); // A scaled and rotated pie keeps them too. new_doc(&mut s); let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); sel(&mut s, &[g]); s.execute("object.scale", &json!({"sx": 400, "sy": 400})).unwrap(); s.execute("object.rotate", &json!({"angle": 30})).unwrap(); let drawn = qs(&s, g); assert_ne!(drawn[0], drawn[1]); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(qs(&s, p), drawn); } /// The legend labels of a pie that kept a fill of their own (red, or black on every wedge), scaled, with two series of /// one name, are pasted without formatting in the colors a redraw gives them. #[test] fn recolored_wedge_labels_pasted_without_formatting_match_a_redraw() { for fill in ["#ff0000", "#000000"] { recolored_wedge_labels_match_a_redraw(fill); } } fn recolored_wedge_labels_match_a_redraw(fill: &str) { let mut s = session(); let csv = ",A,B,Q|,Q|\nP,9,0,0.02,26.98"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); sel(&mut s, &[g]); s.execute("text.setStyle", &json!({"fill": fill})).unwrap(); s.execute("object.scale", &json!({"sx": 400, "sy": 400})).unwrap(); fn legend(s: &Session, id: NodeId) -> Vec<(String, Paint)> { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && ["A", "Q"].iter().any(|p| t.plain_text().starts_with(p)) { out.push((t.plain_text(), t.first_style().fill.clone())); } }); out } assert!(legend(&s, g).iter().all(|(_, f)| *f == Paint::solid(hex(fill))), "{fill}: {:?}", legend(&s, g)); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; let pasted = legend(&s, p); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); let redrawn = legend(&s, p); assert_eq!(pasted, redrawn, "{fill}"); assert!( redrawn.iter().any(|(_, f)| *f == Paint::solid(Color::WHITE)) && redrawn.iter().any(|(_, f)| *f == Paint::solid(Color::BLACK)), "{fill}: {redrawn:?}" ); } /// A wedge whose fill was changed after its label was drawn gives the label, pasted without formatting, the color a /// redraw gives it. #[test] fn a_repainted_wedge_sets_its_label_color_when_pasted_without_formatting() { let mut s = session(); let csv = ",North,South\nP,1,1"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); s.execute("graph.setData", &json!({"id": g.0, "csv": csv})).unwrap(); fn labels(s: &Session, id: NodeId) -> Vec<(String, Paint)> { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && ["North", "South"].contains(&t.plain_text().as_str()) { out.push((t.plain_text(), t.first_style().fill.clone())); } }); out } // Each wedge takes the other's contrast: the dark one (its label white) white, the light one black. let drawn = labels(&s, g); let white = |name: &str| drawn.iter().any(|(t, f)| t == name && *f == Paint::solid(Color::WHITE)); let mut wedges = vec![]; for c in node(&s, g).children().unwrap().iter() { let Some(series) = c.extras().series_index else { continue }; let dark = white(["North", "South"][series as usize]); c.walk(&mut |m| { if let NodeKind::Path { .. } = m.kind { wedges.push((m.id, dark)); } }); } assert!(wedges.iter().any(|w| w.1) && wedges.iter().any(|w| !w.1), "{drawn:?}"); for (id, dark) in &wedges { s.execute("paint.setFill", &json!({"ids": [id.0], "color": if *dark { "#ffffff" } else { "#000000" }})).unwrap(); } let before = labels(&s, g); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; let pasted = labels(&s, p); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert_eq!(pasted, labels(&s, p), "copied as {before:?}"); } /// Wedges linked to a global swatch that the destination document gives a dark color, merged on Paste without /// Formatting, give their legend labels white characters, as a redraw does; added under a new name, they keep the /// copied light color and black labels. #[test] fn wedges_merged_into_a_dark_swatch_give_white_labels_when_pasted_without_formatting() { let csv = ",North,South\nP,1,1"; fn labels(s: &Session, id: NodeId) -> Vec<(String, Paint)> { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && ["North", "South"].contains(&t.plain_text().as_str()) { out.push((t.plain_text(), t.first_style().fill.clone())); } }); out } let both = |c: Color| vec![("North".to_string(), Paint::solid(c)), ("South".to_string(), Paint::solid(c))]; for (conflict, expected) in [("merge", Color::WHITE), ("add", Color::BLACK)] { let mut s = session(); let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); s.execute("swatch.new", &json!({"name": "Ink", "color": "#ffffff", "global": true})).unwrap(); let mut wedges = vec![]; node(&s, g).walk(&mut |m| { if let NodeKind::Path { .. } = m.kind { wedges.push(m.id.0); } }); s.execute("paint.setFill", &json!({"ids": wedges, "swatch": "Ink"})).unwrap(); s.execute("graph.setData", &json!({"id": g.0, "csv": csv})).unwrap(); assert_eq!(labels(&s, g), both(Color::BLACK), "light wedges have black labels"); copy(&mut s, &[g]); new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Ink", "color": "#000000", "global": true})).unwrap(); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({"swatchConflict": conflict})).unwrap())[0]; let pasted = labels(&s, p); assert_eq!(pasted, both(expected), "{conflict}"); s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); assert_eq!(pasted, labels(&s, p), "{conflict}: as a redraw sets them"); } } /// An object linked to a graphic style and to a swatch merged with the document's keeps its graphic style link when /// pasted without formatting, and its color shows the document's swatch. #[test] fn a_merged_swatch_keeps_graphic_style_links_when_pasted_without_formatting() { let mut s = session(); let r = swatched_rect(&mut s, "Ink", "#ffffff"); sel(&mut s, &[r]); s.execute("graphicStyle.new", &json!({"name": "Sun"})).unwrap(); copy(&mut s, &[r]); new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Ink", "color": "#000000", "global": true})).unwrap(); let v = s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap(); assert_eq!(v["merged"], 1); let p = ids_of(&v)[0]; let style = node(&s, p).extras().graphic_style.and_then(|id| doc(&s).graphic_style_by_id(id)).map(|g| g.name.clone()); assert_eq!(style.as_deref(), Some("Sun")); assert_eq!(fill(&s, p), linked(hex("#000000"), "Ink", 1.0)); } /// When one pie's wedge of a series is repainted and another pie's wedge of that series is not, each pasted legend label /// takes the contrast of the wedge it is in. #[test] fn wedges_of_one_series_painted_apart_keep_their_label_colors_when_pasted_without_formatting() { let mut s = session(); fn north(s: &Session, id: NodeId) -> Vec { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text() == "North" { out.push(t.first_style().fill.clone()); } }); out } // Two pies side by side, and two stacked pies of one series (a disk on a larger one, and on one nearly its size). for (csv, position) in [(",North,South\nP,1,1\nQ,1,1", "even"), (",North\nP,1\nQ,3", "stacked"), (",North\nP,1000\nQ,999", "stacked")] { // The second time, the repainted wedge is brought to the front of its series first. let mut pasted = vec![]; for reorder in [false, true] { pasted.push(paste_painted_apart(&mut s, csv, position, reorder, north)); } assert_eq!(pasted[0], pasted[1], "{csv}"); } // A series name of nine lines, from line breaks a quoted CSV cell keeps, on two stacked pies: each label is centered // on its own ring, as a redraw centers it. fn tall(s: &Session, id: NodeId) -> Vec { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text() == ["N"; 9].join("\n") { out.push(t.first_style().fill.clone()); } }); out } let csv = format!(",\"{}\"\nP,1\nQ,3", ["N"; 9].join("\n")); paste_painted_apart(&mut s, &csv, "stacked", false, tall); } /// Paste without Formatting a pie graph made from `csv` with pies at `position` and Legends in Wedges, after its first /// wedge of the first series takes the other contrast and, with `reorder`, comes to the front of its series. Returns /// what `north` reads from the pasted graph, after checking the two values differ. fn paste_painted_apart(s: &mut Session, csv: &str, position: &str, reorder: bool, north: fn(&Session, NodeId) -> Vec) -> Vec { new_doc(s); let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 400, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges", "piePosition": position})).unwrap(); let drawn = north(s, g); assert_eq!(drawn.len(), 2); assert_eq!(drawn[0], drawn[1]); // Repaint the first North wedge with the contrast its label shows, so it takes the other contrast. let mut first = None; for c in node(s, g).children().unwrap().iter() { if c.extras().series_index == Some(0) && first.is_none() { c.walk(&mut |m| { if first.is_none() && matches!(m.kind, NodeKind::Path { .. }) { first = Some(m.id); } }); } } let first = first.unwrap(); let color = if drawn[0] == Paint::solid(Color::WHITE) { "#ffffff" } else { "#000000" }; s.execute("paint.setFill", &json!({"ids": [first.0], "color": color})).unwrap(); if reorder { s.execute("object.arrange.bringToFront", &json!({"ids": [first.0]})).unwrap(); } copy(s, &[g]); new_doc(s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; let labels = north(s, p); assert_ne!(labels[0], labels[1], "drawn as {drawn:?}, {position}, reorder {reorder}"); labels } /// Legend labels of series that share a name, brought into another order, each keep the contrast of the wedge they are /// in when the pie is pasted without formatting. #[test] fn reordered_shared_name_labels_keep_their_colors_when_pasted_without_formatting() { let mut s = session(); let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": ",X,X\nP,1,1"})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); // Each label's fill, by its place from left to right and top to bottom. fn labels(s: &Session, id: NodeId) -> (Vec, Vec) { let mut out = vec![]; node(s, id).walk(&mut |n| { if let NodeKind::Text(t) = &n.kind && t.plain_text() == "X" { let o = t.xf.translation(); out.push((o.x, o.y, n.id, t.first_style().fill.clone())); } }); out.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.total_cmp(&b.1))); out.into_iter().map(|(_, _, id, f)| (id, f)).unzip() } let (ids, drawn) = labels(&s, g); assert_eq!(drawn.len(), 2); assert_ne!(drawn[0], drawn[1]); let first = node(&s, g).children().unwrap().iter().find(|c| c.name.as_deref() == Some("Legend")).unwrap().children().unwrap()[0].id; assert!(ids.contains(&first)); s.execute("object.arrange.bringToFront", &json!({"ids": [first.0]})).unwrap(); copy(&mut s, &[g]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; assert_eq!(labels(&s, p).1, drawn); } /// A wedge's hidden fill does not set its legend label's color: the fill it shows does. #[test] fn a_hidden_wedge_fill_does_not_color_its_label() { let mut s = session(); let csv = ",North,South\nP,1,1"; let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap()); s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap(); let mut n = node(&s, g).clone(); // A hidden black fill above the light South wedge's fill. for c in n.children_mut().unwrap().iter_mut().filter(|c| c.extras().series_index == Some(1)) { for w in std::sync::Arc::make_mut(c).children_mut().unwrap().iter_mut() { let w = std::sync::Arc::make_mut(w); if let Some(vectorcraft_doc::AppearanceItem::Fill(f)) = w.appearance.items.iter().find(|it| it.is_fill()).cloned() { let hidden = vectorcraft_doc::FillLayer { paint: Paint::solid(Color::BLACK), visible: false, ..f }; w.appearance.items.push(vectorcraft_doc::AppearanceItem::Fill(hidden)); } } } crate::cmd::graph::plain_labels(&mut n, &|_| {}); let mut south = None; n.walk(&mut |m| { if let NodeKind::Text(t) = &m.kind && t.plain_text() == "South" { south = Some(t.first_style().fill.clone()); } }); assert_eq!(south, Some(Paint::solid(Color::BLACK))); } /// A graph inside a group, and a graph inside a graph, get plain labels too. #[test] fn graphs_in_groups_pasted_without_formatting_get_plain_labels() { let mut s = session(); let csv = ",2024\nQ1,3\nQ2,5"; let g = id_of(&s.execute("graph.create", &json!({"type": "column", "x": 100, "y": 100, "width": 120, "height": 80, "csv": csv})).unwrap()); let fresh = graph_label_looks(&s, g); sel(&mut s, &[g]); s.execute("text.setStyle", &json!({"size": 14})).unwrap(); let r = rect(&mut s, 10.0, 10.0, 20.0, 20.0); sel(&mut s, &[g, r]); let group = id_of(&s.execute("object.group", &json!({})).unwrap()); // A copy of the graph placed inside it, as a file may hold one. let inner = { let d = doc_mut(&mut s); let mut copy = d.node(g).unwrap().clone(); copy = d.reid(©); let id = copy.id; d.node_mut(g).unwrap().children_mut().unwrap().push(std::sync::Arc::new(copy)); id }; copy(&mut s, &[group]); new_doc(&mut s); let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap())[0]; let mut graphs = vec![]; node(&s, p).walk(&mut |n| { if let Some(spec) = n.extras().graph.as_deref() { graphs.push((n.id, spec.label_styles.clone())); } }); assert_eq!(graphs.len(), 2, "{inner:?}"); for (id, l) in graphs { assert_eq!((l.values, l.categories, l.legend, l.values_para, l.categories_para, l.legend_para), (None, None, None, None, None, None)); let looks = graph_label_looks(&s, id); assert!(looks.iter().all(|(_, size, _)| *size == fresh[0].1), "{looks:?}"); } } /// A graph without its generated bounds (as a file may hold it) is drawn again where Paste without Formatting put it. #[test] fn a_graph_without_generated_bounds_pasted_without_formatting_follows_the_offset() { let mut s = session(); let csv = ",2024\nQ1,3\nQ2,5"; let g = id_of(&s.execute("graph.create", &json!({"type": "bar", "x": 50, "y": 60, "width": 100, "height": 80, "csv": csv})).unwrap()); let plot = { let mut extras = doc_mut(&mut s).node_mut(g).unwrap().extras_mut(); let spec = extras.graph.as_mut().unwrap(); spec.placed = None; spec.rect }; copy(&mut s, &[g]); let v = s.execute("edit.pasteWithoutFormatting", &json!({"dx": 30, "dy": -5})).unwrap(); let p = ids_of(&v)[0]; s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); let r = node(&s, p).extras().graph.as_deref().unwrap().rect; let off = [r.x0 - plot.x0 - 30.0, r.y0 - plot.y0 + 5.0, r.x1 - plot.x1 - 30.0, r.y1 - plot.y1 + 5.0]; assert!(off.iter().all(|d| d.abs() < 1e-6), "{plot:?} → {r:?}"); // A graph saved with the bounds of all its art but not those of its art without type, drawn with 30 pt labels: the // labels set at 9 pt do not read as a move or scale when it is drawn again. let g = id_of(&s.execute("graph.create", &json!({"type": "bar", "x": 300, "y": 60, "width": 100, "height": 80, "csv": csv})).unwrap()); sel(&mut s, &[g]); s.execute("text.setStyle", &json!({"size": 30})).unwrap(); s.execute("graph.setData", &json!({"id": g.0, "csv": csv})).unwrap(); let plot = { let mut extras = doc_mut(&mut s).node_mut(g).unwrap().extras_mut(); let spec = extras.graph.as_mut().unwrap(); spec.placed_art = None; spec.rect }; copy(&mut s, &[g]); let v = s.execute("edit.pasteWithoutFormatting", &json!({"dx": 30, "dy": -5})).unwrap(); let p = ids_of(&v)[0]; s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap(); let r = node(&s, p).extras().graph.as_deref().unwrap().rect; let off = [r.x0 - plot.x0 - 30.0, r.y0 - plot.y0 + 5.0, r.x1 - plot.x1 - 30.0, r.y1 - plot.y1 + 5.0]; assert!(off.iter().all(|d| d.abs() < 1e-6), "without the bounds of the art without type: {plot:?} → {r:?}"); } #[test] fn pasting_again_reuses_what_an_earlier_paste_added() { let mut s = session(); let r = swatched_rect(&mut s, "Brand", "#ff0000"); // A character style whose fill links to Brand. let t = id_of(&s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Hi"})).unwrap()); let red = serde_json::to_value(linked(hex("#ff0000"), "Brand", 1.0)).unwrap(); s.execute("charStyle.new", &json!({"name": "Loud", "attrs": {"fill": red}})).unwrap(); s.execute("charStyle.apply", &json!({"name": "Loud", "id": t.0})).unwrap(); copy(&mut s, &[r, t]); new_doc(&mut s); s.execute("swatch.new", &json!({"name": "Brand", "color": "#0000ff", "global": true})).unwrap(); let v = s.execute("edit.paste", &json!({"swatchConflict": "add"})).unwrap(); assert_eq!(v["added"], 2, "Brand 2 and Loud: {v}"); let style_fill = |s: &Session| serde_json::from_value::(doc(s).char_styles[0].attrs["fill"].clone()).unwrap(); assert_eq!(style_fill(&s), linked(hex("#ff0000"), "Brand 2", 1.0), "the style's colour follows the renamed swatch"); // Again: Brand 2 and Loud are the pasted ones, nothing piles up. let v = s.execute("edit.paste", &json!({"swatchConflict": "add"})).unwrap(); assert_eq!(v["added"], 0, "{v}"); assert_eq!(renamed(&v), [("swatch".to_string(), "Brand".to_string(), "Brand 2".to_string())]); assert_eq!(fill(&s, ids_of(&v)[0]), linked(hex("#ff0000"), "Brand 2", 1.0)); assert!(doc(&s).swatch("Brand 3").is_none() && doc(&s).char_styles.len() == 1); } /// The active document, to edit its definitions directly. fn doc_mut(s: &mut Session) -> &mut Document { std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc) } /// The pattern a paint paints with. fn pattern_of(p: &Paint) -> Option<&str> { match p { Paint::Pattern { pattern, .. } => Some(pattern), _ => None, } } /// The pattern the fill of the active document's character style `name` paints with. fn style_pattern(s: &Session, name: &str) -> Option { let attrs = &doc(s).char_styles.iter().find(|x| x.name == name)?.attrs; pattern_of(&serde_json::from_value::(attrs.get("fill")?.clone()).ok()?).map(str::to_string) } /// A pattern "Dots" made from a `size` square of `color` in the active document. fn dots(s: &mut Session, size: f64, color: &str) { let square = rect(s, 300.0, 200.0, size, size); s.execute("paint.setFill", &json!({"ids": [square.0], "color": color})).unwrap(); s.execute("object.pattern.make", &json!({"name": "Dots", "edit": false, "ids": [square.0]})).unwrap(); } /// Type "Hi" filled with the pattern "Dots" (a small red square), set in a character style /// "Patterned" whose fill is that pattern. fn patterned_type(s: &mut Session) -> NodeId { dots(s, 10.0, "#ff0000"); let t = id_of(&s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Hi"})).unwrap()); s.execute("paint.setFill", &json!({"ids": [t.0], "swatch": "Dots"})).unwrap(); s.execute("charStyle.new", &json!({"name": "Patterned", "id": t.0})).unwrap(); s.execute("charStyle.apply", &json!({"name": "Patterned", "id": t.0})).unwrap(); t } /// The character style name of a type object's first run, and the pattern that run paints with. fn type_links(s: &Session, id: NodeId) -> (Option, Option) { let NodeKind::Text(tx) = node(s, id).kind else { panic!("not type") }; (tx.runs[0].style.style_name.clone(), pattern_of(&tx.runs[0].style.fill).map(str::to_string)) } /// Type set in a style that paints with a pattern, pasted into a document with another pattern of /// that name: the pattern comes in as "Dots 2", and the style paints with "Dots 2" too, so applying /// it later paints with the pasted pattern. Pasting again adds nothing. #[test] fn pasted_styles_paint_with_the_renamed_pattern_they_use() { let mut s = session(); let t = patterned_type(&mut s); copy(&mut s, &[t]); new_doc(&mut s); dots(&mut s, 30.0, "#0000ff"); let v = s.execute("edit.paste", &json!({})).unwrap(); assert!(doc(&s).pattern("Dots 2").is_some(), "{v}"); assert_eq!(style_pattern(&s, "Patterned").as_deref(), Some("Dots 2"), "{v}"); let named = |n: &str| Some(n.to_string()); assert_eq!(type_links(&s, ids_of(&v)[0]), (named("Patterned"), named("Dots 2"))); let other = id_of(&s.execute("text.create", &json!({"x": 10, "y": 150, "text": "Yo"})).unwrap()); s.execute("charStyle.apply", &json!({"name": "Patterned", "id": other.0})).unwrap(); assert_eq!(type_links(&s, other).1.as_deref(), Some("Dots 2"), "the applied style paints with the pasted pattern"); let counts = |s: &Session| (doc(s).patterns.len(), doc(s).char_styles.len()); let before = counts(&s); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["added"], 0, "{v}"); assert_eq!(counts(&s), before); assert_eq!(type_links(&s, ids_of(&v)[0]), (named("Patterned"), named("Dots 2"))); } /// A document whose "Patterned" style has the pasted style's attributes but whose "Dots" is /// another pattern: that style paints with the document's "Dots", so the pasted one comes in as /// "Patterned 2", painting with "Dots 2", and the document's own is left as it was. Pasting again /// uses the numbered copies. #[test] fn pasted_styles_are_not_matched_to_styles_that_paint_with_another_pattern() { let mut s = session(); let t = patterned_type(&mut s); let style = doc(&s).char_styles.iter().find(|x| x.name == "Patterned").unwrap().clone(); copy(&mut s, &[t]); new_doc(&mut s); dots(&mut s, 30.0, "#0000ff"); doc_mut(&mut s).char_styles.push(style); let own = (doc(&s).char_styles.clone(), doc(&s).pattern("Dots").cloned()); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(style_pattern(&s, "Patterned 2").as_deref(), Some("Dots 2"), "{v}"); let d = doc(&s); assert_eq!((&d.char_styles[..own.0.len()], d.pattern("Dots")), (&own.0[..], own.1.as_ref()), "the document's own are unchanged"); let named = |n: &str| Some(n.to_string()); let links = (named("Patterned 2"), named("Dots 2")); assert_eq!(type_links(&s, ids_of(&v)[0]), links); let counts = |s: &Session| (doc(s).patterns.len(), doc(s).char_styles.len()); let before = counts(&s); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["added"], 0, "{v}"); assert_eq!(counts(&s), before); assert_eq!(type_links(&s, ids_of(&v)[0]), links); } /// A style that paints with a pattern whose tile sets type in that same style is pasted with the /// pattern: when the pattern comes in as "Dots 2", the style paints with "Dots 2", and the tile's /// type is set in the style. Pasting again adds nothing. The commands do not make that loop, so the /// source is a document edited directly. #[test] fn a_pasted_style_and_the_pattern_whose_tile_uses_it_come_in_together() { let mut s = session(); let t = id_of(&s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Tile"})).unwrap()); s.execute("charStyle.new", &json!({"name": "Accent", "attrs": {"kerning": 40}})).unwrap(); s.execute("charStyle.apply", &json!({"name": "Accent", "id": t.0})).unwrap(); s.execute("object.pattern.make", &json!({"name": "Dots", "edit": false, "ids": [t.0]})).unwrap(); let other = id_of(&s.execute("text.create", &json!({"x": 10, "y": 90, "text": "B"})).unwrap()); s.execute("charStyle.apply", &json!({"name": "Accent", "id": other.0})).unwrap(); s.execute("paint.setFill", &json!({"swatch": "Dots", "ids": [other.0]})).unwrap(); s.execute("charStyle.new", &json!({"name": "Painted", "id": other.0})).unwrap(); let d = doc_mut(&mut s); let painted = d.char_styles.iter().find(|x| x.name == "Painted").unwrap().attrs.clone(); d.char_styles.retain(|x| x.name != "Painted"); d.char_styles.iter_mut().find(|x| x.name == "Accent").unwrap().attrs = painted; assert_eq!(style_pattern(&s, "Accent").as_deref(), Some("Dots")); copy(&mut s, &[other]); new_doc(&mut s); dots(&mut s, 30.0, "#0000ff"); let v = s.execute("edit.paste", &json!({})).unwrap(); assert!(doc(&s).pattern("Dots 2").is_some(), "{v}"); assert_eq!(style_pattern(&s, "Accent").as_deref(), Some("Dots 2"), "{v}"); let NodeKind::Text(tile) = &doc(&s).pattern("Dots 2").unwrap().art[0].kind else { panic!("the tile is type") }; assert_eq!(tile.runs[0].style.style_name.as_deref(), Some("Accent")); let after = doc(&s).clone(); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["added"], 0, "{v}"); assert!(doc(&s).patterns == after.patterns && doc(&s).char_styles == after.char_styles, "nothing is added"); // Back in the source document, the loop is the document's own. s.execute("document.activate", &json!({"index": 0})).unwrap(); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!((v["added"].as_u64(), v["renamed"].as_array().map(Vec::len)), (Some(0), Some(0)), "{v}"); } /// A symbol whose art paints with a pattern is not matched to the document's symbol of that name /// and art when the document's pattern of that name is another one: it comes in as "Mark 2", /// painting with "Dots 2". #[test] fn pasted_symbols_are_not_matched_to_symbols_that_paint_with_another_pattern() { let mut s = session(); dots(&mut s, 10.0, "#ff0000"); let r = rect(&mut s, 20.0, 20.0, 50.0, 50.0); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Dots"})).unwrap(); sel(&mut s, &[r]); let mark = id_of(&s.execute("symbol.new", &json!({"name": "Mark"})).unwrap()); copy(&mut s, &[mark]); // The document gets "Mark" and "Dots" from a first paste; then its "Dots" gets another tile. new_doc(&mut s); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["renamed"], json!([]), "{v}"); let tile = &mut doc_mut(&mut s).patterns.iter_mut().find(|p| p.name == "Dots").unwrap().tile; *tile = Rect::new(tile.x0, tile.y0, tile.x1 + 30.0, tile.y1 + 30.0); let v = s.execute("edit.paste", &json!({})).unwrap(); assert!(renamed(&v).contains(&("symbol".to_string(), "Mark".to_string(), "Mark 2".to_string())), "{v}"); let art = |s: &Session, name: &str| fill_of(&doc(s).symbols.iter().find(|x| x.name == name).unwrap().art); assert_eq!((art(&s, "Mark").as_deref(), art(&s, "Mark 2").as_deref()), (Some("Dots"), Some("Dots 2"))); assert!(matches!(node(&s, ids_of(&v)[0]).kind, NodeKind::SymbolInstance { ref symbol, .. } if symbol == "Mark 2")); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["added"], 0, "{v}"); } /// The pattern the first filled object in `n` paints with. fn fill_of(n: &Node) -> Option { let mut found = None; n.walk(&mut |m| { if found.is_none() { found = pattern_of(&m.appearance.fill_paint()).map(str::to_string); } }); found } /// A brush whose art sets type in a character style is not matched to the document's brush of /// that name and art when the document's style of that name is another one: the style comes in as /// "Accent 2", and the brush as a copy whose type is set in "Accent 2". #[test] fn pasted_brushes_are_not_matched_to_brushes_that_use_another_style() { let mut s = session(); let t = id_of(&s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ink"})).unwrap()); s.execute("charStyle.new", &json!({"name": "Accent", "attrs": {"kerning": 40}})).unwrap(); s.execute("charStyle.apply", &json!({"name": "Accent", "id": t.0})).unwrap(); let name = s.execute("brush.new", &json!({"type": "art", "name": "Lettering", "ids": [t.0]})).unwrap()["name"].as_str().unwrap().to_string(); let path = rect(&mut s, 200.0, 200.0, 40.0, 10.0); s.execute("brush.apply", &json!({"name": name, "ids": [path.0]})).unwrap(); let brush = vectorcraft_brush::find(doc(&s), &name).unwrap(); copy(&mut s, &[path]); new_doc(&mut s); s.execute("charStyle.new", &json!({"name": "Accent", "attrs": {"kerning": 10}})).unwrap(); let d = doc_mut(&mut s); let mut lib = vectorcraft_brush::library(d); lib.push(brush); vectorcraft_brush::store(d, &lib); let v = s.execute("edit.paste", &json!({})).unwrap(); let names = renamed(&v); let copied = names.iter().find(|(k, from, _)| k == "brush" && *from == name).map(|(_, _, to)| to.clone()); assert!(names.contains(&("charStyle".to_string(), "Accent".to_string(), "Accent 2".to_string())), "{v}"); let copied = copied.unwrap_or_else(|| panic!("the brush is added under a free name: {v}")); let style_of = |s: &Session, b: &str| { let b = vectorcraft_brush::find(doc(s), b).unwrap(); let mut found = None; for a in b.art() { a.walk(&mut |m| { if let NodeKind::Text(tx) = &m.kind { found = found.take().or_else(|| tx.runs[0].style.style_name.clone()); } }); } found }; assert_eq!((style_of(&s, &name).as_deref(), style_of(&s, &copied).as_deref()), (Some("Accent"), Some("Accent 2"))); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(v["added"], 0, "{v}"); } #[test] fn brushes_travel_with_their_strokes() { let mut s = session(); let name = s .execute("brush.new", &json!({"type": "calligraphic", "name": "Wide Nib", "params": {"angle": 30, "roundness": 20, "size": 9}})) .unwrap()["name"] .as_str() .unwrap() .to_string(); let r = rect(&mut s, 10.0, 10.0, 50.0, 50.0); s.execute("brush.apply", &json!({"name": name, "ids": [r.0]})).unwrap(); copy(&mut s, &[r]); assert_eq!(s.clipboard.brushes.len(), 1); new_doc(&mut s); assert!(vectorcraft_brush::find(doc(&s), &name).is_none()); s.execute("edit.paste", &json!({})).unwrap(); assert!(vectorcraft_brush::find(doc(&s), &name).is_some()); } #[test] fn pasting_back_into_the_source_document_adds_nothing() { let mut s = session(); let r = swatched_rect(&mut s, "Brand", "#ff0000"); copy(&mut s, &[r]); // Redefining the swatch afterwards is no conflict in its own document. s.execute("swatch.edit", &json!({"name": "Brand", "color": "#00ff00"})).unwrap(); assert_eq!(s.execute("clipboard.conflicts", &json!({})).unwrap()["swatches"], json!([])); let v = s.execute("edit.paste", &json!({})).unwrap(); assert_eq!((v["added"].as_u64(), v["renamed"].as_array().map(Vec::len)), (Some(0), Some(0))); assert_eq!(fill(&s, ids_of(&v)[0]), linked(hex("#00ff00"), "Brand", 1.0), "it shows the swatch as it is now"); } #[test] fn paste_without_formatting_leaves_text_styles_behind() { let mut s = session(); let t = id_of(&s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Hello"})).unwrap()); s.execute("charStyle.new", &json!({"name": "Emphasis", "attrs": {"size": 24.0}})).unwrap(); s.execute("charStyle.apply", &json!({"name": "Emphasis", "id": t.0})).unwrap(); copy(&mut s, &[t]); new_doc(&mut s); s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap(); assert!(doc(&s).char_styles.is_empty()); s.execute("edit.paste", &json!({})).unwrap(); assert_eq!(doc(&s).char_styles.len(), 1); } #[test] fn clipboard_svg_carries_its_own_patterns() { let mut s = session(); let dot = rect(&mut s, 0.0, 0.0, 10.0, 10.0); sel(&mut s, &[dot]); s.execute("object.pattern.make", &json!({"name": "Dots", "width": 20, "height": 20})).unwrap(); s.execute("object.pattern.done", &json!({})).unwrap(); let r = rect(&mut s, 20.0, 20.0, 100.0, 80.0); s.execute("paint.setFill", &json!({"ids": [r.0], "swatch": "Dots"})).unwrap(); copy(&mut s, &[r]); // Another document is active when the clipboard is published. new_doc(&mut s); let svg = s.clipboard_svg().unwrap(); assert!(svg.contains(">(); s.execute("select.none", &json!({})).unwrap(); let back = ids_of(&s.execute("edit.pasteInBack", &json!({})).unwrap()); assert_eq!(&layer(&s)[..2], &back[..], "pasted at the bottom (index 0), in order"); s.execute("select.none", &json!({})).unwrap(); let front = ids_of(&s.execute("edit.pasteInFront", &json!({})).unwrap()); let l = layer(&s); assert_eq!(&l[l.len() - 2..], &front[..], "pasted on top, in order"); // With a selection: right above / below it. sel(&mut s, &[a]); let above = ids_of(&s.execute("edit.pasteInFront", &json!({})).unwrap()); let l = layer(&s); let i = l.iter().position(|id| *id == a).unwrap(); assert_eq!(&l[i + 1..i + 3], &above[..]); sel(&mut s, &[a]); let below = ids_of(&s.execute("edit.pasteInBack", &json!({})).unwrap()); let l = layer(&s); let i = l.iter().position(|id| *id == a).unwrap(); assert_eq!(&l[i - 2..i], &below[..]); } #[test] fn front_and_back_beside_a_compound_paths_member_go_beside_the_compound_path() { let mut s = session(); let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); let b = rect(&mut s, 20.0, 0.0, 10.0, 10.0); sel(&mut s, &[a, b]); let c = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap()); let members = |s: &Session| doc(s).node(c).unwrap().children().unwrap().iter().map(|n| n.id).collect::>(); let before = members(&s); let layer = |s: &Session| doc(s).layers[0].children().unwrap().iter().map(|n| n.id).collect::>(); // A compound path and a group, each pasted with one of the compound path's members selected. let other = rect(&mut s, 40.0, 0.0, 10.0, 10.0); sel(&mut s, &[other]); let group = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()); for copied in [c, group] { copy(&mut s, &[copied]); sel(&mut s, &[before[0]]); let above = ids_of(&s.execute("edit.pasteInFront", &json!({})).unwrap()); let l = layer(&s); let i = l.iter().position(|id| *id == c).unwrap(); assert_eq!(&l[i + 1..i + 2], &above[..], "right above the compound path"); sel(&mut s, &[before[1]]); let below = ids_of(&s.execute("edit.pasteInBack", &json!({})).unwrap()); let l = layer(&s); let i = l.iter().position(|id| *id == c).unwrap(); assert_eq!(&l[i - 1..i], &below[..], "right below the compound path"); assert_eq!(members(&s), before, "the compound path keeps its own members"); } // A path still goes in front of the member, inside the compound path. let loose = rect(&mut s, 60.0, 0.0, 10.0, 10.0); copy(&mut s, &[loose]); sel(&mut s, &[before[0]]); let path = ids_of(&s.execute("edit.pasteInFront", &json!({})).unwrap()); assert_eq!(members(&s), [before[0], path[0], before[1]]); } #[test] fn paste_in_back_of_a_clipping_path_keeps_it_the_clipping_path() { let mut s = session(); let children = |s: &Session, g: NodeId| doc(s).node(g).unwrap().children().unwrap().iter().map(|n| n.id).collect::>(); let loose = rect(&mut s, 200.0, 0.0, 10.0, 10.0); let other = rect(&mut s, 220.0, 0.0, 10.0, 10.0); sel(&mut s, &[other]); let group = id_of(&s.execute("object.group", &json!({})).unwrap()); // A path as the clipping path, and a compound path as the clipping path (a group pasted in back // of a member goes beside the compound path). let art = rect(&mut s, 0.0, 0.0, 100.0, 100.0); let mask = rect(&mut s, 10.0, 10.0, 50.0, 50.0); sel(&mut s, &[art, mask]); let g = id_of(&s.execute("object.clippingMask.make", &json!({})).unwrap()); let art2 = rect(&mut s, 0.0, 120.0, 100.0, 100.0); let (a, b) = (rect(&mut s, 10.0, 130.0, 20.0, 20.0), rect(&mut s, 40.0, 130.0, 20.0, 20.0)); sel(&mut s, &[a, b]); let c = id_of(&s.execute("object.compoundPath.make", &json!({})).unwrap()); sel(&mut s, &[art2, c]); let g2 = id_of(&s.execute("object.clippingMask.make", &json!({})).unwrap()); for (g, clipping, target, copies) in [(g, mask, mask, vec![loose, group]), (g2, c, a, vec![group])] { assert_eq!(children(&s, g)[0], clipping); for copied in copies { copy(&mut s, &[copied]); sel(&mut s, &[target]); let pasted = ids_of(&s.execute("edit.pasteInBack", &json!({})).unwrap()); let ch = children(&s, g); assert_eq!(ch[0], clipping, "the clipping path stays the bottom child"); assert_eq!(&ch[1..2], &pasted[..], "right above the clipping path"); } } } #[test] fn paste_on_all_artboards_keeps_the_offset_to_the_source_artboard() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 3})).unwrap(); let boards: Vec = doc(&s).artboards.iter().map(|a| a.rect).collect(); // On artboard 2, 10 pt right and 15 pt down from its corner. let r = rect(&mut s, boards[1].x0 + 10.0, boards[1].y0 + 15.0, 20.0, 20.0); copy(&mut s, &[r]); assert_eq!(s.clipboard.source_artboard, Some(boards[1])); let ids = ids_of(&s.execute("edit.pasteOnAllArtboards", &json!({})).unwrap()); assert_eq!(ids.len(), 3); for (id, b) in ids.iter().zip(&boards) { assert_eq!(doc(&s).bounds_of(&[*id], false).unwrap().origin(), Point::new(b.x0 + 10.0, b.y0 + 15.0)); } } /// Paste in Place, in Front and in Back onto the active artboard (#693): where the objects were on /// the artboard they were copied from, on the one named; without it, where they were. #[test] fn in_place_pastes_go_onto_the_artboard_named() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 3})).unwrap(); let boards: Vec = doc(&s).artboards.iter().map(|a| a.rect).collect(); let r = rect(&mut s, boards[0].x0 + 10.0, boards[0].y0 + 15.0, 20.0, 20.0); copy(&mut s, &[r]); for cmd in ["edit.pasteInPlace", "edit.pasteInFront", "edit.pasteInBack"] { let ids = ids_of(&s.execute(cmd, &json!({"artboard": 2})).unwrap()); assert_eq!(doc(&s).bounds_of(&ids, false).unwrap().origin(), Point::new(boards[2].x0 + 10.0, boards[2].y0 + 15.0), "{cmd}"); let ids = ids_of(&s.execute(cmd, &json!({})).unwrap()); assert_eq!(doc(&s).bounds_of(&ids, false).unwrap().origin(), Point::new(boards[0].x0 + 10.0, boards[0].y0 + 15.0), "{cmd} without one"); // An artboard that isn't there, or a value that isn't an index: an error, and nothing pasted. let before = doc(&s).clone(); for bad in [json!(9), json!(-1), json!(1.5), json!("1")] { assert!(s.execute(cmd, &json!({"artboard": bad})).is_err(), "{cmd} with artboard {bad}"); } assert_eq!(doc(&s), &before, "{cmd}"); } } /// Paste in Place, in Front and in Back onto several artboards (the Artboard tool's selection, which /// the app passes as `artboards`): a copy on each, where the objects were on the artboard they were /// copied from, the copies in artboard order and in their own paint order, all selected, in one undo /// step. #[test] fn in_place_pastes_put_a_copy_on_each_artboard_named() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 4})).unwrap(); let boards: Vec = doc(&s).artboards.iter().map(|a| a.rect).collect(); let a = rect(&mut s, boards[1].x0 + 10.0, boards[1].y0 + 15.0, 20.0, 20.0); let b = rect(&mut s, boards[1].x0 + 50.0, boards[1].y0 + 5.0, 10.0, 10.0); copy(&mut s, &[a, b]); for cmd in ["edit.pasteInPlace", "edit.pasteInFront", "edit.pasteInBack"] { let undo = s.doc().unwrap().history.undo.len(); let before = doc(&s).clone(); let ids = ids_of(&s.execute(cmd, &json!({"artboards": [3, 0]})).unwrap()); assert_eq!(ids.len(), 4, "{cmd}: two objects on each of two artboards"); for (pair, board) in ids.chunks(2).zip([boards[0], boards[3]]) { assert_eq!(doc(&s).bounds_of(&pair[..1], false).unwrap().origin(), Point::new(board.x0 + 10.0, board.y0 + 15.0), "{cmd}"); assert_eq!(doc(&s).bounds_of(&pair[1..], false).unwrap().origin(), Point::new(board.x0 + 50.0, board.y0 + 5.0), "{cmd}"); } let layer: Vec = doc(&s).layers[0].children().into_iter().flatten().map(|n| n.id).collect(); let at: Vec = ids.iter().map(|id| layer.iter().position(|n| n == id).unwrap()).collect(); assert!(at.windows(2).all(|w| w[0] < w[1]), "{cmd}: in paint order, artboard by artboard: {at:?}"); assert_eq!(s.doc().unwrap().selection.in_paint_order(doc(&s)), ids, "{cmd}: the copies are selected"); assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "{cmd}: one undo step"); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(doc(&s), &before, "{cmd}: undo takes every copy away"); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(doc(&s).layers[0].children().into_iter().flatten().count(), layer.len(), "{cmd}: redo"); // `artboard` wins over `artboards`. let ids = ids_of(&s.execute(cmd, &json!({"artboard": 2, "artboards": [0, 3]})).unwrap()); assert_eq!(doc(&s).bounds_of(&ids, false).unwrap().origin(), Point::new(boards[2].x0 + 10.0, boards[2].y0 + 5.0), "{cmd}"); // A list that is empty, names an artboard the document lacks or names one twice, holds a // value that is not a whole number, or isn't a list, and an `artboard` that is not a whole // number or not an artboard: an error naming the fault, and nothing pasted. Both keys are // checked when both are given. let (before, undo) = (doc(&s).clone(), s.doc().unwrap().history.undo.len()); let (not_list, missing, not_whole) = ( "`artboards` must be a list of artboard indices", "`artboards` names an artboard the document does not have", "`artboards` must contain whole numbers", ); let cases = [ (json!({"artboards": []}), not_list), (json!({"artboards": 2}), not_list), (json!({"artboards": "0,1"}), not_list), (json!({"artboards": [0, 4]}), missing), (json!({"artboards": [1, 1]}), "`artboards` names an artboard twice"), (json!({"artboards": [0, -1]}), not_whole), (json!({"artboards": [0, 1.5]}), not_whole), (json!({"artboards": [4, "1"]}), not_whole), (json!({"artboard": 1, "artboards": [7]}), missing), (json!({"artboard": 1, "artboards": ["1"]}), not_whole), (json!({"artboard": 4}), "`artboard` must be the index of an artboard of the document"), (json!({"artboard": -1}), "`artboard` must be a whole number"), (json!({"artboard": 1.5}), "`artboard` must be a whole number"), (json!({"artboard": "1"}), "`artboard` must be a whole number"), (json!({"artboard": null}), "`artboard` must be a whole number"), (json!({"artboard": "1", "artboards": [9]}), "`artboard` must be a whole number"), ]; for (p, want) in cases { let e = s.execute(cmd, &p).unwrap_err().to_string(); assert_eq!(e, format!("invalid parameters for `{cmd}`: {want}"), "{cmd} {p}"); } assert_eq!((doc(&s), s.doc().unwrap().history.undo.len()), (&before, undo), "{cmd}"); } } /// With the Artboard tool chosen and several artboards selected, Paste in Place, in Front and in /// Back put a copy on each without naming them; the journal notes them, so a replay pastes on the /// same artboards, and a recorded action leaves them out. With one selected, or another tool, the /// objects go where they were. #[test] fn in_place_pastes_follow_the_artboard_tool_selection() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 3})).unwrap(); let boards: Vec = doc(&s).artboards.iter().map(|a| a.rect).collect(); let r = rect(&mut s, boards[0].x0 + 10.0, boards[0].y0 + 15.0, 20.0, 20.0); copy(&mut s, &[r]); let origins = |s: &Session, ids: &[NodeId]| ids.iter().map(|id| doc(s).bounds_of(&[*id], false).unwrap().origin()).collect::>(); let on = |b: &[usize]| b.iter().map(|i| Point::new(boards[*i].x0 + 10.0, boards[*i].y0 + 15.0)).collect::>(); s.select_tool("artboard", ViewInfo::default()).unwrap(); for cmd in ["edit.pasteInPlace", "edit.pasteInFront", "edit.pasteInBack"] { s.set_tool_option("selected", &json!([2, 1])); let start = s.journal.len(); let ids = ids_of(&s.execute(cmd, &json!({})).unwrap()); assert_eq!(origins(&s, &ids), on(&[1, 2]), "{cmd}"); assert_eq!(s.journal.since(start).last().map(|(_, p)| p["artboards"].clone()), Some(json!([1, 2])), "{cmd}: journaled"); assert!(s.journal_for_action(start).iter().all(|(_, p)| p.get("artboards").is_none()), "{cmd}: not in an action"); // A stale index in the tool's selection is passed over. s.set_tool_option("selected", &json!([0, 9])); let ids = ids_of(&s.execute(cmd, &json!({})).unwrap()); assert_eq!(origins(&s, &ids), on(&[0]), "{cmd}: one left"); s.set_tool_option("selected", &json!([1])); let ids = ids_of(&s.execute(cmd, &json!({})).unwrap()); assert_eq!(origins(&s, &ids), on(&[0]), "{cmd}: one selected, where it was"); } s.set_tool_option("selected", &json!([1, 2])); s.select_tool("selection", ViewInfo::default()).unwrap(); let ids = ids_of(&s.execute("edit.pasteInPlace", &json!({})).unwrap()); assert_eq!(origins(&s, &ids), on(&[0]), "another tool: where it was"); } /// Art copied from no artboard onto several: it keeps its place on the first and its offset to the /// first on the others. Guides alone go on each artboard named. #[test] fn in_place_pastes_onto_several_artboards_of_art_off_them_and_guides() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 3})).unwrap(); let boards: Vec = doc(&s).artboards.iter().map(|a| a.rect).collect(); let r = rect(&mut s, boards[0].x0 - 100.0, boards[0].y0 + 15.0, 20.0, 20.0); copy(&mut s, &[r]); assert_eq!(s.clipboard.source_artboard, None); let ids = ids_of(&s.execute("edit.pasteInPlace", &json!({"artboards": [1, 2]})).unwrap()); let at: Vec = ids.iter().map(|id| doc(&s).bounds_of(&[*id], false).unwrap().origin()).collect(); let first = Point::new(boards[0].x0 - 100.0, boards[0].y0 + 15.0); assert_eq!(at, [first, first + (boards[2].origin() - boards[1].origin())]); // Guides alone, copied from artboard 1: one on each artboard named, 30 pt into it. s.execute("guide.add", &json!({"vertical": true, "pos": boards[0].x0 + 30.0})).unwrap(); s.execute("select.none", &json!({})).unwrap(); s.execute("guide.select", &json!({"indexes": [0]})).unwrap(); s.execute("edit.copy", &json!({})).unwrap(); let r = s.execute("edit.pasteInFront", &json!({"artboards": [1, 2]})).unwrap(); assert_eq!(r["guides"], 2); let mut guides: Vec = doc(&s).ruler_guides().iter().map(|g| g.pos).collect(); guides.sort_by(f64::total_cmp); assert_eq!(guides, [boards[0].x0 + 30.0, boards[1].x0 + 30.0, boards[2].x0 + 30.0]); } /// Artboards on the clipboard come back once, where they were, whichever artboards are named. #[test] fn in_place_pastes_of_copied_artboards_ignore_the_artboards_named() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 3})).unwrap(); rect(&mut s, 10.0, 10.0, 20.0, 20.0); s.execute("artboard.copy", &json!({"index": 0, "art": true})).unwrap(); let r = s.execute("edit.pasteInPlace", &json!({"artboards": [1, 2]})).unwrap(); assert_eq!(r["artboards"], json!([3])); assert_eq!(ids_of(&r).len(), 1); assert_eq!(doc(&s).artboards[3].rect, doc(&s).artboards[0].rect); } /// Art copied from beside the artboards goes back where it was, whichever artboard is active (#1924). #[test] fn in_place_pastes_of_art_off_the_artboards_stay_where_it_was() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 2})).unwrap(); let boards: Vec = doc(&s).artboards.iter().map(|a| a.rect).collect(); let r = rect(&mut s, boards[0].x0 - 100.0, boards[0].y0 + 15.0, 20.0, 20.0); copy(&mut s, &[r]); for cmd in ["edit.pasteInPlace", "edit.pasteInFront", "edit.pasteInBack"] { let ids = ids_of(&s.execute(cmd, &json!({"artboard": 1})).unwrap()); assert_eq!(doc(&s).bounds_of(&ids, false).unwrap().origin(), Point::new(boards[0].x0 - 100.0, boards[0].y0 + 15.0), "{cmd}"); } } /// Art centered on an artboard's right or bottom edge is copied from that artboard: Paste in Place /// puts it on the active artboard where it was on that one. #[test] fn in_place_pastes_of_art_on_an_artboard_edge_go_onto_the_artboard_named() { let mut s = Session::new(); s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 2})).unwrap(); let boards: Vec = doc(&s).artboards.iter().map(|a| a.rect).collect(); let b = boards[1]; // A line along the right edge of artboard 2, then one along its bottom edge. for (x1, y1, x2, y2) in [(b.x1, b.y0 + 10.0, b.x1, b.y0 + 40.0), (b.x0 + 10.0, b.y1, b.x0 + 40.0, b.y1)] { let line = id_of(&s.execute("shape.line", &json!({"x1": x1, "y1": y1, "x2": x2, "y2": y2})).unwrap()); copy(&mut s, &[line]); assert_eq!(s.clipboard.source_artboard, Some(b)); let ids = ids_of(&s.execute("edit.pasteInPlace", &json!({"artboard": 0})).unwrap()); let moved = doc(&s).bounds_of(&ids, false).unwrap().origin() - doc(&s).bounds_of(&[line], false).unwrap().origin(); assert_eq!(moved, boards[0].origin() - b.origin()); } } #[test] fn paste_remembers_layers_restores_the_source_layers() { let mut s = session(); let first = doc(&s).layers[0].id; let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); let art = id_of(&s.execute("layer.new", &json!({"name": "Art"})).unwrap()); let b = rect(&mut s, 20.0, 0.0, 10.0, 10.0); copy(&mut s, &[a, b]); let names: Vec<_> = s.clipboard.source_layers.iter().map(|l| l.as_ref().map(|l| l.names.clone())).collect(); assert_eq!(names, [Some(vec!["Layer 1".to_string()]), Some(vec!["Art".to_string()])]); let other = id_of(&s.execute("layer.new", &json!({"name": "Other"})).unwrap()); assert_eq!(s.execute("layer.pasteRemembersLayers", &json!({})).unwrap()["on"], true); assert!(doc(&s).paste_remembers_layers); assert_eq!(s.execute("document.inspect", &json!({})).unwrap()["pasteRemembersLayers"], true); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); let parents: Vec<_> = ids.iter().map(|id| doc(&s).parent_of(*id)).collect(); assert_eq!(parents, [Some(first), Some(art)]); // In a document without those layers they are made. new_doc(&mut s); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); let names: Vec<_> = ids.iter().map(|id| doc(&s).node(doc(&s).parent_of(*id).unwrap()).unwrap().name.clone().unwrap()).collect(); assert_eq!(names, ["Layer 1", "Art"]); assert_eq!(doc(&s).layers.len(), 2, "Layer 1 exists; Art is new"); // The option is an undoable document setting. s.execute("edit.undo", &json!({})).unwrap(); s.execute("edit.undo", &json!({})).unwrap(); assert!(!doc(&s).paste_remembers_layers); // Off: everything goes to the current layer. s.execute("document.activate", &json!({"index": 0})).unwrap(); assert_eq!(s.execute("layer.pasteRemembersLayers", &json!({"on": false})).unwrap()["on"], false); s.execute("layer.setCurrent", &json!({"id": other.0})).unwrap(); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); assert!(ids.iter().all(|id| doc(&s).parent_of(*id) == Some(other))); } /// A sublayer `name` made inside `parent`; it becomes the current layer. fn sublayer(s: &mut Session, parent: NodeId, name: &str) -> NodeId { id_of(&s.execute("layer.newSublayer", &json!({"parent": parent.0, "name": name})).unwrap()) } /// The names of the layers around `id`, the top-level layer first. fn layer_path(s: &Session, id: NodeId) -> Vec { let d = doc(s); d.ancestry(id).unwrap().iter().filter_map(|a| d.node(*a).filter(|n| n.is_layer())).map(|l| l.name.clone().unwrap()).collect() } /// Art from two sublayers of the same name in different layers pastes back into each one; in /// another document a missing sublayer is made inside its layer, and a missing layer on top with /// the sublayer inside, in the paste's one undo step. #[test] fn paste_remembers_layers_keeps_same_named_sublayers_apart() { let mut s = session(); let first = doc(&s).layers[0].id; let sub1 = sublayer(&mut s, first, "Sub"); let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); let second = id_of(&s.execute("layer.new", &json!({"name": "Layer 2", "top": true})).unwrap()); let sub2 = sublayer(&mut s, second, "Sub"); let b = rect(&mut s, 20.0, 0.0, 10.0, 10.0); copy(&mut s, &[a, b]); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); s.execute("layer.setCurrent", &json!({"id": first.0})).unwrap(); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); let parents: Vec<_> = ids.iter().map(|id| doc(&s).parent_of(*id)).collect(); assert_eq!(parents, [Some(sub1), Some(sub2)]); new_doc(&mut s); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let before = doc(&s).clone(); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); let paths: Vec<_> = ids.iter().map(|id| layer_path(&s, *id)).collect(); assert_eq!(paths, [["Layer 1", "Sub"], ["Layer 2", "Sub"]]); assert_eq!(doc(&s).layers.len(), 2, "Layer 1 is kept; Layer 2 is new"); assert_eq!(doc(&s).layers[0].children().unwrap().len(), 1, "Sub is made inside Layer 1"); let after = doc(&s).clone(); // Pasting again finds the layers made. let again = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); let parents: Vec<_> = again.iter().map(|id| doc(&s).parent_of(*id)).collect(); assert_eq!(parents, ids.iter().map(|id| doc(&s).parent_of(*id)).collect::>()); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(*doc(&s), after); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(*doc(&s), before, "one undo step takes the art and the layers made for it"); } /// Art whose sublayer was deleted after the copy pastes into a new sublayer of that name inside /// the same layer, not into a sublayer of that name in another layer. #[test] fn paste_remembers_layers_makes_a_deleted_sublayer_again_inside_its_layer() { let mut s = session(); let first = doc(&s).layers[0].id; let sub = sublayer(&mut s, first, "Sub"); let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); let second = id_of(&s.execute("layer.new", &json!({"name": "Layer 2", "top": true})).unwrap()); let elsewhere = sublayer(&mut s, second, "Sub"); copy(&mut s, &[a]); s.execute("layer.delete", &json!({"id": sub.0})).unwrap(); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); let made = doc(&s).parent_of(ids[0]).unwrap(); assert_ne!(made, elsewhere); assert_eq!(doc(&s).parent_of(made), Some(first)); assert_eq!(layer_path(&s, ids[0]), ["Layer 1", "Sub"]); } /// Art whose sublayer was moved into another layer after the copy pastes into that sublayer where /// it is now; no sublayer is made where it was. #[test] fn paste_remembers_layers_follows_a_moved_sublayer() { let mut s = session(); let first = doc(&s).layers[0].id; let sub = sublayer(&mut s, first, "Sub"); let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); let second = id_of(&s.execute("layer.new", &json!({"name": "Layer 2", "top": true})).unwrap()); copy(&mut s, &[a]); s.execute("layer.move", &json!({"id": sub.0, "target": second.0})).unwrap(); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); assert_eq!(doc(&s).parent_of(ids[0]), Some(sub)); assert_eq!(layer_path(&s, ids[0]), ["Layer 2", "Sub"]); assert!(node(&s, first).children().unwrap().is_empty(), "no Sub is made in Layer 1"); } /// In another document with layers of the same names, art goes into the topmost chain of layers /// that matches the most names, a shown and unlocked one before a hidden or locked one. #[test] fn paste_remembers_layers_takes_the_topmost_open_match_of_repeated_names() { let mut s = session(); let first = doc(&s).layers[0].id; sublayer(&mut s, first, "Sub"); let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); copy(&mut s, &[a]); new_doc(&mut s); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let lower = doc(&s).layers[0].id; let lower_sub = sublayer(&mut s, lower, "Sub"); s.execute("layer.new", &json!({"name": "Sub", "top": true})).unwrap(); let upper = id_of(&s.execute("layer.new", &json!({"name": "Layer 1", "top": true})).unwrap()); // The upper Layer 1 has no Sub, and a top-level Sub is not inside a Layer 1: the lower chain // matches both names. let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); assert_eq!(doc(&s).parent_of(ids[0]), Some(lower_sub)); let upper_sub = sublayer(&mut s, upper, "Sub"); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); assert_eq!(doc(&s).parent_of(ids[0]), Some(upper_sub), "the topmost of two full matches"); s.execute("layer.setProps", &json!({"id": upper_sub.0, "locked": true})).unwrap(); let ids = ids_of(&s.execute("edit.paste", &json!({})).unwrap()); assert_eq!(doc(&s).parent_of(ids[0]), Some(lower_sub), "an unlocked match before a locked one"); } /// A remembered layer or sublayer that is hidden or locked, or inside a layer that is, refuses the /// whole paste: the document, the selection and the undo history stay as they were. #[test] fn paste_remembers_layers_refuses_a_hidden_or_locked_layer() { let (locked, hidden) = (json!({"locked": true}), json!({"visible": false})); for (on_sub, props) in [(true, &locked), (true, &hidden), (false, &locked), (false, &hidden)] { let mut s = session(); let first = doc(&s).layers[0].id; let sub = sublayer(&mut s, first, "Sub"); let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); let other = id_of(&s.execute("layer.new", &json!({"name": "Other", "top": true})).unwrap()); let b = rect(&mut s, 20.0, 0.0, 10.0, 10.0); copy(&mut s, &[b, a]); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let mut p = props.clone(); p["id"] = json!(if on_sub { sub.0 } else { first.0 }); s.execute("layer.setProps", &p).unwrap(); s.execute("layer.setCurrent", &json!({"id": other.0})).unwrap(); let before = s.doc().unwrap().clone(); assert!(s.execute("edit.paste", &json!({})).is_err(), "{p}"); assert_eq!(s.doc().unwrap().doc, before.doc, "{p}"); assert_eq!(s.doc().unwrap().selection, before.selection, "{p}"); assert_eq!(s.doc().unwrap().history.undo.len(), before.history.undo.len(), "{p}"); } // In another document, a locked layer of the copied layer's name is refused too. let mut s = session(); let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0); copy(&mut s, &[a]); new_doc(&mut s); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let locked = doc(&s).layers[0].id; id_of(&s.execute("layer.new", &json!({"name": "Flyer"})).unwrap()); s.execute("layer.setProps", &json!({"id": locked.0, "locked": true})).unwrap(); let before = doc(&s).clone(); assert!(s.execute("edit.paste", &json!({})).is_err()); assert_eq!(*doc(&s), before, "no second Layer 1 is made"); } #[test] fn paste_remembers_layers_survives_save_and_old_files_load_without_it() { let mut s = session(); s.execute("layer.pasteRemembersLayers", &json!({"on": true})).unwrap(); let bytes = vectorcraft_format::save(doc(&s), false); assert!(vectorcraft_format::load(&bytes).unwrap().paste_remembers_layers); let v: Value = serde_json::from_slice(&vectorcraft_format::save(&Document::new(10.0, 10.0), false)).unwrap(); assert!(v.get("paste_remembers_layers").is_none(), "off is not written"); assert!(!vectorcraft_format::load(v.to_string().as_bytes()).unwrap().paste_remembers_layers); } /// Verify document-scoped object IDs, grab-point placement and one destination Undo/Redo step. #[test] fn artwork_drop_uses_source_ids_hotspot_and_one_target_undo_step() { let mut s = session(); let r = swatched_rect(&mut s, "Brand", "#ff0000"); let source = s.doc().unwrap().clone(); new_doc(&mut s); let other = swatched_rect(&mut s, "Brand", "#0000ff"); assert_eq!(r, other, "node ids collide across documents"); copy(&mut s, &[other]); let clip = s.clipboard.clone(); let target = s.doc().unwrap().clone(); let result = s.execute("edit.dropSelection", &json!({"sourceDocument": source.uid, "ids": [r, r], "grab": [25,30], "at": [175,130]})).unwrap(); let ids = ids_of(&result); assert_eq!(ids.len(), 1); assert_eq!(fill(&s, ids[0]), linked(hex("#ff0000"), "Brand 2", 1.0)); assert_eq!(fill(&s, other), linked(hex("#0000ff"), "Brand", 1.0)); assert_eq!(node(&s, ids[0]).geometric_bounds().unwrap(), Rect::new(170.0, 120.0, 210.0, 160.0)); assert_eq!(s.doc().unwrap().history.undo.len(), target.history.undo.len() + 1); assert_eq!(s.clipboard, clip); assert_eq!(s.documents()[0].doc, source.doc); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(s.doc().unwrap().doc, target.doc); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(s.doc().unwrap().selection.objects, ids); } /// Verify malformed, oversized, stale and overflowing drop requests leave document and clipboard state intact. #[test] fn invalid_artwork_drop_is_atomic() { let mut s = session(); let r = rect(&mut s, 10.0, 10.0, 40.0, 40.0); let uid = s.execute("document.inspect", &json!({})).unwrap()["uid"].as_u64().unwrap(); new_doc(&mut s); let target = s.doc().unwrap().clone(); let clipboard = s.clipboard.clone(); for patch in [ json!({"sourceDocument": u64::MAX}), json!({"sourceDocument": -1}), json!({"sourceDocument": 1.5}), json!({"sourceDocument": null}), json!({"ids": vec![r;10001]}), json!({"ids": null}), json!({"ids": [r,-1]}), json!({"ids": [r,1.5]}), json!({"grab": [0,0,0]}), json!({"grab": ["0",0]}), json!({"ids": []}), json!({"ids": [r, 9999999]}), json!({"ids": ["1"]}), json!({"grab": [0]}), json!({"at": [null, 0]}), json!({"at": [1e308, 0]}), ] { let mut p = json!({"sourceDocument": uid, "ids": [r], "grab": [0,0], "at": [50,60]}); p.as_object_mut().unwrap().extend(patch.as_object().unwrap().clone()); assert!(s.execute("edit.dropSelection", &p).is_err(), "{p}"); assert_eq!(s.doc().unwrap().doc, target.doc); assert_eq!(s.doc().unwrap().history.undo.len(), target.history.undo.len()); assert_eq!(s.doc().unwrap().selection, target.selection); assert_eq!(s.clipboard, clipboard); } s.execute("file.close", &json!({"index":0})).unwrap(); assert!(s.execute("edit.dropSelection", &json!({"sourceDocument": uid,"ids":[r],"grab":[0,0],"at":[50,60]})).is_err()); assert_eq!(s.doc().unwrap().doc, target.doc); } /// Verify refusing a locked insertion context preserves the target document and its undo history. #[test] fn artwork_drop_into_a_locked_destination_is_atomic() { let mut s = session(); let r = swatched_rect(&mut s, "Brand", "#ff0000"); let uid = s.doc().unwrap().uid; new_doc(&mut s); let layer = s.doc().unwrap().doc.layers[0].id; s.execute("layer.setProps", &json!({"id":layer,"locked":true})).unwrap(); let target = s.doc().unwrap().clone(); assert!(s.execute("edit.dropSelection", &json!({"sourceDocument":uid,"ids":[r],"grab":[0,0],"at":[100,100]})).is_err()); assert_eq!(s.doc().unwrap().doc, target.doc); assert_eq!(s.doc().unwrap().selection, target.selection); assert_eq!(s.doc().unwrap().history.undo.len(), target.history.undo.len()); } /// Verify tab drops use the editable current layer despite Paste Remembers Layers and source-layer name collisions. #[test] fn artwork_drop_uses_the_current_layer_even_when_paste_remembers_hidden_or_locked_source_layers() { for hidden in [true, false] { let mut s = session(); let r = rect(&mut s, 10.0, 10.0, 40.0, 40.0); let uid = s.doc().unwrap().uid; new_doc(&mut s); let blocked = doc(&s).layers[0].id; s.execute("layer.setProps", &json!({"id":blocked,"visible":!hidden,"locked":!hidden})).unwrap(); let current = id_of(&s.execute("layer.new", &json!({"name":"Flyer"})).unwrap()); s.execute("layer.pasteRemembersLayers", &json!({"on":true})).unwrap(); let blocked_before = node(&s, blocked); let placed = ids_of(&s.execute("edit.dropSelection", &json!({"sourceDocument":uid,"ids":[r],"grab":[0,0],"at":[100,100]})).unwrap()); assert_eq!(doc(&s).parent_of(placed[0]), Some(current)); assert_eq!(node(&s, blocked), blocked_before); assert_eq!(doc(&s).layers.len(), 2); assert!(doc(&s).paste_remembers_layers, "the preference still applies to ordinary Paste"); } } /// Two touching rectangles made into 9-slice symbol `Audit`, its instance scaled 150% × 75% and /// copied (#5902). fn copied_nine_slice_instance(s: &mut Session) -> Document { let red = rect(s, 30.0, 30.0, 80.0, 60.0); s.execute("paint.setFill", &json!({"ids": [red.0], "color": "#ff0000"})).unwrap(); let blue = rect(s, 110.0, 90.0, 40.0, 30.0); s.execute("paint.setFill", &json!({"ids": [blue.0], "color": "#0000ff"})).unwrap(); s.execute("select.all", &json!({})).unwrap(); s.execute("symbol.new", &json!({"name": "Audit", "nineSlice": true, "registration": 0, "exportType": "graphic"})).unwrap(); s.execute("object.scale", &json!({"sx": 150, "sy": 75})).unwrap(); s.execute("edit.copy", &json!({})).unwrap(); doc(s).clone() } /// The symbol options pasted symbol `to` should have: those of `from` in `src`. fn assert_same_symbol_options(src: &Document, from: &str, d: &Document, to: &str) { assert!(src.symbol_nine_slice(from).is_some()); assert_eq!(d.symbol_nine_slice(to), src.symbol_nine_slice(from)); assert_eq!(d.symbol_registration(to), src.symbol_registration(from)); assert_eq!(d.symbol_export_type(to), src.symbol_export_type(from)); assert_eq!(d.symbol_natural_xf(to), src.symbol_natural_xf(from)); } #[test] fn a_nine_slice_symbol_pasted_into_another_document_keeps_its_options_and_look() { let mut s = session(); let src = copied_nine_slice_instance(&mut s); let before = render(&s); new_doc(&mut s); s.execute("edit.pasteInPlace", &json!({})).unwrap(); assert_same_symbol_options(&src, "Audit", doc(&s), "Audit"); assert!(before == render(&s), "the pasted instance draws as in the source"); // Pasting again uses the symbol the first paste added. let v = s.execute("edit.pasteInPlace", &json!({})).unwrap(); assert_eq!(v["added"], 0, "{v}"); } #[test] fn a_renamed_nine_slice_symbol_keeps_its_options_under_the_new_name() { let mut s = session(); let src = copied_nine_slice_instance(&mut s); new_doc(&mut s); let other = ellipse(&mut s); sel(&mut s, &[other]); s.execute("symbol.new", &json!({"name": "Audit"})).unwrap(); let own = doc(&s).clone(); let v = s.execute("edit.pasteInPlace", &json!({})).unwrap(); assert!(renamed(&v).contains(&("symbol".into(), "Audit".into(), "Audit 2".into())), "{v}"); assert_same_symbol_options(&src, "Audit", doc(&s), "Audit 2"); // The document's own symbol keeps its options. assert_eq!(doc(&s).symbol_nine_slice("Audit"), None); assert_eq!(doc(&s).symbol_natural_xf("Audit"), own.symbol_natural_xf("Audit")); } #[test] fn a_same_named_symbol_with_other_options_is_not_reused() { let mut s = session(); let src = copied_nine_slice_instance(&mut s); new_doc(&mut s); s.execute("edit.pasteInPlace", &json!({})).unwrap(); // The document's `Audit` has the same art but 9-slice scaling off now. s.execute("symbol.options", &json!({"name": "Audit", "nineSlice": false})).unwrap(); let v = s.execute("edit.pasteInPlace", &json!({})).unwrap(); assert!(renamed(&v).contains(&("symbol".into(), "Audit".into(), "Audit 2".into())), "{v}"); assert_same_symbol_options(&src, "Audit", doc(&s), "Audit 2"); assert_eq!(doc(&s).symbol_nine_slice("Audit"), None, "the document's own symbol keeps its options"); } #[test] fn a_symbol_without_a_recorded_natural_size_is_pasted_without_one() { let mut s = session(); let r = rect(&mut s, 30.0, 30.0, 80.0, 60.0); sel(&mut s, &[r]); s.execute("symbol.new", &json!({"name": "Plain"})).unwrap(); s.edit("Forget size", |d, _| { if let Some(m) = d.unknown.get_mut(vectorcraft_doc::SYMBOL_SIZES).and_then(Value::as_object_mut) { m.remove("Plain"); } Ok(()) }) .unwrap(); assert_eq!(doc(&s).unknown.get(vectorcraft_doc::SYMBOL_SIZES).and_then(|m| m.get("Plain")), None); s.execute("edit.copy", &json!({})).unwrap(); let before = render(&s); new_doc(&mut s); s.execute("edit.pasteInPlace", &json!({})).unwrap(); assert!(doc(&s).symbols.iter().any(|x| x.name == "Plain")); assert_eq!(doc(&s).unknown.get(vectorcraft_doc::SYMBOL_SIZES).and_then(|m| m.get("Plain")), None, "no size is made up for it"); assert!(before == render(&s), "the pasted instance draws as in the source"); }