Files
2026-11-08 19:23:07 -03:00

372 lines
12 KiB
Rust

//! Milestone 6: export (PNG/SVG/PDF of selections, frames, pages), import (.excalidraw,
//! .excalidrawlib, SVG) and the clipboard between pages, projects and apps.
mod common;
use common::*;
use papercraft::editor::shortcuts::Action;
use papercraft::editor::{Editor, Key, Modifiers};
use papercraft::geom::{Rect, V2, v2};
use papercraft::io::clipboard::{Memory, Provider};
use papercraft::io::export::{self, Format, Scope, Spec};
use papercraft::model::{Color, ImageMode, Node, NodeId, NodeKind, Paint};
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
fn tmp(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("papercraft-io-{tag}-{:016x}", fastrand::u64(..)));
std::fs::create_dir_all(&d).unwrap();
d
}
/// pdftoppm, when installed, renders a PDF page so we can look at it.
fn rasterize_pdf(pdf: &PathBuf, out_stem: &PathBuf, page: usize) -> Option<image::RgbaImage> {
let st = std::process::Command::new("pdftoppm")
.args([
"-png",
"-r",
"96",
"-f",
&page.to_string(),
"-l",
&page.to_string(),
"-singlefile",
])
.arg(pdf)
.arg(out_stem)
.status()
.ok()?;
if !st.success() {
return None;
}
Some(image::open(out_stem.with_extension("png")).ok()?.to_rgba8())
}
fn board() -> Editor {
let mut e = papercraft::demo::showcase();
// A gradient, an image fill and a multiply blend, so the PDF exercises every paint.
let mut g = Node::new(
NodeId(0),
NodeKind::Ellipse,
Rect::new(700.0, 500.0, 160.0, 120.0),
);
g.style.fills = vec![Paint::linear(
Color::rgb(255, 80, 80),
Color::rgb(60, 60, 255),
)];
e.add_node(g, None);
let img = image::RgbaImage::from_fn(40, 30, |x, y| {
image::Rgba([(x * 6) as u8, (y * 8) as u8, 180, 255])
});
let asset = papercraft::assets::register_rgba(&img);
let mut r = Node::new(
NodeId(0),
NodeKind::Rect,
Rect::new(900.0, 500.0, 160.0, 120.0),
);
r.style.fills = vec![Paint::Image {
asset,
mode: ImageMode::Fill,
opacity: 1.0,
}];
r.style.corner_radius = 16.0;
e.add_node(r, None);
e
}
#[test]
fn m6_pdf_export_pages_frames_and_selection() {
let e = board();
let dir = tmp("pdf");
let pages = [("Launch plan", &e.doc)];
// Each frame → one PDF page per frame.
let spec = Spec {
format: Format::Pdf,
scope: Scope::Frames,
..Spec::default()
};
let items = export::items(&spec, &pages, 0, &[]);
assert_eq!(items.len(), 2);
let out = dir.join("frames.pdf");
export::write(&spec, &items, &out, None).unwrap();
let bytes = std::fs::read(&out).unwrap();
let text = String::from_utf8_lossy(&bytes);
assert!(text.contains("/Count 2"));
// Whole page, rendered back through pdftoppm when available.
let spec = Spec {
format: Format::Pdf,
scope: Scope::Page,
..Spec::default()
};
let out = dir.join("page.pdf");
export::write(&spec, &export::items(&spec, &pages, 0, &[]), &out, None).unwrap();
let text = String::from_utf8_lossy(&std::fs::read(&out).unwrap()).to_string();
assert!(text.contains("/ShadingType 2"), "gradient as a shading");
assert!(text.contains("/Subtype /Image"), "image XObject");
if let Some(img) = rasterize_pdf(&out, &shot("milestone6_pdf_page"), 1) {
// The yellow note on the week plan is visible in the rasterized PDF.
let yellow = Color::rgb(0xff, 0xe0, 0x82);
let n = img.pixels().filter(|p| close(p.0, yellow, 12)).count();
assert!(n > 1000, "yellow pixels in PDF render: {n}");
}
// Selection: one layer → its own bounds.
let id = e.doc.root[0];
let spec = Spec {
format: Format::Pdf,
scope: Scope::Selection,
..Spec::default()
};
let items = export::items(&spec, &pages, 0, &[id]);
assert_eq!(items[0].roots, vec![id]);
std::fs::remove_dir_all(dir).ok();
}
#[test]
fn m6_png_and_svg_export_of_frames_and_all_pages() {
let Some(g) = gpu() else { return };
let mut e = board();
let p2 = e.add_page();
e.add_node(
Node::new(NodeId(0), NodeKind::Rect, Rect::new(0.0, 0.0, 50.0, 50.0)),
None,
);
e.switch_page(0);
let names: Vec<String> = e.pages.iter().map(|p| p.name.clone()).collect();
let pages: Vec<(&str, &papercraft::model::Document)> = names
.iter()
.enumerate()
.map(|(i, n)| (n.as_str(), e.page_doc(i)))
.collect();
let dir = tmp("png");
let spec = Spec {
format: Format::Png,
scope: Scope::Frames,
scale: 1.0,
transparent: true,
};
let files = export::write(
&spec,
&export::items(&spec, &pages, 0, &[]),
&dir.join("frames"),
Some(g),
)
.unwrap();
assert_eq!(files.len(), 2);
assert!(
files
.iter()
.any(|f| f.file_name().unwrap() == "Week plan.png")
);
let img = image::open(&files[0]).unwrap();
assert!(img.width() >= 400);
let spec = Spec {
format: Format::Svg,
scope: Scope::AllPages,
..Spec::default()
};
let files = export::write(
&spec,
&export::items(&spec, &pages, 0, &[]),
&dir.join("pages"),
Some(g),
)
.unwrap();
assert_eq!(files.len(), 2);
let _ = p2;
std::fs::remove_dir_all(dir).ok();
}
#[test]
fn m6_import_excalidraw_and_svg_screenshots() {
let Some(g) = gpu() else { return };
let json = include_str!("fixtures/excalidraw/basic.excalidraw");
let doc = papercraft::io::excalidraw::import_scene(json).unwrap();
let mut e = editor(1200.0, 800.0);
e.load(doc, None, None);
e.viewport = v2(1200.0, 800.0);
e.zoom_to_fit();
let img = render_canvas(g, &e);
img.save(shot("milestone6_excalidraw_import.png")).unwrap();
// Hand-drawn shapes rendered: plenty of dark stroke pixels.
assert!(count(&img, Rect::new(0.0, 0.0, 1200.0, 800.0), is_dark) > 2000);
let svg = r##"<svg xmlns="http://www.w3.org/2000/svg" width="300" height="200" viewBox="0 0 300 200">
<defs><radialGradient id="r"><stop offset="0" stop-color="#ffe066"/><stop offset="1" stop-color="#ff6b6b"/></radialGradient></defs>
<circle cx="80" cy="100" r="70" fill="url(#r)"/>
<path d="M170 30 L280 30 L225 170 Z" fill="#4dabf7" stroke="#1c3d5a" stroke-width="6" stroke-linejoin="round"/>
<text x="40" y="195" font-size="18" fill="#222">SVG import</text></svg>"##;
let doc = papercraft::io::svg_import::import_page(svg, "logo").unwrap();
let mut e = editor(800.0, 560.0);
e.load(doc, None, None);
e.viewport = v2(800.0, 560.0);
e.zoom_to_fit();
let img = render_canvas(g, &e);
img.save(shot("milestone6_svg_import.png")).unwrap();
let blue = Color::rgb(0x4d, 0xab, 0xf7);
assert!(
count(&img, Rect::new(0.0, 0.0, 800.0, 560.0), |p| close(
p, blue, 10
)) > 1000
);
}
/// A clipboard shared by two "apps".
#[derive(Clone, Default)]
struct Shared(Arc<Mutex<Memory>>);
impl Provider for Shared {
fn read_text(&mut self) -> Option<String> {
self.0.lock().unwrap().read_text()
}
fn write_text(&mut self, s: &str) {
self.0.lock().unwrap().write_text(s)
}
fn read_image(&mut self) -> Option<image::RgbaImage> {
self.0.lock().unwrap().read_image()
}
fn write_image(&mut self, img: &image::RgbaImage) {
self.0.lock().unwrap().write_image(img)
}
}
#[test]
fn m6_clipboard_between_apps_and_from_other_tools() {
let clip = Shared::default();
let mut a = board();
a.clipboard_io = Some(Box::new(clip.clone()));
let mut b = editor(1000.0, 700.0);
b.clipboard_io = Some(Box::new(clip.clone()));
// Copy a frame (with children) and the image layer in "app A", paste in "app B".
let frame = a.doc.root[0];
let img_layer = *a.doc.root.last().unwrap();
a.selection = vec![frame, img_layer];
key(&mut a, Key::Char('c'), Modifiers::cmd());
key(&mut b, Key::Char('v'), Modifiers::cmd());
assert_eq!(b.selection.len(), 2);
let pasted_frame = *b
.selection
.iter()
.find(|id| b.doc.get(**id).unwrap().is_frame())
.unwrap();
assert_eq!(
b.doc.subtree(pasted_frame).len(),
a.doc.subtree(frame).len(),
"children came along"
);
assert_eq!(
b.doc.world_rect(pasted_frame),
a.doc.world_rect(frame),
"positions kept"
);
// Pasting in A again (its own copy) uses the internal clipboard: offset on the same page.
let n = a.doc.nodes.len();
key(&mut a, Key::Char('v'), Modifiers::cmd());
assert!(a.doc.nodes.len() > n);
// SVG markup from another app.
clip.0.lock().unwrap().write_text(r#"<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><rect width="10" height="10" fill="red"/></svg>"#);
let n = b.doc.nodes.len();
b.run(Action::Paste);
assert!(b.doc.nodes.len() > n);
// Excalidraw clipboard JSON.
clip.0.lock().unwrap().write_text(
r##"{"type":"excalidraw/clipboard","elements":[{"id":"x","type":"rectangle","x":0,"y":0,"width":80,"height":40,"strokeColor":"#1e1e1e","backgroundColor":"#a5d8ff","fillStyle":"hachure","strokeWidth":2,"roughness":1,"opacity":100,"seed":5}]}"##,
);
b.run(Action::Paste);
let r = b.doc.get(b.selection[0]).unwrap();
assert!(r.style.rough.is_some(), "Excalidraw shapes stay hand-drawn");
// Plain text becomes a text layer; an image becomes an image layer.
clip.0
.lock()
.unwrap()
.write_text("Hello from the clipboard");
b.run(Action::Paste);
assert_eq!(
b.doc.get(b.selection[0]).unwrap().kind.text().unwrap(),
"Hello from the clipboard"
);
{
let mut m = clip.0.lock().unwrap();
m.text = None;
m.image = Some(image::RgbaImage::from_pixel(
20,
10,
image::Rgba([0, 200, 0, 255]),
));
}
b.run(Action::Paste);
assert!(matches!(
b.doc.get(b.selection[0]).unwrap().style.fills[0],
Paint::Image { .. }
));
// Copy as SVG writes markup.
b.selection = vec![pasted_frame];
b.run(Action::CopyAsSvg);
assert!(
clip.0
.lock()
.unwrap()
.text
.as_ref()
.unwrap()
.starts_with("<svg")
);
let _ = V2::ZERO;
}
#[test]
fn m6_cli_exports_pdf_and_imports_excalidraw() {
let dir = tmp("cli");
let exe = env!("CARGO_BIN_EXE_papercraft");
let pdf = dir.join("demo.pdf");
let st = std::process::Command::new(exe)
.args(["--export-pdf"])
.arg(&pdf)
.args(["--demo", "--frames"])
.status()
.unwrap();
assert!(st.success());
assert!(std::fs::read(&pdf).unwrap().starts_with(b"%PDF-1.7"));
let out = std::process::Command::new(exe)
.env("PAPERCRAFT_HOME", dir.join("home"))
.arg("--import")
.arg(concat!(
env!("CARGO_MANIFEST_DIR"),
"/tests/fixtures/excalidraw/basic.excalidraw"
))
.output()
.unwrap();
assert!(
out.status.success(),
"{}",
String::from_utf8_lossy(&out.stderr)
);
let proj = PathBuf::from(String::from_utf8_lossy(&out.stdout).trim().to_string());
assert!(proj.join("project.json").is_file());
let p = papercraft::project::Project::open(&proj).unwrap();
let pages = p.load_pages().unwrap();
assert!(pages[0].doc.nodes.len() >= 8);
// The fixture's image came along as a project asset.
assert!(
std::fs::read_dir(proj.join("assets"))
.map(|d| d.count())
.unwrap_or(0)
>= 1
);
std::fs::remove_dir_all(dir).ok();
}
#[test]
fn a_boolean_group_exports_as_one_path() {
use papercraft::geom::Rect;
use papercraft::model::{BoolOp, Node, NodeId, NodeKind};
let mut e = papercraft::editor::Editor::default();
let ids: Vec<NodeId> = [0.0, 50.0]
.map(|x| e.add_node(Node::new(NodeId(0), NodeKind::Rect, Rect::new(x, x, 100.0, 100.0)), None))
.into();
e.select(ids);
e.boolean(BoolOp::Subtract);
let svg = papercraft::io::svg::export(&e.doc, None, None).unwrap();
assert_eq!(svg.matches("<path").count(), 1, "{svg}");
assert!(!svg.contains("<rect"), "the operands are not drawn: {svg}");
}