2bc41aeb8602
tests_screens.rs
//! Export for Screens, drawn headlessly: the fields it opens on (defaults, then the document's last
//! settings, and the artboards the Artboard tool has selected), the artboard choice, Format
//! Settings, desktop folders, the export on the background thread and web downloads.
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_engine::Session;
use vectorcraft_engine::cmd::fileio;
use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
use super::tests_export::{frame, kind, set};
use super::*;
use crate::Services;
use crate::background;
use crate::tests_background::{Files, Gate, written};
type Log = Rc<RefCell<Vec<(String, Vec<u8>)>>>;
/// An app with `artboards` 60×40 pt artboards and an ellipse on the first; `web` gives it a
/// download service (recorded in the log) instead of a file manager (whose reveals are recorded).
fn app(artboards: usize, web: bool) -> (VectorcraftApp, Log) {
let log = Log::default();
let l = log.clone();
let mut services = Services::default();
if web {
services.download = Some(Box::new(move |name: &str, bytes: &[u8]| {
l.borrow_mut().push((name.to_string(), bytes.to_vec()));
Ok(())
}));
} else {
services.reveal = Some(Box::new(move |path: &str| {
l.borrow_mut().push((path.to_string(), vec![]));
Ok(())
}));
services.pick_folder = Some(Box::new(|| None));
}
let mut app = VectorcraftApp::new(Session::new(), services);
app.run("file.new", json!({"width": 60, "height": 40, "artboards": artboards})).unwrap();
app.run("shape.ellipse", json!({"x": 5, "y": 4, "width": 30, "height": 20})).unwrap();
(app, log)
}
fn field(app: &VectorcraftApp, k: &str) -> Value {
app.ui.dialog.as_ref().expect("a dialog is open").fields.get(k).cloned().unwrap_or(Value::Null)
}
fn open(app: &mut VectorcraftApp) {
app.run("file.exportForScreens", json!({})).unwrap();
assert_eq!(kind(app), Some(export_for_screens::KIND));
}
fn temp_folder(tag: &str) -> std::path::PathBuf {
std::env::temp_dir().join(format!("vc-efs-{tag}-{}", std::process::id()))
}
#[test]
fn opens_on_defaults_and_draws_every_view() {
let (mut app, _) = app(3, false);
open(&mut app);
assert_eq!((field(&app, "select"), field(&app, "range"), field(&app, "boards")), (json!("all"), json!("1-3"), json!([true, true, true])));
assert_eq!(field(&app, "formats"), json!([{"format": "png", "scale": "1x", "suffix": ""}]));
assert_eq!(field(&app, "folder"), json!(fileio::export_folder().unwrap_or_default()), "the Desktop, else home");
assert_eq!((field(&app, "openLocation"), field(&app, "subfolders"), field(&app, "preset")), (json!(true), json!(true), json!("")));
assert_eq!((field(&app, "subfolderBy"), field(&app, "pdfs"), field(&app, "view")), (json!("scale"), json!("multiple"), json!("grid")));
assert_eq!((field(&app, "includeBleed"), field(&app, "includeArtboardFill")), (json!(false), json!(true)));
let settings = field(&app, "settings");
for f in ["png", "png8", "jpg", "webp", "gif", "tiff", "svg", "pdf"] {
assert!(settings[f].is_object(), "{f} has settings");
}
assert!(settings["jpg"].get("quality").is_none() && settings["jpg"].get("imageMap").is_none(), "rows choose quality; no maps");
assert!(settings["svg"].get("images").is_none(), "no linked images");
assert_eq!(settings["pdf"]["preset"], json!(fileio::pdf::DEFAULT_PRESET));
frame(&mut app);
// Assets, Full Document, each format's Format Settings: all draw.
set(&mut app, "tab", json!("assets"));
frame(&mut app);
set(&mut app, "tab", json!("artboards"));
set(&mut app, "select", json!("full"));
for f in ["png", "png8", "jpg", "webp", "gif", "tiff", "svg", "pdf"] {
set(&mut app, "__settings", json!(f));
frame(&mut app);
assert_eq!(field(&app, "__settings"), json!(f));
}
assert_eq!(kind(&app), Some(export_for_screens::KIND));
assert_eq!((spec(export_for_screens::KIND).ok_label.unwrap())(&app), "Export Artboard");
}
/// The dialog's own request, with a row of every format its Format menu offers and every format's
/// settings as it opens, gets no note about an option a file doesn't read.
#[test]
fn the_dialogs_own_rows_and_settings_get_no_unused_option_notes() {
let (mut app, _) = app(1, true);
open(&mut app);
let rows: Vec<Value> = [
json!({"format": "png"}),
json!({"format": "png8"}),
json!({"format": "jpg", "quality": 100}),
json!({"format": "webp"}),
json!({"format": "gif"}),
json!({"format": "tiff"}),
json!({"format": "svg"}),
json!({"format": "pdf"}),
json!({"format": "pdf", "marks": {"trim": true}, "suffix": "-print"}),
json!({"format": "eps"}),
json!({"format": "ai"}),
json!({"format": "vectorcraft"}),
]
.into_iter()
.map(|mut r| {
r["scale"] = json!("1x");
r
})
.collect();
set(&mut app, "formats", json!(rows));
let p = export_for_screens::params(&app, app.ui.dialog.as_ref().unwrap()).unwrap();
let r = app.session.execute("document.exportForScreens", &p).unwrap();
let unused: Vec<&str> = r["warnings"].as_array().unwrap().iter().filter_map(Value::as_str).filter(|w| w.contains("was not used")).collect();
assert!(unused.is_empty(), "{unused:?}");
}
#[test]
fn checked_artboards_read_as_a_range() {
let (mut app, _) = app(5, false);
open(&mut app);
set(&mut app, "boards", json!([true, false, true, true, false]));
frame(&mut app);
// Nothing clicked: the fields stay as set.
assert_eq!(field(&app, "boards"), json!([true, false, true, true, false]));
for (boards, text) in [
(vec![true, true, true], "1-3"),
(vec![false, true, false, true], "2, 4"),
(vec![true, false, true, true, false, true], "1, 3-4, 6"),
(vec![false], ""),
] {
assert_eq!(export_for_screens::range_text(&boards), text);
}
}
#[test]
fn opens_with_the_artboards_the_artboard_tool_selected_and_exports_only_them() {
let (mut app, log) = app(4, true);
app.run("tool.select", json!({"tool": "artboard"})).unwrap();
let boards: Vec<_> = app.session.active().unwrap().doc.artboards.iter().map(|a| a.rect).collect();
let view = app.view_info();
let click = |app: &mut VectorcraftApp, i: usize, shift: bool| {
let mods = Mods { shift, ..Default::default() };
for kind in [PointerKind::Down, PointerKind::Up] {
crate::canvas::dispatch(app, &PointerEvent { kind, pos: boards[i].center(), mods, backquote: false, pressure: 1.0, pen: None }, view);
}
};
// A click on artboard 2 and a Shift-click on artboard 3 select those two. The dialog opens with
// them checked, and Download writes only them.
click(&mut app, 1, false);
click(&mut app, 2, true);
open(&mut app);
assert_eq!(
(field(&app, "select"), field(&app, "range"), field(&app, "boards")),
(json!("range"), json!("2-3"), json!([false, true, true, false]))
);
frame(&mut app);
assert_eq!(field(&app, "boards"), json!([false, true, true, false]), "drawing the dialog keeps them");
let r = confirm(&mut app).unwrap();
// Create Sub-folders is on by default, a folder per scale.
assert_eq!(r["files"], json!(["1x/Artboard-2.png", "1x/Artboard-3.png"]));
assert_eq!(log.borrow().len(), 1, "one zip");
// With every artboard selected it opens on All.
click(&mut app, 0, true);
click(&mut app, 3, true);
open(&mut app);
assert_eq!((field(&app, "select"), field(&app, "range"), field(&app, "boards")), (json!("all"), json!("1-4"), json!([true, true, true, true])));
}
#[test]
fn opens_with_the_rows_selected_in_the_artboards_panel_else_on_the_saved_choice() {
let (mut app, _) = app(4, true);
// An export of the full document with a prefix and a JPEG row is the saved choice.
app.run("file.exportForScreens", json!({"fullDocument": true, "prefix": "proof-", "formats": [{"format": "jpg", "quality": 80, "scale": "2x"}]}))
.unwrap();
app.run("tool.select", json!({"tool": "artboard"})).unwrap();
let ctx = egui::Context::default();
let screen = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(240.0, 400.0)));
let panel = |app: &mut VectorcraftApp, time: f64, events: Vec<egui::Event>| {
let raw = egui::RawInput { events, time: Some(time), screen_rect: screen, ..Default::default() };
let mut out = ctx.run_ui(raw, |ui| crate::panels::artboards::show(app, ui));
out.textures_delta.clear();
out
};
// With the Artboard tool in use, a click on Artboard 2's row and a Shift-click on Artboard 3's
// select those two. The dialog opens with them checked instead of the saved Full Document.
let rows = panel(&mut app, 0.0, vec![]);
for (time, label, modifiers) in [(1.0, "Artboard 2", egui::Modifiers::NONE), (2.0, "Artboard 3", egui::Modifiers::SHIFT)] {
let at = screen_text_at(&rows, label);
let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers };
panel(&mut app, time, vec![egui::Event::ModifiersChanged(modifiers), egui::Event::PointerMoved(at), button(true), button(false)]);
}
assert_eq!(crate::panels::artboards::picked(&app, 4), [1, 2], "the panel highlights rows 2 and 3");
open(&mut app);
let picked = app.ui.dialog.take().expect("a dialog is open").fields;
assert_eq!((&picked["select"], &picked["range"], &picked["boards"]), (&json!("range"), &json!("2-3"), &json!([false, true, true, false])));
// With the Selection tool in use, the dialog opens on the saved choice.
app.run("tool.select", json!({"tool": "selection"})).unwrap();
open(&mut app);
assert_eq!((field(&app, "select"), field(&app, "range"), field(&app, "boards")), (json!("full"), json!("1-4"), json!([true, true, true, true])));
assert_eq!((field(&app, "prefix"), field(&app, "formats")[0]["format"].clone()), (json!("proof-"), json!("jpg")));
// Only the artboard fields differ.
let others = |fields: &serde_json::Map<String, Value>| {
let mut f = fields.clone();
for k in ["select", "range", "boards"] {
f.remove(k);
}
f
};
assert_eq!(others(&picked), others(&app.ui.dialog.as_ref().expect("a dialog is open").fields));
}
#[test]
fn exports_into_the_folder_and_shows_it() {
let (mut app, log) = app(2, false);
let dir = temp_folder("desk");
let folder = dir.to_string_lossy().replace('\\', "/");
open(&mut app);
set(&mut app, "folder", json!(folder));
set(&mut app, "subfolders", json!(true));
set(
&mut app,
"formats",
json!([{"format": "png", "scale": "1x", "suffix": ""}, {"format": "png", "scale": "120w", "suffix": "@120w"}, {"format": "svg", "scale": "1x", "suffix": ""}]),
);
// A bad range keeps the dialog open; so does no folder.
set(&mut app, "select", json!("range"));
set(&mut app, "range", json!("7"));
assert!(confirm(&mut app).is_err());
assert_eq!(kind(&app), Some(export_for_screens::KIND));
set(&mut app, "range", json!("2"));
set(&mut app, "folder", json!(" "));
assert!(confirm(&mut app).is_err());
set(&mut app, "folder", json!(folder));
let r = confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
let files: Vec<&str> = r["files"].as_array().unwrap().iter().map(|f| f.as_str().unwrap()).collect();
assert_eq!(files, [format!("{folder}/1x/Artboard-2.png"), format!("{folder}/120w/Artboard-2@120w.png"), format!("{folder}/SVG/Artboard-2.svg")]);
let png = craft_image_codecs::decode(&std::fs::read(dir.join("120w").join("Artboard-2@120w.png")).unwrap())
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap();
assert_eq!((png.width(), png.height()), (120, 80));
assert_eq!(log.borrow().iter().map(|(p, _)| p.as_str()).collect::<Vec<_>>(), [files[0]], "Open Location shows the first file");
// It reopens on those settings.
open(&mut app);
assert_eq!((field(&app, "select"), field(&app, "range"), field(&app, "boards")), (json!("range"), json!("2"), json!([false, true])));
assert_eq!(field(&app, "formats")[1]["scale"], json!("120w"));
assert_eq!((field(&app, "subfolders"), field(&app, "folder")), (json!(true), json!(folder)));
let _ = std::fs::remove_dir_all(dir);
}
/// [`app`] on the desktop with Background Export's thread-safe writer, which records the files it
/// is given once `gate` opens.
fn app_with_worker(artboards: usize, gate: &Gate) -> (VectorcraftApp, Log, Files) {
let (mut app, log) = app(artboards, false);
let (files, g) = (Files::default(), gate.clone());
let recorded = files.clone();
app.services.write_shared = Some(Arc::new(move |p: &str, b: &[u8]| {
g.wait();
recorded.lock().unwrap().push((p.to_string(), b.to_vec()));
Ok(())
}));
(app, log, files)
}
fn background_export(app: &mut VectorcraftApp, on: bool) {
app.session.execute("prefs.set", &json!({"values": {"backgroundExport": on}})).unwrap();
}
/// The files reply `r` names (its `files`, else the ZIP at its `path`) as they are on disk.
fn on_disk(r: &Value) -> Vec<(String, Vec<u8>)> {
let paths: Vec<&str> = match r["path"].as_str() {
Some(zip) => vec![zip],
None => r["files"].as_array().unwrap().iter().map(|f| f.as_str().unwrap()).collect(),
};
paths.into_iter().map(|p| (p.to_string(), std::fs::read(p).unwrap())).collect()
}
/// With Background Export on, OK closes the dialog with nothing written, and the background thread
/// writes the files OK writes at once with it off: the same names (`-2` included), sub-folders and
/// bytes, and the same status; Open Location shows the first file once it is written. The same
/// holds for one ZIP in the folder.
#[test]
fn the_files_are_written_in_the_background_as_at_once() {
let rows = json!([{"format": "png", "scale": "1x", "suffix": ""}, {"format": "png", "scale": "2x", "suffix": "@2x"}, {"format": "svg", "scale": "1x", "suffix": ""}]);
let dir = temp_folder("background");
let folder = dir.to_string_lossy().replace('\\', "/");
for zip in [false, true] {
let gate = Gate::default();
let (mut app, log, files) = app_with_worker(2, &gate);
app.run("artboard.setProps", json!({"index": 0, "name": "Icon"})).unwrap();
app.run("artboard.setProps", json!({"index": 1, "name": "icon"})).unwrap();
let export = |app: &mut VectorcraftApp| {
if zip {
let p = json!({"folder": folder, "zip": true, "folders": "rows", "name": "<name>", "formats": rows, "openLocation": true});
return app.run("file.exportForScreens", p);
}
open(app);
set(app, "folder", json!(folder));
set(app, "folders", json!("rows"));
set(app, "name", json!("<name>"));
set(app, "formats", rows.clone());
confirm(app)
};
background_export(&mut app, false);
let r = export(&mut app).unwrap();
let want = on_disk(&r);
if !zip {
assert_eq!(want.len(), 6, "{r}");
assert_eq!(want[3].0, format!("{folder}/1x/icon-2.png"));
}
let (status, shown) = (app.ui.status.clone(), log.borrow().clone());
assert_eq!(shown.len(), 1);
std::fs::remove_dir_all(&dir).unwrap();
log.borrow_mut().clear();
background_export(&mut app, true);
let r = export(&mut app).unwrap();
assert_eq!(r["background"], true, "{r}");
assert!(app.ui.dialog.is_none(), "closed");
assert_eq!(app.ui.status, format!("Exporting {}…", dir.file_name().unwrap().to_string_lossy()));
assert!(written(&files).is_empty() && log.borrow().is_empty(), "nothing written yet");
gate.open();
background::wait_all(&mut app);
assert_eq!(*files.lock().unwrap(), want, "zip: {zip}");
assert_eq!((app.ui.status.clone(), log.borrow().clone()), (status, shown));
let _ = std::fs::remove_dir_all(&dir);
}
}
#[test]
fn the_asset_export_panel_writes_in_the_background_as_at_once() {
let gate = Gate::default();
let (mut app, _, files) = app_with_worker(1, &gate);
app.run("select.all", json!({})).unwrap();
app.run("assets.add", json!({"multiple": false})).unwrap();
let dir = temp_folder("assets-background");
let folder = dir.to_string_lossy().replace('\\', "/");
let p = json!({"folder": folder, "formats": [{"format": "png", "scale": "2x", "suffix": "@2x"}, {"format": "svg"}]});
background_export(&mut app, false);
let want = on_disk(&crate::io::export_files(&mut app, "assets.export", p.clone()).unwrap());
assert_eq!(want.len(), 2);
let status = app.ui.status.clone();
std::fs::remove_dir_all(&dir).unwrap();
background_export(&mut app, true);
assert_eq!(crate::io::export_files(&mut app, "assets.export", p).unwrap()["background"], true);
assert!(written(&files).is_empty(), "nothing written yet");
gate.open();
background::wait_all(&mut app);
assert_eq!((files.lock().unwrap().clone(), app.ui.status.clone()), (want, status));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn edits_after_ok_do_not_reach_the_files() {
let gate = Gate::default();
let (mut app, _, files) = app_with_worker(1, &gate);
let dir = temp_folder("snapshot");
let p = json!({"folder": dir.to_string_lossy().replace('\\', "/"), "formats": [{"format": "svg"}]});
background_export(&mut app, false);
let want = on_disk(&app.run("file.exportForScreens", p.clone()).unwrap());
std::fs::remove_dir_all(&dir).unwrap();
background_export(&mut app, true);
assert_eq!(app.run("file.exportForScreens", p).unwrap()["background"], true);
app.run("select.all", json!({})).unwrap();
app.run("edit.clear", json!({})).unwrap();
app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
gate.open();
background::wait_all(&mut app);
assert_eq!(*files.lock().unwrap(), want, "the document as it was at OK");
let _ = std::fs::remove_dir_all(&dir);
}
/// An export into the folder its export preset keeps, with no folder of its own, is written in the
/// background as one into a folder it names, and the status bar names that folder.
#[test]
fn an_export_into_a_presets_folder_writes_in_the_background() {
let gate = Gate::default();
let (mut app, _, files) = app_with_worker(1, &gate);
let dir = temp_folder("preset-folder");
let folder = dir.to_string_lossy().replace('\\', "/");
let settings = json!({"formats": [{"format": "svg"}], "folder": folder});
app.run("document.exportPresets.save", json!({"name": "Kept", "settings": settings})).unwrap();
let p = json!({"exportPreset": "Kept"});
background_export(&mut app, false);
let want = on_disk(&app.run("file.exportForScreens", p.clone()).unwrap());
assert_eq!(want.len(), 1);
let status = app.ui.status.clone();
assert_eq!(status, format!("Exported 1 file to {folder}"));
std::fs::remove_dir_all(&dir).unwrap();
background_export(&mut app, true);
assert_eq!(app.run("file.exportForScreens", p).unwrap()["background"], true);
assert!(written(&files).is_empty(), "nothing written yet");
gate.open();
background::wait_all(&mut app);
assert_eq!((files.lock().unwrap().clone(), app.ui.status.clone()), (want, status));
let _ = std::fs::remove_dir_all(&dir);
}
/// Cancel stops the export before its next file; the file being written when it came stays.
#[test]
fn cancel_stops_the_export_before_its_next_file() {
let (gate, writing) = (Gate::default(), Gate::default());
let (mut app, _) = app(3, false);
let files = Files::default();
let (f, g, w) = (files.clone(), gate.clone(), writing.clone());
app.services.write_shared = Some(Arc::new(move |p: &str, b: &[u8]| {
w.open();
g.wait();
f.lock().unwrap().push((p.to_string(), b.to_vec()));
Ok(())
}));
let dir = temp_folder("cancel");
let folder = dir.to_string_lossy().replace('\\', "/");
let r = app.run("file.exportForScreens", json!({"folder": folder, "formats": [{"format": "svg"}]})).unwrap();
assert_eq!(r["background"], true, "{r}");
writing.wait();
assert_eq!(app.run("file.cancelExport", json!({})).unwrap()["cancelled"], 1);
gate.open();
background::wait_all(&mut app);
assert_eq!(written(&files), [format!("{folder}/Artboard-1.svg")]);
assert_eq!(app.ui.status, crate::io::EXPORT_CANCELLED);
let _ = std::fs::remove_dir_all(&dir);
}
/// With Background Export turned off, an export into the same folder is written after the one in
/// the background.
#[test]
fn an_export_made_at_once_waits_for_one_in_the_background() {
let gate = Gate::default();
let (mut app, _, files) = app_with_worker(1, &gate);
let dir = temp_folder("twice");
let folder = dir.to_string_lossy().replace('\\', "/");
let p = json!({"folder": folder, "formats": [{"format": "svg"}]});
assert_eq!(app.run("file.exportForScreens", p.clone()).unwrap()["background"], true);
background_export(&mut app, false);
let opener = gate.clone();
let release = std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(500));
opener.open();
});
let r = app.run("file.exportForScreens", p).unwrap();
assert!(app.background.jobs.is_empty(), "the export in the background was written first");
release.join().unwrap();
let file = format!("{folder}/Artboard-1.svg");
assert_eq!((written(&files), r["files"].clone()), (vec![file.clone()], json!([file])));
assert_eq!(app.ui.status, format!("Exported 1 file to {folder}"));
let _ = std::fs::remove_dir_all(&dir);
}
/// Without a folder (a script or an agent on the desktop) the files come back in the reply at once,
/// with Background Export on too.
#[test]
fn an_export_without_a_folder_replies_with_its_files() {
let (mut app, _, files) = app_with_worker(1, &Gate::default());
let r = app.run("file.exportForScreens", json!({"formats": [{"format": "svg"}]})).unwrap();
assert!(r.get("background").is_none(), "{r}");
assert_eq!(r["files"][0]["name"], "Artboard-1.svg");
assert!(app.background.jobs.is_empty() && written(&files).is_empty());
}
/// The command's refusal keeps the dialog open and starts nothing, as at once.
#[test]
fn a_refused_export_keeps_the_dialog_open_with_background_export_on() {
let (mut app, _, files) = app_with_worker(2, &Gate::default());
open(&mut app);
set(&mut app, "folder", json!(temp_folder("refused").to_string_lossy().replace('\\', "/")));
set(&mut app, "formats", json!([{"format": "dxf", "scale": "1x", "suffix": ""}]));
let e = confirm(&mut app).unwrap_err();
assert!(e.contains("Export for Screens writes png"), "{e}");
assert_eq!((kind(&app), app.ui.status.as_str()), (Some(export_for_screens::KIND), e.as_str()));
assert!(app.background.jobs.is_empty() && written(&files).is_empty());
}
#[test]
fn the_web_downloads_one_zip_or_the_file() {
let (mut app, log) = app(2, true);
assert_eq!((spec(export_for_screens::KIND).ok_label.unwrap())(&app), "Download");
open(&mut app);
frame(&mut app);
set(
&mut app,
"formats",
json!([{"format": "png", "scale": "1x", "suffix": ""}, {"format": "jpg", "quality": 80, "scale": "2x", "suffix": "@2x"}]),
);
set(&mut app, "settings", json!({"png": {"background": "black"}}));
let r = confirm(&mut app).unwrap();
assert!(r.get("dataBase64").is_some(), "four files: one zip");
{
let log = log.borrow();
let [(name, zip)] = log.as_slice() else { panic!("one download: {:?}", log.iter().map(|(n, _)| n).collect::<Vec<_>>()) };
assert_eq!(name, "Untitled-1.zip");
assert_eq!(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap(), zip);
}
assert_eq!(r["files"], json!(["1x/Artboard-1.png", "2x/Artboard-1@2x.jpg", "1x/Artboard-2.png", "2x/Artboard-2@2x.jpg"]));
// One file downloads as itself, with the format's settings.
log.borrow_mut().clear();
open(&mut app);
assert_eq!(field(&app, "settings")["png"]["background"], json!("black"), "remembered");
set(&mut app, "select", json!("range"));
set(&mut app, "range", json!("1"));
set(&mut app, "formats", json!([{"format": "png", "scale": "1x", "suffix": ""}]));
confirm(&mut app).unwrap();
let log = log.borrow();
assert_eq!(log.len(), 1);
assert_eq!(log[0].0, "Artboard-1.png");
assert_eq!(
craft_image_codecs::decode(&log[0].1)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8()
.get_pixel(1, 1)
.0,
[0, 0, 0, 255],
"the PNG settings' background"
);
}
/// Include Artboard Fill: checked, the file shows the artboard's background color behind the art
/// (on transparency too); unchecked, it doesn't, and the dialog reopens unchecked.
#[test]
fn include_artboard_fill_reaches_the_files_and_is_remembered() {
let (mut app, log) = app(1, true);
app.run("artboard.setProps", json!({"index": 0, "color": "#ff0000"})).unwrap();
for include in [true, false] {
log.borrow_mut().clear();
open(&mut app);
assert_eq!(field(&app, "includeArtboardFill"), json!(true), "on until unchecked");
set(&mut app, "includeArtboardFill", json!(include));
set(&mut app, "settings", json!({"png": {"background": "transparent"}}));
frame(&mut app);
confirm(&mut app).unwrap();
let px = craft_image_codecs::decode(&log.borrow()[0].1)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8()
.get_pixel(58, 38)
.0;
assert_eq!(px, if include { [255, 0, 0, 255] } else { [0, 0, 0, 0] }, "include {include}");
if include {
continue;
}
open(&mut app);
assert_eq!(field(&app, "includeArtboardFill"), json!(false), "remembered");
}
}
#[test]
fn the_status_bar_says_when_an_image_could_not_be_decoded() {
const NOTE: &str = "with 1 note: an image couldn't be decoded and is missing from the picture";
// A PNG whose header reads but whose pixel data is cut short: the renderer draws nothing for it.
let mut png = Vec::new();
{
let __dyn: image::DynamicImage = (image::RgbaImage::from_pixel(64, 32, image::Rgba([200, 30, 30, 255]))).into();
let (__w, __h) = (__dyn.width(), __dyn.height());
let (__layout, __sample, __raw) = match __dyn {
image::DynamicImage::ImageLuma8(b) => (craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageLumaA8(b) => (craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageRgb8(b) => (craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageRgba8(b) => (craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageLuma16(b) => (
craft_image_codecs::ChannelLayout::Gray,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageLumaA16(b) => (
craft_image_codecs::ChannelLayout::GrayA,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageRgb16(b) => (
craft_image_codecs::ChannelLayout::Rgb,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageRgba16(b) => (
craft_image_codecs::ChannelLayout::Rgba,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
other => (craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, other.into_rgba8().into_raw()),
};
let __cimg = craft_image_codecs::Image::from_raw(__w, __h, __layout, __sample, __raw).unwrap();
craft_image_codecs::encode(&__cimg, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default())
.map(|__b| png.extend_from_slice(&__b))
}
.unwrap();
let place = |app: &mut VectorcraftApp| vectorcraft_testkit::fixtures::place_cut_png(&mut app.session, &png, json!({"at": [10, 10]}));
let rows = json!([{"format": "png", "scale": "1x", "suffix": ""}, {"format": "jpg", "scale": "2x", "suffix": "@2x"}]);
let dir = temp_folder("undecoded");
let folder = dir.to_string_lossy().replace('\\', "/");
let (mut desktop, log) = app(1, false);
desktop.run("file.exportForScreens", json!({"folder": folder, "formats": rows})).unwrap();
assert_eq!(desktop.ui.status, format!("Exported 2 files to {folder}"));
place(&mut desktop);
desktop.run("file.exportForScreens", json!({"folder": folder, "formats": rows, "openLocation": true})).unwrap();
assert_eq!(desktop.ui.status, format!("Saved {folder} {NOTE}"));
assert_eq!(log.borrow().len(), 1, "Open Location still shows the first file");
let r = desktop.run("file.exportForScreens", json!({"folder": folder, "formats": rows, "zip": true})).unwrap();
assert_eq!(desktop.ui.status, format!("Saved {} {NOTE}", r["path"].as_str().unwrap()));
// The Asset Export panel's export goes the same way.
desktop.run("select.all", json!({})).unwrap();
desktop.run("assets.add", json!({"multiple": false})).unwrap();
crate::io::export_files(&mut desktop, "assets.export", json!({"folder": folder, "formats": rows})).unwrap();
assert_eq!(desktop.ui.status, format!("Saved {folder} {NOTE}"), "assets.export");
let (mut web, _) = app(1, true);
place(&mut web);
web.run("file.exportForScreens", json!({"zip": true, "formats": rows})).unwrap();
assert_eq!(web.ui.status, format!("Saved Untitled-1.zip {NOTE}"));
let _ = std::fs::remove_dir_all(dir);
}
/// An export into a folder with several notes, from Export for Screens and from the Asset Export
/// panel: the status bar names the first, counts them, and keeps every one of them for its hover.
#[test]
fn an_export_into_a_folder_keeps_every_note_for_the_hover() {
let mut png = Vec::new();
{
let __dyn: image::DynamicImage = (image::RgbaImage::from_pixel(64, 32, image::Rgba([200, 30, 30, 255]))).into();
let (__w, __h) = (__dyn.width(), __dyn.height());
let (__layout, __sample, __raw) = match __dyn {
image::DynamicImage::ImageLuma8(b) => (craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageLumaA8(b) => (craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageRgb8(b) => (craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageRgba8(b) => (craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageLuma16(b) => (
craft_image_codecs::ChannelLayout::Gray,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageLumaA16(b) => (
craft_image_codecs::ChannelLayout::GrayA,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageRgb16(b) => (
craft_image_codecs::ChannelLayout::Rgb,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageRgba16(b) => (
craft_image_codecs::ChannelLayout::Rgba,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
other => (craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, other.into_rgba8().into_raw()),
};
let __cimg = craft_image_codecs::Image::from_raw(__w, __h, __layout, __sample, __raw).unwrap();
craft_image_codecs::encode(&__cimg, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default())
.map(|__b| png.extend_from_slice(&__b))
}
.unwrap();
let dir = temp_folder("notes");
let folder = dir.to_string_lossy().replace('\\', "/");
let rows = json!([{"format": "png", "scale": "1x", "suffix": ""}]);
let (mut app, _) = app(1, false);
vectorcraft_testkit::fixtures::place_cut_png(&mut app.session, &png, json!({"at": [10, 10]}));
app.run("text.create", json!({"x": 5, "y": 20, "text": "Ab", "font": "Nonexistent Sans Probe"})).unwrap();
let r = app.run("file.exportForScreens", json!({"folder": folder, "formats": rows})).unwrap();
let notes = crate::io::notes_of(&r);
assert_eq!(notes.len(), 2, "{r}");
assert!(app.ui.status.starts_with(&format!("Saved {folder} with 2 notes: {}", notes[0])), "{}", app.ui.status);
assert_eq!(app.ui.status_notes, Some((app.ui.status.clone(), notes)));
app.ui.status_notes = None;
app.run("select.all", json!({})).unwrap();
app.run("assets.add", json!({"multiple": false})).unwrap();
let r = crate::io::export_files(&mut app, "assets.export", json!({"folder": folder, "formats": rows})).unwrap();
let notes = crate::io::notes_of(&r);
assert_eq!(notes.len(), 2, "{r}");
assert_eq!(app.ui.status_notes, Some((app.ui.status.clone(), notes)), "assets.export");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn a_preset_export_reopens_on_its_rows() {
let (mut app, _) = app(1, true);
app.run("file.exportForScreens", json!({"preset": "density", "fullDocument": true})).unwrap();
open(&mut app);
assert_eq!(field(&app, "preset"), json!("density"));
assert_eq!(field(&app, "select"), json!("full"));
assert_eq!(field(&app, "subfolders"), json!(true));
let rows = field(&app, "formats");
assert_eq!(rows.as_array().unwrap().len(), 6);
assert_eq!((rows[0]["scale"].clone(), rows[0]["folder"].clone()), (json!("0.75x"), json!("ldpi")));
frame(&mut app);
// Agents' numeric sizes show as text.
app.run(
"file.exportForScreens",
json!({"formats": [{"format": "png", "width": 64}, {"format": "png", "scale": 3}, {"format": "png", "ppi": 144}]}),
)
.unwrap();
open(&mut app);
let scales: Vec<Value> = field(&app, "formats").as_array().unwrap().iter().map(|r| r["scale"].clone()).collect();
assert_eq!(scales, [json!("64w"), json!("3x"), json!("144ppi")]);
}
/// Persistent frames keep dropdowns open between the pointer press and release.
struct ScreensFrame {
ctx: egui::Context,
time: f64,
}
impl ScreensFrame {
fn new() -> Self {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
Self { ctx, time: 0.0 }
}
fn frame(&mut self, app: &mut VectorcraftApp, events: Vec<egui::Event>) -> egui::FullOutput {
self.time += 0.1;
let input = egui::RawInput {
events,
time: Some(self.time),
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1100.0, 900.0))),
..Default::default()
};
let mut out = self.ctx.run_ui(input, |ui| super::show(app, ui.ctx()));
out.textures_delta.clear();
out
}
fn settle(&mut self, app: &mut VectorcraftApp) -> egui::FullOutput {
self.frame(app, vec![]);
self.frame(app, vec![])
}
fn asset_panel(&mut self, app: &mut VectorcraftApp, events: Vec<egui::Event>) -> egui::FullOutput {
self.time += 0.1;
let input = egui::RawInput {
events,
time: Some(self.time),
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(236.0, 700.0))),
..Default::default()
};
let mut out = self.ctx.run_ui(input, |ui| crate::panels::show_icon_panel(app, ui, "assetExport"));
out.textures_delta.clear();
out
}
fn click(&mut self, app: &mut VectorcraftApp, at: egui::Pos2) -> egui::FullOutput {
let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
self.frame(app, vec![egui::Event::PointerMoved(at)]);
self.frame(app, vec![button(true)]);
self.frame(app, vec![button(false)]);
self.settle(app)
}
fn click_label(&mut self, app: &mut VectorcraftApp, label: &str) -> egui::FullOutput {
let out = self.settle(app);
self.click(app, screen_text_at(&out, label))
}
fn choose(&mut self, app: &mut VectorcraftApp, current: &str, next: &str) {
let out = self.click_label(app, current);
self.click(app, screen_text_at(&out, next));
}
}
fn screen_text_at(out: &egui::FullOutput, label: &str) -> egui::Pos2 {
fn find(shape: &egui::Shape, label: &str) -> Option<egui::Pos2> {
match shape {
egui::Shape::Text(t) if t.galley.text().trim() == label => Some(t.visual_bounding_rect().center()),
egui::Shape::Vec(v) => v.iter().find_map(|s| find(s, label)),
_ => None,
}
}
out.shapes.iter().find_map(|s| find(&s.shape, label)).unwrap_or_else(|| panic!("missing {label}: {}", crate::tests_labels::shapes_text(out)))
}
/// First-directory entries of the big-endian TIFF chosen below: tag, type, count, inline value.
fn big_tiff_tags(bytes: &[u8]) -> Vec<(u16, u16, u32, u16)> {
assert_eq!(&bytes[..4], b"MM\0*");
let short = |at| u16::from_be_bytes(bytes[at..at + 2].try_into().unwrap());
let long = |at| u32::from_be_bytes(bytes[at..at + 4].try_into().unwrap());
let dir = long(4) as usize;
(0..usize::from(short(dir)))
.map(|i| {
let at = dir + 2 + 12 * i;
(short(at), short(at + 2), long(at + 4), short(at + 8))
})
.collect()
}
/// Locate the gear from the painted Formats label and its production column width.
fn screen_format_gear(out: &egui::FullOutput, width: f32) -> egui::Pos2 {
fn label(shape: &egui::Shape) -> Option<egui::Rect> {
match shape {
egui::Shape::Text(t) if t.galley.text().trim() == "Formats:" => Some(t.visual_bounding_rect()),
egui::Shape::Vec(shapes) => shapes.iter().find_map(label),
_ => None,
}
}
let label = out.shapes.iter().find_map(|s| label(&s.shape)).expect("painted Formats row");
// The existing 24 pt gear is right-aligned in the dialog's 370 pt column or the 236 pt panel.
egui::pos2(label.left() + width - 12.0, label.center().y)
}
fn saved_tiff_alias_gear(alias: &str, asset_panel: bool) {
let (mut app, log) = app(1, true);
app.run("paint.setStroke", json!({"none": true})).unwrap();
app.run("object.convertDocumentColorMode", json!({"mode": "cmyk"})).unwrap();
if asset_panel {
app.run("assets.add", json!({"name": "Badge"})).unwrap();
}
let rows = json!([{"format": alias, "scale": "2x", "suffix": "@2x", "antiAlias": "none"}]);
app.run(
"assets.settings.set",
json!({
"formats": rows.clone(),
"settings": {
"tiff": {"colorModel": "rgb", "byteOrder": "little", "lzw": false, "embedIcc": false, "antiAlias": "type"},
"png": {"interlaced": true}
}
}),
)
.unwrap();
let saved_before = app.session.active().unwrap().doc.export_settings.clone();
if !asset_panel {
open(&mut app);
}
let mut h = ScreensFrame::new();
let draw = |h: &mut ScreensFrame, app: &mut VectorcraftApp, events| {
if asset_panel { h.asset_panel(app, events) } else { h.frame(app, events) }
};
draw(&mut h, &mut app, vec![]);
let out = draw(&mut h, &mut app, vec![]);
let gear = screen_format_gear(&out, if asset_panel { 236.0 } else { 370.0 });
draw(&mut h, &mut app, vec![egui::Event::PointerMoved(gear)]);
for pressed in [true, false] {
draw(
&mut h,
&mut app,
vec![egui::Event::PointerButton { pos: gear, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }],
);
}
assert_eq!(field(&app, "__settings"), "tiff", "gear for {alias}, asset panel={asset_panel}");
assert_eq!(field(&app, "tab"), if asset_panel { "assets" } else { "artboards" });
let out = h.settle(&mut app);
for label in ["Format Settings", "TIFF", "Color Model:", "RGB", "Byte Order:", "Little-endian (II)", "LZW Compression", "Embed ICC Profile"] {
screen_text_at(&out, label);
}
assert_eq!(field(&app, "formats"), rows, "opening the gear preserves the saved spelling and row options");
assert_eq!(app.session.active().unwrap().doc.export_settings, saved_before, "opening settings does not save them");
let mut expected = field(&app, "settings");
assert_eq!(expected["tiff"]["colorModel"], "rgb", "saved RGB overrides the CMYK document default");
assert_eq!(expected["tiff"]["lzw"], false);
assert_eq!(expected["tiff"]["embedIcc"], false);
assert_eq!(expected["tiff"]["antiAlias"], "type");
assert_eq!(expected["png"]["interlaced"], true);
h.choose(&mut app, "Little-endian (II)", "Big-endian (MM)");
expected["tiff"]["byteOrder"] = json!("big");
assert_eq!(field(&app, "settings"), expected, "only the chosen TIFF option changes");
h.click_label(&mut app, "Done");
assert_eq!(field(&app, "formats"), rows);
h.click_label(&mut app, "Download");
assert!(app.ui.dialog.is_none(), "{}", app.ui.status);
{
let log = log.borrow();
let [(name, bytes)] = log.as_slice() else { panic!("expected one TIFF download for {alias}") };
assert_eq!(name, if asset_panel { "Badge@2x.tif" } else { "Artboard-1@2x.tif" });
let tags = big_tiff_tags(bytes); // The gear's edited canonical settings reach the aliased row.
assert!(tags.contains(&(259, 3, 1, 1)), "saved uncompressed option survives");
assert!(tags.contains(&(262, 3, 1, 2)), "saved RGB survives");
assert!(!tags.iter().any(|t| t.0 == 34675), "saved profile-off option survives");
let img = craft_image_codecs::decode_as(craft_image_codecs::Format::Tiff, bytes)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap();
assert_eq!((img.width(), img.height()), if asset_panel { (60, 40) } else { (120, 80) });
}
let saved = app.run("document.exportSettings", json!({})).unwrap()["settings"].clone();
assert_eq!(saved["formats"], rows, "export preserves the alias, scale, suffix and row override");
assert_eq!(saved["settings"], expected, "canonical TIFF edits and other format settings persist");
open(&mut app);
assert_eq!(field(&app, "formats"), rows);
assert_eq!(field(&app, "settings"), expected);
}
#[test]
fn tiff_saved_alias_gear_opens_and_edits_settings_in_screens() {
for alias in ["tiff", "tif", "TIFF", ".tif"] {
saved_tiff_alias_gear(alias, false);
}
}
#[test]
fn tiff_saved_alias_gear_opens_and_edits_settings_in_asset_export() {
for alias in ["tiff", "tif", "TIFF", ".tif"] {
saved_tiff_alias_gear(alias, true);
}
}
#[test]
fn tiff_dropdown_exports_scaled_artboards_with_options_and_reopens() {
let (mut app, log) = app(2, true);
app.run("paint.setStroke", json!({"none": true})).unwrap();
app.run("paint.setFill", json!({"color": "#c03020"})).unwrap();
open(&mut app);
// Begin with an existing PNG row; TIFF must be chosen from the actual popup.
set(&mut app, "formats", json!([{"format": "png", "scale": "2x", "suffix": "@2x"}]));
set(&mut app, "prefix", json!("proof-"));
set(&mut app, "subfolders", json!(false));
let mut h = ScreensFrame::new();
h.choose(&mut app, "PNG", "TIFF");
assert_eq!(field(&app, "formats"), json!([{"format": "tiff", "scale": "2x", "suffix": "@2x"}]));
// Leave only the first of two boards checked.
h.click_label(&mut app, "2 Artboard 2");
assert_eq!(field(&app, "boards"), json!([true, false]));
assert_eq!(field(&app, "range"), json!("1"));
// Exercise the settings dropdown independently of the row's format choice.
set(&mut app, "__settings", json!("png"));
h.choose(&mut app, "PNG", "TIFF");
assert_eq!(field(&app, "__settings"), json!("tiff"));
let settings = field(&app, "settings");
assert_eq!(settings["tiff"]["colorModel"], "rgb");
assert_eq!(settings["tiff"]["byteOrder"], "little");
assert_eq!(settings["tiff"]["lzw"], true);
assert_eq!(settings["tiff"]["embedIcc"], true);
h.choose(&mut app, "Little-endian (II)", "Big-endian (MM)");
h.click_label(&mut app, "LZW Compression");
h.click_label(&mut app, "Embed ICC Profile");
let settings = field(&app, "settings");
assert_eq!(settings["tiff"]["byteOrder"], "big");
assert_eq!(settings["tiff"]["lzw"], false);
assert_eq!(settings["tiff"]["embedIcc"], false);
h.click_label(&mut app, "Done");
h.click_label(&mut app, "Download");
assert!(app.ui.dialog.is_none(), "{}", app.ui.status);
{
let log = log.borrow();
let [(name, bytes)] = log.as_slice() else { panic!("expected one TIFF download") };
assert_eq!(name, "proof-Artboard-1@2x.tif");
let tags = big_tiff_tags(bytes);
assert!(tags.contains(&(259, 3, 1, 1)), "uncompressed as selected");
assert!(tags.contains(&(262, 3, 1, 2)), "RGB");
assert!(!tags.iter().any(|t| t.0 == 34675), "ICC profile disabled");
let img = craft_image_codecs::decode_as(craft_image_codecs::Format::Tiff, bytes)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8();
assert_eq!(img.dimensions(), (120, 80));
assert_eq!(img.get_pixel(0, 0).0[3], 0, "transparent board corner");
let inside = img.get_pixel(40, 28).0;
assert!(inside[0] > inside[1] && inside[3] == 255, "ellipse at the scaled position: {inside:?}");
}
open(&mut app);
assert_eq!(field(&app, "formats"), json!([{"format": "tiff", "scale": "2x", "suffix": "@2x"}]));
assert_eq!(field(&app, "boards"), json!([true, false]));
assert_eq!(field(&app, "prefix"), "proof-");
assert_eq!(field(&app, "settings")["tiff"], settings["tiff"]);
// Existing vector and raster choices remain selectable.
h.choose(&mut app, "TIFF", "SVG");
assert_eq!(field(&app, "formats")[0]["format"], "svg");
// The list opens with SVG in its middle, so a raster format near it is in view.
h.choose(&mut app, "SVG", "GIF");
assert_eq!(field(&app, "formats")[0]["format"], "gif");
}
/// The Example line names the first file the export writes for the same settings: the item's file
/// name, a prefix with characters Windows does not allow, a range, a Windows device name as an item
/// folder, the rows' folders and sizes, Create Sub-folders, a vector row's size suffix, the counter
/// typed as text, and the Layers and Selection tabs.
/// The dialog is laid out as Illustrator's: two tabs (Artboards, Assets), Clear Selection and the
/// prefix under the thumbnails, Create Sub-folders by scale or format, Export PDFs As, the iOS and
/// Android rows, and how many items and files the export takes; no naming, layer or selection
/// pages, presets bar or folders list.
#[test]
fn the_dialog_is_laid_out_as_illustrators() {
let (mut app, _) = app(3, false);
open(&mut app);
let text = crate::tests_labels::shapes_text(&ScreensFrame::new().settle(&mut app));
for label in [
"Artboards",
"Assets",
"Select:",
"Full Document",
"Include Bleed",
"Include Artboard Fill",
"Export to:",
"Open Location after Export",
"Create Sub-folders",
"Scale",
"Format",
"Export PDFs As:",
"Single File",
"Multiple Files",
"Formats:",
"iOS",
"Android",
"+ Add Scale",
"Clear Selection",
"Prefix:",
"Selected: 3, Total number of files to export: 3",
] {
assert!(text.lines().any(|l| l.trim() == label), "{label} missing:\n{text}");
}
for gone in ["Layers", "Selection", "Export Preset:", "File Name:", "Folders:", "Start at:"] {
assert!(!text.lines().any(|l| l.trim() == gone), "{gone} shown:\n{text}");
}
}
/// iOS and Android set the rows those platforms use (in sub-folders); Clear Selection unchecks
/// every artboard, so nothing is exported until one is checked again.
#[test]
fn ios_android_and_clear_selection() {
let (mut app, _) = app(2, false);
open(&mut app);
set(&mut app, "subfolders", json!(false));
let mut h = ScreensFrame::new();
h.click_label(&mut app, "iOS");
let scales: Vec<Value> = field(&app, "formats").as_array().unwrap().iter().map(|r| r["scale"].clone()).collect();
assert_eq!((field(&app, "preset"), field(&app, "subfolders")), (json!("mobile"), json!(true)));
assert_eq!(scales, [json!("1x"), json!("2x"), json!("3x")]);
h.click_label(&mut app, "Android");
assert_eq!((field(&app, "preset"), field(&app, "formats").as_array().unwrap().len()), (json!("density"), 6));
h.click_label(&mut app, "Clear Selection");
assert_eq!((field(&app, "boards"), field(&app, "select")), (json!([false, false]), json!("range")));
let text = crate::tests_labels::shapes_text(&h.settle(&mut app));
assert!(text.contains("Selected: 0, Total number of files to export: 0"), "{text}");
set(&mut app, "folder", json!(temp_folder("cleared").to_string_lossy()));
assert!(confirm(&mut app).is_err(), "nothing to export");
}
/// Create Sub-folders sorts the files into a folder per scale or per format; Export PDFs As ›
/// Single file writes the chosen artboards as one PDF named after the document.
#[test]
fn sub_folders_and_single_file_pdfs() {
let (mut app, _) = app(3, false);
let dir = temp_folder("subfolders");
let _ = std::fs::remove_dir_all(&dir);
let folder = dir.to_string_lossy().to_string();
let title = app.session.active().unwrap().doc.title.clone();
let rows = json!([
{"format": "png", "scale": "1x", "suffix": ""},
{"format": "png", "scale": "2x", "suffix": "@2x"},
{"format": "pdf", "scale": "1x", "suffix": ""}
]);
let files = |app: &mut VectorcraftApp, extra: &[(&str, Value)]| -> Vec<String> {
open(app);
let base = [("folder", json!(folder)), ("select", json!("range")), ("range", json!("1-2")), ("formats", rows.clone())];
for (k, v) in base.into_iter().chain(extra.iter().cloned()) {
set(app, k, v);
}
frame(app);
let r = confirm(app).unwrap();
r["files"].as_array().unwrap().iter().map(|f| f.as_str().unwrap().strip_prefix(&format!("{folder}/")).unwrap().to_string()).collect()
};
let by_scale = files(&mut app, &[("subfolders", json!(true)), ("subfolderBy", json!("scale"))]);
assert_eq!(&by_scale[..2], ["1x/Artboard-1.png", "2x/Artboard-1@2x.png"]);
let by_format = files(&mut app, &[("subfolders", json!(true)), ("subfolderBy", json!("format")), ("pdfs", json!("single"))]);
let pdf = format!("pdf/{title}.pdf");
assert_eq!(by_format, ["png/Artboard-1.png", "png/Artboard-1@2x.png", pdf.as_str(), "png/Artboard-2.png", "png/Artboard-2@2x.png"]);
let flat = files(&mut app, &[("subfolders", json!(false)), ("pdfs", json!("multiple"))]);
assert_eq!(flat.len(), 6);
assert!(flat.contains(&"Artboard-2.pdf".to_string()), "{flat:?}");
// The status line counts the files Single file writes.
open(&mut app);
for (k, v) in [("select", json!("range")), ("range", json!("1-2")), ("formats", rows.clone()), ("pdfs", json!("single"))] {
set(&mut app, k, v);
}
let text = crate::tests_labels::shapes_text(&ScreensFrame::new().settle(&mut app));
assert!(text.contains("Selected: 2, Total number of files to export: 5"), "{text}");
// A format preset sets the rows, their settings and the sub-folders, not a prefix it lacks.
set(&mut app, "prefix", json!("x-"));
let presets = field(&app, "__exportPresets");
let logo = presets.as_array().unwrap().iter().find(|p| p["name"] == "Logo Package").unwrap().clone();
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &logo);
assert_eq!(field(&app, "formats").as_array().unwrap().len(), 5);
assert_eq!(
(field(&app, "subfolders"), field(&app, "subfolderBy"), field(&app, "exportPreset")),
(json!(true), json!("format"), json!("Logo Package"))
);
let _ = std::fs::remove_dir_all(&dir);
}
/// Save Preset… on an applied preset saves the dialog's rows, settings, prefix and sub-folders and
/// keeps the preset's keys the dialog does not show (a file name pattern, other export settings).
#[test]
fn saving_an_applied_preset_keeps_the_keys_the_dialog_does_not_show() {
use export_for_screens::PresetPick;
let (mut app, _) = app(2, false);
app.run(
"document.exportPresets.save",
json!({
"name": "Repeat",
"settings": {"formats": [{"format": "png"}], "name": "<name>-###", "counterPer": "file", "antiAlias": "none", "prefix": "a-"}
}),
)
.unwrap();
open(&mut app);
let preset = export_for_screens::export_presets(&mut app).as_array().unwrap().iter().find(|p| p["name"] == "Repeat").cloned().unwrap();
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &preset);
set(&mut app, "prefix", json!("b-"));
set(&mut app, "subfolders", json!(true));
set(&mut app, "subfolderBy", json!("format"));
let mut d = app.ui.dialog.take().unwrap();
export_for_screens::preset_pick(&mut app, &mut d, PresetPick::Save("Repeat".into()));
app.ui.dialog = Some(d);
let saved = app.session.prefs.screen_export_presets.iter().find(|p| p.name == "Repeat").unwrap_or_else(|| panic!("{}", app.ui.status));
let s = &saved.settings;
assert_eq!((s.get("counterPer"), s.get("antiAlias"), s.get("name")), (Some(&json!("file")), Some(&json!("none")), Some(&json!("<name>-###"))));
assert_eq!((s.get("prefix"), s.get("folders")), (Some(&json!("b-")), Some(&json!("format"))));
assert_eq!(field(&app, "exportPreset"), "Repeat");
}
/// Save Preset… on an applied preset saves the dialog's Include Bleed and Include Artboard Fill.
#[test]
fn saving_an_applied_preset_keeps_its_bleed_and_fill() {
use export_for_screens::PresetPick;
let (mut app, _) = app(2, false);
let settings = json!({"formats": [{"format": "png"}], "includeBleed": true, "includeArtboardFill": false});
app.run("document.exportPresets.save", json!({"name": "Bleed", "settings": settings})).unwrap();
open(&mut app);
let preset = export_for_screens::export_presets(&mut app).as_array().unwrap().iter().find(|p| p["name"] == "Bleed").cloned().unwrap();
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &preset);
let mut d = app.ui.dialog.take().unwrap();
export_for_screens::preset_pick(&mut app, &mut d, PresetPick::Save("Bleed".into()));
app.ui.dialog = Some(d);
let saved = app.session.prefs.screen_export_presets.iter().find(|p| p.name == "Bleed").unwrap_or_else(|| panic!("{}", app.ui.status));
let s = &saved.settings;
assert_eq!((s.get("includeBleed"), s.get("includeArtboardFill")), (Some(&json!(true)), Some(&json!(false))));
}
/// Remembered settings and a preset that hold keys the export no longer reads, in a row, in a
/// format's settings and inside an object option, and settings for a format it doesn't write, open
/// without them, so the dialog's export is not refused.
#[test]
fn saved_keys_no_longer_read_are_left_out_of_the_dialog_s_export() {
let (mut app, _) = app(1, false);
let stale = json!({
"formats": [{"format": "png", "scale": "2x", "noSuchOption": 1}, {"format": "pdf", "marks": {"trim": true, "noSuchMark": 1}}],
"settings": {"png": {"noSuchSetting": true}, "dxf": {}, "pdf": {"bleed": {"top": 1, "inner": 2}}}
});
let Value::Object(saved) = stale.clone() else { panic!("an object") };
std::sync::Arc::make_mut(&mut app.session.active_mut().unwrap().doc).export_settings = saved;
let folder = temp_folder("stale");
let check = |app: &VectorcraftApp| {
let p = export_for_screens::params(app, app.ui.dialog.as_ref().unwrap()).unwrap();
app.session.check_params("document.exportForScreens", &p).unwrap_or_else(|e| panic!("{e}: {p}"));
p
};
open(&mut app);
set(&mut app, "folder", json!(folder.to_string_lossy()));
let p = check(&app);
assert_eq!(p["formats"][0]["scale"], json!("2x"));
assert_eq!(p["formats"][1]["marks"]["trim"], json!(true));
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &json!({"name": "Old", "settings": stale}));
check(&app);
let _ = std::fs::remove_dir_all(&folder);
}
/// A preset that puts each item in its own folder (`item` or `itemFormat`, which the dialog has no
/// control for) keeps that folder mode when it is exported or saved again from the dialog, until
/// the sub-folder controls change (in the dialog or by `ui.dialog.set`).
#[test]
fn an_applied_preset_keeps_its_item_folders() {
use crate::control::{ControlRequest, Outcome};
use export_for_screens::PresetPick;
for mode in ["item", "itemFormat"] {
let (mut app, _) = app(2, false);
app.run("document.exportPresets.save", json!({"name": "Items", "settings": {"formats": [{"format": "png"}], "folders": mode}})).unwrap();
open(&mut app);
let preset = export_for_screens::export_presets(&mut app).as_array().unwrap().iter().find(|p| p["name"] == "Items").cloned().unwrap();
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &preset);
set(&mut app, "folder", json!("out"));
let p = export_for_screens::params(&app, app.ui.dialog.as_ref().unwrap()).unwrap();
assert_eq!(p["folders"], json!(mode), "exported");
let mut d = app.ui.dialog.take().unwrap();
export_for_screens::preset_pick(&mut app, &mut d, PresetPick::Save("Items".into()));
app.ui.dialog = Some(d);
let saved = app.session.prefs.screen_export_presets.iter().find(|p| p.name == "Items").unwrap_or_else(|| panic!("{}", app.ui.status));
assert_eq!(saved.settings.get("folders"), Some(&json!(mode)), "saved");
// `ui.dialog.set` of the sub-folder controls, as a change in the dialog, ends the item folders.
for (on, folders) in [(false, "none"), (true, "rows")] {
let (req, _rx) = ControlRequest::new("ui.dialog.set", json!({"field": "subfolders", "value": on}));
let Outcome::Done(r) = crate::control::handle(&mut app, &egui::Context::default(), &req) else { panic!("not done") };
assert_eq!(r["ok"], true, "{r}");
let p = export_for_screens::params(&app, app.ui.dialog.as_ref().unwrap()).unwrap();
assert_eq!(p["folders"], json!(folders), "subfolders {on}");
}
}
}
/// A preset whose `folders` is empty turns Create Sub-folders off whatever its `subfolders`, as
/// the export command puts every file in the folder itself; without `folders` it uses its
/// `subfolders`, and without either it keeps the dialog's sub-folders.
#[test]
fn a_preset_with_empty_folders_exports_into_the_folder() {
let (mut app, _) = app(2, false);
open(&mut app);
let apply = |app: &mut VectorcraftApp, settings: Value| {
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &json!({"name": "Empty", "settings": settings}));
};
for settings in [json!({"folders": ""}), json!({"folders": "", "subfolders": true})] {
set(&mut app, "subfolders", json!(true));
apply(&mut app, settings.clone());
assert_eq!(field(&app, "subfolders"), json!(false), "{settings}");
}
apply(&mut app, json!({"subfolders": true}));
assert_eq!(field(&app, "subfolders"), json!(true));
set(&mut app, "subfolderBy", json!("format"));
apply(&mut app, json!({}));
assert_eq!((field(&app, "subfolders"), field(&app, "subfolderBy")), (json!(true), json!("format")));
}
/// The Asset Export panel menu's Export Preset… writes a preset to a file and its Import Preset… adds
/// the presets of a file, which the open dialog's dropdown then lists, as it does after opening
/// the file (the web's Import).
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn export_preset_and_import_preset_go_through_files() {
let dir = temp_folder("preset-files");
std::fs::create_dir_all(&dir).unwrap();
let file = dir.join("pack.vcexportpresets").to_string_lossy().to_string();
let (saved_to, picked) = (file.clone(), file.clone());
let suggested = Rc::new(RefCell::new(vec![]));
let shown = suggested.clone();
let services = Services {
pick_save: Some(Box::new(move |pick: &crate::FilePick| {
shown.borrow_mut().push(pick.name.clone());
Some(saved_to.clone())
})),
pick_open: Some(Box::new(move |_: &crate::FilePick| Some(picked.clone()))),
write: Some(Box::new(|p: &str, b: &[u8]| std::fs::write(p, b).map_err(|e| e.to_string()))),
..Default::default()
};
let mut app = VectorcraftApp::new(Session::new(), services);
app.run("file.new", json!({"width": 60, "height": 40})).unwrap();
app.run("document.exportPresets.save", json!({"name": "Pack", "settings": {"formats": [{"format": "svg"}], "folders": "format"}})).unwrap();
open(&mut app);
let names = |app: &VectorcraftApp| -> Vec<String> {
field(app, "__exportPresets").as_array().unwrap().iter().filter_map(|p| p["name"].as_str().map(str::to_string)).collect()
};
assert_eq!(export_for_screens::export_preset(&mut app, "Pack").unwrap(), file);
// The save panel suggests the preset's name, not the document's.
assert_eq!(*suggested.borrow(), ["Pack.vcexportpresets"]);
app.run("document.exportPresets.delete", json!({"name": "Pack"})).unwrap();
frame(&mut app);
assert_eq!(names(&app), ["Logo Package", "Print-Ready PDF"]);
assert_eq!(export_for_screens::import_presets(&mut app).unwrap(), ["Pack"]);
assert_eq!(app.ui.status, "Imported export presets: Pack");
frame(&mut app);
assert_eq!(names(&app), ["Logo Package", "Print-Ready PDF", "Pack"]);
let pack = field(&app, "__exportPresets")[2].clone();
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &pack);
assert_eq!((field(&app, "formats")[0]["format"].clone(), field(&app, "subfolderBy")), (json!("svg"), json!("format")));
// The file opened again: a second copy, numbered, in the open dialog's dropdown.
let bytes = std::fs::read(&file).unwrap();
crate::io::open_bytes(&mut app, &file, &bytes, Some(file.clone())).unwrap();
frame(&mut app);
assert_eq!(kind(&app), Some(export_for_screens::KIND));
assert_eq!(names(&app), ["Logo Package", "Print-Ready PDF", "Pack", "Pack 2"]);
let _ = std::fs::remove_dir_all(&dir);
}
/// Export Preset… suggests the preset's name as a file name, as Export Library… does a library's.
#[test]
fn an_exported_preset_file_is_named_after_the_preset() {
let name = export_for_screens::preset_file_name;
assert_eq!(name("Logo Package 2"), "Logo Package 2.vcexportpresets");
assert_eq!(name("Print-Ready PDF"), "Print-Ready PDF.vcexportpresets");
assert_eq!(name("Web/App: v1.2"), "Web-App- v1-2.vcexportpresets");
assert_eq!(name("CON"), "CON-.vcexportpresets");
}
/// A preset saved with the mobile or density rows (as the Asset Export panel saves one) sets the
/// dialog's rows to them.
#[test]
fn a_mobile_preset_sets_the_rows() {
let (mut app, _) = app(1, false);
app.run("document.exportPresets.save", json!({"name": "Phones", "settings": {"preset": "mobile", "subfolders": true}})).unwrap();
open(&mut app);
let phones = export_for_screens::export_presets(&mut app).as_array().unwrap().iter().find(|p| p["name"] == "Phones").cloned().unwrap();
set(&mut app, "subfolders", json!(false));
set(&mut app, "subfolderBy", json!("format"));
export_for_screens::apply_preset(app.ui.dialog.as_mut().unwrap(), &phones);
assert_eq!(field(&app, "formats"), json!(fileio::screen_preset_rows("mobile").unwrap()));
assert_eq!((field(&app, "preset"), field(&app, "subfolders"), field(&app, "subfolderBy")), (json!("mobile"), json!(true), json!("scale")));
}
/// `ui.dialog.set` of `exportPreset` applies the preset it names, as a pick in the ☰ menu does, so
/// the dialog holds the settings of the preset it names; a name that is no preset's is an error and
/// leaves the dialog as it was.
#[test]
fn setting_the_export_preset_field_applies_the_preset() {
use crate::control::{ControlRequest, Outcome};
let (mut app, _) = app(1, false);
let ctx = egui::Context::default();
open(&mut app);
let set_preset = |app: &mut VectorcraftApp, name: &str| {
let (req, _rx) = ControlRequest::new("ui.dialog.set", json!({"field": "exportPreset", "value": name}));
let Outcome::Done(r) = crate::control::handle(app, &ctx, &req) else { panic!("not done") };
r
};
let r = set_preset(&mut app, "Logo Package");
assert_eq!(r["ok"], true, "{r}");
let rows: Vec<Value> = field(&app, "formats").as_array().unwrap().iter().map(|r| r["format"].clone()).collect();
assert_eq!(rows, [json!("svg"), json!("png"), json!("png"), json!("pdf"), json!("pdf")]);
assert_eq!(field(&app, "subfolderBy"), json!("format"));
assert_eq!(r["result"]["fields"]["subfolderBy"], "format", "{r}");
let r = set_preset(&mut app, "Never saved");
assert_eq!(r["ok"], false, "{r}");
assert_eq!(field(&app, "exportPreset"), "Logo Package");
assert_eq!(field(&app, "subfolderBy"), "format");
// A request that fails on a later field changes none of its fields.
let fields = json!({"fields": [{"field": "subfolderBy", "value": "scale"}, {"field": "exportPreset", "value": "Never saved"}]});
let (req, _rx) = ControlRequest::new("ui.dialog.set", fields);
let Outcome::Done(r) = crate::control::handle(&mut app, &ctx, &req) else { panic!("not done") };
assert_eq!(r["ok"], false, "{r}");
assert_eq!((field(&app, "exportPreset"), field(&app, "subfolderBy")), (json!("Logo Package"), json!("format")));
// In one request the fields apply in order: a field after the preset goes over it.
let fields = json!({"fields": [{"field": "exportPreset", "value": "Logo Package"}, {"field": "subfolderBy", "value": "scale"}]});
let (req, _rx) = ControlRequest::new("ui.dialog.set", fields);
let Outcome::Done(r) = crate::control::handle(&mut app, &ctx, &req) else { panic!("not done") };
assert_eq!(r["ok"], true, "{r}");
assert_eq!((field(&app, "exportPreset"), field(&app, "subfolderBy")), (json!("Logo Package"), json!("scale")));
}
/// The Asset Export panel menu's Import Preset… and Export Preset… show their file dialogs off the UI
/// thread (as sheets on macOS) and read or write the file when the dialog answers.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn preset_files_ask_off_the_ui_thread() {
use crate::panels::asset_export;
use crate::picks::PickRequest;
use export_for_screens::PresetPick;
let mut services = Services { dialogs_are_sheets: true, ..Default::default() };
let (shown, written) = crate::tests_picks::off_the_ui_thread(&mut services);
let mut app = VectorcraftApp::new(Session::new(), services);
app.run("file.new", json!({"width": 60, "height": 40})).unwrap();
app.run("document.exportPresets.save", json!({"name": "Pack", "settings": {"formats": [{"format": "svg"}]}})).unwrap();
let dir = temp_folder("preset-sheets");
std::fs::create_dir_all(&dir).unwrap();
let file = dir.join("pack.vcexportpresets");
std::fs::write(&file, app.run("document.exportPresets.export", json!({"names": ["Pack"]})).unwrap()["data"].as_str().unwrap()).unwrap();
let file = file.to_string_lossy().to_string();
let names = |app: &VectorcraftApp| app.session.prefs.screen_export_presets.iter().map(|p| p.name.clone()).collect::<Vec<_>>();
let poll = |app: &mut VectorcraftApp| crate::picks::poll(app, &egui::Context::default());
let ctx = egui::Context::default();
let doc = app.session.active().unwrap().uid;
asset_export::preset(&mut app, &ctx, doc, PresetPick::Export("Pack".into()));
assert!(matches!(shown.requests().as_slice(), [PickRequest::Save(p)] if p.name == "Pack.vcexportpresets"), "{:?}", shown.requests());
assert!(written.borrow().is_empty() && app.ui.status.is_empty(), "{}", app.ui.status);
shown.answer(&["/presets/pack.vcexportpresets"]);
poll(&mut app);
assert_eq!(*written.borrow(), ["/presets/pack.vcexportpresets"], "{}", app.ui.status);
asset_export::preset(&mut app, &ctx, doc, PresetPick::Import);
assert!(matches!(shown.requests().as_slice(), [PickRequest::Open(_)]), "{:?}", shown.requests());
assert_eq!(names(&app), ["Pack"]);
shown.answer(&[&file]);
poll(&mut app);
assert_eq!(names(&app), ["Pack", "Pack 2"], "{}", app.ui.status);
let _ = std::fs::remove_dir_all(&dir);
}
/// The dialog's Export Preset row has no Import Preset… or Export Preset…: those picks change
/// nothing there.
#[test]
fn the_dialog_leaves_preset_files_to_the_panel() {
use export_for_screens::PresetPick;
let (mut app, _) = app(1, false);
open(&mut app);
let before = serde_json::to_value(&app.ui.dialog).unwrap();
for pick in [PresetPick::Import, PresetPick::Export("Logo Package".into())] {
let mut d = app.ui.dialog.take().unwrap();
export_for_screens::preset_pick(&mut app, &mut d, pick);
app.ui.dialog = Some(d);
}
assert_eq!(serde_json::to_value(&app.ui.dialog).unwrap(), before);
assert_eq!(app.ui.status, "");
}
/// The dialog keeps its list of export presets from frame to frame, and builds it again when the
/// saved presets change.
#[test]
fn the_dialog_builds_the_preset_list_again_only_when_the_presets_change() {
let (mut app, _) = app(1, false);
open(&mut app);
frame(&mut app);
let mark = |app: &mut VectorcraftApp| app.ui.dialog.as_mut().unwrap().fields.get_mut("__exportPresets").unwrap()[0]["mark"] = json!(true);
mark(&mut app);
frame(&mut app);
frame(&mut app);
assert_eq!(field(&app, "__exportPresets")[0]["mark"], true, "the list was not built again");
app.run("document.exportPresets.save", json!({"name": "Mine", "settings": {"formats": [{"format": "svg"}]}})).unwrap();
frame(&mut app);
let list = field(&app, "__exportPresets");
assert!(list[0].get("mark").is_none() && list.as_array().unwrap().iter().any(|p| p["name"] == "Mine"), "{list}");
// A saved preset changed under the same name is a change too.
mark(&mut app);
app.run("document.exportPresets.save", json!({"name": "Mine", "settings": {"formats": [{"format": "pdf"}]}})).unwrap();
frame(&mut app);
let list = field(&app, "__exportPresets");
let mine = list.as_array().unwrap().iter().find(|p| p["name"] == "Mine").unwrap();
assert_eq!(mine["settings"]["formats"][0]["format"], "pdf", "{list}");
}
/// #7275: a double-click on an artboard name enters rename without leaving Export for Screens.
#[test]
fn same_frame_artboard_double_click_keeps_export_selection() {
for view in ["grid", "list"] {
for checked in [true, false] {
let (mut app, _) = app(2, true);
open(&mut app);
set(&mut app, "view", json!(view));
let mut h = ScreensFrame::new();
let out = h.settle(&mut app);
let name = app.session.active().unwrap().doc.artboards[0].name.clone();
let at = screen_text_at(&out, &format!("1 {name}"));
if !checked {
h.click(&mut app, at);
h.time += 1.0;
h.settle(&mut app);
}
let before = field(&app, "boards");
h.frame(&mut app, vec![egui::Event::PointerMoved(at)]);
let events = [true, false, true, false]
.into_iter()
.map(|pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() })
.collect();
h.frame(&mut app, events);
h.settle(&mut app);
assert!(h.ctx.egui_wants_keyboard_input(), "{view}, checked={checked}");
assert_eq!(field(&app, "boards"), before, "{view}, checked={checked}");
}
}
}
/// #7275: a double-click on an artboard name enters rename without leaving Export for Screens.
#[test]
fn switching_export_tabs_commits_an_artboard_name() {
for view in ["grid", "list"] {
let (mut app, log) = app(2, true);
open(&mut app);
set(&mut app, "view", json!(view));
let mut h = ScreensFrame::new();
let before = field(&app, "boards");
let out = h.settle(&mut app);
let old = app.session.active().unwrap().doc.artboards[0].name.clone();
let at = screen_text_at(&out, &format!("1 {old}"));
h.frame(&mut app, vec![egui::Event::PointerMoved(at)]);
for pressed in [true, false, true, false] {
h.frame(
&mut app,
vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }],
);
}
h.settle(&mut app);
assert!(h.ctx.egui_wants_keyboard_input());
h.frame(&mut app, vec![egui::Event::Text("Committed on tab".into())]);
h.click_label(&mut app, "Assets");
assert_eq!(app.session.active().unwrap().doc.artboards[0].name, "Committed on tab");
assert_eq!(field(&app, "tab"), "assets");
assert_eq!(field(&app, "boards"), before);
assert!(log.borrow().is_empty());
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc.artboards[0].name, old);
}
}
/// #7275: a double-click on an artboard name enters rename without leaving Export for Screens.
#[test]
fn double_clicking_an_artboard_name_in_export_for_screens_renames_it() {
for view in ["grid", "list"] {
let (mut app, log) = app(2, true);
open(&mut app);
set(&mut app, "view", json!(view));
let mut h = ScreensFrame::new();
let before = field(&app, "boards");
let out = h.settle(&mut app);
let old = app.session.active().unwrap().doc.artboards[0].name.clone();
let at = screen_text_at(&out, &format!("1 {old}"));
h.frame(&mut app, vec![egui::Event::PointerMoved(at)]);
for pressed in [true, false, true, false] {
h.frame(
&mut app,
vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }],
);
}
h.settle(&mut app);
assert!(h.ctx.egui_wants_keyboard_input(), "double-clicking the artboard name must open an editable field");
h.frame(&mut app, vec![egui::Event::Text("Renamed".into())]);
h.frame(
&mut app,
vec![egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }],
);
h.settle(&mut app);
assert_eq!(app.session.active().unwrap().doc.artboards[0].name, "Renamed");
assert_eq!(kind(&app), Some(export_for_screens::KIND));
assert_eq!(field(&app, "boards"), before, "renaming must not change the checked artboards");
assert!(log.borrow().is_empty(), "renaming must not export");
// The real shortcut handler runs before the dialog body. Escape cancels only the name.
let out = h.settle(&mut app);
let at = screen_text_at(&out, "1 Renamed");
h.frame(&mut app, vec![egui::Event::PointerMoved(at)]);
for pressed in [true, false, true, false] {
h.frame(
&mut app,
vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }],
);
}
h.settle(&mut app);
h.frame(&mut app, vec![egui::Event::Text("Discard".into())]);
let key = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
h.time += 0.1;
let input = egui::RawInput {
events: vec![key],
time: Some(h.time),
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1100.0, 900.0))),
..Default::default()
};
let mut out = h.ctx.run_ui(input, |ui| {
crate::shortcuts::handle(&mut app, ui.ctx());
super::show(&mut app, ui.ctx());
});
out.textures_delta.clear();
h.settle(&mut app);
assert_eq!(kind(&app), Some(export_for_screens::KIND));
assert_eq!(app.session.active().unwrap().doc.artboards[0].name, "Renamed");
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc.artboards[0].name, old);
}
}
/// #7275: the typed name goes to the artboard whose name was double-clicked, even when the
/// artboards change order (a command from the control channel or MCP) while it is typed. When that
/// artboard is deleted, the field closes and Escape closes the dialog.
#[test]
fn an_artboard_name_follows_its_artboard_while_it_is_typed() {
for view in ["grid", "list"] {
let (mut app, log) = app(3, true);
open(&mut app);
set(&mut app, "view", json!(view));
let mut h = ScreensFrame::new();
let names = |app: &VectorcraftApp| app.session.active().unwrap().doc.artboards.iter().map(|a| a.name.clone()).collect::<Vec<_>>();
let rename = |h: &mut ScreensFrame, app: &mut VectorcraftApp, label: &str| {
let out = h.settle(app);
let at = screen_text_at(&out, label);
h.frame(app, vec![egui::Event::PointerMoved(at)]);
for pressed in [true, false, true, false] {
h.frame(
app,
vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }],
);
}
h.settle(app);
assert!(h.ctx.egui_wants_keyboard_input(), "{view}: the double-click opens the name");
};
let enter = egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
rename(&mut h, &mut app, "2 Artboard 2");
app.run("artboard.reorder", json!({"index": 1, "to": 0})).unwrap();
h.frame(&mut app, vec![egui::Event::Text("Hero".into())]);
h.frame(&mut app, vec![enter]);
h.settle(&mut app);
assert_eq!(names(&app), ["Hero", "Artboard 1", "Artboard 3"], "{view}");
assert_eq!(kind(&app), Some(export_for_screens::KIND), "{view}");
assert!(log.borrow().is_empty(), "{view}: renaming must not export");
// The artboard is deleted while its name is typed: the field closes, no other artboard
// takes the name, and Escape closes the dialog again.
rename(&mut h, &mut app, "2 Artboard 1");
h.frame(&mut app, vec![egui::Event::Text("Gone".into())]);
app.run("artboard.delete", json!({"indices": [1]})).unwrap();
h.settle(&mut app);
assert!(!h.ctx.egui_wants_keyboard_input(), "{view}: the field of a deleted artboard closes");
assert_eq!(names(&app), ["Hero", "Artboard 3"], "{view}");
let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
h.time += 0.1;
let input = egui::RawInput {
events: vec![escape],
time: Some(h.time),
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1100.0, 900.0))),
..Default::default()
};
let mut out = h.ctx.run_ui(input, |ui| {
crate::shortcuts::handle(&mut app, ui.ctx());
super::show(&mut app, ui.ctx());
});
out.textures_delta.clear();
h.settle(&mut app);
assert_eq!(kind(&app), None, "{view}: Escape closes the dialog");
assert_eq!(names(&app), ["Hero", "Artboard 3"], "{view}");
assert!(log.borrow().is_empty(), "{view}: renaming must not export");
}
}
/// #7275: a name typed while another document becomes active (a command from the control channel
/// or MCP) renames no artboard in either document, and Escape closes the dialog.
#[test]
fn an_artboard_name_stays_with_its_document() {
let (mut app, log) = app(2, true);
app.run("file.new", json!({"width": 60, "height": 40, "artboards": 2})).unwrap();
app.run("document.activate", json!({"index": 0})).unwrap();
open(&mut app);
let mut h = ScreensFrame::new();
let names = |app: &VectorcraftApp, i: usize| app.session.documents()[i].doc.artboards.iter().map(|a| a.name.clone()).collect::<Vec<_>>();
let out = h.settle(&mut app);
let at = screen_text_at(&out, "2 Artboard 2");
h.frame(&mut app, vec![egui::Event::PointerMoved(at)]);
for pressed in [true, false, true, false] {
h.frame(&mut app, vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }]);
}
h.settle(&mut app);
assert!(h.ctx.egui_wants_keyboard_input(), "the double-click opens the name");
h.frame(&mut app, vec![egui::Event::Text("Elsewhere".into())]);
app.run("document.activate", json!({"index": 1})).unwrap();
let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
h.time += 0.1;
let input = egui::RawInput {
events: vec![escape],
time: Some(h.time),
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1100.0, 900.0))),
..Default::default()
};
let mut out = h.ctx.run_ui(input, |ui| {
crate::shortcuts::handle(&mut app, ui.ctx());
super::show(&mut app, ui.ctx());
});
out.textures_delta.clear();
h.settle(&mut app);
assert_eq!(kind(&app), None, "Escape closes the dialog");
assert_eq!(names(&app, 0), ["Artboard 1", "Artboard 2"]);
assert_eq!(names(&app, 1), ["Artboard 1", "Artboard 2"]);
assert!(log.borrow().is_empty(), "renaming must not export");
}
/// Escape or Enter in the first frame that draws an artboard's name field closes the field, and
/// the dialog stays open.
#[test]
fn a_key_in_the_first_frame_of_an_artboard_name_closes_it() {
for view in ["grid", "list"] {
for key in [egui::Key::Escape, egui::Key::Enter] {
let (mut app, log) = app(2, true);
open(&mut app);
set(&mut app, "view", json!(view));
let mut h = ScreensFrame::new();
let out = h.settle(&mut app);
let at = screen_text_at(&out, "1 Artboard 1");
h.frame(&mut app, vec![egui::Event::PointerMoved(at)]);
for pressed in [true, false, true, false] {
h.frame(
&mut app,
vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }],
);
}
// The double-click opened the field in the last frame; this frame draws it first.
h.time += 0.1;
let input = egui::RawInput {
events: vec![egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }],
time: Some(h.time),
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1100.0, 900.0))),
..Default::default()
};
let mut out = h.ctx.run_ui(input, |ui| {
crate::shortcuts::handle(&mut app, ui.ctx());
super::show(&mut app, ui.ctx());
});
out.textures_delta.clear();
h.settle(&mut app);
assert!(!h.ctx.egui_wants_keyboard_input(), "{view}, {key:?}: the field closes");
assert_eq!(kind(&app), Some(export_for_screens::KIND), "{view}, {key:?}");
assert_eq!(app.session.active().unwrap().doc.artboards[0].name, "Artboard 1", "{view}, {key:?}");
assert!(log.borrow().is_empty(), "{view}, {key:?}: the key must not export");
}
}
}
/// A double-click on an earlier artboard's name, both clicks in one frame, renames the artboard
/// whose name was being typed before it opens the new field.
#[test]
fn double_clicking_another_artboard_name_keeps_the_typed_name() {
for view in ["grid", "list"] {
let (mut app, log) = app(2, true);
open(&mut app);
set(&mut app, "view", json!(view));
let mut h = ScreensFrame::new();
let before = field(&app, "boards");
let double_click = |h: &mut ScreensFrame, app: &mut VectorcraftApp, at: egui::Pos2| {
h.frame(app, vec![egui::Event::PointerMoved(at)]);
let events = [true, false, true, false]
.into_iter()
.map(|pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() })
.collect();
h.frame(app, events);
h.settle(app);
};
let out = h.settle(&mut app);
let first = screen_text_at(&out, "1 Artboard 1");
double_click(&mut h, &mut app, screen_text_at(&out, "2 Artboard 2"));
assert!(h.ctx.egui_wants_keyboard_input(), "{view}: the double-click opens the name");
h.frame(&mut app, vec![egui::Event::Text("Typed".into())]);
h.time += 1.0;
double_click(&mut h, &mut app, first);
let names: Vec<String> = app.session.active().unwrap().doc.artboards.iter().map(|a| a.name.clone()).collect();
assert_eq!(names, ["Artboard 1", "Typed"], "{view}");
assert!(h.ctx.egui_wants_keyboard_input(), "{view}: the second double-click opens its name");
assert_eq!(field(&app, "boards"), before, "{view}");
assert!(log.borrow().is_empty(), "{view}: renaming must not export");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.