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.rsindex 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.rsindex 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.rsindex aa304bd61,11a7d5d17..ab233773d--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@@ -545,13 -549,14 +558,14 @@@ impl DesignApplet 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 testsassert!(!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());+ }+ }