Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Merge #119: Web Place/Open/swatches remember the document and purpose they started from; multipage PDF Place shows the page dialog in the browser

aiongge5e48d2ed1c5
diff --cc apps/designcraft-web/src/web.rs
index f5659863f,52a16f677..fe7cca4ae
--- a/apps/designcraft-web/src/web.rs
+++ b/apps/designcraft-web/src/web.rs
@@@ -1,8 -1,7 +1,8 @@@
//! The browser shell: web `Services`, drag-and-drop, and the eframe web runner.
+use super::browser_policy::{has_query_flag, mime_for};
use designcraft_engine::Session;
- use designcraft_ui_egui::{DesignApp, Inbox, Services};
+ use designcraft_ui_egui::{DesignApp, ImportRequest, ImportedFile, Inbox, Services};
use wasm_bindgen::JsCast as _;
const DOC_EXTS: &[&str] = &["designcraft", "idml"];
diff --cc crates/ui-egui/src/dialogs.rs
index 87bfa4292,59fb63611..fc3e1e270
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@@ -1574,7 -1504,13 +1580,13 @@@ pub fn confirm(app: &mut DesignApp) ->
}
"pdfImport" => {
let crop = d.s("crop");
+ if d.b("async") {
+ return app.confirm_pdf_import(d.n("page").unwrap_or(1.0).max(1.0) as u64, if crop.is_empty() { "crop".into() } else { crop });
+ }
+ if let Some(target) = d.fields.get("target").and_then(Value::as_u64) {
+ app.activate_import_target(&crate::ImportRequest { purpose: "place".into(), target: Some(target) })?;
+ }
- app.run("file.place", json!({"path": d.s("path"), "pdfPage": d.n("page").unwrap_or(1.0).max(1.0) as u64, "pdfCrop": if crop.is_empty() { "crop".to_string() } else { crop }}))
+ app.open_file("file.place", json!({"path": d.s("path"), "pdfPage": d.n("page").unwrap_or(1.0).max(1.0) as u64, "pdfCrop": if crop.is_empty() { "crop".to_string() } else { crop }}))
}
"print" => {
let pages = if d.s("range") == "all" { Value::Null } else { json!(d.s("pages")) };
diff --cc crates/ui-egui/src/lib.rs
index aa304bd61,11a7d5d17..ab233773d
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@@ -545,13 -549,14 +558,14 @@@ impl DesignApp
let pages =
self.services.read.as_mut().and_then(|r| r(&path).ok()).and_then(|b| designcraft_render::pdf_page_count(&b)).unwrap_or(1);
if pages > 1 {
- self.ui.dialog = Some(dialogs::Dialog::new("pdfImport", json!({"path": path, "page": "1", "pages": pages})));
+ self.ui.dialog =
+ Some(dialogs::Dialog::new("pdfImport", json!({"path": path, "page": "1", "pages": pages, "target": target})));
Ok(Value::Null)
} else {
- self.run(cmd, json!({"path": path}))
+ self.open_file(cmd, json!({"path": path}))
}
}
- Some(path) => self.run(cmd, json!({"path": path})),
+ Some(path) => self.open_file(cmd, json!({"path": path})),
None => Ok(Value::Null),
};
}
@@@ -561,27 -567,92 +576,92 @@@
Ok(Value::Null)
}
- /// Open or place files delivered through the inbox.
+ pub fn import_request(&self, purpose: &str) -> ImportRequest {
+ ImportRequest { purpose: purpose.into(), target: self.session.active().map(|d| d.uid) }
+ }
+
+ pub(crate) fn activate_import_target(&mut self, request: &ImportRequest) -> Result<(), String> {
+ let Some(index) = request.target.and_then(|uid| self.session.documents().iter().position(|d| d.uid == uid)) else {
+ let message = "Import cancelled: the originating document has closed";
+ self.status(message);
+ return Err(message.into());
+ };
+ self.run("file.activate", json!({"index": index}))?;
+ Ok(())
+ }
+
+ pub(crate) fn cancel_pdf_import(&mut self) {
+ self.pending_pdf = None;
+ }
+
+ pub(crate) fn confirm_pdf_import(&mut self, page: u64, crop: String) -> Result<Value, String> {
+ let file = self.pending_pdf.take().ok_or("PDF import cancelled: no pending file")?;
+ self.activate_import_target(&file.request)?;
- self.run(
++ self.open_file(
+ "file.place",
+ json!({"name": file.name, "base64": designcraft_engine::cmd::base64_encode(&file.bytes), "pdfPage": page, "pdfCrop": crop}),
+ )
+ }
+
+ /// A single unresolved PDF owns its bytes. Later deliveries cancel explicitly rather than
+ /// replacing its options. Cancellation, replacement and target closure release its payload.
fn drain_inbox(&mut self) {
+ if let Some(file) = &self.pending_pdf {
+ let target_exists = self.session.documents().iter().any(|d| Some(d.uid) == file.request.target);
+ let owns_dialog =
+ self.ui.dialog.as_ref().is_some_and(|d| d.id == "pdfImport" && d.fields.get("async").and_then(Value::as_bool) == Some(true));
+ if !target_exists || !owns_dialog {
+ self.pending_pdf = None;
+ if !target_exists {
+ if owns_dialog {
+ self.ui.dialog = None;
+ }
+ self.status("PDF import cancelled: the originating document has closed");
+ }
+ }
+ }
let Some(inbox) = self.services.inbox.clone() else { return };
let files = std::mem::take(&mut *inbox.lock().unwrap_or_else(|e| e.into_inner()));
- for (name, bytes) in files {
- let b64 = designcraft_engine::cmd::base64_encode(&bytes);
- let lower = name.to_ascii_lowercase();
- let r = if lower.ends_with(".ase") {
- self.run("swatch.load", json!({"base64": b64}))
- } else if opens_as_document(&name) {
- let title = name.rsplit_once('.').map_or(name.as_str(), |(stem, _)| stem);
- self.open_file("file.openBytes", json!({"name": title, "base64": b64}))
- } else {
- self.open_file("file.place", json!({"name": name, "base64": b64}))
- };
- if let Err(e) = r {
+ for file in files {
+ if self.ui.dialog.is_some() {
+ self.status(format!("{}: import cancelled while a dialog is open; choose the file again", file.name));
+ continue;
+ }
+ let name = file.name.clone();
+ if let Err(e) = self.import_file(file) {
self.status(format!("{name}: {e}"));
}
}
}
+ fn import_file(&mut self, file: ImportedFile) -> Result<Value, String> {
+ let lower = file.name.to_ascii_lowercase();
- let layout = lower.ends_with(".designcraft") || lower.ends_with(".idml");
++ let layout = opens_as_document(&file.name);
+ let place =
+ file.request.purpose == "place" || (matches!(file.request.purpose.as_str(), "drop" | "open") && !layout && !lower.ends_with(".ase"));
+ if place || lower.ends_with(".ase") || file.request.purpose == "swatches" {
+ self.activate_import_target(&file.request)?;
+ }
+ if place && lower.ends_with(".pdf") {
+ let pages = designcraft_render::pdf_page_count(&file.bytes).unwrap_or(1);
+ if pages > 1 {
+ self.ui.dialog =
+ Some(dialogs::Dialog::new("pdfImport", json!({"async": true, "name": file.name.clone(), "page": "1", "pages": pages})));
+ self.pending_pdf = Some(file);
+ return Ok(Value::Null);
+ }
+ }
+ let b64 = designcraft_engine::cmd::base64_encode(&file.bytes);
+ if lower.ends_with(".ase") || file.request.purpose == "swatches" {
+ self.run("swatch.load", json!({"base64": b64}))
+ } else if place {
- self.run("file.place", json!({"name": file.name, "base64": b64}))
++ self.open_file("file.place", json!({"name": file.name, "base64": b64}))
+ } else {
+ let title = file.name.rsplit_once('.').map_or(file.name.as_str(), |(stem, _)| stem);
- self.run("file.openBytes", json!({"name": title, "base64": b64}))
++ self.open_file("file.openBytes", json!({"name": title, "base64": b64}))
+ }
+ }
+
pub fn select_tool(&mut self, id: &str) {
let _ = self.run("tool.select", json!({"tool": id}));
self.ui.flyout = None;
@@@ -1043,140 -963,255 +1123,391 @@@ mod tests
assert!(!ui.snap_view().snap_to_guides);
assert_eq!(ui.snap_view().zone_px, 0.0);
}
+
+ /// A temporary file named `name` whose bytes aren't a document or a graphic.
+ fn unreadable_file(name: &str) -> std::path::PathBuf {
+ let path = std::env::temp_dir().join(format!("designcraft-ui-{}-{name}", std::process::id()));
+ std::fs::write(&path, b"neither a document nor a graphic").unwrap();
+ path
+ }
+
+ /// The open alert dialog: (title, message).
+ fn alert(app: &DesignApp) -> (String, String) {
+ let d = app.ui.dialog.as_ref().expect("an alert is open");
+ assert_eq!(d.id, "alert");
+ (d.fields["title"].as_str().unwrap().to_string(), d.fields["message"].as_str().unwrap().to_string())
+ }
+
+ #[test]
+ fn dropped_documents_open_and_the_rest_is_placed() {
+ for name in ["a.designcraft", "B.IDML"] {
+ assert!(opens_as_document(name), "{name}");
+ }
+ for name in ["a.png", "b.pdf", "idml.txt", "c.idml.zip"] {
+ assert!(!opens_as_document(name), "{name}");
+ }
+ }
+
+ #[test]
+ fn dropping_an_unreadable_file_alerts() {
+ // A document opens, so it says it can't be opened.
+ let path = unreadable_file("broken.designcraft");
+ let mut app = DesignApp::new(Session::new(), Services::default());
+ let r = app.open_dropped(&path.to_string_lossy());
+ let _ = std::fs::remove_file(&path);
+ let e = r.unwrap_err();
+ let (title, message) = alert(&app);
+ assert_eq!(title, "Can't Open the File", "a document opens, it isn't placed");
+ assert_eq!(message, e);
+ assert!(app.ui.status.contains(&e), "the status line says it too");
+ assert!(app.session.documents().is_empty());
+ dialogs::confirm(&mut app).unwrap();
+ assert!(app.ui.dialog.is_none(), "OK closes the alert");
+ // Anything else is placed, so it says it can't be placed.
+ app.run("file.new", json!({})).unwrap();
+ let path = unreadable_file("notes.xyz");
+ let r = app.open_dropped(&path.to_string_lossy());
+ let _ = std::fs::remove_file(&path);
+ let e = r.unwrap_err();
+ assert_eq!(alert(&app), ("Can't Place the File".to_string(), e));
+ }
+
+ #[test]
+ fn file_open_failures_show_an_alert() {
+ let path = unreadable_file("open.designcraft");
+ let picked = path.to_string_lossy().to_string();
+ let services = Services { pick_open: Some(Box::new(move |_| Some(picked.clone()))), ..Default::default() };
+ let mut app = DesignApp::new(Session::new(), services);
+ let e = app.run("app.openDialog", json!({})).unwrap_err();
+ assert_eq!(alert(&app), ("Can't Open the File".to_string(), e));
+ // Placing it says so too.
+ app.ui.dialog = None;
+ app.run("file.new", json!({})).unwrap();
+ let e = app.run("app.placeDialog", json!({})).unwrap_err();
+ let _ = std::fs::remove_file(&path);
+ assert_eq!(alert(&app), ("Can't Place the File".to_string(), e));
+ }
+
+ #[test]
+ fn other_command_errors_stay_in_the_status_line() {
+ let mut app = DesignApp::new(Session::new(), Services::default());
+ assert!(app.run("file.open", json!({"path": "/nonexistent/x.designcraft"})).is_err());
+ assert!(app.ui.dialog.is_none(), "a scripted file.open doesn't raise an alert");
+ assert!(!app.ui.status.is_empty());
+ // The control channel's app.open answers with the error; no alert waits for a click.
+ let (req, _rx) = control::ControlRequest::new("app.open", json!({"path": "/nonexistent/x.designcraft"}));
+ let control::Outcome::Done(r) = control::handle(&mut app, &egui::Context::default(), &req) else { panic!("app.open answers") };
+ assert_eq!(r["ok"], json!(false), "{r}");
+ assert!(app.ui.dialog.is_none(), "a control-channel app.open doesn't raise an alert");
+ }
+}
+
+/// The whole window in a headless test harness, at a chosen window size.
+#[cfg(test)]
+pub(crate) mod test_window {
+ use egui_kittest::Harness;
+
+ pub struct Window {
+ pub app: crate::DesignApp,
+ ready: bool,
+ }
+
+ /// The window at `size` with a new document open.
+ pub fn open(mut app: crate::DesignApp, size: egui::Vec2) -> Harness<'static, Window> {
+ if app.session.active().is_none() {
+ app.run("file.new", serde_json::json!({})).unwrap();
+ }
+ let mut h = Harness::builder().with_size(size).with_max_steps(1000).build_ui_state(
+ |ui, w: &mut Window| {
+ // The builder runs a frame before the texture size can be raised: skip it.
+ if !w.ready {
+ return;
+ }
+ let ctx = ui.ctx().clone();
+ w.app.logic(&ctx);
+ w.app.ui(ui);
+ },
+ Window { app, ready: false },
+ );
+ h.input_mut().max_texture_side = Some(8192);
+ h.state_mut().ready = true;
+ h.run_steps(6);
+ h
+ }
+
+ /// The mouse wheel turned over `pos`: positive `delta` moves the content right and down.
+ pub fn wheel(h: &mut Harness<'static, Window>, pos: egui::Pos2, delta: egui::Vec2) {
+ h.hover_at(pos);
+ h.event(egui::Event::MouseWheel {
+ unit: egui::MouseWheelUnit::Point,
+ delta,
+ phase: egui::TouchPhase::Move,
+ modifiers: egui::Modifiers::NONE,
+ });
+ h.run_steps(10);
+ }
+
+ /// The outer rect of a side or top panel, from egui's memory.
+ pub fn panel_rect(h: &Harness<'static, Window>, id: &str) -> egui::Rect {
+ egui::containers::panel::PanelState::load(&h.ctx, egui::Id::new(id)).map(|s| s.outer_rect).unwrap()
+ }
+
+ /// A primary click at `pos`, then a few frames.
+ pub fn click_at(h: &mut Harness<'static, Window>, pos: egui::Pos2) {
+ h.hover_at(pos);
+ h.drag_at(pos);
+ h.drop_at(pos);
+ h.run_steps(4);
+ }
}
+
+ #[cfg(test)]
+ mod browser_import_tests {
+ use super::*;
+
+ fn app() -> DesignApp {
+ let mut app = DesignApp::new(Session::new(), Services { inbox: Some(Inbox::default()), ..Default::default() });
+ app.run("file.new", json!({"title": "A"})).unwrap();
+ app
+ }
+ fn deliver(app: &mut DesignApp, request: ImportRequest, name: &str, bytes: Vec<u8>) {
+ app.services.inbox.as_ref().unwrap().lock().unwrap().push(ImportedFile { request, name: name.into(), bytes });
+ app.drain_inbox();
+ }
+ fn image() -> Vec<u8> {
+ br##"<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><rect width="10" height="10" fill="#ff0000"/></svg>"##.to_vec()
+ }
+ fn pdf_pages(count: usize) -> Vec<u8> {
+ let kids = (0..count).map(|i| format!("{} 0 R", 3 + i * 2)).collect::<Vec<_>>().join(" ");
+ let mut objects = vec!["<< /Type /Catalog /Pages 2 0 R >>".to_string(), format!("<< /Type /Pages /Kids [{kids}] /Count {count} >>")];
+ for (i, color) in ["1 0 0", "0 1 0", "0 0 1"].iter().take(count).enumerate() {
+ let content = format!("{color} rg 0 0 200 200 re f\n");
+ objects.push(format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Resources << >> /Contents {} 0 R >>", 4 + i * 2));
+ objects.push(format!("<< /Length {} >>\nstream\n{content}endstream", content.len()));
+ }
+ let mut result = "%PDF-1.4\n".to_string();
+ let mut offsets = Vec::new();
+ for (i, object) in objects.iter().enumerate() {
+ offsets.push(result.len());
+ result.push_str(&format!("{} 0 obj\n{object}\nendobj\n", i + 1));
+ }
+ let xref = result.len();
+ result.push_str(&format!("xref\n0 {}\n0000000000 65535 f \n", offsets.len() + 1));
+ for offset in offsets {
+ result.push_str(&format!("{offset:010} 00000 n \n"));
+ }
+ result.push_str(&format!("trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n", objects.len() + 1));
+ result.into_bytes()
+ }
+ fn pdf() -> Vec<u8> {
+ pdf_pages(3)
+ }
+
+ #[test]
+ fn picker_receives_context_before_returning_and_cancel_does_not_edit() {
+ let captured = std::sync::Arc::new(std::sync::Mutex::new(None));
+ let copy = captured.clone();
+ let mut app = app();
+ app.services.open_async = Some(Box::new(move |request| *copy.lock().unwrap() = Some(request)));
+ let uid = app.session.doc().unwrap().uid;
+ app.pick_and_open("place").unwrap();
+ app.run("file.new", json!({"title": "B"})).unwrap();
+ let request = captured.lock().unwrap().take().unwrap();
+ assert_eq!(request.purpose, "place");
+ assert_eq!(request.target, Some(uid));
+ assert!(app.session.documents().iter().all(|d| d.doc.assets.is_empty()));
+ deliver(&mut app, request, "broken.pdf", b"not a PDF".to_vec());
+ assert!(app.session.documents().iter().all(|d| d.doc.assets.is_empty()));
+ assert!(app.pending_pdf.is_none());
+ }
+
+ #[test]
+ fn delayed_place_activates_original_document_and_undo_belongs_to_it() {
+ let mut app = app();
+ let request = app.import_request("place");
+ app.run("file.new", json!({"title": "B"})).unwrap();
+ deliver(&mut app, request, "red.svg", image());
+ assert_eq!(app.session.active_index(), Some(0));
+ assert_eq!(app.session.documents()[0].doc.assets.len(), 1);
+ assert!(app.session.documents()[1].doc.assets.is_empty());
+ app.run("edit.undo", json!({})).unwrap();
+ assert!(app.session.doc().unwrap().doc.assets.is_empty());
+ app.run("edit.redo", json!({})).unwrap();
+ assert_eq!(app.session.doc().unwrap().doc.assets.len(), 1);
+ }
+
+ #[test]
+ fn closed_target_is_not_replaced_by_a_reused_tab_index() {
+ let mut app = app();
+ let request = app.import_request("place");
+ app.run("file.close", json!({})).unwrap();
+ app.run("file.new", json!({"title": "replacement"})).unwrap();
+ deliver(&mut app, request, "red.svg", image());
+ assert!(app.session.doc().unwrap().doc.assets.is_empty());
+ }
+
+ #[test]
+ fn closing_earlier_tab_does_not_shift_import_target() {
+ let mut app = app();
+ app.run("file.new", json!({"title": "target"})).unwrap();
+ let request = app.import_request("place");
+ app.run("file.new", json!({"title": "other"})).unwrap();
+ app.run("file.close", json!({"index": 0})).unwrap();
+ deliver(&mut app, request, "red.svg", image());
+ assert_eq!(app.session.doc().unwrap().doc.title, "target");
+ assert_eq!(app.session.documents()[0].doc.assets.len(), 1);
+ assert!(app.session.documents()[1].doc.assets.is_empty());
+ }
+
+ #[test]
+ fn layout_place_and_open_preserve_explicit_intent() {
+ let mut source = Session::new();
+ source.execute("file.new", &json!({"title": "source"})).unwrap();
+ source.execute("frame.create", &json!({"rect": [10, 10, 50, 50], "content": "text", "text": "placed"})).unwrap();
+ let native = designcraft_engine::cmd::to_bytes(&source.doc().unwrap().doc);
+ let idml = designcraft_idml::export_idml(&source.doc().unwrap().doc);
+ for (name, bytes) in [("source.designcraft", native), ("source.idml", idml)] {
+ let mut app = app();
+ let request = app.import_request("place");
+ deliver(&mut app, request, name, bytes.clone());
+ assert_eq!(app.session.documents().len(), 1);
+ assert_eq!(app.session.doc().unwrap().doc.title, "A");
+ assert!(app.session.doc().unwrap().doc.stories.values().any(|s| s.text == "placed"));
+ app.run("edit.undo", json!({})).unwrap();
+ assert!(app.session.doc().unwrap().doc.stories.is_empty());
+ app.run("edit.redo", json!({})).unwrap();
+ assert!(!app.session.doc().unwrap().doc.stories.is_empty());
+ let request = app.import_request("open");
+ deliver(&mut app, request, name, bytes);
+ assert_eq!(app.session.documents().len(), 2);
+ }
+ }
+
+ #[test]
+ fn pdf_options_keep_bytes_target_and_selected_page() {
+ let mut app = app();
+ let bytes = pdf();
+ let request = app.import_request("place");
+ deliver(&mut app, request, "three.pdf", bytes.clone());
+ assert!(app.session.doc().unwrap().doc.assets.is_empty());
+ assert_eq!(app.ui.dialog.as_ref().unwrap().id, "pdfImport");
+ app.run("file.new", json!({"title": "B"})).unwrap();
+ app.ui.dialog.as_mut().unwrap().fields.insert("page".into(), json!("2"));
+ dialogs::confirm(&mut app).unwrap();
+ assert_eq!(app.session.active_index(), Some(0));
+ let asset = app.session.doc().unwrap().doc.assets.values().next().unwrap();
+ assert_eq!(asset.page, 1);
+ assert_eq!(*asset.data, bytes);
+ assert!(app.pending_pdf.is_none());
+ assert!(app.session.documents()[1].doc.assets.is_empty());
+ let exported = app.run("file.exportPdf", json!({})).unwrap();
+ let exported = designcraft_engine::cmd::base64_decode(exported["base64"].as_str().unwrap());
+ let pixels = designcraft_render::render_pdf_page(&exported, 0, 400).unwrap();
+ assert!(pixels.data().iter().filter(|p| p.g > 240 && p.r < 10 && p.b < 10).count() > 1000);
+ assert_eq!(pixels.data().iter().filter(|p| p.r > 240 && p.g < 10 && p.b < 10).count(), 0);
+ }
+
+ #[test]
+ fn pdf_options_reject_oversized_page_without_editing() {
+ let mut app = app();
+ for page in [0_u64, 4, 4_294_967_296, 4_294_967_297, u64::MAX] {
+ let request = app.import_request("place");
+ deliver(&mut app, request, "three.pdf", pdf());
+ app.ui.dialog.as_mut().unwrap().fields.insert("page".into(), json!(page.to_string()));
+ // The native dialog clamps zero to one; positive invalid pages must fail.
+ if page == 0 {
+ assert!(app.confirm_pdf_import(page, "crop".into()).is_err());
+ } else {
+ assert!(dialogs::confirm(&mut app).is_err());
+ }
+ app.ui.dialog = None;
+ assert!(app.session.doc().unwrap().doc.assets.is_empty());
+ assert!(app.pending_pdf.is_none());
+ }
+ let request = app.import_request("place");
+ deliver(&mut app, request, "three.pdf", pdf());
+ app.ui.dialog.as_mut().unwrap().fields.insert("page".into(), json!("2"));
+ dialogs::confirm(&mut app).unwrap();
+ assert_eq!(app.session.doc().unwrap().doc.assets.values().next().unwrap().page, 1);
+ }
+
+ #[test]
+ fn drop_routing_and_nonlayout_open_remain_compatible() {
+ let mut app = app();
+ let native = designcraft_engine::cmd::to_bytes(&app.session.doc().unwrap().doc);
+ let request = app.import_request("drop");
+ deliver(&mut app, request, "document.designcraft", native);
+ assert_eq!(app.session.documents().len(), 2);
+ let request = app.import_request("drop");
+ app.run("file.activate", json!({"index": 0})).unwrap();
+ deliver(&mut app, request, "red.svg", image());
+ assert_eq!(app.session.active_index(), Some(1));
+ assert_eq!(app.session.doc().unwrap().doc.assets.len(), 1);
+ let request = app.import_request("open");
+ deliver(&mut app, request, "single.pdf", pdf_pages(1));
+ assert_eq!(app.session.documents().len(), 2);
+ assert!(app.pending_pdf.is_none());
+ assert!(app.ui.dialog.is_none());
+ }
+
+ #[test]
+ fn ase_swatches_keep_purpose_and_target() {
+ let mut source = Session::new();
+ source.execute("file.new", &json!({})).unwrap();
+ source.execute("swatch.create", &json!({"name": "Import Teal", "color": "#108080"})).unwrap();
+ let data = source.execute("swatch.save", &json!({"names": ["Import Teal"]})).unwrap();
+ let bytes = designcraft_engine::cmd::base64_decode(data["base64"].as_str().unwrap());
+ for (purpose, name) in [("swatches", "picker-file"), ("drop", "palette.ase")] {
+ let mut app = app();
+ let request = app.import_request(purpose);
+ app.run("file.new", json!({"title": "B"})).unwrap();
+ deliver(&mut app, request, name, bytes.clone());
+ assert_eq!(app.session.active_index(), Some(0));
+ assert!(app.session.documents()[0].doc.swatches.iter().any(|s| s.name == "Import Teal"));
+ assert!(!app.session.documents()[1].doc.swatches.iter().any(|s| s.name == "Import Teal"));
+ }
+ }
+
+ #[test]
+ fn native_pdf_dialog_keeps_path_and_uid_at_confirmation() {
+ let mut app = app();
+ let path = std::env::temp_dir().join(format!("designcraft-native-import-{}-{}.pdf", std::process::id(), app.session.doc().unwrap().uid));
+ std::fs::write(&path, pdf()).unwrap();
+ let pick_path = path.to_string_lossy().to_string();
+ app.services.pick_open = Some(Box::new(move |_| Some(pick_path.clone())));
+ app.services.read = Some(Box::new(|path| std::fs::read(path).map_err(|e| e.to_string())));
+ app.pick_and_open("place").unwrap();
+ assert_eq!(app.ui.dialog.as_ref().unwrap().id, "pdfImport");
+ app.run("file.new", json!({"title": "B"})).unwrap();
+ app.ui.dialog.as_mut().unwrap().fields.insert("page".into(), json!("2"));
+ dialogs::confirm(&mut app).unwrap();
+ assert_eq!(app.session.active_index(), Some(0));
+ assert_eq!(app.session.doc().unwrap().doc.assets.values().next().unwrap().page, 1);
+ assert!(app.session.documents()[1].doc.assets.is_empty());
+ std::fs::remove_file(path).unwrap();
+ }
+
+ #[test]
+ fn pending_pdf_cancel_close_supersession_and_second_delivery_release_bytes() {
+ let mut app = app();
+ let request = app.import_request("place");
+ deliver(&mut app, request.clone(), "first.pdf", pdf());
+ deliver(&mut app, request.clone(), "second.svg", image());
+ assert_eq!(app.pending_pdf.as_ref().unwrap().name, "first.pdf");
+ assert!(app.session.doc().unwrap().doc.assets.is_empty());
+ app.ui.dialog = None;
+ app.drain_inbox();
+ assert!(app.pending_pdf.is_none());
+ deliver(&mut app, request.clone(), "first.pdf", pdf());
+ app.ui.dialog = Some(dialogs::Dialog::new("newDocument", json!({})));
+ app.drain_inbox();
+ assert!(app.pending_pdf.is_none());
+ app.ui.dialog = None;
+ deliver(&mut app, request, "first.pdf", pdf());
+ app.run("file.close", json!({})).unwrap();
+ app.run("file.new", json!({})).unwrap();
+ assert!(dialogs::confirm(&mut app).is_err());
+ assert!(app.pending_pdf.is_none());
+ assert!(app.session.doc().unwrap().doc.assets.is_empty());
+ }
+ }