diff --git a/Cargo.lock b/Cargo.lock index acdbbcc66..7af09affa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1103,6 +1103,20 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-doc" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=47107f660191de2f0b425569506f4daa4faadac9#47107f660191de2f0b425569506f4daa4faadac9" +dependencies = [ + "craft-ecproj-format", + "craft-pcraft-format", + "craft-vectorcraft-format", + "flate2", + "serde", + "serde_json", + "thiserror 2.0.21", +] + [[package]] name = "craft-docpath" version = "0.1.0" @@ -1206,6 +1220,16 @@ dependencies = [ "serde_json", ] +[[package]] +name = "craft-pcraft-format" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=47107f660191de2f0b425569506f4daa4faadac9#47107f660191de2f0b425569506f4daa4faadac9" +dependencies = [ + "serde", + "serde_json", + "thiserror 2.0.21", +] + [[package]] name = "craft-pdf" version = "0.1.0" @@ -1297,6 +1321,17 @@ dependencies = [ "zip 9.1.3", ] +[[package]] +name = "craft-vectorcraft-format" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=47107f660191de2f0b425569506f4daa4faadac9#47107f660191de2f0b425569506f4daa4faadac9" +dependencies = [ + "flate2", + "serde", + "serde_json", + "thiserror 2.0.21", +] + [[package]] name = "craft-video" version = "0.1.0" @@ -1770,6 +1805,7 @@ dependencies = [ name = "effectcraft-host" version = "0.24.1" dependencies = [ + "craft-vectorcraft-format", "effectcraft-engine", "effectcraft-export", "effectcraft-expr", @@ -1915,14 +1951,18 @@ dependencies = [ name = "effectcraft-pdf" version = "0.24.1" dependencies = [ + "craft-doc", "craft-eps", "craft-pdf", + "craft-vectorcraft-format", "effectcraft-raster", "effectcraft-svg", "effectcraft-text", + "flate2", "image", "kurbo", "miniz_oxide 0.9.1", + "serde_json", "skrifa", "wasm-bindgen-test", "zune-jpeg", diff --git a/Cargo.toml b/Cargo.toml index 08e34d741..ae0fd3d09 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,6 +25,8 @@ craft-webp = { version = "0.1.0", git = "https://github.com/storytold/craft-libs craft-lottie = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "47107f660191de2f0b425569506f4daa4faadac9" } craft-mesh = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "47107f660191de2f0b425569506f4daa4faadac9", default-features = false, features = ["stl", "obj", "gltf", "fbx"] } craft-aep = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "47107f660191de2f0b425569506f4daa4faadac9" } +craft-doc = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "47107f660191de2f0b425569506f4daa4faadac9" } +craft-vectorcraft-format = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "47107f660191de2f0b425569506f4daa4faadac9" } # craft-update: app-specific pretend versions apply to startup and manual checks. craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "47107f660191de2f0b425569506f4daa4faadac9", features = ["egui"] } # internal diff --git a/crates/engine/src/background/jobs.rs b/crates/engine/src/background/jobs.rs index 229d1950e..f8403f278 100644 --- a/crates/engine/src/background/jobs.rs +++ b/crates/engine/src/background/jobs.rs @@ -187,7 +187,8 @@ impl Session { "cancelled" => format!("{} cancelled", t.label), _ => format!("{} failed: {message}", t.label), }; - self.events.push(crate::Event::Toast { message: toast, error: status == "failed" }); + let has_errors = rec.result["errors"].as_array().is_some_and(|errors| !errors.is_empty()); + self.events.push(crate::Event::Toast { message: toast, error: status == "failed" || has_errors }); self.job_log.push(rec.clone()); if self.job_log.len() > 50 { self.job_log.remove(0); diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs index d0158a286..af3942f64 100644 --- a/crates/engine/src/cmd/file.rs +++ b/crates/engine/src/cmd/file.rs @@ -143,7 +143,8 @@ fn import_cmd(s: &mut Session, p: &Value) -> Result { _ => format!("Importing {total} files"), }; let p = p.clone(); - return s.spawn_task("import", label, false, move |ctl| { + let immediate_errors = pending.errors.clone(); + let mut result = s.spawn_task("import", label, false, move |ctl| { let mut probed = Vec::with_capacity(total); for (k, src) in sources.iter().enumerate() { ctl.message(format!("{} ({} of {total})", src.name(), k + 1)); @@ -162,13 +163,19 @@ fn import_cmd(s: &mut Session, p: &Value) -> Result { match errors.as_slice() { [] => {} [one] => toast = format!("{toast}. {one}"), - [first, rest @ ..] => toast = format!("{toast}. {first} (and {} more)", rest.len()), + [first, rest @ ..] => toast = format!("{toast}. {first} (and {} more)\n{}", rest.len(), errors.join("\n")), } r["toast"] = json!(toast); Ok(r) }); Ok(apply) - }); + })?; + // Preparation can reject layered files before the remaining footage needs probing. + // Report those failures now as well as in the eventual job result. + if result["started"] == true { + result["errors"] = json!(immediate_errors); + } + return Ok(result); } let probed = pending.sources.iter().map(|src| pending.prober.probe(src)).collect(); let mut r = add_footage(s, pending, probed)?; @@ -346,8 +353,9 @@ impl Prober { None => ask_alpha = true, } } - // Page: another page of a PDF / Illustrator file. - if self.page > 0 && matches!(f.codec.as_str(), "PDF" | "AI") { + // Page: another page of a PDF / Illustrator file, or another artboard of a VectorCraft + // document's PDF. + if self.page > 0 && matches!(f.codec.as_str(), "PDF" | "AI" | "VectorCraft") { let doc = self .services .read_file(path) @@ -563,7 +571,8 @@ fn add_footage(s: &mut Session, pending: PendingImport, probed: Vec bool { let ext = std::path::Path::new(path).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default(); - matches!(ext.as_str(), "png" | "gif" | "webp" | "psd" | "psb" | "exr" | "svg" | "jpg" | "jpeg" | "ai" | "pdf" | "eps") || codec.eq_ignore_ascii_case("PSD") + matches!(ext.as_str(), "png" | "gif" | "webp" | "psd" | "psb" | "exr" | "svg" | "jpg" | "jpeg" | "ai" | "pdf" | "eps" | "vectorcraft") + || codec.eq_ignore_ascii_case("PSD") } /// A Photoshop layer by index or name (pixel layers only). diff --git a/crates/engine/src/footage/media_browser.rs b/crates/engine/src/footage/media_browser.rs index 2c40fcf20..bd125ad7a 100644 --- a/crates/engine/src/footage/media_browser.rs +++ b/crates/engine/src/footage/media_browser.rs @@ -197,7 +197,7 @@ fn sort_entries(entries: &mut [Entry]) { entries.sort_by_cached_key(|e| (!e.is_dir, e.name.to_lowercase())); } -const IMAGE: &[&str] = &["png", "jpg", "jpeg", "tif", "tiff", "exr", "bmp", "webp", "psd", "psb", "svg", "tga", "dpx", "cin", "hdr"]; +const IMAGE: &[&str] = &["png", "jpg", "jpeg", "tif", "tiff", "exr", "bmp", "webp", "psd", "psb", "svg", "tga", "dpx", "cin", "hdr", "vectorcraft"]; const AUDIO: &[&str] = &["wav", "aif", "aiff", "mp3", "m4a", "aac", "flac", "ogg", "opus"]; const DATA: &[&str] = &["json", "csv", "tsv", "mgjson"]; const MODEL: &[&str] = &["gltf", "glb", "obj", "stl", "fbx"]; diff --git a/crates/engine/src/footage/sequence.rs b/crates/engine/src/footage/sequence.rs index 891ebdbe1..0d4c33453 100644 --- a/crates/engine/src/footage/sequence.rs +++ b/crates/engine/src/footage/sequence.rs @@ -99,7 +99,7 @@ fn extension(path: &str) -> String { /// Stills that can form a sequence (not layered or vector documents, which import as comps). fn sequenceable(path: &str) -> bool { - crate::media_browser::kind_of(path) == Some("image") && !matches!(extension(path).as_str(), "svg" | "psd" | "psb") + crate::media_browser::kind_of(path) == Some("image") && !matches!(extension(path).as_str(), "svg" | "psd" | "psb" | "vectorcraft") } /// The run a still belongs to: (folder, name prefix, extension); alphabetical runs ignore the @@ -343,6 +343,17 @@ mod tests { assert_eq!(sequences(&t, &strs(&["/s/a_0001.png", "/s/c.png"]), false).len(), 1); } + /// VectorCraft documents list as media in the Media Browser and import from a folder, each on + /// its own, as SVG files do: numbered ones don't form a sequence. + #[test] + fn vectorcraft_documents_are_media_but_not_sequences() { + assert_eq!(crate::media_browser::kind_of("/art/Poster.VECTORCRAFT"), Some("image")); + let t = Table(vec!["/art/frame_0001.vectorcraft", "/art/frame_0002.vectorcraft"]); + let on = SequenceOptions::default(); + assert_eq!(group(&t, &strs(&["/art/frame_0001.vectorcraft"]), on), [Source::File("/art/frame_0001.vectorcraft".into())]); + assert_eq!(group(&t, &strs(&["/art"]), on), [Source::File("/art/frame_0001.vectorcraft".into()), Source::File("/art/frame_0002.vectorcraft".into())]); + } + /// Thousands of files picked one by one from one folder: the folder is listed once, not /// once per file, and each finds its run by key. #[test] diff --git a/crates/engine/src/tests/session.rs b/crates/engine/src/tests/session.rs index 020c2daf0..463462580 100644 --- a/crates/engine/src/tests/session.rs +++ b/crates/engine/src/tests/session.rs @@ -173,6 +173,7 @@ fn background_imports_report_progress_and_select_what_arrived() { s.execute("jobs.wait", json!({})).unwrap(); assert_eq!(s.active_comp().unwrap().layers.iter().map(|l| l.name.as_str()).collect::>(), ["c.png"]); assert_eq!(s.job_log.last().unwrap().message, "Imported 1 item. /drop/d.xyz: unsupported file"); + assert!(s.drain_events().iter().any(|e| matches!(e, crate::Event::Toast { message, error: true } if message.contains("/drop/d.xyz")))); // Agents and scripts import at once by default. let r = s.execute("file.import", json!({"paths": ["/drop/e.png"]})).unwrap(); assert_eq!(r["items"].as_array().map(Vec::len), Some(1)); diff --git a/crates/host/Cargo.toml b/crates/host/Cargo.toml index 70991b22e..df7e6e869 100644 --- a/crates/host/Cargo.toml +++ b/crates/host/Cargo.toml @@ -32,6 +32,7 @@ tempfile = { workspace = true } effectcraft-psd = { workspace = true } effectcraft-svg = { workspace = true } effectcraft-pdf = { workspace = true } +craft-vectorcraft-format = { workspace = true } effectcraft-raster = { workspace = true } effectcraft-time = { workspace = true } effectcraft-interchange = { workspace = true } diff --git a/crates/host/tests/it/vector_import.rs b/crates/host/tests/it/vector_import.rs index 8487c45b1..81b0d8e59 100644 --- a/crates/host/tests/it/vector_import.rs +++ b/crates/host/tests/it/vector_import.rs @@ -951,6 +951,17 @@ fn ai_composition_retains_layer_sizes_and_positions() { } } +/// A `.vectorcraft` file (written with craft-vectorcraft-format's envelope) holding an empty +/// document and `pdf` as the PDF it carries (Create PDF-Compatible File). +fn vectorcraft_file(pdf: Option<&[u8]>) -> Vec { + let mut file = craft_vectorcraft_format::File::new(json!({"artboards": [], "layers": []})); + let mut tail = file.tail(); + file.pdf = pdf.map(|b| tail.image("application/pdf", b, false)); + let mut out = serde_json::to_vec(&file).unwrap(); + tail.write_to(&mut out).unwrap(); + out +} + /// An A4 page (595.28 × 841.89 pt) whose artwork sits inside a page clip and ten nested /// clipping groups, as PDFs exported from layout and office applications nest them: a black bar /// whose left edge is at x = 30 pt, from 41.89 to 191.89 pt down the page. @@ -1025,3 +1036,64 @@ fn a4_pdf_scaled_200_percent_continuously_rasterizes_sharp() { // Outside the clips (x = 10 pt) nothing is drawn. assert!(on.get(20, 240)[3] < 0.01); } + +#[test] +fn vectorcraft_documents_import_through_the_pdf_they_carry() { + let bytes = layered_pdf(); + let doc = effectcraft_pdf::parse(&bytes).unwrap(); + let direct = effectcraft_svg::rasterize(&doc, 120, 80, 1.0); + let path = tmp("art.vectorcraft"); + std::fs::write(&path, vectorcraft_file(Some(&bytes))).unwrap(); + // As footage: drawn as the PDF, and continuously rasterized. + let mut s = effectcraft_host::session(); + let r = s.execute_checked("file.import", json!({"paths": [path]})).unwrap(); + assert_eq!(r["errors"], json!([]), "{r}"); + let item = r["items"][0].as_u64().unwrap(); + let effectcraft_project::ItemKind::Footage(f) = &s.project.item(ItemId(item)).unwrap().kind else { panic!("footage") }; + assert_eq!((f.codec.as_str(), f.width, f.height), ("VectorCraft", 120, 80)); + s.execute("comp.new", json!({"name": "V", "width": 120, "height": 80, "frameRate": 30, "duration": 1})).unwrap(); + let lid = s.execute_checked("layer.addItem", json!({"item": item})).unwrap()["layer"].as_u64().unwrap(); + let cid = s.active_comp_id().unwrap(); + let t = effectcraft_time::Tick::ZERO; + assert!(mean_diff(&s.render(cid, t, RenderOpts::default()), &direct) < 1.0 / 255.0, "footage = the carried PDF"); + for (k, v) in [("transform/anchor", json!([0, 0])), ("transform/position", json!([0, 0])), ("transform/scale", json!([300, 300]))] { + s.execute("prop.set", json!({"layer": lid, "path": k, "value": v})).unwrap(); + } + let want = effectcraft_svg::rasterize(&doc, 120, 80, 3.0); + s.execute("layer.setSwitch", json!({"layers": [lid], "switch": "collapse", "value": true})).unwrap(); + let sharp = mean_diff(&s.render(cid, t, RenderOpts::default()), &want); + assert!(sharp < 0.004, "continuously rasterized {sharp}"); + // As a composition: one layer per PDF layer, top first. + for import_as in ["composition", "compositionLayerSizes"] { + let mut s = effectcraft_host::session(); + let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": import_as})).unwrap(); + assert_eq!(r["errors"], json!([]), "{r}"); + let cid = ItemId(r["comps"][0].as_u64().unwrap()); + let comp = s.project.comp(cid).unwrap(); + assert_eq!(comp.layers.iter().map(|l| l.name.as_str()).collect::>(), vec!["Art", "Sky"]); + assert_eq!((comp.width, comp.height), (120, 80)); + let d = mean_diff(&s.render(cid, t, RenderOpts::default()), &direct); + assert!(d < 1.0 / 255.0, "{import_as}: comp vs page {d}"); + } + // Another artboard: the carried PDF's page 2. + let pages = tmp("pages.vectorcraft"); + std::fs::write(&pages, vectorcraft_file(Some(&two_page_pdf()))).unwrap(); + let mut s = effectcraft_host::session(); + let r = s.execute_checked("file.import", json!({"paths": [pages], "page": 2})).unwrap(); + assert_eq!(r["errors"], json!([]), "{r}"); + let effectcraft_project::ItemKind::Footage(f) = &s.project.item(ItemId(r["items"][0].as_u64().unwrap())).unwrap().kind else { panic!("footage") }; + assert_eq!((f.width, f.height, f.page), (100, 60, 1)); +} + +#[test] +fn a_vectorcraft_document_without_a_pdf_reports_the_option_to_turn_on() { + let path = tmp("no-pdf.vectorcraft"); + std::fs::write(&path, vectorcraft_file(None)).unwrap(); + for import_as in ["footage", "composition"] { + let mut s = effectcraft_host::session(); + let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": import_as})).unwrap(); + let e = r["errors"][0].as_str().unwrap_or_default(); + assert!(e.contains("no-pdf.vectorcraft") && e.contains("Create PDF-Compatible File"), "{import_as}: {r}"); + assert_eq!(r["items"], json!([]), "{import_as}: {r}"); + } +} diff --git a/crates/media/src/layered.rs b/crates/media/src/layered.rs index adc23cf31..68edd9808 100644 --- a/crates/media/src/layered.rs +++ b/crates/media/src/layered.rs @@ -1,7 +1,7 @@ //! Layered and vector stills: Photoshop documents (`effectcraft-psd`: the merged image, or one //! layer for footage imported as a composition) and vector files rasterised at any scale: SVG -//! (`effectcraft-svg`), PDF / Illustrator / EPS (`effectcraft-pdf`; one layer of the file for -//! footage imported as a composition). +//! (`effectcraft-svg`), PDF / Illustrator / EPS and the PDF a VectorCraft document carries +//! (`effectcraft-pdf`; one layer of the file for footage imported as a composition). use effectcraft_project::{AlphaMode, Footage}; use effectcraft_raster::Image; diff --git a/crates/media/src/lib.rs b/crates/media/src/lib.rs index 454c3705f..b2bf1563b 100644 --- a/crates/media/src/lib.rs +++ b/crates/media/src/lib.rs @@ -65,7 +65,7 @@ impl From for MediaError { /// File extensions recognised as stills. pub const STILL_EXTENSIONS: &[&str] = - &["png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "tga", "hdr", "psd", "psb", "svg", "pdf", "ai", "eps"]; + &["png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "tga", "hdr", "psd", "psb", "svg", "pdf", "ai", "eps", "vectorcraft"]; /// File extensions recognised as audio-only files. pub const AUDIO_EXTENSIONS: &[&str] = filmcraft_media::AUDIO_EXTENSIONS; pub use effectcraft_project::VIDEO_EXTENSIONS; diff --git a/crates/pdf/Cargo.toml b/crates/pdf/Cargo.toml index 68aabfbd7..63e86a46a 100644 --- a/crates/pdf/Cargo.toml +++ b/crates/pdf/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "effectcraft-pdf" -description = "Vector footage import: PDF and PDF-compatible Illustrator (.ai) pages and EPS (a PostScript subset) parsed into the SVG render tree (paths, fills, strokes, shadings, tiling patterns, clipping, text with embedded fonts, images, blend modes, soft masks, optional-content layers)" +description = "Vector footage import: PDF and PDF-compatible Illustrator (.ai) pages, EPS (a PostScript subset) and the PDF a VectorCraft (.vectorcraft) document carries, parsed into the SVG render tree (paths, fills, strokes, shadings, tiling patterns, clipping, text with embedded fonts, images, blend modes, soft masks, optional-content layers)" version.workspace = true edition.workspace = true license.workspace = true @@ -12,6 +12,8 @@ workspace = true [dependencies] craft-eps = { workspace = true } craft-pdf.workspace = true +# The PDF a VectorCraft document carries (Create PDF-Compatible File). +craft-doc = { workspace = true } effectcraft-svg = { workspace = true } kurbo = { workspace = true } effectcraft-text = { workspace = true } @@ -25,6 +27,10 @@ zune-jpeg = "0.5" # Encodes JPEG fixtures for the DCT image test. image = { workspace = true } effectcraft-raster = { workspace = true } +# Writes the VectorCraft documents the tests read. +craft-vectorcraft-format = { workspace = true } +flate2 = { version = "1", default-features = false, features = ["rust_backend"] } +serde_json = { workspace = true } [target.'cfg(target_arch = "wasm32")'.dev-dependencies] wasm-bindgen-test = "0.3" diff --git a/crates/pdf/README.md b/crates/pdf/README.md index 53689ba9a..ff37aa93c 100644 --- a/crates/pdf/README.md +++ b/crates/pdf/README.md @@ -114,6 +114,10 @@ ffmpeg elsewhere) to check the code tables against an independent implementation stitching and PostScript calculator (type 4) functions. - **Pages:** any page ([`parse_page`], [`page_count`]); File ▸ Import takes `page` (from 1) and the Import dialog asks for it; footage remembers its page (`Footage::page`). +- **VectorCraft documents** (`.vectorcraft`, plain or compressed): the PDF the document carries + when VectorCraft saved it with Create PDF-Compatible File, one page per artboard, read through + `craft-doc` from craft-libs. The footage codec is `VectorCraft`. A document saved without that + option has no PDF, and importing it reports an error that names the option. ## Limitations diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs index ff914e759..12e3f63e0 100644 --- a/crates/pdf/src/lib.rs +++ b/crates/pdf/src/lib.rs @@ -34,6 +34,8 @@ pub enum Error { NoPages, PageOutOfRange(usize), NoBoundingBox, + /// A VectorCraft document saved without Create PDF-Compatible File. + NoCarriedPdf, Read(String), } @@ -45,6 +47,9 @@ impl std::fmt::Display for Error { Error::NoPages => write!(f, "the PDF has no pages"), Error::PageOutOfRange(n) => write!(f, "the PDF has no page {}", n.saturating_add(1)), Error::NoBoundingBox => write!(f, "the EPS file has no %%BoundingBox"), + Error::NoCarriedPdf => { + write!(f, "the VectorCraft document holds no PDF; save it in VectorCraft with Create PDF-Compatible File turned on") + } Error::Read(message) => f.write_str(message), } } @@ -53,17 +58,24 @@ impl std::fmt::Display for Error { impl std::error::Error for Error {} /// File extensions read as vector footage by this crate. -pub const EXTENSIONS: &[&str] = &["pdf", "ai", "eps", "epsf", "epsi"]; +pub const EXTENSIONS: &[&str] = &["pdf", "ai", "eps", "epsf", "epsi", "vectorcraft"]; /// The format of a file, by its first bytes. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Format { Pdf, Eps, + /// A VectorCraft document (`.vectorcraft`), read through the PDF it carries when it was + /// saved with Create PDF-Compatible File: one page per artboard. + VectorCraft, } -/// Sniff a PDF (`%PDF-` near the start, as PDF-compatible `.ai` files are) or an EPS file. +/// Sniff a VectorCraft document, a PDF (`%PDF-` near the start, as PDF-compatible `.ai` files +/// are) or an EPS file. The first 64 KiB suffice. pub fn sniff(bytes: &[u8]) -> Option { + if craft_doc::sniff(bytes) == Some(craft_doc::Kind::VectorCraft) { + return Some(Format::VectorCraft); + } let head = &bytes[..bytes.len().min(1024)]; if head.windows(5).any(|w| w == b"%PDF-") { return Some(Format::Pdf); @@ -74,11 +86,12 @@ pub fn sniff(bytes: &[u8]) -> Option { None } -/// A footage codec name for a sniffed file ("PDF", "AI", "EPS"). +/// A footage codec name for a sniffed file ("PDF", "AI", "EPS", "VectorCraft"). pub fn codec(path: &str, bytes: &[u8]) -> Option<&'static str> { let f = sniff(bytes)?; let ai = path.to_ascii_lowercase().ends_with(".ai"); Some(match (f, ai) { + (Format::VectorCraft, _) => "VectorCraft", (_, true) => "AI", (Format::Pdf, false) => "PDF", (Format::Eps, false) => "EPS", @@ -112,19 +125,47 @@ pub fn parse_page_framed(bytes: &[u8], index: usize, framing: Framing) -> Result match sniff(bytes) { Some(Format::Pdf) => parse_pdf(bytes, index, framing), Some(Format::Eps) => parse_eps(bytes), + Some(Format::VectorCraft) => parse_pdf(&carried_pdf(bytes)?, index, framing), None => Err(Error::NotVector), } } /// Number of pages (1 for EPS). pub fn page_count(bytes: &[u8]) -> usize { + let pdf_pages = |bytes: &[u8]| object::File::parse(bytes).map(|file| page::pages(&file).len()).unwrap_or(0); match sniff(bytes) { - Some(Format::Pdf) => object::File::parse(bytes).map(|file| page::pages(&file).len()).unwrap_or(0), + Some(Format::Pdf) => pdf_pages(bytes), Some(Format::Eps) => 1, + Some(Format::VectorCraft) => carried_pdf(bytes).map(|pdf| pdf_pages(&pdf)).unwrap_or(0), None => 0, } } +/// The PDF a VectorCraft document carries: [`Error::NoCarriedPdf`] when it was saved without +/// Create PDF-Compatible File. The preview is not read, so a damaged preview does not stop the +/// import. +fn carried_pdf(bytes: &[u8]) -> Result, Error> { + let pdf = craft_doc::rendition(bytes, craft_doc::RenditionKind::Pdf, &carried_limits()) + .map_err(|e| Error::Read(format!("VectorCraft document: {e}")))? + .ok_or(Error::NoCarriedPdf)?; + if sniff(&pdf.bytes) != Some(Format::Pdf) { + return Err(Error::Read("VectorCraft document: its PDF member is not a PDF".into())); + } + Ok(pdf.bytes) +} + +/// craft-doc's limits for [`carried_pdf`]: a PDF after the JSON (version 4) may be as large as a +/// PDF file this crate opens (`craft_pdf::MAX_INPUT_BYTES`); one inline in the JSON as base64 +/// (version 3) stays within `max_json`, about 192 MiB of PDF. `max_total` allows `max_json` (craft-doc's default) for a +/// compressed document's JSON, and twice `max_entry` for its data up to the PDF's end and the PDF +/// copied out, which caps what a hostile file can make the import allocate. +fn carried_limits() -> craft_doc::Limits { + let mut limits = craft_doc::Limits::default(); + limits.max_entry = u64::try_from(craft_pdf::MAX_INPUT_BYTES).unwrap_or(u64::MAX); + limits.max_total = limits.max_json.saturating_add(limits.max_entry.saturating_mul(2)); + limits +} + /// Build the document: `root` children become layer groups (see the crate docs). fn finish(nodes: Vec, flags: Vec, skipped: Vec, width: f64, height: f64, to_doc: Affine) -> Doc { let mut layers: Vec = vec![]; diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs index 66b5c79a2..15dd54b17 100644 --- a/crates/pdf/src/tests.rs +++ b/crates/pdf/src/tests.rs @@ -8,6 +8,7 @@ mod groups; mod import; mod reader; mod shading; +mod vectorcraft; const CONTENT: &str = "/OC /MC0 BDC\n0 1 0 rg 0 0 200 100 re f\nEMC\n\ /OC /MC1 BDC\nq 10 10 80 80 re W n\n1 0 0 rg 0 0 50 100 re f\nQ\n\ diff --git a/crates/pdf/src/tests/vectorcraft.rs b/crates/pdf/src/tests/vectorcraft.rs new file mode 100644 index 000000000..d4a3b73ad --- /dev/null +++ b/crates/pdf/src/tests/vectorcraft.rs @@ -0,0 +1,140 @@ +//! VectorCraft documents read through the PDF they carry (Create PDF-Compatible File), written +//! with craft-vectorcraft-format's envelope types: plain and compressed, the PDF inline as base64 +//! (version 3) and after the JSON (version 4). + +use std::io::Write; + +use craft_vectorcraft_format::{BLOB_MAGIC, File, INLINE_MAX, Image}; + +use crate::write::pdf; +use crate::*; + +/// Two artboards: a 200×100 page with the layers "Background" (green) and "Art" (a red left +/// half), and a 100×50 blue page. `pad` adds an unused object so the PDF is long enough to go +/// after the JSON. +fn artboards_pdf(pad: bool) -> Vec { + let first = "/OC /L0 BDC\n0 1 0 rg 0 0 200 100 re f\nEMC\n/OC /L1 BDC\n1 0 0 rg 0 0 100 100 re f\nEMC\n"; + let mut objs = vec![ + (1, "<< /Type /Catalog /Pages 2 0 R >>".to_string(), None), + (2, "<< /Type /Pages /Kids [3 0 R 8 0 R] /Count 2 >>".to_string(), None), + (3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 100] /Resources << /Properties << /L0 5 0 R /L1 6 0 R >> >> /Contents 4 0 R >>".to_string(), None), + (4, "<< >>".to_string(), Some(first.as_bytes().to_vec())), + (5, "<< /Type /OCG /Name (Background) >>".to_string(), None), + (6, "<< /Type /OCG /Name (Art) >>".to_string(), None), + (7, "<< >>".to_string(), Some(b"0 0 1 rg 0 0 100 50 re f\n".to_vec())), + (8, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 50] /Contents 7 0 R >>".to_string(), None), + ]; + if pad { + // Written as given (the writer compresses streams without a `/Filter`); never read. + objs.push((9, "<< /Filter /ASCIIHexDecode >>".to_string(), Some(vec![b'0'; INLINE_MAX + 1024]))); + } + pdf(&objs, 1) +} + +/// A `.vectorcraft` file of `version` holding an empty document and `carried` as its `pdf` +/// member, gzip-compressed when `gzip` is set (Use Compression). +fn vectorcraft(carried: Option<&[u8]>, version: u32, gzip: bool) -> Vec { + vectorcraft_with_preview(carried, None, version, gzip) +} + +/// [`vectorcraft`] with `preview` as the file's `preview` member. +fn vectorcraft_with_preview(carried: Option<&[u8]>, preview: Option, version: u32, gzip: bool) -> Vec { + let mut file = File::new(serde_json::json!({"artboards": [], "layers": []})); + file.version = version; + file.generator = Some("VectorCraft 0.1.0".into()); + file.preview = preview; + let mut tail = file.tail(); + file.pdf = carried.map(|b| tail.image("application/pdf", b, false)); + let mut out = serde_json::to_vec(&file).unwrap(); + tail.write_to(&mut out).unwrap(); + if !gzip { + return out; + } + let mut gz = flate2::write::GzEncoder::new(vec![], flate2::Compression::default()); + gz.write_all(&out).unwrap(); + gz.finish().unwrap() +} + +fn pixels(doc: &Doc) -> Vec<[f32; 4]> { + let (w, h) = doc.pixel_size(); + effectcraft_svg::rasterize(doc, w, h, 1.0).data +} + +#[test] +fn a_vectorcraft_document_reads_as_the_pdf_it_carries() { + for (version, gzip, pad) in [(3, false, false), (3, true, false), (4, false, true), (4, true, true)] { + let carried = artboards_pdf(pad); + let file = vectorcraft(Some(&carried), version, gzip); + let case = format!("version {version}, gzip {gzip}"); + if !gzip { + let after_json = file.windows(BLOB_MAGIC.len()).any(|w| w == BLOB_MAGIC); + assert_eq!(after_json, version == 4, "{case}: the PDF goes after the JSON in version 4"); + } + assert_eq!(sniff(&file), Some(Format::VectorCraft), "{case}"); + assert_eq!(codec("art.vectorcraft", &file), Some("VectorCraft"), "{case}"); + assert_eq!(page_count(&file), 2, "{case}"); + let doc = parse(&file).unwrap(); + assert_eq!((doc.width, doc.height), (200.0, 100.0), "{case}"); + assert_eq!(layer_names(&doc), vec!["Background", "Art"], "{case}"); + assert_eq!(pixels(&doc), pixels(&parse(&carried).unwrap()), "{case}: drawn as the PDF itself"); + let second = parse_page(&file, 1).unwrap(); + assert_eq!((second.width, second.height), (100.0, 50.0), "{case}"); + assert_eq!(parse_page(&file, 2).err(), Some(Error::PageOutOfRange(2)), "{case}"); + } +} + +#[test] +fn a_vectorcraft_document_without_a_pdf_names_create_pdf_compatible_file() { + for gzip in [false, true] { + let file = vectorcraft(None, 4, gzip); + assert_eq!(sniff(&file), Some(Format::VectorCraft)); + assert_eq!(page_count(&file), 0); + let e = parse(&file).err(); + assert_eq!(e, Some(Error::NoCarriedPdf)); + assert!(e.map(|e| e.to_string()).unwrap_or_default().contains("Create PDF-Compatible File")); + } +} + +#[test] +fn a_damaged_preview_does_not_stop_the_carried_pdf_from_reading() { + let mut not_base64 = Image::default(); + not_base64.mime = "image/png".into(); + not_base64.data = "not base64!".into(); + let mut past_the_end = Image::default(); + past_the_end.mime = "image/png".into(); + past_the_end.blob = Some([u64::MAX / 2, 16]); + for (preview, what) in [(not_base64, "not base64"), (past_the_end, "past the end")] { + for (version, gzip, pad) in [(3, false, false), (4, false, true), (4, true, true)] { + let carried = artboards_pdf(pad); + let file = vectorcraft_with_preview(Some(&carried), Some(preview.clone()), version, gzip); + let case = format!("{what}, version {version}, gzip {gzip}"); + assert_eq!(page_count(&file), 2, "{case}"); + let doc = parse(&file).unwrap_or_else(|e| panic!("{case}: {e}")); + assert_eq!(layer_names(&doc), vec!["Background", "Art"], "{case}"); + } + } +} + +#[test] +fn a_carried_pdf_may_be_as_large_as_a_pdf_file() { + let limits = carried_limits(); + assert_eq!(limits.max_entry, craft_pdf::MAX_INPUT_BYTES as u64); + assert_eq!(limits.max_json, craft_doc::Limits::default().max_json); + assert_eq!(limits.max_total, limits.max_json + 2 * limits.max_entry); +} + +#[test] +fn a_vectorcraft_document_read_wrongly_is_an_error() { + // A newer format version. + let newer = vectorcraft(Some(&artboards_pdf(false)), craft_vectorcraft_format::VERSION + 1, false); + let e = parse(&newer).err().map(|e| e.to_string()).unwrap_or_default(); + assert!(e.contains("newer"), "{e}"); + // A `pdf` member that holds something else. + let not_pdf = vectorcraft(Some(b"not a PDF"), 4, false); + assert!(matches!(parse(¬_pdf), Err(Error::Read(_)))); + // A cut-off file. + let file = vectorcraft(Some(&artboards_pdf(true)), 4, true); + assert!(parse(&file[..file.len() / 2]).is_err()); + // Other JSON is not a VectorCraft document. + assert_eq!(sniff(br#"{"format":"other","version":1}"#), None); +} diff --git a/crates/render/src/footage.rs b/crates/render/src/footage.rs index c14961d0f..90aa008cd 100644 --- a/crates/render/src/footage.rs +++ b/crates/render/src/footage.rs @@ -231,7 +231,7 @@ impl FootageSource for CancellableFootage<'_> { /// Footage that can be rasterised at any scale: SVG, PDF, Illustrator and EPS files, and a /// placed page of an After Effects project (its codec is not stored there). pub fn is_vector_footage(f: &Footage) -> bool { - matches!(f.codec.as_str(), "SVG" | "PDF" | "AI" | "EPS") || f.placed_page + matches!(f.codec.as_str(), "SVG" | "PDF" | "AI" | "EPS" | "VectorCraft") || f.placed_page } /// How vector footage `f` is drawn at `scale` × its size: the image size, and the x and y scale diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index 518f4e809..f1373607d 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -74,6 +74,7 @@ impl EffectcraftApp { last_activity: (0.0, 0), last_edit: (0.0, 0), toast: None, + error_toasts: Default::default(), viewer_tex: None, passive_tex: std::collections::HashMap::new(), viewer_native: None, diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs index b1beab972..06f8c1657 100644 --- a/crates/ui-egui/src/app/files.rs +++ b/crates/ui-egui/src/app/files.rs @@ -1,6 +1,32 @@ use super::{Dialog, EffectcraftApp}; impl EffectcraftApp { + pub(crate) fn push_error_toast(&mut self, toast: crate::ErrorToast) { + if self.error_toasts.len() >= crate::ErrorToast::MAX_PENDING { + // Preserve the visible notification and summarize the pending backlog. + let reports = self.error_toasts.drain(1..).fold(0usize, |sum, toast| sum.saturating_add(toast.reports)); + self.error_toasts.push_back(crate::ErrorToast::omitted(reports)); + } + self.error_toasts.push_back(toast); + } + + /// Imports can succeed as commands while individual files fail before a job starts. + pub(crate) fn report_import_errors(&mut self, command: &str, result: &serde_json::Value) { + if !matches!(command, "file.import" | "file.importMultiple") { + return; + } + let errors: Vec<&str> = result["errors"].as_array().into_iter().flatten().filter_map(serde_json::Value::as_str).collect(); + match errors.as_slice() { + [] => {} + [one] => self.ui.status = (*one).into(), + [first, rest @ ..] => self.ui.status = format!("{first} (and {} more)", rest.len()), + } + if !errors.is_empty() { + self.ui.status = crate::ErrorToast::bounded_text([self.ui.status.as_str()]); + self.push_error_toast(crate::ErrorToast::new(errors.iter().copied(), Some(&self.ui.status))); + } + } + /// Show the crash-recovery dialog for a previous run that didn't exit cleanly. pub fn offer_recovery(&mut self, r: effectcraft_engine::autosave::Recovery) { if r.autosave.is_some() { diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rs index f3129c66d..14bbabd72 100644 --- a/crates/ui-egui/src/app/frame.rs +++ b/crates/ui-egui/src/app/frame.rs @@ -142,7 +142,13 @@ impl EffectcraftApp { panels::viewers::on_open_comp(self, c); self.ui.timeline.pps = None; } - effectcraft_engine::Event::Toast { message, .. } => self.toast = Some((message, self.now)), + effectcraft_engine::Event::Toast { message, error } => { + if error { + self.push_error_toast(crate::ErrorToast::new([message.as_str()], None)); + } else { + self.toast = Some((message, self.now)); + } + } effectcraft_engine::Event::OpenUrl(url) => ctx.open_url(egui::OpenUrl::new_tab(url)), // Frames are keyed by content: an edit keeps those of comps it doesn't touch. effectcraft_engine::Event::ProjectChanged { .. } => {} @@ -567,21 +573,44 @@ impl EffectcraftApp { if self.ui.status.is_empty() { ui.data_mut(|d| d.remove::<(f64, String)>(egui::Id::unique("status-since"))); } - let msg = if !self.ui.status.is_empty() { - Some(self.ui.status.clone()) + while self.error_toasts.front().is_some_and(|toast| toast.shown_at.is_some_and(|at| now - at >= 4.0)) { + self.error_toasts.pop_front(); + } + let error = self.error_toasts.front_mut().and_then(|toast| toast.message_at(!self.ui.status.is_empty(), now)).map(str::to_owned); + let notice = self.toast.as_ref().filter(|(_, at)| now - at < 4.0).map(|(message, _)| crate::ErrorToast::bounded_text([message.as_str()])); + let mut msg = if !self.ui.status.is_empty() { + // A background result must get its display time after the foreground status. + // Keep its details available on hover while the status takes precedence. + let status = crate::ErrorToast::bounded_text([self.ui.status.as_str()]); + if let Some(details) = error { Some(format!("{status}\n{details}")) } else { Some(status) } } else { - self.toast.as_ref().filter(|(_, at)| now - at < 4.0).map(|(m, _)| m.clone()) + error.or_else(|| notice.clone()) }; + if let Some(m) = &mut msg + && let Some(notice) = ¬ice + && m != notice + { + m.push('\n'); + m.push_str(notice); + } if let Some(m) = msg { let t = &self.tokens; - let galley = ui.painter().layout_no_wrap(m.clone(), Tokens::ui(12.0), t.text); + let summary = m.lines().next().unwrap_or_default().to_owned(); + let galley = ui.painter().layout_no_wrap(summary, Tokens::ui(12.0), t.text); let r = egui::Rect::from_min_size(egui::pos2(full.min.x + 16.0, full.max.y - 44.0 - lift), galley.size() + egui::vec2(24.0, 14.0)); ui.painter().rect_filled(r, 6.0, t.panel_bg); ui.painter().rect_stroke(r, 6.0, egui::Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside); ui.painter().galley(r.min + egui::vec2(12.0, 7.0), galley, t.text); self.auto.add("toast", r, &m); - let resp = ui.interact(r, egui::Id::unique("toast"), egui::Sense::click()); + let resp = ui.interact(r, egui::Id::unique("toast"), egui::Sense::click()).on_hover_text(&m); if resp.clicked() { + if self.ui.status.is_empty() { + self.error_toasts.pop_front(); + } else if let Some(index) = self.error_toasts.iter().rposition(|toast| toast.reported_by(&self.ui.status)) { + // The current status belongs to the latest matching import. Earlier + // imports can share its summary while carrying different details. + self.error_toasts.remove(index); + } self.ui.status.clear(); self.toast = None; } @@ -711,3 +740,250 @@ impl EffectcraftApp { } } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn dismissing_a_status_acknowledges_its_queued_error_behind_another() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.session.events.push(effectcraft_engine::Event::Toast { message: "Earlier background error".into(), error: true }); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + app.report_import_errors("file.import", &json!({"errors":["Later import error"]})); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + let r = app.auto.elements.iter().find(|e| e.id == "toast").unwrap().rect; + let pos = egui::pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0); + for pressed in [true, false] { + app.auto.elements.clear(); + let events = vec![ + egui::Event::PointerMoved(pos), + egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }, + ]; + ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + assert!(app.ui.status.is_empty()); + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().any(|e| e.label.contains("Earlier background error"))); + app.now = 4.1; + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(!app.auto.elements.iter().any(|e| e.id == "toast"), "the acknowledged later error must not reappear"); + } + + #[test] + fn matching_import_summaries_only_acknowledge_the_latest_details() { + for first in ["Shared error".to_owned(), "💥".repeat(20_000)] { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.report_import_errors("file.import", &json!({"errors":[first, "Earlier details"]})); + app.report_import_errors("file.import", &json!({"errors":[first, "Later details"]})); + let ctx = egui::Context::default(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + let r = app.auto.elements.iter().find(|e| e.id == "toast").unwrap().rect; + let pos = egui::pos2(r[0] + 4.0, r[1] + 4.0); + for pressed in [true, false] { + let events = vec![ + egui::Event::PointerMoved(pos), + egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }, + ]; + ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + assert!(app.ui.status.is_empty()); + assert_eq!(app.error_toasts.len(), 1, "only the latest matching import is acknowledged, including long statuses"); + if first.len() < 100 { + assert!(app.error_toasts.front().unwrap().message.contains("Earlier details")); + } + } + } + + #[test] + fn pending_error_notifications_are_bounded_and_report_omissions() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.session.events.extend((0..40).map(|i| effectcraft_engine::Event::Toast { message: format!("Error {i}"), error: true })); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + assert!(app.error_toasts.len() <= 32); + assert_eq!(app.error_toasts.front().unwrap().message, "Error 0"); + assert_eq!(app.error_toasts.back().unwrap().message, "Error 39"); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + app.now += 4.1; + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().any(|e| e.label.contains("notifications omitted"))); + let long = format!("a{}", "💥".repeat(20_000)); + let toast = crate::ErrorToast::new([long.as_str()], None); + assert!(toast.message.starts_with("a💥")); + assert!(toast.message.len() < 20 << 10); + assert!(toast.message.capacity() < 64 << 10, "the large input allocation must not remain retained"); + assert!(toast.message.contains("truncated")); + } + + #[test] + fn consecutive_background_errors_are_each_shown_before_expiring_or_dismissal() { + for dismiss in [false, true] { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.session.events.extend([ + effectcraft_engine::Event::Toast { message: "First.vectorcraft failed".into(), error: true }, + effectcraft_engine::Event::Toast { message: "A routine notice".into(), error: false }, + effectcraft_engine::Event::Toast { message: "Second.vectorcraft failed".into(), error: true }, + ]); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().any(|e| e.id == "toast" && e.label.contains("First.vectorcraft"))); + if dismiss { + let r = app.auto.elements.iter().find(|e| e.id == "toast").unwrap().rect; + let pos = egui::pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0); + for pressed in [true, false] { + app.auto.elements.clear(); + let events = vec![ + egui::Event::PointerMoved(pos), + egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }, + ]; + ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + app.now = 0.1; + } else { + app.now = 4.1; + } + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().any(|e| e.id == "toast" && e.label.contains("Second.vectorcraft"))); + assert!(!app.auto.elements.iter().any(|e| e.label.contains("First.vectorcraft"))); + app.now += 4.1; + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(!app.auto.elements.iter().any(|e| e.id == "toast")); + } + } + + #[test] + fn an_unshown_error_survives_a_replacement_foreground_status() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.ui.status = "First foreground status".into(); + app.session.events.push(effectcraft_engine::Event::Toast { message: "An unseen import error".into(), error: true }); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + app.ui.status = "Another foreground status".into(); + for now in [1.0, 3.0, 6.0, 6.1] { + app.now = now; + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + assert!(app.auto.elements.iter().any(|e| e.id == "toast" && e.label.contains("unseen import error"))); + } + + #[test] + fn dismissing_a_status_keeps_an_unshown_background_error() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.ui.status = "A local drop failed".into(); + app.session.events.push(effectcraft_engine::Event::Toast { message: "A later background import failed".into(), error: true }); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + let click = |app: &mut EffectcraftApp| { + let r = app.auto.elements.iter().find(|e| e.id == "toast").unwrap().rect; + let pos = egui::pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0); + for pressed in [true, false] { + app.auto.elements.clear(); + let events = vec![ + egui::Event::PointerMoved(pos), + egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }, + ]; + ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + }; + click(&mut app); + assert!(app.ui.status.is_empty()); + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().any(|e| e.id == "toast" && e.label.contains("later background import failed"))); + click(&mut app); + assert!(app.error_toasts.is_empty(), "the displayed error can be dismissed too"); + app.report_import_errors("file.import", &json!({"errors": ["An immediate import error", "Another import error"]})); + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + click(&mut app); + assert!(app.ui.status.is_empty()); + assert!(app.error_toasts.is_empty(), "dismissing an error status acknowledges its own details"); + } + + #[test] + fn a_later_status_does_not_extend_an_error_already_shown() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.session.events.push(effectcraft_engine::Event::Toast { message: "An earlier error".into(), error: true }); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + app.ui.status = "An unrelated later status".into(); + for now in [1.0, 4.0, 7.0, 7.1] { + app.now = now; + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + assert!(!app.auto.elements.iter().any(|e| e.id == "toast")); + } + + #[test] + fn import_error_details_survive_a_warning_event() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.report_import_errors("file.import", &json!({"errors": ["first failed file", "second failed file"]})); + app.session.events.push(effectcraft_engine::Event::Toast { message: "Sequence has missing frames".into(), error: false }); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().any(|e| e.id == "toast" && e.label.contains("second failed file"))); + assert!(app.auto.elements.iter().any(|e| e.id == "toast" && e.label.contains("missing frames"))); + } + + #[test] + fn a_foreground_status_does_not_extend_a_confirmation_toast() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.ui.status = "A foreground status".into(); + app.toast = Some(("Saved".into(), 0.0)); + let ctx = egui::Context::default(); + for now in [0.0, 3.0, 6.0, 6.1] { + app.now = now; + app.auto.elements.clear(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + assert!(!app.auto.elements.iter().any(|e| e.id == "toast")); + } + + #[test] + fn a_new_status_does_not_revive_an_expired_toast() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.ui.status = "A new status".into(); + app.toast = Some(("An old toast".into(), 0.0)); + app.now = 8.0; + let ctx = egui::Context::default(); + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().all(|e| !e.label.contains("old toast"))); + app.ui.status.clear(); + app.auto.elements.clear(); + app.now = 8.1; + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(!app.auto.elements.iter().any(|e| e.id == "toast")); + } + + #[test] + fn a_status_message_does_not_expire_a_background_import_error() { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.ui.status = "A local drop failed".into(); + app.session.events.push(effectcraft_engine::Event::Toast { message: "Imported 1 item. Failed first file\nFailed second file".into(), error: true }); + let ctx = egui::Context::default(); + app.handle_events(&ctx); + for now in [0.0, 3.0, 6.0] { + app.now = now; + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + } + assert!(app.ui.status.is_empty()); + app.auto.elements.clear(); + app.now = 6.1; + ctx.run_ui(egui::RawInput::default(), |ui| app.draw_toast(ui, ui.max_rect(), 0.0)).textures_delta.clear(); + assert!(app.auto.elements.iter().any(|e| e.id == "toast" && e.label.contains("Failed second file")), "{:?}", app.auto.elements); + } +} diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index dacb42de5..717a9a370 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -268,6 +268,77 @@ impl Playback { } } +/// An error awaiting its first standalone display. +pub(crate) struct ErrorToast { + message: String, + shown_at: Option, + /// A status already reports this error; dismissing that same status acknowledges both. + reported_status: Option, + reports: usize, +} + +impl ErrorToast { + const MAX_PENDING: usize = 32; + const MAX_DETAILS: usize = 16 << 10; + + fn bounded_text<'a>(messages: impl IntoIterator) -> String { + let mut text = String::new(); + let mut truncated = false; + for (index, part) in messages.into_iter().enumerate() { + let separator = usize::from(!text.is_empty()); + let remaining = Self::MAX_DETAILS.saturating_sub(text.len() + separator); + if remaining == 0 || index >= Self::MAX_DETAILS { + truncated = true; + break; + } + if separator != 0 { + text.push('\n'); + } + let end = part.floor_char_boundary(remaining.min(part.len())); + text.push_str(part.get(..end).unwrap_or_default()); + if end < part.len() { + truncated = true; + break; + } + } + if truncated { + let marker = crate::i18n::ui::tr("Further error details were truncated."); + let marker = marker.get(..marker.floor_char_boundary(Self::MAX_DETAILS - 1)).unwrap_or_default(); + text.truncate(text.floor_char_boundary(Self::MAX_DETAILS.saturating_sub(marker.len() + 1))); + text.push('\n'); + text.push_str(marker); + } + text + } + + fn new<'a>(messages: impl IntoIterator, reported_status: Option<&str>) -> Self { + Self { message: Self::bounded_text(messages), shown_at: None, reported_status: reported_status.map(|status| Self::bounded_text([status])), reports: 1 } + } + + fn omitted(reports: usize) -> Self { + let message = crate::i18n::ui::tr_args("Additional error notifications omitted: {}.", &[&reports.to_string()]); + Self { reports, ..Self::new([message.as_str()], None) } + } + + fn reported_by(&self, status: &str) -> bool { + self.reported_status.as_deref().is_some_and(|reported| status == reported || status.strip_prefix(reported).is_some_and(|rest| rest.starts_with("; "))) + } + + /// Pair the details with `status`, a later status line that reports the same errors. + fn restate(&mut self, status: &str) { + self.reported_status = Some(Self::bounded_text([status])); + } + + fn message_at(&mut self, foreground_status: bool, now: f64) -> Option<&str> { + if self.shown_at.is_none() && !foreground_status { + // Only the first standalone display starts the timer. Later statuses cannot + // extend it, and an unseen error cannot expire behind a foreground status. + self.shown_at = Some(now); + } + self.shown_at.is_none_or(|at| now - at < 4.0).then_some(self.message.as_str()) + } +} + pub struct EffectcraftApp { pub session: Session, pub ui: UiState, @@ -327,6 +398,8 @@ pub struct EffectcraftApp { /// When the project last changed, and its revision then (see [`Self::editing`]). last_edit: (f64, u64), pub(crate) toast: Option<(String, f64)>, + /// Error details survive routine notifications and wait for a foreground status to clear. + pub(crate) error_toasts: std::collections::VecDeque, /// Texture of the last CPU frame shown in the viewer, the key it came from and the factor it /// was averaged down by for the magnification (`panels::viewer::minify_factor`). pub(crate) viewer_tex: Option<(egui::TextureHandle, FrameKey, usize)>, diff --git a/crates/ui-egui/src/menus/bar.rs b/crates/ui-egui/src/menus/bar.rs index dc4478a47..7301cd7a1 100644 --- a/crates/ui-egui/src/menus/bar.rs +++ b/crates/ui-egui/src/menus/bar.rs @@ -117,7 +117,7 @@ pub fn menu_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui) { } if let Some((id, params)) = clicked.map(|(id, params)| menu_choice(app, id, params)) { match invoke(app, &ctx, &id, if params.is_null() { json!({}) } else { params }) { - Ok(result) => super::frontend::show_result_errors(app, &result), + Ok(result) => super::frontend::show_command_result_errors(app, &id, &result), Err(e) => app.ui.status = e, } } diff --git a/crates/ui-egui/src/menus/frontend.rs b/crates/ui-egui/src/menus/frontend.rs index 121f4cad2..d03aa77cf 100644 --- a/crates/ui-egui/src/menus/frontend.rs +++ b/crates/ui-egui/src/menus/frontend.rs @@ -62,6 +62,9 @@ pub(crate) fn run_engine(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str } else if COPY_COMMANDS.contains(&id) && app.session.state.text_edit.is_none() { ctx.copy_text(clipboard_text(&app.session)); } + if let Ok(result) = &r { + app.report_import_errors(id, result); + } // Frontend events below may show the Home screen again (Help ▸ In-App Tutorials). leave_home_if_opened(app, before, r.is_ok()); let events = app.session.drain_events(); @@ -683,8 +686,10 @@ pub(super) fn file_dialog(app: &mut EffectcraftApp, id: &str, params: &Value) -> "png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "dpx", "cin", "wav", "aif", "aiff", "mp3", "flac", "ogg", "opus", "svg", "pdf", "ai", "eps", "psd", "psb", "tga", "hdr", "gltf", "glb", "obj", "stl", "fbx", "json", "csv", "tsv", ]; + // VectorCraft documents, read through the PDF they carry. + let media = [MEDIA, &["vectorcraft"]].concat(); let footage = |more: &[&'static str]| effectcraft_project::VIDEO_EXTENSIONS.iter().chain(more).copied().collect::>(); - let importable = |more: &[&'static str]| footage(MEDIA).into_iter().chain(more.iter().copied()).collect::>(); + let importable = |more: &[&'static str]| footage(&media).into_iter().chain(more.iter().copied()).collect::>(); // A host whose blocking dialogs are unsafe inside this frame shows the dialog without // blocking — macOS: the nested event loop re-entered winit's handler on a drag over the // window and aborted the app (#511); Linux: the desktop portal's answer never gets pumped, @@ -763,7 +768,7 @@ pub(crate) fn dialog_answered(app: &mut EffectcraftApp, answer: crate::DialogAns }; let Some(v) = picked_value(answer.key, paths) else { return }; match run_with_picked(app, &answer.command, answer.key, &answer.params, v) { - Ok(result) => show_result_errors(app, &result), + Ok(result) => show_command_result_errors(app, &answer.command, &result), Err(e) => app.ui.status = e, } } @@ -791,6 +796,27 @@ pub(crate) fn show_result_errors(app: &mut EffectcraftApp, result: &Value) { app.ui.status = msg; } +/// [`show_result_errors`] for the result of command `id`. An import has already queued its +/// details with the shorter status `report_import_errors` set; this status reports the same +/// errors in its place, so the details move to it and dismissing it still acknowledges them. +pub(crate) fn show_command_result_errors(app: &mut EffectcraftApp, id: &str, result: &Value) { + show_result_errors_after_import(app, matches!(id, "file.import" | "file.importMultiple"), result); +} + +/// [`show_result_errors`]; when `reported` is set, `report_import_errors` has just queued the +/// details of the import whose result this is, last, with the status shown before this call. +fn show_result_errors_after_import(app: &mut EffectcraftApp, reported: bool, result: &Value) { + let previous = app.ui.status.clone(); + show_result_errors(app, result); + if reported + && app.ui.status != previous + && let Some(toast) = app.error_toasts.back_mut().filter(|toast| toast.reported_by(&previous)) + { + app.ui.status = crate::ErrorToast::bounded_text([app.ui.status.as_str()]); + toast.restate(&app.ui.status); + } +} + /// Run command `id` with the path picked for it in parameter `key`. fn run_with_picked(app: &mut EffectcraftApp, id: &str, key: &str, params: &Value, v: Value) -> Result { if matches!(id, "file.import" | "file.importMultiple") @@ -834,6 +860,9 @@ fn run_with_picked(app: &mut EffectcraftApp, id: &str, key: &str, params: &Value if let Err(e) = &r { app.ui.status = e.clone(); } + if let Ok(result) = &r { + app.report_import_errors(id, result); + } leave_home_if_opened(app, before, r.is_ok()); r } @@ -882,8 +911,9 @@ fn import_picked_with_aep(app: &mut EffectcraftApp, id: &str, key: &str, params: result = json!({"result": result}); } let own = result.get("errors").and_then(Value::as_array).cloned().unwrap_or_default(); + let reported = !own.is_empty(); result["errors"] = Value::Array(errors.into_iter().map(Value::from).chain(own).collect()); - show_result_errors(app, &result); + show_result_errors_after_import(app, reported, &result); Ok(result) } Err(e) => { diff --git a/crates/ui-egui/src/menus/tests.rs b/crates/ui-egui/src/menus/tests.rs index 8c5091691..68c8d3f43 100644 --- a/crates/ui-egui/src/menus/tests.rs +++ b/crates/ui-egui/src/menus/tests.rs @@ -528,6 +528,80 @@ fn tga_is_available_in_import_replace_and_proxy_dialogs() { } } +#[test] +#[cfg(not(target_arch = "wasm32"))] +fn dropped_files_keep_import_errors_alongside_local_drop_errors() { + #[derive(Debug)] + struct Drop(std::path::PathBuf); + impl egui::DroppedFile for Drop { + fn path(&self) -> &std::path::Path { + &self.0 + } + fn bytes(&self) -> Result, String> { + std::fs::read(&self.0).map_err(|e| e.to_string()) + } + } + let folder = std::env::temp_dir().join(format!("effectcraft-mixed-drop-{}", std::process::id())); + std::fs::create_dir_all(&folder).unwrap(); + let path = folder.join("no-pdf.vectorcraft"); + std::fs::write(&path, br#"{"format":"vectorcraft","version":4,"document":{"artboards":[],"layers":[]}}"#).unwrap(); + let second = folder.join("also-no-pdf.vectorcraft"); + std::fs::copy(&path, &second).unwrap(); + let footage = folder.join("pending.png"); + std::fs::write(&footage, b"not a PNG").unwrap(); + for (bad_import, background) in [(false, false), (true, false), (true, true)] { + let mut app = EffectcraftApp::new(effectcraft_host::session()); + app.session.prefs.import.drag_import_as = "comp".into(); + let ctx = egui::Context::default(); + let mut dropped_files: Vec = vec![std::sync::Arc::new(Drop("no-local-path".into()))]; + if bad_import { + dropped_files.push(std::sync::Arc::new(Drop(path.clone()))); + dropped_files.push(std::sync::Arc::new(Drop(second.clone()))); + } + if background { + dropped_files.push(std::sync::Arc::new(Drop(footage.clone()))); + } + ctx.run_ui(egui::RawInput { dropped_files, ..Default::default() }, |ui| { + crate::prefs_live::dropped_files(&mut app, ui, ui.max_rect()); + }) + .textures_delta + .clear(); + assert!(app.ui.status.contains("without a local path"), "{}", app.ui.status); + if bad_import { + assert!(app.ui.status.contains("no-pdf.vectorcraft") && app.ui.status.contains("Create PDF-Compatible File"), "{}", app.ui.status); + let details = &app.error_toasts.back().expect("all import errors remain available").message; + assert!(details.contains("also-no-pdf.vectorcraft"), "{details}"); + if background { + app.session.execute("jobs.wait", json!({})).unwrap(); + app.handle_events(&ctx); + let details = &app.error_toasts.back().unwrap().message; + for name in ["no-pdf.vectorcraft", "also-no-pdf.vectorcraft", "pending.png"] { + assert!(details.contains(name), "{details}"); + } + assert!(app.ui.status.contains("without a local path")); + } + } else { + assert!(!app.ui.status.contains(";"), "{}", app.ui.status); + } + } + std::fs::remove_dir_all(folder).unwrap(); +} + +#[test] +fn importing_without_a_form_shows_immediate_file_errors() { + let folder = std::env::temp_dir().join(format!("effectcraft-drop-import-{}", std::process::id())); + std::fs::create_dir_all(&folder).unwrap(); + let path = folder.join("no-pdf.vectorcraft"); + std::fs::write(&path, br#"{"format":"vectorcraft","version":4,"document":{"artboards":[],"layers":[]}}"#).unwrap(); + let mut app = EffectcraftApp::new(effectcraft_host::session()); + let ctx = egui::Context::default(); + let r = invoke(&mut app, &ctx, "file.import", json!({"paths": [path], "importAs": "composition", "background": true, "drag": true})).unwrap(); + assert!(app.dialog.is_none()); + assert!(r["errors"][0].as_str().unwrap().contains("Create PDF-Compatible File")); + assert!(app.ui.status.contains("no-pdf.vectorcraft") && app.ui.status.contains("Create PDF-Compatible File"), "{}", app.ui.status); + std::fs::remove_dir_all(folder).unwrap(); +} + /// Cmd+W with the Render Queue focused closes the queue; the composition next to it stays /// open (it used to be closed, and the queue stayed). #[test] @@ -769,6 +843,35 @@ fn bundle_result_errors_show_compactly_in_the_status_line() { assert_eq!(app.ui.status, "a.wasm: already installed; b.wasm: does not load; c.wasm: cannot read it; +1 more"); } +/// A picked or menu import reports its errors twice: `report_import_errors` queues the details +/// with a short status, and the command's result then writes the longer status. Dismissing that +/// status still acknowledges the queued details, also when After Effects project errors lead it. +/// Another command's errors do not take over an import's details, even with the same text. +#[test] +fn an_import_status_rewritten_by_its_result_still_acknowledges_its_details() { + let long = format!("first failed file {}", "x".repeat(20_000)); + for first in ["first failed file", "first failed file\nwith a second line", long.as_str()] { + let import = json!({"errors": [first, "second failed file"]}); + let with_aep = json!({"errors": ["project.aep: cannot read it", first, "second failed file"]}); + for result in [&import, &with_aep] { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.report_import_errors("file.import", &import); + super::frontend::show_command_result_errors(&mut app, "file.import", result); + assert!(app.ui.status.contains("first failed file"), "{}", app.ui.status); + assert_eq!(app.error_toasts.len(), 1); + assert!(app.error_toasts.back().unwrap().reported_by(&app.ui.status), "{first:.40}: {:.80}", app.ui.status); + } + } + let import = json!({"errors": ["first failed file", "second failed file"]}); + for other in [json!({"errors": [{"file": "a.wasm", "error": "does not load"}]}), import.clone()] { + let mut app = EffectcraftApp::new(effectcraft_engine::Session::default()); + app.report_import_errors("file.import", &import); + super::frontend::show_command_result_errors(&mut app, "effect.installBundle", &other); + assert!(!app.ui.status.contains("(and"), "{}", app.ui.status); + assert!(!app.error_toasts.back().unwrap().reported_by(&app.ui.status), "{}", app.ui.status); + } +} + /// Effect ▸ Install Effect Plug-in… picks its dialog by params: a bundle asks for a folder, /// a plain install asks for a `.wasm`, and with both given inline nothing asks at all. #[test] diff --git a/crates/ui-egui/src/panels/forms.rs b/crates/ui-egui/src/panels/forms.rs index 58f89e39d..08aa9337b 100644 --- a/crates/ui-egui/src/panels/forms.rs +++ b/crates/ui-egui/src/panels/forms.rs @@ -146,9 +146,10 @@ fn is_layered(p: &Value) -> bool { imports_ext(p, &["psd", "psb"]) } -/// The import includes a PDF or Illustrator file (which may have several pages). +/// The import includes a PDF or Illustrator file, or a VectorCraft document read through its +/// PDF (which may have several pages). fn is_pdf(p: &Value) -> bool { - imports_ext(p, &["pdf", "ai"]) + imports_ext(p, &["pdf", "ai", "vectorcraft"]) } /// File ▸ Import ▸ File… picked numbered stills that import as image sequences: ask, as After @@ -991,8 +992,9 @@ pub fn show_form(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) { if ok || enter { app.dialog = None; let params = f.params(); - if let Err(e) = app.session.execute(&f.command, params) { - app.ui.status = e.to_string(); + match app.session.execute(&f.command, params) { + Ok(r) => app.report_import_errors(&f.command, &r), + Err(e) => app.ui.status = e.to_string(), } return; } @@ -1079,6 +1081,37 @@ mod tests { assert_eq!(f.params(), json!({"prop": "position", "value": [10.0, 20.0], "mode": "b"})); } + #[test] + fn import_form_shows_errors_returned_in_a_successful_result() { + let folder = std::env::temp_dir().join(format!("effectcraft-form-import-{}", std::process::id())); + std::fs::create_dir_all(&folder).unwrap(); + let path = folder.join("no-pdf.vectorcraft"); + std::fs::write(&path, br#"{"format":"vectorcraft","version":4,"document":{"artboards":[],"layers":[]}}"#).unwrap(); + for (import_as, background) in [("footage", false), ("composition", true), ("compositionLayerSizes", true)] { + let mut app = EffectcraftApp::new(effectcraft_host::session()); + let ctx = egui::Context::default(); + crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app)); + app.dialog_state.form = Form { + title: "Import".into(), + command: "file.import".into(), + base: json!({"paths": [path, path], "importAs": import_as, "background": background}), + fields: vec![], + }; + app.dialog = Some(Dialog::Form); + let raw = egui::RawInput { + events: vec![egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }], + ..Default::default() + }; + let tokens = app.tokens; + ctx.run_ui(raw, |ui| show_form(&mut app, ui.ctx(), &tokens)).textures_delta.clear(); + assert!(app.dialog.is_none()); + assert!(app.ui.status.contains("no-pdf.vectorcraft") && app.ui.status.contains("Create PDF-Compatible File"), "{import_as}: {}", app.ui.status); + assert!(app.ui.status.ends_with("(and 1 more)"), "{}", app.ui.status); + assert!(!app.ui.status.contains('\n')); + } + std::fs::remove_dir_all(folder).unwrap(); + } + /// A numeric form (Layer ▸ Transform ▸ Position…) opens with its first number being edited /// and selected: typing replaces it, and one Enter confirms. #[test] diff --git a/crates/ui-egui/src/prefs_live.rs b/crates/ui-egui/src/prefs_live.rs index af8e27856..e5a09159d 100644 --- a/crates/ui-egui/src/prefs_live.rs +++ b/crates/ui-egui/src/prefs_live.rs @@ -59,6 +59,7 @@ pub fn dropped_files(app: &mut EffectcraftApp, ui: &egui::Ui, bounds: Rect) { } let mut errors = Vec::new(); + let mut import_reported_errors = false; if skipped != 0 { errors.push(crate::i18n::tr_args("Skipped {} dropped file(s) without a local path. Use File ▸ Import ▸ File…", &[&skipped])); } @@ -162,13 +163,17 @@ pub fn dropped_files(app: &mut EffectcraftApp, ui: &egui::Ui, bounds: Rect) { params["sequence"] = json!(false); } - if let Err(e) = crate::menus::invoke(app, &ctx, "file.import", params) { - errors.push(crate::i18n::tr_args("Cannot import dropped files: {}", &[&e])); + match crate::menus::invoke(app, &ctx, "file.import", params) { + Ok(result) => { + import_reported_errors = result["errors"].as_array().is_some_and(|errors| errors.iter().any(Value::is_string)); + } + Err(e) => errors.push(crate::i18n::tr_args("Cannot import dropped files: {}", &[&e])), } } if !errors.is_empty() { - app.ui.status = errors.join("; "); + let local = errors.join("; "); + app.ui.status = if import_reported_errors { format!("{}; {local}", app.ui.status) } else { local }; } }