Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

refactor(ui-egui): move panels/appearance.rs tests to panels/appearance/tests.rs

aionggdd22bf4b1d93
diff --git a/crates/ui-egui/src/panels/appearance.rs b/crates/ui-egui/src/panels/appearance.rs
index 04ca1bae6..9d8bc5937 100644
--- a/crates/ui-egui/src/panels/appearance.rs
+++ b/crates/ui-egui/src/panels/appearance.rs
@@ -1023,544 +1023,4 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
}
#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn opacity_labels() {
- assert_eq!(opacity_text(1.0, BlendMode::Normal), "Default");
- assert_eq!(opacity_text(0.5, BlendMode::Normal), "50%");
- assert_eq!(opacity_text(0.5, BlendMode::Multiply), "50% Multiply");
- }
-
- #[test]
- fn labels() {
- assert_eq!(param_label("offsetX", true), "Offset X");
- assert_eq!(param_label("blur", true), "Blur");
- assert!(!effect_label("stylize.dropShadow").contains('…'));
- assert_eq!(effect_label("path.outlineObject"), "Outline Object");
- assert_eq!(effect_label("x.unknownThing"), "unknownThing");
- // Only our own effects are interface labels; a plug-in's name is its own.
- assert!(built_in_effect("stylize.dropShadow") && !built_in_effect("plugin.example.glow"));
- assert_eq!(shown_effect_label("plugin.example.glow"), effect_label("plugin.example.glow"));
- }
-
- /// A Drop Shadow's inline editor has Color and Darkness as radio buttons in its Shade row; a
- /// click on Darkness sets the effect's `shade`.
- #[test]
- fn the_drop_shadow_editor_chooses_color_or_darkness() {
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
- let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
- app.run("effect.apply", json!({"effect": "stylize.dropShadow"})).unwrap();
- let ctx = egui::Context::default();
- crate::theme::install_fonts(&ctx);
- set_pstate(&ctx, "ap-fx-open-None-0", true);
- let mut time = 0.0;
- let mut run = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
- time += 0.1;
- let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), ..Default::default() }, |ui| show(app, ui));
- out.textures_delta.clear();
- out
- };
- run(&mut app, vec![]);
- let out = run(&mut app, vec![]);
- // The Shade row's Darkness, below the Darkness value's own row.
- fn find(s: &egui::Shape, out: &mut Vec<egui::Pos2>) {
- match s {
- egui::Shape::Text(t) if t.galley.text() == "Darkness" => out.push(t.visual_bounding_rect().center()),
- egui::Shape::Vec(v) => v.iter().for_each(|s| find(s, out)),
- _ => {}
- }
- }
- let mut found = vec![];
- out.shapes.iter().for_each(|c| find(&c.shape, &mut found));
- assert_eq!(found.len(), 2, "{found:?}");
- let at = found.into_iter().max_by(|a, b| a.y.total_cmp(&b.y)).unwrap();
- let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
- for events in [vec![egui::Event::PointerMoved(at)], vec![button(true)], vec![button(false)]] {
- run(&mut app, events);
- }
- let n = app.session.doc().unwrap().doc.node(NodeId(id)).unwrap().clone();
- assert_eq!(n.appearance.effects[0].params["shade"], json!("darkness"));
- }
-
- /// A rectangle with `effect` applied, its inline editor open, after a first frame in `ctx`.
- fn editing(effect: &str) -> (VectorcraftApp, egui::Context, NodeId) {
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
- let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
- app.run("effect.apply", json!({"effect": effect})).unwrap();
- let ctx = egui::Context::default();
- crate::theme::install_fonts(&ctx);
- set_pstate(&ctx, "ap-fx-open-None-0", true);
- panel_frame(&mut app, &ctx, vec![]);
- (app, ctx, NodeId(id))
- }
-
- /// One frame of the panel in `ctx` with `events`: the texts drawn and where.
- fn panel_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> Vec<(String, Rect)> {
- fn texts(s: &egui::Shape, out: &mut Vec<(String, Rect)>) {
- match s {
- egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.visual_bounding_rect())),
- egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
- _ => {}
- }
- }
- let time = ctx.input(|i| i.time) + 0.1;
- let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), ..Default::default() }, |ui| show(app, ui));
- out.textures_delta.clear();
- let mut v = vec![];
- out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
- v
- }
-
- /// Clicks the text `label` drawn in the panel (the last one drawn when there are several).
- fn click_text(app: &mut VectorcraftApp, ctx: &egui::Context, label: &str) {
- let shown = panel_frame(app, ctx, vec![]);
- let at = shown.iter().rev().find(|(s, _)| s == label).unwrap_or_else(|| panic!("no {label:?} in {shown:?}")).1.center();
- let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
- for events in [vec![egui::Event::PointerMoved(at)], vec![button(true)], vec![button(false)]] {
- panel_frame(app, ctx, events);
- }
- }
-
- fn shown_texts(app: &mut VectorcraftApp, ctx: &egui::Context) -> Vec<String> {
- panel_frame(app, ctx, vec![]).into_iter().map(|(s, _)| s).collect()
- }
-
- /// Roughen's Points and Offset Path's Joins are dropdowns with the effect dialog's labels, and
- /// a pick sends the dialog's value as one undo step.
- #[test]
- fn the_effect_editor_picks_choices_from_the_dialogs_dropdowns() {
- for (effect, key, shown, pick, value) in
- [("distort.roughen", "points", "Smooth", "Corner", "corner"), ("path.offsetPath", "joins", "Miter", "Round", "round")]
- {
- let (mut app, ctx, id) = editing(effect);
- let texts = shown_texts(&mut app, &ctx);
- assert!(texts.iter().any(|s| s == shown), "{effect}: {texts:?}");
- let undo = app.session.doc().unwrap().history.undo.len();
- click_text(&mut app, &ctx, shown);
- click_text(&mut app, &ctx, pick);
- let st = app.session.doc().unwrap();
- assert_eq!(st.doc.node(id).unwrap().appearance.effects[0].params[key], json!(value), "{effect}");
- assert_eq!(st.history.undo.len(), undo + 1, "{effect}");
- assert!(shown_texts(&mut app, &ctx).iter().any(|s| s == pick), "{effect}");
- }
- }
-
- /// The editor labels a parameter as the effect dialog does, without the ":".
- #[test]
- fn the_effect_editor_labels_parameters_as_the_dialog_does() {
- for (effect, labels) in [
- ("pixelate.colorHalftone", &["Max. Radius", "Channel 1", "Channel 4"][..]),
- ("video.deinterlace", &["Create New Fields by", "Duplication", "Eliminate", "Odd Fields"][..]),
- ] {
- let (mut app, ctx, _) = editing(effect);
- let texts = shown_texts(&mut app, &ctx);
- for label in labels {
- assert!(texts.iter().any(|s| s == label), "{effect}: no {label:?} in {texts:?}");
- }
- }
- }
-
- /// A plug-in's choice is a dropdown of the plug-in's own values, also when the parameter is
- /// called `mode` and its value names a blend mode.
- #[test]
- fn a_plug_in_choice_lists_the_plug_ins_values() {
- use vectorcraft_plugins::wat as tpl;
- let params = r#"{"mode":{"type":"choice","options":["normal","screen","dots"],"default":"screen"}}"#;
- let src = tpl::module(&tpl::manifest("test.ui.inlinechoice", "effect", params), tpl::ECHO, "", 1);
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- app.run("plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&wat::parse_str(src).unwrap())})).unwrap();
- app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
- let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
- app.run("effect.apply", json!({"effect": "plugin.test.ui.inlinechoice"})).unwrap();
- let ctx = egui::Context::default();
- crate::theme::install_fonts(&ctx);
- set_pstate(&ctx, "ap-fx-open-None-0", true);
- panel_frame(&mut app, &ctx, vec![]);
- click_text(&mut app, &ctx, "screen");
- click_text(&mut app, &ctx, "dots");
- let mode = |app: &VectorcraftApp| app.session.doc().unwrap().doc.node(NodeId(id)).unwrap().appearance.effects[0].params["mode"].clone();
- assert_eq!(mode(&app), json!("dots"));
- click_text(&mut app, &ctx, "dots");
- click_text(&mut app, &ctx, "screen");
- assert_eq!(mode(&app), json!("screen"));
- // Once the plug-in is removed, its value shows as it is, not as a blend mode.
- app.run("plugin.remove", json!({"id": "test.ui.inlinechoice"})).unwrap();
- let texts = shown_texts(&mut app, &ctx);
- assert!(texts.iter().any(|s| s == "screen") && !texts.iter().any(|s| s == "Screen"), "{texts:?}");
- }
-
- /// A plug-in effect's editor labels its parameters, shows their units and leaves out those whose
- /// `visibleWhen` isn't met, as the effect's dialog does, and reads a typed number list the same
- /// way.
- #[test]
- fn a_plug_in_effect_s_editor_follows_its_manifest() {
- use vectorcraft_plugins::wat as tpl;
- let params = r#"{"outline":{"type":"bool","default":true,"label":"Outline"},
- "spacing":{"type":"number","min":0.1,"max":10,"default":1.5,"label":"Spacing","unit":"mm","help":"Distance between the lines."},
- "angles":{"type":"numberList","min":0,"max":360,"default":[45,135],"minItems":1,"maxItems":4,"unit":"°"},
- "width":{"type":"number","min":0,"max":10,"default":0.5,"label":"Width","unit":"pt","visibleWhen":{"outline":[true]}}}"#;
- let src = tpl::module(&tpl::manifest("test.ui.inlinekeys", "effect", params), tpl::ECHO, "", 1);
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- app.run("plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&wat::parse_str(src).unwrap())})).unwrap();
- app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
- let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
- app.run("effect.apply", json!({"effect": "plugin.test.ui.inlinekeys"})).unwrap();
- let ctx = egui::Context::default();
- crate::theme::install_fonts(&ctx);
- set_pstate(&ctx, "ap-fx-open-None-0", true);
- let texts = shown_texts(&mut app, &ctx);
- for shown in ["Spacing", "1.5 mm", "Angles", "45, 135", "°", "Width", "0.5 pt"] {
- assert!(texts.iter().any(|s| s == shown), "no {shown:?} in {texts:?}");
- }
- assert!(!texts.iter().any(|s| s == "spacing" || s == "width"), "the labels replace the names: {texts:?}");
- // Without the outline, its width isn't shown.
- app.run("effect.setParams", json!({"item": null, "index": 0, "params": {"outline": false}})).unwrap();
- let texts = shown_texts(&mut app, &ctx);
- assert!(!texts.iter().any(|s| s == "Width") && texts.iter().any(|s| s == "Spacing"), "{texts:?}");
- // A list typed in the field: separated by a semicolon and a space, and clamped.
- click_text(&mut app, &ctx, "45, 135");
- let key = |key, modifiers| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers };
- panel_frame(&mut app, &ctx, vec![key(egui::Key::A, egui::Modifiers::COMMAND)]);
- panel_frame(&mut app, &ctx, vec![egui::Event::Text("10; 400 20".into())]);
- panel_frame(&mut app, &ctx, vec![key(egui::Key::Enter, egui::Modifiers::NONE)]);
- panel_frame(&mut app, &ctx, vec![]);
- let angles = app.session.doc().unwrap().doc.node(NodeId(id)).unwrap().appearance.effects[0].params["angles"].clone();
- assert_eq!(angles, json!([10.0, 360.0, 20.0]));
- app.run("plugin.remove", json!({"id": "test.ui.inlinekeys"})).unwrap();
- }
-
- /// Glass with a loaded texture lists Loaded Texture in its Texture menu, as its dialog does.
- #[test]
- fn the_effect_editor_lists_a_loaded_glass_texture() {
- let mut png = vec![];
- image::RgbaImage::from_pixel(4, 4, image::Rgba([90, 120, 150, 255]))
- .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
- .unwrap();
- let stored = vectorcraft_engine::cmd::fileio::texture_image(&png).unwrap();
- let (mut app, ctx, id) = editing("distort.glass");
- app.run("effect.setParams", json!({"item": null, "index": 0, "params": {"texture": "loaded", "textureImage": stored}})).unwrap();
- let texts = shown_texts(&mut app, &ctx);
- assert!(texts.iter().any(|s| s == "Loaded Texture") && !texts.iter().any(|s| s == "loaded"), "{texts:?}");
- click_text(&mut app, &ctx, "Loaded Texture");
- click_text(&mut app, &ctx, "Frosted");
- let st = app.session.doc().unwrap();
- assert_eq!(st.doc.node(id).unwrap().appearance.effects[0].params["texture"], json!("frosted"));
- }
-
- /// The choices that their dialogs list in their own bodies are dropdowns with those dialogs'
- /// labels too: Revolve's edge, Extrude & Bevel's bevel, Warp's orientation, Rasterize's
- /// options and the channel of Levels and Curves. A pick sends the dialog's value as one undo
- /// step.
- #[test]
- fn the_effect_editor_picks_choices_their_own_dialogs_list() {
- for (effect, key, shown, pick, value) in [
- ("threeD.revolve", "edge", "Left", "Right", "right"),
- ("threeD.extrude", "bevel", "None", "Rounded", "rounded"),
- ("warp.arc", "orientation", "Horizontal", "Vertical", "vertical"),
- ("rasterize", "colorModel", "RGB", "Grayscale", "grayscale"),
- ("rasterize", "background", "Transparent", "White", "white"),
- ("rasterize", "antiAlias", "Art Optimized", "Type Optimized", "type"),
- ("adjust.levels", "channel", "RGB", "Red", "red"),
- ("adjust.curves", "channel", "RGB", "Blue", "blue"),
- ] {
- let (mut app, ctx, id) = editing(effect);
- let texts = shown_texts(&mut app, &ctx);
- assert!(texts.iter().any(|s| s == shown), "{effect} {key}: {texts:?}");
- let undo = app.session.doc().unwrap().history.undo.len();
- click_text(&mut app, &ctx, shown);
- click_text(&mut app, &ctx, pick);
- let st = app.session.doc().unwrap();
- assert_eq!(st.doc.node(id).unwrap().appearance.effects[0].params[key], json!(value), "{effect} {key}");
- assert_eq!(st.history.undo.len(), undo + 1, "{effect} {key}");
- assert!(shown_texts(&mut app, &ctx).iter().any(|s| s == pick), "{effect} {key}");
- }
- }
-
- /// Those choices read as their dialogs show them in the UI language: in French, the channel's
- /// RGB as the "effect" row translates it, and in Spanish, Extrude & Bevel's Rounded as the "3d"
- /// row does, not the plain row. Rasterize names the document's color mode.
- #[test]
- fn the_effect_editor_shows_those_choices_as_their_dialogs_do() {
- let fr = crate::i18n::Lang::from_code("fr").unwrap();
- crate::i18n::set_current(fr);
- let (mut app, ctx, _) = editing("adjust.levels");
- let texts = shown_texts(&mut app, &ctx);
- let rgb = crate::i18n::tr_ctx(fr, "effect", "RGB");
- assert!(texts.iter().any(|s| s == rgb), "{rgb}: {texts:?}");
- let es = crate::i18n::Lang::from_code("es").unwrap();
- crate::i18n::set_current(es);
- let (mut app, ctx, _) = editing("threeD.extrude");
- app.run("effect.setParams", json!({"item": null, "index": 0, "params": {"bevel": "rounded"}})).unwrap();
- let rounded = crate::i18n::tr_ctx(es, "3d", "Rounded");
- assert_ne!(rounded, crate::i18n::tr(es, "Rounded"));
- assert!(shown_texts(&mut app, &ctx).iter().any(|s| s == rounded), "{rounded}");
- crate::i18n::set_current(crate::i18n::Lang::EN);
- let (mut app, ctx, _) = editing("rasterize");
- app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
- let texts = shown_texts(&mut app, &ctx);
- assert!(texts.iter().any(|s| s == "CMYK") && !texts.iter().any(|s| s == "document"), "{texts:?}");
- }
-
- #[test]
- fn the_effect_editor_lists_earlier_parameters_in_their_current_form() {
- // A Scribble saved with one `variation` lists it as its Path Overlap and Spacing variations.
- let e = Effect { id: "stylize.scribble".into(), params: json!({"variation": 2, "angle": 270}), visible: true };
- let p = editor_params(&e);
- assert!(!p.contains_key("variation"), "{p:?}");
- assert_eq!((&p["overlapVariation"], &p["spacingVariation"], &p["curvinessVariation"]), (&json!(2), &json!(2), &json!(0.0)));
- assert_eq!(p["angle"].as_f64(), Some(-90.0));
- // Another effect lists its values over its defaults, as before.
- let e = Effect { id: "distort.twist".into(), params: json!({"angle": 270}), visible: true };
- assert_eq!(editor_params(&e).get("angle"), Some(&json!(270)));
- }
-
- /// A text field of the inline editor keeps what is typed from one frame to the next: a Drop
- /// Shadow's color typed a character a frame and confirmed with Enter is set in one undo step.
- /// Escape drops what is typed.
- #[test]
- fn the_effect_editor_keeps_text_typed_across_frames() {
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
- let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
- app.run("effect.apply", json!({"effect": "stylize.dropShadow"})).unwrap();
- let ctx = egui::Context::default();
- crate::theme::install_fonts(&ctx);
- set_pstate(&ctx, "ap-fx-open-None-0", true);
- let mut time = 0.0;
- let mut run = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
- time += 0.1;
- let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), ..Default::default() }, |ui| show(app, ui));
- out.textures_delta.clear();
- out
- };
- // Every text drawn, with its center.
- fn texts(s: &egui::Shape, out: &mut Vec<(String, egui::Pos2)>) {
- match s {
- egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.visual_bounding_rect().center())),
- egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
- _ => {}
- }
- }
- let drawn = |out: &egui::FullOutput| {
- let mut v = vec![];
- out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
- v
- };
- run(&mut app, vec![]);
- let shown = drawn(&run(&mut app, vec![]));
- let at = shown.iter().find(|(t, _)| t == "#000000").map(|(_, p)| *p);
- let Some(at) = at else { panic!("no color field: {shown:?}") };
- let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
- let key = |key, modifiers| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers };
- for events in [vec![egui::Event::PointerMoved(at)], vec![button(true)], vec![button(false)]] {
- run(&mut app, events);
- }
- run(&mut app, vec![key(egui::Key::A, egui::Modifiers::COMMAND)]);
- let undo = app.session.active().unwrap().history.undo.len();
- for ch in "#ff0000".chars() {
- run(&mut app, vec![egui::Event::Text(ch.to_string())]);
- }
- let shown = drawn(&run(&mut app, vec![]));
- assert!(shown.iter().any(|(t, _)| t == "#ff0000"), "the field shows what was typed: {shown:?}");
- run(&mut app, vec![key(egui::Key::Enter, egui::Modifiers::NONE)]);
- run(&mut app, vec![]);
- let color = |app: &VectorcraftApp| app.session.active().unwrap().doc.node(NodeId(id)).unwrap().appearance.effects[0].params["color"].clone();
- assert_eq!(color(&app), json!("#ff0000"));
- assert_eq!(app.session.active().unwrap().history.undo.len(), undo + 1, "one undo step");
- // Escape drops what is typed.
- for events in [vec![button(true)], vec![button(false)]] {
- run(&mut app, events);
- }
- run(&mut app, vec![egui::Event::Text("0".into())]);
- let shown = drawn(&run(&mut app, vec![]));
- assert!(shown.iter().any(|(t, _)| t.len() == 8 && t.starts_with('#')), "a 0 typed into the color: {shown:?}");
- run(&mut app, vec![key(egui::Key::Escape, egui::Modifiers::NONE)]);
- run(&mut app, vec![]);
- assert_eq!(color(&app), json!("#ff0000"));
- assert_eq!(app.session.active().unwrap().history.undo.len(), undo + 1);
- }
-
- #[test]
- fn drops_pick_the_command() {
- use vectorcraft_doc::{Appearance, FillLayer};
- let fx = |id: &str| Effect { id: id.into(), params: Value::Null, visible: true };
- let mut n = Node::path(NodeId(1), vectorcraft_geom::PathData::default(), Appearance::default_art());
- n.appearance.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None))); // [F, S, F]
- n.appearance.items[1].effects_mut().extend([fx("distort.twist"), fx("distort.roughen")]);
- n.appearance.effects.push(fx("stylize.dropShadow"));
- let slots = [
- Slot::Object { top: true },
- Slot::Item { index: 2, sub: false },
- Slot::Item { index: 1, sub: false },
- Slot::Effect(Some(1), 0),
- Slot::Effect(Some(1), 1),
- Slot::Item { index: 0, sub: false },
- Slot::Effect(None, 0),
- Slot::Object { top: false },
- ];
- let rows: Vec<(Slot, Rect)> =
- slots.iter().enumerate().map(|(i, s)| (*s, Rect::from_min_size(pos2(0.0, i as f32 * ROW), vec2(200.0, ROW)))).collect();
- // The upper or lower half of row `i`.
- let at = |i: usize, lower: bool| pos2(50.0, i as f32 * ROW + if lower { ROW * 0.75 } else { ROW * 0.25 });
- let drop = |what, p, copy| drop_command(&n, &rows, what, p, copy);
- // Fill/stroke rows: moves, Alt copies to where it was dropped.
- assert_eq!(drop(Dragged::Item(0), at(1, false), false), Some(("appearance.moveItem", json!({"from": 0, "to": 2}))));
- assert_eq!(drop(Dragged::Item(0), at(0, false), true), Some(("appearance.duplicateItem", json!({"index": 0, "to": 3}))));
- assert_eq!(drop(Dragged::Item(2), at(7, false), true), Some(("appearance.duplicateItem", json!({"index": 2, "to": 0}))));
- assert_eq!(drop(Dragged::Item(1), at(3, false), false), None, "onto its own effect");
- // Effects: within the list (below the next one), into a fill, out onto the object.
- let mv = |from: usize, fi: Value, to: usize, ti: Value, copy: bool| {
- Some(("effect.move", json!({"from": from, "fromItem": fi, "to": to, "toItem": ti, "copy": copy})))
- };
- assert_eq!(drop(Dragged::Effect(Some(1), 0), at(4, true), false), mv(0, json!(1), 1, json!(1), false));
- assert_eq!(drop(Dragged::Effect(Some(1), 0), at(3, true), false), None, "dropped on itself");
- assert_eq!(drop(Dragged::Effect(Some(1), 1), at(5, false), true), mv(1, json!(1), 0, json!(0), true));
- assert_eq!(drop(Dragged::Effect(Some(1), 1), at(7, false), false), mv(1, json!(1), 1, Value::Null, false));
- assert_eq!(drop(Dragged::Effect(None, 0), at(3, false), false), mv(0, Value::Null, 0, json!(1), false));
- assert_eq!(drop(Dragged::Effect(None, 0), pos2(500.0, 10.0), false), None, "outside the stack");
- }
-
- /// One headless frame of the panel: the texts drawn, top to bottom.
- fn frame(app: &mut VectorcraftApp) -> Vec<String> {
- fn texts(s: &egui::Shape, out: &mut Vec<(f32, String)>) {
- match s {
- egui::Shape::Text(t) => out.push((t.pos.y, t.galley.text().to_string())),
- egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
- _ => {}
- }
- }
- let ctx = egui::Context::default();
- let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui));
- out.textures_delta.clear();
- let mut v = vec![];
- out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
- v.sort_by(|a, b| a.0.total_cmp(&b.0));
- v.into_iter().map(|(_, t)| t).collect()
- }
-
- #[test]
- fn groups_show_a_contents_row_and_type_a_characters_row_in_their_slot() {
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- let run = |app: &mut VectorcraftApp, id: &str, p: Value| app.session.execute(id, &p).unwrap();
- run(&mut app, "file.new", json!({"width": 100, "height": 100}));
- let a = run(&mut app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20}))["id"].clone();
- let b = run(&mut app, "shape.rectangle", json!({"x": 30, "y": 0, "width": 20, "height": 20}))["id"].clone();
- run(&mut app, "select.set", json!({"ids": [a, b]}));
- run(&mut app, "object.group", json!({}));
- run(&mut app, "appearance.addFill", json!({}));
- run(&mut app, "appearance.addStroke", json!({}));
- let rows =
- |t: Vec<String>| t.into_iter().filter(|t| ["Fill:", "Stroke:", "Contents", "Characters"].contains(&t.as_str())).collect::<Vec<_>>();
- assert_eq!(rows(frame(&mut app)), ["Stroke:", "Fill:", "Contents"]);
- run(&mut app, "appearance.moveItem", json!({"from": "contents", "to": 1}));
- assert_eq!(rows(frame(&mut app)), ["Stroke:", "Contents", "Fill:"]);
- let t = run(&mut app, "text.create", json!({"x": 0, "y": 60, "text": "Hi"}))["id"].clone();
- run(&mut app, "select.set", json!({"ids": [t]}));
- assert_eq!(rows(frame(&mut app)), ["Characters"]);
- run(&mut app, "appearance.addFill", json!({}));
- assert_eq!(rows(frame(&mut app)), ["Fill:", "Characters"]);
- }
-
- #[test]
- fn images_show_a_contents_row_with_new_fills_and_strokes_below_it() {
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- let run = |app: &mut VectorcraftApp, id: &str, p: Value| app.session.execute(id, &p).unwrap();
- run(&mut app, "file.new", json!({"width": 100, "height": 100}));
- let rows = |t: Vec<String>| t.into_iter().filter(|t| ["Fill:", "Stroke:", "Contents"].contains(&t.as_str())).collect::<Vec<_>>();
- let mut png = vec![];
- image::RgbaImage::from_pixel(4, 4, image::Rgba([255, 0, 0, 255]))
- .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
- .unwrap();
- run(&mut app, "file.place", json!({"name": "red.png", "dataBase64": vectorcraft_format::base64_encode(&png)}));
- assert_eq!(rows(frame(&mut app)), ["Contents"]);
- run(&mut app, "appearance.addStroke", json!({}));
- assert_eq!(rows(frame(&mut app)), ["Contents", "Stroke:"]);
- }
-
- #[test]
- fn drops_move_items_across_the_contents_row_and_the_row_itself() {
- use vectorcraft_doc::FillLayer;
- // A group [F0 | F1 F2]: the Contents row sits above item 0.
- let mut n = Node::group(NodeId(1), vec![]);
- n.appearance.items = (0..3).map(|_| AppearanceItem::Fill(FillLayer::new(Paint::None))).collect();
- n.appearance.set_contents_at(1);
- let slots = [
- Slot::Object { top: true },
- Slot::Item { index: 2, sub: false },
- Slot::Item { index: 1, sub: false },
- Slot::Contents,
- Slot::Item { index: 0, sub: false },
- Slot::Object { top: false },
- ];
- let rows: Vec<(Slot, Rect)> =
- slots.iter().enumerate().map(|(i, s)| (*s, Rect::from_min_size(pos2(0.0, i as f32 * ROW), vec2(200.0, ROW)))).collect();
- let at = |i: usize| pos2(50.0, i as f32 * ROW + ROW / 2.0);
- let drop = |what, i| drop_command(&n, &rows, what, at(i), false);
- // Onto the Contents row: from above it lands just below, from below just above.
- assert_eq!(drop(Dragged::Item(2), 3), Some(("appearance.moveItem", json!({"from": 2, "to": 1, "contents": 2}))));
- assert_eq!(drop(Dragged::Item(0), 3), Some(("appearance.moveItem", json!({"from": 0, "to": 0, "contents": 0}))));
- // Onto the object row: above everything; under the stack: below everything.
- assert_eq!(drop(Dragged::Item(0), 0), Some(("appearance.moveItem", json!({"from": 0, "to": 2, "contents": 0}))));
- assert_eq!(drop(Dragged::Item(2), 5), Some(("appearance.moveItem", json!({"from": 2, "to": 0, "contents": 2}))));
- // The row itself: above item 2, below item 0; nowhere new on itself.
- assert_eq!(drop(Dragged::Contents, 1), Some(("appearance.moveItem", json!({"from": "contents", "to": 3}))));
- assert_eq!(drop(Dragged::Contents, 4), Some(("appearance.moveItem", json!({"from": "contents", "to": 0}))));
- assert_eq!(drop(Dragged::Contents, 3), None);
- assert_eq!(drop(Dragged::Contents, 2), Some(("appearance.moveItem", json!({"from": "contents", "to": 2}))));
- }
-
- #[test]
- fn with_nothing_selected_it_lists_what_new_art_gets() {
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- let run = |app: &mut VectorcraftApp, id: &str, p: Value| app.session.execute(id, &p).unwrap();
- run(&mut app, "file.new", json!({"width": 100, "height": 100}));
- run(&mut app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20}));
- run(&mut app, "appearance.addFill", json!({}));
- run(&mut app, "effect.apply", json!({"effect": "stylize.dropShadow"}));
- run(&mut app, "transparency.set", json!({"opacity": 50}));
- run(&mut app, "graphicStyle.new", json!({"name": "Fancy"}));
- run(&mut app, "select.none", json!({}));
- let shown = frame(&mut app);
- assert!(shown.contains(&"No Selection".to_string()) && shown.contains(&"Opacity: Default".to_string()), "{shown:?}");
- // A style clicked with nothing selected: the rows show what the next object gets.
- run(&mut app, "graphicStyle.apply", json!({"name": "Fancy"}));
- run(&mut app, "stroke.set", json!({"dash": [3, 3]}));
- let shown = frame(&mut app);
- let rows: Vec<&String> = shown.iter().filter(|t| ["Fill:", "Stroke:"].contains(&t.as_str())).collect();
- assert_eq!(rows, ["Fill:", "Stroke:", "Fill:"], "the added fill is on top");
- for want in ["No Selection: Fancy".to_string(), effect_label("stylize.dropShadow"), "Opacity: 50%".into(), "Dashed".into()] {
- assert!(shown.contains(&want), "{want} in {shown:?}");
- }
- }
-
- /// Both stroke rows expose named Weight inputs, and the drop-shadow effect names its Blur input and
- /// Color radio button.
- #[test]
- fn inline_stroke_weight_and_effect_fields_are_named() {
- use egui_kittest::kittest::Queryable;
- let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
- app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
- app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap();
- app.run("appearance.addStroke", json!({})).unwrap();
- app.run("effect.apply", json!({"effect": "stylize.dropShadow"})).unwrap();
- let mut first = true;
- let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(360.0, 760.0)).with_accessibility_check(false).build_ui_state(
- move |ui, app: &mut VectorcraftApp| {
- if std::mem::replace(&mut first, false) {
- crate::theme::install_fonts(ui.ctx());
- set_pstate(ui.ctx(), "ap-fx-open-None-0", true);
- }
- show(app, ui);
- },
- app,
- );
- h.run_steps(4);
- assert_eq!(h.get_all_by_role_and_label(egui::accesskit::Role::TextInput, "Weight:").count(), 2, "both stroke rows are named");
- let _ = h.get_by_role_and_label(egui::accesskit::Role::TextInput, "Blur");
- let _ = h.get_by_role_and_label(egui::accesskit::Role::RadioButton, "Color");
- }
-}
+mod tests;
diff --git a/crates/ui-egui/src/panels/appearance/tests.rs b/crates/ui-egui/src/panels/appearance/tests.rs
new file mode 100644
index 000000000..982de7443
--- /dev/null
+++ b/crates/ui-egui/src/panels/appearance/tests.rs
@@ -0,0 +1,539 @@
+use super::*;
+
+#[test]
+fn opacity_labels() {
+ assert_eq!(opacity_text(1.0, BlendMode::Normal), "Default");
+ assert_eq!(opacity_text(0.5, BlendMode::Normal), "50%");
+ assert_eq!(opacity_text(0.5, BlendMode::Multiply), "50% Multiply");
+}
+
+#[test]
+fn labels() {
+ assert_eq!(param_label("offsetX", true), "Offset X");
+ assert_eq!(param_label("blur", true), "Blur");
+ assert!(!effect_label("stylize.dropShadow").contains('…'));
+ assert_eq!(effect_label("path.outlineObject"), "Outline Object");
+ assert_eq!(effect_label("x.unknownThing"), "unknownThing");
+ // Only our own effects are interface labels; a plug-in's name is its own.
+ assert!(built_in_effect("stylize.dropShadow") && !built_in_effect("plugin.example.glow"));
+ assert_eq!(shown_effect_label("plugin.example.glow"), effect_label("plugin.example.glow"));
+}
+
+/// A Drop Shadow's inline editor has Color and Darkness as radio buttons in its Shade row; a
+/// click on Darkness sets the effect's `shade`.
+#[test]
+fn the_drop_shadow_editor_chooses_color_or_darkness() {
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+ let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
+ app.run("effect.apply", json!({"effect": "stylize.dropShadow"})).unwrap();
+ let ctx = egui::Context::default();
+ crate::theme::install_fonts(&ctx);
+ set_pstate(&ctx, "ap-fx-open-None-0", true);
+ let mut time = 0.0;
+ let mut run = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
+ time += 0.1;
+ let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), ..Default::default() }, |ui| show(app, ui));
+ out.textures_delta.clear();
+ out
+ };
+ run(&mut app, vec![]);
+ let out = run(&mut app, vec![]);
+ // The Shade row's Darkness, below the Darkness value's own row.
+ fn find(s: &egui::Shape, out: &mut Vec<egui::Pos2>) {
+ match s {
+ egui::Shape::Text(t) if t.galley.text() == "Darkness" => out.push(t.visual_bounding_rect().center()),
+ egui::Shape::Vec(v) => v.iter().for_each(|s| find(s, out)),
+ _ => {}
+ }
+ }
+ let mut found = vec![];
+ out.shapes.iter().for_each(|c| find(&c.shape, &mut found));
+ assert_eq!(found.len(), 2, "{found:?}");
+ let at = found.into_iter().max_by(|a, b| a.y.total_cmp(&b.y)).unwrap();
+ let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+ for events in [vec![egui::Event::PointerMoved(at)], vec![button(true)], vec![button(false)]] {
+ run(&mut app, events);
+ }
+ let n = app.session.doc().unwrap().doc.node(NodeId(id)).unwrap().clone();
+ assert_eq!(n.appearance.effects[0].params["shade"], json!("darkness"));
+}
+
+/// A rectangle with `effect` applied, its inline editor open, after a first frame in `ctx`.
+fn editing(effect: &str) -> (VectorcraftApp, egui::Context, NodeId) {
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+ let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
+ app.run("effect.apply", json!({"effect": effect})).unwrap();
+ let ctx = egui::Context::default();
+ crate::theme::install_fonts(&ctx);
+ set_pstate(&ctx, "ap-fx-open-None-0", true);
+ panel_frame(&mut app, &ctx, vec![]);
+ (app, ctx, NodeId(id))
+}
+
+/// One frame of the panel in `ctx` with `events`: the texts drawn and where.
+fn panel_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> Vec<(String, Rect)> {
+ fn texts(s: &egui::Shape, out: &mut Vec<(String, Rect)>) {
+ match s {
+ egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.visual_bounding_rect())),
+ egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+ _ => {}
+ }
+ }
+ let time = ctx.input(|i| i.time) + 0.1;
+ let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), ..Default::default() }, |ui| show(app, ui));
+ out.textures_delta.clear();
+ let mut v = vec![];
+ out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
+ v
+}
+
+/// Clicks the text `label` drawn in the panel (the last one drawn when there are several).
+fn click_text(app: &mut VectorcraftApp, ctx: &egui::Context, label: &str) {
+ let shown = panel_frame(app, ctx, vec![]);
+ let at = shown.iter().rev().find(|(s, _)| s == label).unwrap_or_else(|| panic!("no {label:?} in {shown:?}")).1.center();
+ let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+ for events in [vec![egui::Event::PointerMoved(at)], vec![button(true)], vec![button(false)]] {
+ panel_frame(app, ctx, events);
+ }
+}
+
+fn shown_texts(app: &mut VectorcraftApp, ctx: &egui::Context) -> Vec<String> {
+ panel_frame(app, ctx, vec![]).into_iter().map(|(s, _)| s).collect()
+}
+
+/// Roughen's Points and Offset Path's Joins are dropdowns with the effect dialog's labels, and
+/// a pick sends the dialog's value as one undo step.
+#[test]
+fn the_effect_editor_picks_choices_from_the_dialogs_dropdowns() {
+ for (effect, key, shown, pick, value) in
+ [("distort.roughen", "points", "Smooth", "Corner", "corner"), ("path.offsetPath", "joins", "Miter", "Round", "round")]
+ {
+ let (mut app, ctx, id) = editing(effect);
+ let texts = shown_texts(&mut app, &ctx);
+ assert!(texts.iter().any(|s| s == shown), "{effect}: {texts:?}");
+ let undo = app.session.doc().unwrap().history.undo.len();
+ click_text(&mut app, &ctx, shown);
+ click_text(&mut app, &ctx, pick);
+ let st = app.session.doc().unwrap();
+ assert_eq!(st.doc.node(id).unwrap().appearance.effects[0].params[key], json!(value), "{effect}");
+ assert_eq!(st.history.undo.len(), undo + 1, "{effect}");
+ assert!(shown_texts(&mut app, &ctx).iter().any(|s| s == pick), "{effect}");
+ }
+}
+
+/// The editor labels a parameter as the effect dialog does, without the ":".
+#[test]
+fn the_effect_editor_labels_parameters_as_the_dialog_does() {
+ for (effect, labels) in [
+ ("pixelate.colorHalftone", &["Max. Radius", "Channel 1", "Channel 4"][..]),
+ ("video.deinterlace", &["Create New Fields by", "Duplication", "Eliminate", "Odd Fields"][..]),
+ ] {
+ let (mut app, ctx, _) = editing(effect);
+ let texts = shown_texts(&mut app, &ctx);
+ for label in labels {
+ assert!(texts.iter().any(|s| s == label), "{effect}: no {label:?} in {texts:?}");
+ }
+ }
+}
+
+/// A plug-in's choice is a dropdown of the plug-in's own values, also when the parameter is
+/// called `mode` and its value names a blend mode.
+#[test]
+fn a_plug_in_choice_lists_the_plug_ins_values() {
+ use vectorcraft_plugins::wat as tpl;
+ let params = r#"{"mode":{"type":"choice","options":["normal","screen","dots"],"default":"screen"}}"#;
+ let src = tpl::module(&tpl::manifest("test.ui.inlinechoice", "effect", params), tpl::ECHO, "", 1);
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ app.run("plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&wat::parse_str(src).unwrap())})).unwrap();
+ app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+ let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
+ app.run("effect.apply", json!({"effect": "plugin.test.ui.inlinechoice"})).unwrap();
+ let ctx = egui::Context::default();
+ crate::theme::install_fonts(&ctx);
+ set_pstate(&ctx, "ap-fx-open-None-0", true);
+ panel_frame(&mut app, &ctx, vec![]);
+ click_text(&mut app, &ctx, "screen");
+ click_text(&mut app, &ctx, "dots");
+ let mode = |app: &VectorcraftApp| app.session.doc().unwrap().doc.node(NodeId(id)).unwrap().appearance.effects[0].params["mode"].clone();
+ assert_eq!(mode(&app), json!("dots"));
+ click_text(&mut app, &ctx, "dots");
+ click_text(&mut app, &ctx, "screen");
+ assert_eq!(mode(&app), json!("screen"));
+ // Once the plug-in is removed, its value shows as it is, not as a blend mode.
+ app.run("plugin.remove", json!({"id": "test.ui.inlinechoice"})).unwrap();
+ let texts = shown_texts(&mut app, &ctx);
+ assert!(texts.iter().any(|s| s == "screen") && !texts.iter().any(|s| s == "Screen"), "{texts:?}");
+}
+
+/// A plug-in effect's editor labels its parameters, shows their units and leaves out those whose
+/// `visibleWhen` isn't met, as the effect's dialog does, and reads a typed number list the same
+/// way.
+#[test]
+fn a_plug_in_effect_s_editor_follows_its_manifest() {
+ use vectorcraft_plugins::wat as tpl;
+ let params = r#"{"outline":{"type":"bool","default":true,"label":"Outline"},
+ "spacing":{"type":"number","min":0.1,"max":10,"default":1.5,"label":"Spacing","unit":"mm","help":"Distance between the lines."},
+ "angles":{"type":"numberList","min":0,"max":360,"default":[45,135],"minItems":1,"maxItems":4,"unit":"°"},
+ "width":{"type":"number","min":0,"max":10,"default":0.5,"label":"Width","unit":"pt","visibleWhen":{"outline":[true]}}}"#;
+ let src = tpl::module(&tpl::manifest("test.ui.inlinekeys", "effect", params), tpl::ECHO, "", 1);
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ app.run("plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&wat::parse_str(src).unwrap())})).unwrap();
+ app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+ let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
+ app.run("effect.apply", json!({"effect": "plugin.test.ui.inlinekeys"})).unwrap();
+ let ctx = egui::Context::default();
+ crate::theme::install_fonts(&ctx);
+ set_pstate(&ctx, "ap-fx-open-None-0", true);
+ let texts = shown_texts(&mut app, &ctx);
+ for shown in ["Spacing", "1.5 mm", "Angles", "45, 135", "°", "Width", "0.5 pt"] {
+ assert!(texts.iter().any(|s| s == shown), "no {shown:?} in {texts:?}");
+ }
+ assert!(!texts.iter().any(|s| s == "spacing" || s == "width"), "the labels replace the names: {texts:?}");
+ // Without the outline, its width isn't shown.
+ app.run("effect.setParams", json!({"item": null, "index": 0, "params": {"outline": false}})).unwrap();
+ let texts = shown_texts(&mut app, &ctx);
+ assert!(!texts.iter().any(|s| s == "Width") && texts.iter().any(|s| s == "Spacing"), "{texts:?}");
+ // A list typed in the field: separated by a semicolon and a space, and clamped.
+ click_text(&mut app, &ctx, "45, 135");
+ let key = |key, modifiers| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers };
+ panel_frame(&mut app, &ctx, vec![key(egui::Key::A, egui::Modifiers::COMMAND)]);
+ panel_frame(&mut app, &ctx, vec![egui::Event::Text("10; 400 20".into())]);
+ panel_frame(&mut app, &ctx, vec![key(egui::Key::Enter, egui::Modifiers::NONE)]);
+ panel_frame(&mut app, &ctx, vec![]);
+ let angles = app.session.doc().unwrap().doc.node(NodeId(id)).unwrap().appearance.effects[0].params["angles"].clone();
+ assert_eq!(angles, json!([10.0, 360.0, 20.0]));
+ app.run("plugin.remove", json!({"id": "test.ui.inlinekeys"})).unwrap();
+}
+
+/// Glass with a loaded texture lists Loaded Texture in its Texture menu, as its dialog does.
+#[test]
+fn the_effect_editor_lists_a_loaded_glass_texture() {
+ let mut png = vec![];
+ image::RgbaImage::from_pixel(4, 4, image::Rgba([90, 120, 150, 255]))
+ .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
+ .unwrap();
+ let stored = vectorcraft_engine::cmd::fileio::texture_image(&png).unwrap();
+ let (mut app, ctx, id) = editing("distort.glass");
+ app.run("effect.setParams", json!({"item": null, "index": 0, "params": {"texture": "loaded", "textureImage": stored}})).unwrap();
+ let texts = shown_texts(&mut app, &ctx);
+ assert!(texts.iter().any(|s| s == "Loaded Texture") && !texts.iter().any(|s| s == "loaded"), "{texts:?}");
+ click_text(&mut app, &ctx, "Loaded Texture");
+ click_text(&mut app, &ctx, "Frosted");
+ let st = app.session.doc().unwrap();
+ assert_eq!(st.doc.node(id).unwrap().appearance.effects[0].params["texture"], json!("frosted"));
+}
+
+/// The choices that their dialogs list in their own bodies are dropdowns with those dialogs'
+/// labels too: Revolve's edge, Extrude & Bevel's bevel, Warp's orientation, Rasterize's
+/// options and the channel of Levels and Curves. A pick sends the dialog's value as one undo
+/// step.
+#[test]
+fn the_effect_editor_picks_choices_their_own_dialogs_list() {
+ for (effect, key, shown, pick, value) in [
+ ("threeD.revolve", "edge", "Left", "Right", "right"),
+ ("threeD.extrude", "bevel", "None", "Rounded", "rounded"),
+ ("warp.arc", "orientation", "Horizontal", "Vertical", "vertical"),
+ ("rasterize", "colorModel", "RGB", "Grayscale", "grayscale"),
+ ("rasterize", "background", "Transparent", "White", "white"),
+ ("rasterize", "antiAlias", "Art Optimized", "Type Optimized", "type"),
+ ("adjust.levels", "channel", "RGB", "Red", "red"),
+ ("adjust.curves", "channel", "RGB", "Blue", "blue"),
+ ] {
+ let (mut app, ctx, id) = editing(effect);
+ let texts = shown_texts(&mut app, &ctx);
+ assert!(texts.iter().any(|s| s == shown), "{effect} {key}: {texts:?}");
+ let undo = app.session.doc().unwrap().history.undo.len();
+ click_text(&mut app, &ctx, shown);
+ click_text(&mut app, &ctx, pick);
+ let st = app.session.doc().unwrap();
+ assert_eq!(st.doc.node(id).unwrap().appearance.effects[0].params[key], json!(value), "{effect} {key}");
+ assert_eq!(st.history.undo.len(), undo + 1, "{effect} {key}");
+ assert!(shown_texts(&mut app, &ctx).iter().any(|s| s == pick), "{effect} {key}");
+ }
+}
+
+/// Those choices read as their dialogs show them in the UI language: in French, the channel's
+/// RGB as the "effect" row translates it, and in Spanish, Extrude & Bevel's Rounded as the "3d"
+/// row does, not the plain row. Rasterize names the document's color mode.
+#[test]
+fn the_effect_editor_shows_those_choices_as_their_dialogs_do() {
+ let fr = crate::i18n::Lang::from_code("fr").unwrap();
+ crate::i18n::set_current(fr);
+ let (mut app, ctx, _) = editing("adjust.levels");
+ let texts = shown_texts(&mut app, &ctx);
+ let rgb = crate::i18n::tr_ctx(fr, "effect", "RGB");
+ assert!(texts.iter().any(|s| s == rgb), "{rgb}: {texts:?}");
+ let es = crate::i18n::Lang::from_code("es").unwrap();
+ crate::i18n::set_current(es);
+ let (mut app, ctx, _) = editing("threeD.extrude");
+ app.run("effect.setParams", json!({"item": null, "index": 0, "params": {"bevel": "rounded"}})).unwrap();
+ let rounded = crate::i18n::tr_ctx(es, "3d", "Rounded");
+ assert_ne!(rounded, crate::i18n::tr(es, "Rounded"));
+ assert!(shown_texts(&mut app, &ctx).iter().any(|s| s == rounded), "{rounded}");
+ crate::i18n::set_current(crate::i18n::Lang::EN);
+ let (mut app, ctx, _) = editing("rasterize");
+ app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
+ let texts = shown_texts(&mut app, &ctx);
+ assert!(texts.iter().any(|s| s == "CMYK") && !texts.iter().any(|s| s == "document"), "{texts:?}");
+}
+
+#[test]
+fn the_effect_editor_lists_earlier_parameters_in_their_current_form() {
+ // A Scribble saved with one `variation` lists it as its Path Overlap and Spacing variations.
+ let e = Effect { id: "stylize.scribble".into(), params: json!({"variation": 2, "angle": 270}), visible: true };
+ let p = editor_params(&e);
+ assert!(!p.contains_key("variation"), "{p:?}");
+ assert_eq!((&p["overlapVariation"], &p["spacingVariation"], &p["curvinessVariation"]), (&json!(2), &json!(2), &json!(0.0)));
+ assert_eq!(p["angle"].as_f64(), Some(-90.0));
+ // Another effect lists its values over its defaults, as before.
+ let e = Effect { id: "distort.twist".into(), params: json!({"angle": 270}), visible: true };
+ assert_eq!(editor_params(&e).get("angle"), Some(&json!(270)));
+}
+
+/// A text field of the inline editor keeps what is typed from one frame to the next: a Drop
+/// Shadow's color typed a character a frame and confirmed with Enter is set in one undo step.
+/// Escape drops what is typed.
+#[test]
+fn the_effect_editor_keeps_text_typed_across_frames() {
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+ let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
+ app.run("effect.apply", json!({"effect": "stylize.dropShadow"})).unwrap();
+ let ctx = egui::Context::default();
+ crate::theme::install_fonts(&ctx);
+ set_pstate(&ctx, "ap-fx-open-None-0", true);
+ let mut time = 0.0;
+ let mut run = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
+ time += 0.1;
+ let mut out = ctx.run_ui(egui::RawInput { events, time: Some(time), ..Default::default() }, |ui| show(app, ui));
+ out.textures_delta.clear();
+ out
+ };
+ // Every text drawn, with its center.
+ fn texts(s: &egui::Shape, out: &mut Vec<(String, egui::Pos2)>) {
+ match s {
+ egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.visual_bounding_rect().center())),
+ egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+ _ => {}
+ }
+ }
+ let drawn = |out: &egui::FullOutput| {
+ let mut v = vec![];
+ out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
+ v
+ };
+ run(&mut app, vec![]);
+ let shown = drawn(&run(&mut app, vec![]));
+ let at = shown.iter().find(|(t, _)| t == "#000000").map(|(_, p)| *p);
+ let Some(at) = at else { panic!("no color field: {shown:?}") };
+ let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+ let key = |key, modifiers| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers };
+ for events in [vec![egui::Event::PointerMoved(at)], vec![button(true)], vec![button(false)]] {
+ run(&mut app, events);
+ }
+ run(&mut app, vec![key(egui::Key::A, egui::Modifiers::COMMAND)]);
+ let undo = app.session.active().unwrap().history.undo.len();
+ for ch in "#ff0000".chars() {
+ run(&mut app, vec![egui::Event::Text(ch.to_string())]);
+ }
+ let shown = drawn(&run(&mut app, vec![]));
+ assert!(shown.iter().any(|(t, _)| t == "#ff0000"), "the field shows what was typed: {shown:?}");
+ run(&mut app, vec![key(egui::Key::Enter, egui::Modifiers::NONE)]);
+ run(&mut app, vec![]);
+ let color = |app: &VectorcraftApp| app.session.active().unwrap().doc.node(NodeId(id)).unwrap().appearance.effects[0].params["color"].clone();
+ assert_eq!(color(&app), json!("#ff0000"));
+ assert_eq!(app.session.active().unwrap().history.undo.len(), undo + 1, "one undo step");
+ // Escape drops what is typed.
+ for events in [vec![button(true)], vec![button(false)]] {
+ run(&mut app, events);
+ }
+ run(&mut app, vec![egui::Event::Text("0".into())]);
+ let shown = drawn(&run(&mut app, vec![]));
+ assert!(shown.iter().any(|(t, _)| t.len() == 8 && t.starts_with('#')), "a 0 typed into the color: {shown:?}");
+ run(&mut app, vec![key(egui::Key::Escape, egui::Modifiers::NONE)]);
+ run(&mut app, vec![]);
+ assert_eq!(color(&app), json!("#ff0000"));
+ assert_eq!(app.session.active().unwrap().history.undo.len(), undo + 1);
+}
+
+#[test]
+fn drops_pick_the_command() {
+ use vectorcraft_doc::{Appearance, FillLayer};
+ let fx = |id: &str| Effect { id: id.into(), params: Value::Null, visible: true };
+ let mut n = Node::path(NodeId(1), vectorcraft_geom::PathData::default(), Appearance::default_art());
+ n.appearance.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None))); // [F, S, F]
+ n.appearance.items[1].effects_mut().extend([fx("distort.twist"), fx("distort.roughen")]);
+ n.appearance.effects.push(fx("stylize.dropShadow"));
+ let slots = [
+ Slot::Object { top: true },
+ Slot::Item { index: 2, sub: false },
+ Slot::Item { index: 1, sub: false },
+ Slot::Effect(Some(1), 0),
+ Slot::Effect(Some(1), 1),
+ Slot::Item { index: 0, sub: false },
+ Slot::Effect(None, 0),
+ Slot::Object { top: false },
+ ];
+ let rows: Vec<(Slot, Rect)> =
+ slots.iter().enumerate().map(|(i, s)| (*s, Rect::from_min_size(pos2(0.0, i as f32 * ROW), vec2(200.0, ROW)))).collect();
+ // The upper or lower half of row `i`.
+ let at = |i: usize, lower: bool| pos2(50.0, i as f32 * ROW + if lower { ROW * 0.75 } else { ROW * 0.25 });
+ let drop = |what, p, copy| drop_command(&n, &rows, what, p, copy);
+ // Fill/stroke rows: moves, Alt copies to where it was dropped.
+ assert_eq!(drop(Dragged::Item(0), at(1, false), false), Some(("appearance.moveItem", json!({"from": 0, "to": 2}))));
+ assert_eq!(drop(Dragged::Item(0), at(0, false), true), Some(("appearance.duplicateItem", json!({"index": 0, "to": 3}))));
+ assert_eq!(drop(Dragged::Item(2), at(7, false), true), Some(("appearance.duplicateItem", json!({"index": 2, "to": 0}))));
+ assert_eq!(drop(Dragged::Item(1), at(3, false), false), None, "onto its own effect");
+ // Effects: within the list (below the next one), into a fill, out onto the object.
+ let mv = |from: usize, fi: Value, to: usize, ti: Value, copy: bool| {
+ Some(("effect.move", json!({"from": from, "fromItem": fi, "to": to, "toItem": ti, "copy": copy})))
+ };
+ assert_eq!(drop(Dragged::Effect(Some(1), 0), at(4, true), false), mv(0, json!(1), 1, json!(1), false));
+ assert_eq!(drop(Dragged::Effect(Some(1), 0), at(3, true), false), None, "dropped on itself");
+ assert_eq!(drop(Dragged::Effect(Some(1), 1), at(5, false), true), mv(1, json!(1), 0, json!(0), true));
+ assert_eq!(drop(Dragged::Effect(Some(1), 1), at(7, false), false), mv(1, json!(1), 1, Value::Null, false));
+ assert_eq!(drop(Dragged::Effect(None, 0), at(3, false), false), mv(0, Value::Null, 0, json!(1), false));
+ assert_eq!(drop(Dragged::Effect(None, 0), pos2(500.0, 10.0), false), None, "outside the stack");
+}
+
+/// One headless frame of the panel: the texts drawn, top to bottom.
+fn frame(app: &mut VectorcraftApp) -> Vec<String> {
+ fn texts(s: &egui::Shape, out: &mut Vec<(f32, String)>) {
+ match s {
+ egui::Shape::Text(t) => out.push((t.pos.y, t.galley.text().to_string())),
+ egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+ _ => {}
+ }
+ }
+ let ctx = egui::Context::default();
+ let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui));
+ out.textures_delta.clear();
+ let mut v = vec![];
+ out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
+ v.sort_by(|a, b| a.0.total_cmp(&b.0));
+ v.into_iter().map(|(_, t)| t).collect()
+}
+
+#[test]
+fn groups_show_a_contents_row_and_type_a_characters_row_in_their_slot() {
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ let run = |app: &mut VectorcraftApp, id: &str, p: Value| app.session.execute(id, &p).unwrap();
+ run(&mut app, "file.new", json!({"width": 100, "height": 100}));
+ let a = run(&mut app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20}))["id"].clone();
+ let b = run(&mut app, "shape.rectangle", json!({"x": 30, "y": 0, "width": 20, "height": 20}))["id"].clone();
+ run(&mut app, "select.set", json!({"ids": [a, b]}));
+ run(&mut app, "object.group", json!({}));
+ run(&mut app, "appearance.addFill", json!({}));
+ run(&mut app, "appearance.addStroke", json!({}));
+ let rows =
+ |t: Vec<String>| t.into_iter().filter(|t| ["Fill:", "Stroke:", "Contents", "Characters"].contains(&t.as_str())).collect::<Vec<_>>();
+ assert_eq!(rows(frame(&mut app)), ["Stroke:", "Fill:", "Contents"]);
+ run(&mut app, "appearance.moveItem", json!({"from": "contents", "to": 1}));
+ assert_eq!(rows(frame(&mut app)), ["Stroke:", "Contents", "Fill:"]);
+ let t = run(&mut app, "text.create", json!({"x": 0, "y": 60, "text": "Hi"}))["id"].clone();
+ run(&mut app, "select.set", json!({"ids": [t]}));
+ assert_eq!(rows(frame(&mut app)), ["Characters"]);
+ run(&mut app, "appearance.addFill", json!({}));
+ assert_eq!(rows(frame(&mut app)), ["Fill:", "Characters"]);
+}
+
+#[test]
+fn images_show_a_contents_row_with_new_fills_and_strokes_below_it() {
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ let run = |app: &mut VectorcraftApp, id: &str, p: Value| app.session.execute(id, &p).unwrap();
+ run(&mut app, "file.new", json!({"width": 100, "height": 100}));
+ let rows = |t: Vec<String>| t.into_iter().filter(|t| ["Fill:", "Stroke:", "Contents"].contains(&t.as_str())).collect::<Vec<_>>();
+ let mut png = vec![];
+ image::RgbaImage::from_pixel(4, 4, image::Rgba([255, 0, 0, 255]))
+ .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
+ .unwrap();
+ run(&mut app, "file.place", json!({"name": "red.png", "dataBase64": vectorcraft_format::base64_encode(&png)}));
+ assert_eq!(rows(frame(&mut app)), ["Contents"]);
+ run(&mut app, "appearance.addStroke", json!({}));
+ assert_eq!(rows(frame(&mut app)), ["Contents", "Stroke:"]);
+}
+
+#[test]
+fn drops_move_items_across_the_contents_row_and_the_row_itself() {
+ use vectorcraft_doc::FillLayer;
+ // A group [F0 | F1 F2]: the Contents row sits above item 0.
+ let mut n = Node::group(NodeId(1), vec![]);
+ n.appearance.items = (0..3).map(|_| AppearanceItem::Fill(FillLayer::new(Paint::None))).collect();
+ n.appearance.set_contents_at(1);
+ let slots = [
+ Slot::Object { top: true },
+ Slot::Item { index: 2, sub: false },
+ Slot::Item { index: 1, sub: false },
+ Slot::Contents,
+ Slot::Item { index: 0, sub: false },
+ Slot::Object { top: false },
+ ];
+ let rows: Vec<(Slot, Rect)> =
+ slots.iter().enumerate().map(|(i, s)| (*s, Rect::from_min_size(pos2(0.0, i as f32 * ROW), vec2(200.0, ROW)))).collect();
+ let at = |i: usize| pos2(50.0, i as f32 * ROW + ROW / 2.0);
+ let drop = |what, i| drop_command(&n, &rows, what, at(i), false);
+ // Onto the Contents row: from above it lands just below, from below just above.
+ assert_eq!(drop(Dragged::Item(2), 3), Some(("appearance.moveItem", json!({"from": 2, "to": 1, "contents": 2}))));
+ assert_eq!(drop(Dragged::Item(0), 3), Some(("appearance.moveItem", json!({"from": 0, "to": 0, "contents": 0}))));
+ // Onto the object row: above everything; under the stack: below everything.
+ assert_eq!(drop(Dragged::Item(0), 0), Some(("appearance.moveItem", json!({"from": 0, "to": 2, "contents": 0}))));
+ assert_eq!(drop(Dragged::Item(2), 5), Some(("appearance.moveItem", json!({"from": 2, "to": 0, "contents": 2}))));
+ // The row itself: above item 2, below item 0; nowhere new on itself.
+ assert_eq!(drop(Dragged::Contents, 1), Some(("appearance.moveItem", json!({"from": "contents", "to": 3}))));
+ assert_eq!(drop(Dragged::Contents, 4), Some(("appearance.moveItem", json!({"from": "contents", "to": 0}))));
+ assert_eq!(drop(Dragged::Contents, 3), None);
+ assert_eq!(drop(Dragged::Contents, 2), Some(("appearance.moveItem", json!({"from": "contents", "to": 2}))));
+}
+
+#[test]
+fn with_nothing_selected_it_lists_what_new_art_gets() {
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ let run = |app: &mut VectorcraftApp, id: &str, p: Value| app.session.execute(id, &p).unwrap();
+ run(&mut app, "file.new", json!({"width": 100, "height": 100}));
+ run(&mut app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20}));
+ run(&mut app, "appearance.addFill", json!({}));
+ run(&mut app, "effect.apply", json!({"effect": "stylize.dropShadow"}));
+ run(&mut app, "transparency.set", json!({"opacity": 50}));
+ run(&mut app, "graphicStyle.new", json!({"name": "Fancy"}));
+ run(&mut app, "select.none", json!({}));
+ let shown = frame(&mut app);
+ assert!(shown.contains(&"No Selection".to_string()) && shown.contains(&"Opacity: Default".to_string()), "{shown:?}");
+ // A style clicked with nothing selected: the rows show what the next object gets.
+ run(&mut app, "graphicStyle.apply", json!({"name": "Fancy"}));
+ run(&mut app, "stroke.set", json!({"dash": [3, 3]}));
+ let shown = frame(&mut app);
+ let rows: Vec<&String> = shown.iter().filter(|t| ["Fill:", "Stroke:"].contains(&t.as_str())).collect();
+ assert_eq!(rows, ["Fill:", "Stroke:", "Fill:"], "the added fill is on top");
+ for want in ["No Selection: Fancy".to_string(), effect_label("stylize.dropShadow"), "Opacity: 50%".into(), "Dashed".into()] {
+ assert!(shown.contains(&want), "{want} in {shown:?}");
+ }
+}
+
+/// Both stroke rows expose named Weight inputs, and the drop-shadow effect names its Blur input and
+/// Color radio button.
+#[test]
+fn inline_stroke_weight_and_effect_fields_are_named() {
+ use egui_kittest::kittest::Queryable;
+ let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+ app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+ app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap();
+ app.run("appearance.addStroke", json!({})).unwrap();
+ app.run("effect.apply", json!({"effect": "stylize.dropShadow"})).unwrap();
+ let mut first = true;
+ let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(360.0, 760.0)).with_accessibility_check(false).build_ui_state(
+ move |ui, app: &mut VectorcraftApp| {
+ if std::mem::replace(&mut first, false) {
+ crate::theme::install_fonts(ui.ctx());
+ set_pstate(ui.ctx(), "ap-fx-open-None-0", true);
+ }
+ show(app, ui);
+ },
+ app,
+ );
+ h.run_steps(4);
+ assert_eq!(h.get_all_by_role_and_label(egui::accesskit::Role::TextInput, "Weight:").count(), 2, "both stroke rows are named");
+ let _ = h.get_by_role_and_label(egui::accesskit::Role::TextInput, "Blur");
+ let _ = h.get_by_role_and_label(egui::accesskit::Role::RadioButton, "Color");
+}