//! The new-art template (M3.65): Stroke panel options and graphic styles chosen with nothing //! selected, New Art Has Basic Appearance and `paint.default`. use serde_json::{Value, json}; use vectorcraft_color::{BlendMode, Paint}; use vectorcraft_doc::{Appearance, Dash, LineCap, Node}; use crate::*; fn session() -> Session { let mut s = Session::new(); s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap(); s } fn run(s: &mut Session, cmd: &str, p: Value) -> Value { s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}")) } fn rect(s: &mut Session, x: f64) -> NodeId { NodeId(run(s, "shape.rectangle", json!({"x": x, "y": 20, "width": 60, "height": 40}))["id"].as_u64().unwrap()) } fn node(s: &Session, id: NodeId) -> Node { s.doc().unwrap().doc.node(id).unwrap().clone() } fn undo_len(s: &Session) -> usize { s.doc().unwrap().history.undo.len() } #[test] fn invalid_new_art_basic_parameters_keep_the_preference_unchanged() { let mut s = session(); let undo = undo_len(&s); for params in [json!({"on": "false"}), json!({"on": 1})] { assert!(s.execute("appearance.setNewArtBasic", ¶ms).is_err(), "accepted {params}"); assert!(s.prefs.new_art_basic, "changed the preference for {params}"); assert_eq!(undo_len(&s), undo, "recorded undo for {params}"); } // Left out, or null as for every command, it toggles. assert_eq!(s.execute("appearance.setNewArtBasic", &json!(null)).unwrap(), json!({"on": false})); assert_eq!(s.execute("appearance.setNewArtBasic", &json!({"on": null})).unwrap(), json!({"on": true})); } #[test] fn stroke_options_set_with_nothing_selected_carry_to_the_next_object() { let mut s = session(); let before = rect(&mut s, 20.0); run(&mut s, "select.none", json!({})); let undo = undo_len(&s); run(&mut s, "stroke.set", json!({"cap": "round", "dash": [4, 2], "weight": 3, "endArrow": "Arrow"})); assert_eq!(undo_len(&s), undo, "no document change, no undo step"); // The Stroke panel shows them with nothing selected. let shown = s.shown_stroke().unwrap(); assert_eq!((shown.cap, shown.width, shown.dash.as_ref().map(|d| d.pattern.clone())), (LineCap::Round, 3.0, Some(vec![4.0, 2.0]))); let id = rect(&mut s, 120.0); let st = node(&s, id).appearance.stroke().unwrap().clone(); assert_eq!((st.cap, st.width, st.end_arrow.is_some()), (LineCap::Round, 3.0, true)); assert_eq!(st.dash, Some(Dash { pattern: vec![4.0, 2.0], ..Default::default() })); assert_eq!(node(&s, id).appearance.fill_paint(), Paint::solid(vectorcraft_color::Color::WHITE), "the fill stays the proxy's"); assert_eq!(node(&s, before).appearance.stroke().unwrap().cap, LineCap::Butt, "art drawn before keeps its stroke"); // Editing a selected object's stroke leaves the template alone. run(&mut s, "stroke.set", json!({"cap": "square"})); run(&mut s, "select.none", json!({})); assert_eq!(s.shown_stroke().unwrap().cap, LineCap::Round); // Other new art takes it too (a line still without a fill). let line = NodeId(run(&mut s, "shape.line", json!({"x1": 10, "y1": 200, "x2": 200, "y2": 200}))["id"].as_u64().unwrap()); let l = node(&s, line).appearance; assert_eq!((l.fill_paint(), l.stroke().unwrap().cap), (Paint::None, LineCap::Round)); // Default Fill and Stroke resets the template. run(&mut s, "paint.default", json!({})); let plain = rect(&mut s, 200.0); assert_eq!(node(&s, plain).appearance, Appearance::default_art()); assert!(s.shown_stroke().is_some_and(|st| st.dash.is_none() && st.cap == LineCap::Butt)); } /// A rectangle with two fills, a drop shadow and 50% opacity, selected. fn fancy(s: &mut Session) -> NodeId { let id = rect(s, 20.0); run(s, "paint.setFill", json!({"color": "#ff0000"})); run(s, "appearance.addFill", json!({})); run(s, "paint.setFill", json!({"color": "#0000ff"})); run(s, "effect.apply", json!({"effect": "stylize.dropShadow"})); run(s, "transparency.set", json!({"opacity": 50})); id } #[test] fn with_basic_appearance_off_new_art_takes_the_last_selections_whole_appearance() { let mut s = session(); assert!(s.prefs.new_art_basic, "on by default"); let src = fancy(&mut s); run(&mut s, "select.none", json!({})); let basic = rect(&mut s, 120.0); let b = node(&s, basic); assert_eq!((b.appearance.items.len(), b.appearance.effects.len(), b.opacity), (2, 0, 1.0), "on: one fill and stroke"); assert_eq!(run(&mut s, "appearance.setNewArtBasic", json!({})), json!({"on": false}), "no param toggles"); run(&mut s, "select.set", json!({"ids": [src.0]})); run(&mut s, "select.none", json!({})); let id = rect(&mut s, 220.0); let (n, from) = (node(&s, id), node(&s, src)); assert_eq!(n.appearance.items.iter().filter(|i| i.is_fill()).count(), 2, "both fills"); assert_eq!(n.appearance.effects.len(), 1, "the drop shadow"); assert!(n.appearance.approx_eq(&from.appearance)); assert_eq!((n.opacity, n.blend), (0.5, BlendMode::Normal)); let q = run(&mut s, "appearance.newArt", json!({})); assert_eq!((q["basic"].clone(), q["inherited"].clone(), q["opacity"].clone()), (json!(false), json!(true), json!(50.0))); // Back on, new art takes only the basic fill and stroke again. run(&mut s, "appearance.setNewArtBasic", json!({"on": true})); run(&mut s, "select.none", json!({})); let again = rect(&mut s, 300.0); let again = node(&s, again); assert_eq!((again.appearance.items.len(), again.appearance.effects.len(), again.opacity), (2, 0, 1.0)); } #[test] fn a_graphic_style_clicked_with_nothing_selected_styles_the_next_object() { let mut s = session(); fancy(&mut s); // A placed gradient on the top fill: the style keeps it relative to the object's bounds. let stops = json!([{"offset": 0, "color": "#ffffff"}, {"offset": 1, "color": "#000000"}]); run(&mut s, "paint.setFill", json!({"gradient": {"stops": stops, "start": [20, 40], "end": [50, 40]}})); let name = run(&mut s, "graphicStyle.new", json!({"name": "Fancy"}))["name"].as_str().unwrap().to_string(); run(&mut s, "select.none", json!({})); let undo = undo_len(&s); assert_eq!(run(&mut s, "graphicStyle.apply", json!({"name": name})), json!({"newArt": true})); assert_eq!(undo_len(&s), undo); assert_eq!(run(&mut s, "appearance.newArt", json!({}))["graphicStyle"], json!("Fancy")); let id = NodeId(run(&mut s, "shape.ellipse", json!({"x": 200, "y": 100, "width": 100, "height": 50}))["id"].as_u64().unwrap()); let n = node(&s, id); assert_eq!((n.appearance.items.len(), n.appearance.effects.len(), n.opacity), (3, 1, 0.5)); // Linked to the style (its look, gradient placed on the ellipse's own bounds). let (g, linked) = s.selection_graphic_style().unwrap(); assert_eq!((g.name.as_str(), linked), ("Fancy", true)); // Alt-click (add) with nothing selected stacks a style on the template, unlinked. run(&mut s, "select.none", json!({})); run(&mut s, "graphicStyle.apply", json!({"name": name, "add": true})); let q = run(&mut s, "appearance.newArt", json!({})); assert_eq!((q["appearance"]["items"].as_array().unwrap().len(), q["graphicStyle"].clone()), (6, Value::Null)); assert!(s.execute("graphicStyle.apply", &json!({"name": name, "ids": []})).is_err(), "explicit ids that match nothing"); } /// A rectangle with this fill, stroke and weight, selected. fn painted(s: &mut Session, x: f64, fill: &str, stroke: &str, weight: f64) -> NodeId { let id = rect(s, x); run(s, "paint.setFill", json!({"color": fill})); run(s, "paint.setStroke", json!({"color": stroke})); run(s, "stroke.set", json!({"weight": weight})); id } fn select(s: &mut Session, ids: &[NodeId]) { run(s, "select.set", json!({"ids": ids.iter().map(|id| id.0).collect::>()})); } #[test] fn selecting_an_object_gives_new_art_its_fill_stroke_and_weight_with_basic_appearance_on() { let mut s = session(); assert!(s.prefs.new_art_basic, "on by default"); let green = painted(&mut s, 20.0, "#ff0000", "#00ff00", 5.0); painted(&mut s, 120.0, "#0000ff", "#000000", 2.0); select(&mut s, &[green]); run(&mut s, "select.none", json!({})); let id = rect(&mut s, 220.0); let (n, from) = (node(&s, id).appearance, node(&s, green).appearance); assert_eq!((n.fill_paint(), n.stroke_paint(), n.stroke_width()), (from.fill_paint(), from.stroke_paint(), 5.0)); } #[test] fn with_basic_appearance_on_only_the_basic_fill_and_stroke_follow_the_selection() { let mut s = session(); let src = fancy(&mut s); painted(&mut s, 120.0, "#00ff00", "#000000", 2.0); select(&mut s, &[src]); run(&mut s, "select.none", json!({})); let id = rect(&mut s, 220.0); let n = node(&s, id); assert_eq!(n.appearance.fill_paint(), node(&s, src).appearance.fill_paint(), "the top fill"); assert_eq!((n.appearance.items.len(), n.appearance.effects.len(), n.opacity), (2, 0, 1.0), "one fill and stroke, nothing else"); } #[test] fn a_paint_the_selected_objects_do_not_share_stays_as_it_was() { let mut s = session(); let a = painted(&mut s, 20.0, "#ff0000", "#00ff00", 5.0); let b = painted(&mut s, 120.0, "#0000ff", "#00ff00", 5.0); painted(&mut s, 220.0, "#ffff00", "#000000", 1.0); let before = s.paint.fill.clone(); select(&mut s, &[a, b]); assert_eq!(s.paint.fill, before, "the fills differ"); assert_eq!((s.paint.stroke.clone(), s.paint.stroke_width), (node(&s, a).appearance.stroke_paint(), 5.0), "the strokes are shared"); } #[test] fn art_without_paint_leaves_the_proxies_as_they_were() { let mut s = session(); painted(&mut s, 20.0, "#ff0000", "#00ff00", 5.0); let (fill, stroke) = (s.paint.fill.clone(), s.paint.stroke.clone()); let dir = super::links::Folder::new("new-art-image"); let path = dir.file("pic.png"); super::links::write(&path, &super::links::png(4, 4, super::links::RED)); let image = super::links::place(&mut s, &path); run(&mut s, "select.none", json!({})); select(&mut s, &[image]); assert_eq!((s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width), (fill, stroke, 5.0), "new art stays visible"); } #[test] fn an_object_without_a_stroke_clears_the_stroke_and_keeps_the_weight() { let mut s = session(); let bare = rect(&mut s, 20.0); run(&mut s, "paint.setStroke", json!({"none": true})); painted(&mut s, 120.0, "#0000ff", "#000000", 7.0); select(&mut s, &[bare]); assert_eq!((s.paint.stroke.clone(), s.paint.stroke_width), (Paint::None, 7.0)); } #[test] fn a_selected_gradient_loads_without_its_place_on_the_object() { let mut s = session(); let src = rect(&mut s, 20.0); let stops = json!([{"offset": 0, "color": "#ffffff"}, {"offset": 1, "color": "#000000"}]); run(&mut s, "paint.setFill", json!({"gradient": {"stops": stops, "start": [20, 40], "end": [50, 40]}})); painted(&mut s, 120.0, "#0000ff", "#000000", 2.0); select(&mut s, &[src]); assert!(matches!(s.paint.fill, Paint::Gradient(_)), "{:?}", s.paint.fill); run(&mut s, "select.none", json!({})); let id = rect(&mut s, 220.0); assert!(matches!(node(&s, id).appearance.fill_paint(), Paint::Gradient(_))); } #[test] fn selecting_leaves_the_stroke_panels_options_for_new_art_alone() { let mut s = session(); let plain = painted(&mut s, 20.0, "#ff0000", "#00ff00", 5.0); run(&mut s, "select.none", json!({})); run(&mut s, "stroke.set", json!({"cap": "round", "dash": [4, 2]})); select(&mut s, &[plain]); run(&mut s, "select.none", json!({})); let id = rect(&mut s, 120.0); let st = node(&s, id).appearance.stroke().unwrap().clone(); assert_eq!((st.paint.clone(), st.width), (node(&s, plain).appearance.stroke_paint(), 5.0)); assert_eq!((st.cap, st.dash.map(|d| d.pattern)), (LineCap::Round, Some(vec![4.0, 2.0]))); } #[test] fn a_sampled_paint_stays_until_the_selection_changes() { let mut s = session(); let a = painted(&mut s, 20.0, "#ff0000", "#00ff00", 5.0); let sampled = Paint::solid(vectorcraft_color::Color::WHITE); s.paint.fill = sampled.clone(); run(&mut s, "transparency.set", json!({"opacity": 50})); assert_eq!(s.paint.fill, sampled, "not a selection command"); select(&mut s, &[a]); assert_eq!(s.paint.fill, sampled, "the same selection again"); run(&mut s, "select.none", json!({})); assert_eq!(s.paint.fill, sampled, "nothing selected shows nothing to load"); select(&mut s, &[a]); assert_eq!(s.paint.fill, node(&s, a).appearance.fill_paint(), "selected anew"); } #[test] fn targeting_a_layer_loads_the_paints_of_its_contents() { let mut s = session(); let a = painted(&mut s, 20.0, "#ff0000", "#00ff00", 5.0); let layer = s.doc().unwrap().doc.layers[0].id; run(&mut s, "select.none", json!({})); run(&mut s, "paint.setFill", json!({"color": "#0000ff"})); run(&mut s, "layer.target", json!({"id": layer.0})); assert_eq!(s.paint.fill, node(&s, a).appearance.fill_paint()); } #[test] fn the_option_round_trips_with_the_preferences() { let mut s = session(); run(&mut s, "prefs.set", json!({"key": "newArtBasic", "value": false})); assert!(!s.prefs.new_art_basic); assert_eq!(run(&mut s, "prefs.get", json!({"key": "newArtBasic"})), json!(false)); let json = s.prefs.to_json(); assert_eq!(json["newArtBasic"], json!(false)); let back: Prefs = serde_json::from_value(json).unwrap(); assert_eq!(back, s.prefs); // Older preference files load with it on. let old: Prefs = serde_json::from_value(json!({"keyboardIncrement": 2})).unwrap(); assert!(old.new_art_basic); } /// Line Segment Tool Options' Fill Line: `shape.line {fill: true}` gives the line the current /// fill; without it a new line has none. #[test] fn fill_line_gives_a_new_line_the_current_fill() { let mut s = session(); run(&mut s, "paint.setFill", json!({"color": "#ff0000"})); let plain = NodeId(run(&mut s, "shape.line", json!({"x1": 10, "y1": 20, "x2": 200, "y2": 80}))["id"].as_u64().unwrap()); let filled = NodeId(run(&mut s, "shape.line", json!({"x1": 10, "y1": 20, "x2": 200, "y2": 80, "fill": true}))["id"].as_u64().unwrap()); assert_eq!(node(&s, plain).appearance.fill_paint(), Paint::None); assert_eq!(node(&s, filled).appearance.fill_paint(), s.paint.fill); assert_ne!(s.paint.fill, Paint::None); assert!(s.execute("shape.line", &json!({"x1": 0, "y1": 0, "x2": 1, "y2": 1, "fill": "yes"})).is_err()); }