Skip to content

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

M6.4: PDF export (krilla) + file.exportPdf

Brandon Thomascc4a8610c251
diff --git a/Cargo.lock b/Cargo.lock
index d373ce949..d7bc6393f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -134,6 +134,21 @@ dependencies = [
"zerocopy",
]
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
[[package]]
name = "allocator-api2"
version = "0.2.21"
@@ -194,6 +209,12 @@ dependencies = [
"x11rb",
]
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
[[package]]
name = "arrayvec"
version = "0.7.8"
@@ -395,6 +416,12 @@ version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
[[package]]
name = "bit-set"
version = "0.8.0"
@@ -468,6 +495,27 @@ dependencies = [
"piper",
]
+[[package]]
+name = "brotli"
+version = "8.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
[[package]]
name = "bumpalo"
version = "3.20.3"
@@ -684,6 +732,15 @@ dependencies = [
"libc",
]
+[[package]]
+name = "core_maths"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30"
+dependencies = [
+ "libm",
+]
+
[[package]]
name = "crc32fast"
version = "1.5.2"
@@ -807,8 +864,13 @@ dependencies = [
"designcraft-doc",
"designcraft-fonts",
"designcraft-geom",
+ "designcraft-pdf",
"designcraft-render",
"designcraft-tools",
+ "hayro-cmap",
+ "hayro-interpret",
+ "hayro-syntax",
+ "kurbo",
"log",
"serde",
"serde_json",
@@ -836,6 +898,25 @@ dependencies = [
"thiserror 2.0.21",
]
+[[package]]
+name = "designcraft-pdf"
+version = "0.1.0"
+dependencies = [
+ "designcraft-color",
+ "designcraft-compose",
+ "designcraft-doc",
+ "designcraft-fonts",
+ "designcraft-geom",
+ "hayro-cmap",
+ "hayro-interpret",
+ "hayro-syntax",
+ "image",
+ "krilla",
+ "kurbo",
+ "log",
+ "thiserror 2.0.21",
+]
+
[[package]]
name = "designcraft-render"
version = "0.1.0"
@@ -1102,7 +1183,7 @@ dependencies = [
"ecolor",
"emath",
"epaint_default_fonts",
- "font-types",
+ "font-types 0.12.5",
"harfrust 0.12.0",
"log",
"nohash-hasher",
@@ -1217,6 +1298,15 @@ dependencies = [
"zlib-rs",
]
+[[package]]
+name = "float-cmp"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
+dependencies = [
+ "num-traits",
+]
+
[[package]]
name = "fnv"
version = "1.0.7"
@@ -1229,6 +1319,15 @@ version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+[[package]]
+name = "font-types"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b38ad915f6dadd993ced50848a8291a543bd41ca62bc10740d5e64e2ab4cfd7"
+dependencies = [
+ "bytemuck",
+]
+
[[package]]
name = "font-types"
version = "0.12.5"
@@ -1565,6 +1664,82 @@ dependencies = [
"foldhash",
]
+[[package]]
+name = "hayro-ccitt"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f4d0e94ddd48749f06bbe4e5389fb9799a0c45bcaf00495042076ef05e3241a"
+
+[[package]]
+name = "hayro-cmap"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d285dc30731c8485de5fa732fbdf2b3affdf01e4da7c2135022ca6fa664bf6"
+dependencies = [
+ "brotli",
+ "hayro-postscript",
+]
+
+[[package]]
+name = "hayro-interpret"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2613d0406898995042d0794c4245b2f2fba1246490c8ac593769bba6551129d"
+dependencies = [
+ "bitflags 2.13.2",
+ "hayro-cmap",
+ "hayro-syntax",
+ "kurbo",
+ "moxcms",
+ "phf",
+ "rustc-hash 2.1.3",
+ "siphasher",
+ "skrifa 0.42.1",
+ "smallvec",
+ "yoke",
+]
+
+[[package]]
+name = "hayro-jbig2"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69374b3668dd45aeb3d3145cda68f2c7b4f223aaa2511e67d076f1c7d741388d"
+dependencies = [
+ "fearless_simd",
+ "hayro-ccitt",
+]
+
+[[package]]
+name = "hayro-jpeg2000"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c75ab947623ef4ccaa7acf0579edf7cbb5a73838e3839a7be73335e522f433a1"
+dependencies = [
+ "fearless_simd",
+]
+
+[[package]]
+name = "hayro-postscript"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "885c5ef0654933139a9b9546fc2c69e18d37f38aa2520f079092b1be18f1fcaa"
+
+[[package]]
+name = "hayro-syntax"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0edeafd70aa2db743de8ede8637d07ec87db05efe69cde371d03f1b185fcef27"
+dependencies = [
+ "flate2",
+ "hayro-ccitt",
+ "hayro-jbig2",
+ "hayro-jpeg2000",
+ "memchr",
+ "rustc-hash 2.1.3",
+ "smallvec",
+ "zune-jpeg",
+]
+
[[package]]
name = "hermit-abi"
version = "0.5.3"
@@ -1606,6 +1781,12 @@ dependencies = [
"quick-error 2.0.1",
]
+[[package]]
+name = "imagesize"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e54e57b4c48b40f7aec75635392b12b3421fa26fe8b4332e63138ed278459c"
+
[[package]]
name = "indexmap"
version = "2.14.2"
@@ -1727,6 +1908,34 @@ version = "3.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
+[[package]]
+name = "krilla"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27da593198b20eeba65caeb73c2bbeec3e53ab08fa549898312ce81c4fce5e33"
+dependencies = [
+ "base64",
+ "bumpalo",
+ "flate2",
+ "float-cmp",
+ "gif",
+ "image-webp",
+ "imagesize",
+ "indexmap",
+ "pdf-writer",
+ "png",
+ "rustc-hash 2.1.3",
+ "rustybuzz",
+ "siphasher",
+ "skrifa 0.42.1",
+ "smallvec",
+ "subsetter",
+ "tiny-skia-path",
+ "xmp-writer",
+ "yoke",
+ "zune-jpeg",
+]
+
[[package]]
name = "kurbo"
version = "0.13.1"
@@ -2357,6 +2566,18 @@ dependencies = [
"windows-link",
]
+[[package]]
+name = "pdf-writer"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5e456864a7a304047bff84977dc6fb162bd956475d40ba50b2dcecaada7f753"
+dependencies = [
+ "bitflags 2.13.2",
+ "itoa",
+ "memchr",
+ "ryu",
+]
+
[[package]]
name = "peniko"
version = "0.6.1"
@@ -2719,6 +2940,16 @@ dependencies = [
"crossbeam-utils",
]
+[[package]]
+name = "read-fonts"
+version = "0.39.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ed38b89c2c77ff968c524145ad65fb010f38af5c7a224b53b81d47ac2daa81"
+dependencies = [
+ "bytemuck",
+ "font-types 0.11.3",
+]
+
[[package]]
name = "read-fonts"
version = "0.41.0"
@@ -2726,7 +2957,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709"
dependencies = [
"bytemuck",
- "font-types",
+ "font-types 0.12.5",
"once_cell",
]
@@ -2737,7 +2968,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "005c8acf251756c478b0bf402885bfd88a1476020c4c7e6060edc1aa68da38ea"
dependencies = [
"bytemuck",
- "font-types",
+ "font-types 0.12.5",
"once_cell",
]
@@ -2748,7 +2979,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d5a0cf4bb6cbce4c29756270d189a5e400ac05e91192161d83a0bcb6e68492e8"
dependencies = [
"bytemuck",
- "font-types",
+ "font-types 0.12.5",
"once_cell",
]
@@ -2883,6 +3114,30 @@ dependencies = [
"wait-timeout",
]
+[[package]]
+name = "rustybuzz"
+version = "0.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3c7c96f8a08ee34eff8857b11b49b07d71d1c3f4e88f8a88d4c9e9f90b1702"
+dependencies = [
+ "bitflags 2.13.2",
+ "bytemuck",
+ "core_maths",
+ "log",
+ "smallvec",
+ "ttf-parser",
+ "unicode-bidi-mirroring",
+ "unicode-ccc",
+ "unicode-properties",
+ "unicode-script",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
[[package]]
name = "same-file"
version = "1.0.6"
@@ -3014,6 +3269,16 @@ version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256"
+[[package]]
+name = "skrifa"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c34617370ae968efb7161bb2beb517d9084659aae19e24b89e3db25b46e4564"
+dependencies = [
+ "bytemuck",
+ "read-fonts 0.39.2",
+]
+
[[package]]
name = "skrifa"
version = "0.44.0"
@@ -3139,12 +3404,36 @@ dependencies = [
"bitflags 2.13.2",
]
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+[[package]]
+name = "strict-num"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
+
+[[package]]
+name = "subsetter"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38803281d1c23166c5ebcb455439a5d2afe711cc909cf88af72448c297756ad6"
+dependencies = [
+ "kurbo",
+ "rustc-hash 2.1.3",
+ "skrifa 0.42.1",
+ "write-fonts",
+]
+
[[package]]
name = "syn"
version = "2.0.119"
@@ -3167,6 +3456,17 @@ dependencies = [
"unicode-ident",
]
+[[package]]
+name = "synstructure"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
[[package]]
name = "tempfile"
version = "3.27.0"
@@ -3252,6 +3552,17 @@ dependencies = [
"zune-jpeg",
]
+[[package]]
+name = "tiny-skia-path"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edca365c3faccca67d06593c5980fa6c57687de727a03131735bb85f01fdeeb9"
+dependencies = [
+ "arrayref",
+ "bytemuck",
+ "strict-num",
+]
+
[[package]]
name = "tokio"
version = "1.53.1"
@@ -3323,6 +3634,15 @@ dependencies = [
"once_cell",
]
+[[package]]
+name = "ttf-parser"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
+dependencies = [
+ "core_maths",
+]
+
[[package]]
name = "type-map"
version = "0.5.1"
@@ -3349,6 +3669,18 @@ version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+[[package]]
+name = "unicode-bidi-mirroring"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfa6e8c60bb66d49db113e0125ee8711b7647b5579dc7f5f19c42357ed039fe"
+
+[[package]]
+name = "unicode-ccc"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce61d488bcdc9bc8b5d1772c404828b17fc481c0a582b5581e95fb233aef503e"
+
[[package]]
name = "unicode-general-category"
version = "1.1.0"
@@ -3361,6 +3693,18 @@ version = "1.0.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+[[package]]
+name = "unicode-properties"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
+
+[[package]]
+name = "unicode-script"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee"
+
[[package]]
name = "unicode-segmentation"
version = "1.13.3"
@@ -4228,6 +4572,19 @@ version = "0.57.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+[[package]]
+name = "write-fonts"
+version = "0.48.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb731d4c4d93eacc69a1ad2f270f905788a98e4a3438267bcafbe08d3431c8d8"
+dependencies = [
+ "font-types 0.11.3",
+ "indexmap",
+ "kurbo",
+ "log",
+ "read-fonts 0.39.2",
+]
+
[[package]]
name = "x11-dl"
version = "2.21.0"
@@ -4291,6 +4648,12 @@ version = "0.8.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
+[[package]]
+name = "xmp-writer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
+
[[package]]
name = "xtask"
version = "0.1.0"
@@ -4298,6 +4661,29 @@ dependencies = [
"serde_json",
]
+[[package]]
+name = "yoke"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+ "synstructure",
+]
+
[[package]]
name = "zbus"
version = "5.19.0"
@@ -4424,6 +4810,27 @@ dependencies = [
"syn 2.0.119",
]
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+ "synstructure",
+]
+
[[package]]
name = "zlib-rs"
version = "0.6.8"
diff --git a/ROADMAP.md b/ROADMAP.md
index 14206957e..def9f5233 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -10,9 +10,10 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope
- Rendering: vello_cpu (SIMD, multithreaded) — pages, items, images with mip levels, gradients, composed text.
- UI (egui): application bar + menus, Control panel (object and text modes), Tools panel with flyouts, document tabs, rulers, pasteboard, guides (margins, columns, bleed, baseline grid), frame edges, selection handles, text ports and threads, Properties / Pages / Layers dock, Swatches, Styles, Character, Paragraph, Stroke, Text Wrap panels, New Document dialog, ⌘K palette, 4 brightness themes.
- Tools: Selection (click, marquee, move, Alt-duplicate, resize handles), Direct Selection (basic), Type (draw frame, click caret, select, type), Rectangle/Ellipse/Polygon (+ frame variants), Line, Hand, Zoom.
+- PDF export (krilla): real selectable text with embedded font subsets, DeviceCMYK/RGB + spot Separations, bleed boxes, crop/bleed marks + page info, pages or spreads, PDF/A-2b (PDF/X-4 output intent pending) — `file.exportPdf`, File › Export PDF…, `designcraft-cli run --export out.pdf`.
- ~100 commands, all reachable through the JSON control channel; headless CLI rendering to PNG.
-**Next (in order):** MCP server · PDF export (krilla, PDF/X-4) · IDML import/export · native format as zip · web build · Pen tool & Direct Selection anchors · Story Editor · Find/Change (+GREP) · tables · Liang hyphenation · smart guides · Links panel + relink · Preflight · TOC/index/footnotes · EPUB.
+**Next (in order):** MCP server · PDF/X-4 output intent, bookmarks, tagged PDF · IDML import/export · native format as zip · web build · Pen tool & Direct Selection anchors · Story Editor · Find/Change (+GREP) · tables · Liang hyphenation · smart guides · Links panel + relink · Preflight · TOC/index/footnotes · EPUB.
## Milestones
@@ -24,7 +25,7 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope
| M3 | Styles (nested/GREP, bullets, keeps, span columns) | started |
| M4 | Color & effects | started |
| M5 | Graphics & links | started |
-| M6 | Files & export (native, IDML, PDF, PNG/JPEG) | next |
+| M6 | Files & export (native, IDML, PDF, PNG/JPEG) | in progress (PDF export) |
| M7 | Long documents (sections, TOC, index, footnotes, books) | |
| M8 | Tables | |
| M9 | Performance (MT composition, tiles) | |
diff --git a/apps/designcraft-cli/src/main.rs b/apps/designcraft-cli/src/main.rs
index 03977eedb..4555c9623 100644
--- a/apps/designcraft-cli/src/main.rs
+++ b/apps/designcraft-cli/src/main.rs
@@ -1,7 +1,7 @@
//! Headless DesignCraft.
//!
//! ```text
-//! designcraft-cli run [--in FILE | --sample] [--cmd ID[=JSON]]... [--page N] [--scale S] [--export OUT.png|.jpg|.designcraft] [--all-pages DIR]
+//! designcraft-cli run [--in FILE | --sample] [--cmd ID[=JSON]]... [--page N] [--scale S] [--export OUT.png|.jpg|.pdf|.designcraft] [--pdf-options JSON] [--all-pages DIR]
//! designcraft-cli commands # list every command (JSON)
//! designcraft-cli mcp [--connect PORT] # MCP server over stdio
//! ```
@@ -22,7 +22,7 @@ fn main() -> ExitCode {
Some("mcp") => report(mcp(&args[1..])),
_ => {
eprintln!(
- "usage: designcraft-cli run [--in FILE | --sample] [--cmd ID[=JSON]]... [--page N] [--scale S] [--export OUT] [--all-pages DIR]\n designcraft-cli commands\n designcraft-cli mcp [--connect PORT]"
+ "usage: designcraft-cli run [--in FILE | --sample] [--cmd ID[=JSON]]... [--page N] [--scale S] [--pdf-options JSON] [--export OUT] [--all-pages DIR]\n designcraft-cli commands\n designcraft-cli mcp [--connect PORT]"
);
ExitCode::FAILURE
}
@@ -49,6 +49,7 @@ fn run(args: &[String]) -> Result<(), String> {
let mut scale = 1.0f64;
let mut it = args.iter();
let mut opened = false;
+ let mut pdf_opts = json!({});
while let Some(a) = it.next() {
let mut val = || it.next().cloned().ok_or_else(|| format!("{a} needs a value"));
match a.as_str() {
@@ -76,9 +77,22 @@ fn run(args: &[String]) -> Result<(), String> {
}
"--page" => page = val()?.parse().map_err(|_| "bad --page")?,
"--scale" => scale = val()?.parse().map_err(|_| "bad --scale")?,
+ "--pdf-options" => {
+ pdf_opts = serde_json::from_str(&val()?).map_err(|e| format!("--pdf-options: {e}"))?;
+ }
"--export" => {
let out = val()?;
- export(&mut s, &out, page, scale)?;
+ if out.ends_with(".pdf") {
+ let mut p = pdf_opts.clone();
+ p["path"] = json!(out);
+ let r = s.execute("file.exportPdf", &p).map_err(|e| e.to_string())?;
+ eprintln!("wrote {out} ({} pages, {} bytes)", r["pages"], r["bytes"]);
+ for w in r["warnings"].as_array().into_iter().flatten() {
+ eprintln!("warning: {}", w.as_str().unwrap_or_default());
+ }
+ } else {
+ export(&mut s, &out, page, scale)?;
+ }
}
"--all-pages" => {
let dir = val()?;
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index 5d9e5ec56..237690cf3 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -15,8 +15,15 @@ designcraft-doc = { workspace = true }
designcraft-fonts = { workspace = true }
designcraft-compose = { workspace = true }
designcraft-render = { workspace = true }
+designcraft-pdf = { workspace = true }
designcraft-tools = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
log = { workspace = true }
+
+[dev-dependencies]
+hayro-syntax = "0.7.2"
+hayro-interpret = { version = "0.7.0", default-features = false, features = ["embed-fonts"] }
+hayro-cmap = "0.1"
+kurbo = { workspace = true }
diff --git a/crates/engine/src/cmd/export.rs b/crates/engine/src/cmd/export.rs
new file mode 100644
index 000000000..6a8e118b9
--- /dev/null
+++ b/crates/engine/src/cmd/export.rs
@@ -0,0 +1,88 @@
+//! File › Export: Adobe PDF (Print).
+
+use designcraft_pdf::{Marks, PdfOptions, Standard};
+use serde_json::{Value, json};
+
+use super::{CommandSpec, bad, cmd, has_doc, str_param};
+use crate::{EngineError, Result, Session};
+
+pub fn specs() -> Vec<CommandSpec> {
+ vec![cmd!(noundo "file.exportPdf", "Export PDF…", ["File"], None,
+ "{path?, pages?: \"1-3,5\" | [1,3] (1-based positions; default all), spreads?: bool, bleed?: bool (document bleed), marks?: bool | {crop?, bleed?, pageInfo?, weight?, offset?}, standard?: \"none\"|\"x4\"|\"a2b\", compressImages?: bool, title?, author?} → {path, bytes, pages, warnings} (no path: {base64, …})",
+ has_doc, export_pdf)]
+}
+
+pub(crate) fn options(p: &Value, page_count: usize) -> Result<PdfOptions> {
+ const ID: &str = "file.exportPdf";
+
+ let pages = match p.get("pages") {
+ None | Some(Value::Null) => None,
+ Some(Value::String(s)) => Some(designcraft_pdf::parse_page_range(s, page_count).map_err(|e| bad(ID, e.to_string()))?),
+ Some(Value::Array(a)) => {
+ let mut v = Vec::new();
+ for x in a {
+ let n = x.as_u64().filter(|n| *n >= 1 && (*n as usize) <= page_count).ok_or_else(|| bad(ID, format!("bad page {x}")))?;
+ v.push(n as usize - 1);
+ }
+ Some(v)
+ }
+ Some(Value::Number(n)) => {
+ let n = n.as_u64().filter(|n| *n >= 1 && (*n as usize) <= page_count).ok_or_else(|| bad(ID, format!("bad page {n}")))?;
+ Some(vec![n as usize - 1])
+ }
+ Some(v) => return Err(bad(ID, format!("bad `pages`: {v}"))),
+ };
+ let spreads = p.get("spreads").and_then(Value::as_bool).unwrap_or(false);
+ let bleed = p.get("bleed").and_then(Value::as_bool).unwrap_or(false);
+ let marks = match p.get("marks") {
+ Some(Value::Bool(true)) => Marks::ALL,
+ Some(Value::Object(m)) => {
+ let b = |k: &str| m.get(k).and_then(Value::as_bool).unwrap_or(false);
+ Marks {
+ crop: b("crop"),
+ bleed: b("bleed"),
+ page_info: b("pageInfo"),
+ weight: m.get("weight").and_then(Value::as_f64).unwrap_or(0.25),
+ offset: m.get("offset").and_then(Value::as_f64).unwrap_or(6.0),
+ }
+ }
+ _ => Marks::NONE,
+ };
+ let standard = match str_param(p, "standard") {
+ Some(s) => Standard::parse(s).ok_or_else(|| bad(ID, format!("unknown standard `{s}` (none, x4, a2b)")))?,
+ None => Standard::None,
+ };
+ Ok(PdfOptions {
+ pages,
+ spreads,
+ bleed,
+ marks,
+ standard,
+ compress_images: p.get("compressImages").and_then(Value::as_bool).unwrap_or(false),
+ title: str_param(p, "title").map(str::to_string),
+ author: str_param(p, "author").map(str::to_string),
+ ..PdfOptions::default()
+ })
+}
+
+fn export_pdf(s: &mut Session, p: &Value) -> Result<Value> {
+ let st = s.doc()?;
+ let opts = options(p, st.doc.page_count())?;
+ let r = designcraft_pdf::export_pdf_with_report(&st.doc, &s.cache, &opts).map_err(|e| EngineError::Other(e.to_string()))?;
+ match str_param(p, "path") {
+ Some(path) => {
+ write_file(path, &r.bytes)?;
+ Ok(json!({"path": path, "bytes": r.bytes.len(), "pages": r.pages, "warnings": r.warnings}))
+ }
+ None => Ok(json!({"base64": super::base64_encode(&r.bytes), "bytes": r.bytes.len(), "pages": r.pages, "warnings": r.warnings})),
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn write_file(path: &str, bytes: &[u8]) -> Result<()> {
+ std::fs::write(path, bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))
+}
+#[cfg(target_arch = "wasm32")]
+fn write_file(path: &str, _bytes: &[u8]) -> Result<()> {
+ Err(EngineError::Other(format!("{path}: no file system on the web; omit `path` to get the bytes")))
+}
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index a95f2882a..94a68a3e1 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -1,6 +1,7 @@
//! The command registry. Ids follow InDesign's menu structure.
mod edit;
+mod export;
mod file;
mod inspect;
mod layout;
@@ -100,6 +101,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
SPECS.get_or_init(|| {
let mut v = Vec::new();
v.extend(file::specs());
+ v.extend(export::specs());
v.extend(edit::specs());
v.extend(object::specs());
v.extend(text::specs());
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 736b73ab9..1f085450b 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -104,3 +104,69 @@ fn every_command_has_metadata() {
}
assert!(command_specs().len() > 60);
}
+
+/// Unicode text per page, through hayro's interpreter (ToUnicode / ActualText).
+fn pdf_text(bytes: &[u8]) -> Vec<String> {
+ use hayro_interpret::font::Glyph;
+ use hayro_interpret::{
+ BlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, Paint, PathDrawMode, SoftMask,
+ interpret_page,
+ };
+ struct Ex(String);
+ impl Device<'_> for Ex {
+ fn set_soft_mask(&mut self, _: Option<SoftMask<'_>>) {}
+ fn set_blend_mode(&mut self, _: BlendMode) {}
+ fn draw_path(&mut self, _: &kurbo::BezPath, _: kurbo::Affine, _: &Paint<'_>, _: &PathDrawMode) {}
+ fn push_clip_path(&mut self, _: &ClipPath) {}
+ fn push_transparency_group(&mut self, _: f32, _: Option<SoftMask<'_>>, _: BlendMode) {}
+ fn draw_glyph(&mut self, g: &Glyph<'_>, _: kurbo::Affine, _: kurbo::Affine, _: &Paint<'_>, _: &GlyphDrawMode) {
+ match g.as_unicode() {
+ Some(hayro_cmap::BfString::Char(c)) => self.0.push(c),
+ Some(hayro_cmap::BfString::String(s)) => self.0.push_str(&s),
+ None => self.0.push('\u{FFFD}'),
+ }
+ }
+ fn draw_image(&mut self, _: Image<'_, '_>, _: kurbo::Affine) {}
+ fn pop_clip_path(&mut self) {}
+ fn pop_transparency_group(&mut self) {}
+ }
+ let pdf = hayro_syntax::Pdf::new(bytes.to_vec()).expect("valid PDF");
+ let cache = InterpreterCache::new();
+ pdf.pages()
+ .iter()
+ .map(|page| {
+ let mut ctx =
+ Context::new(kurbo::Affine::IDENTITY, kurbo::Rect::new(0.0, 0.0, 1.0, 1.0), &cache, pdf.xref(), InterpreterSettings::default());
+ let mut ex = Ex(String::new());
+ interpret_page(page, &mut ctx, &mut ex);
+ ex.0
+ })
+ .collect()
+}
+
+#[test]
+fn export_pdf_of_the_sample() {
+ let mut s = Session::new();
+ s.execute("file.newSample", &json!({})).unwrap();
+ let r = s.execute("file.exportPdf", &json!({"bleed": true, "marks": true})).unwrap();
+ assert_eq!(r["pages"], 4);
+ let bytes = cmd::base64_decode(r["base64"].as_str().unwrap());
+ assert!(bytes.starts_with(b"%PDF-"));
+ let pdf = hayro_syntax::Pdf::new(bytes.clone()).expect("parse");
+ assert_eq!(pdf.pages().len(), 4);
+ let raw = String::from_utf8_lossy(&bytes);
+ assert!(raw.contains("/FontFile2") || raw.contains("/FontFile3"), "fonts embedded");
+ let text = pdf_text(&bytes);
+ let all: String = text.join("\n");
+ assert!(all.contains("Notes on the Grid"), "{all}");
+ // Page range + spreads + file output.
+ let dir = std::env::temp_dir().join(format!("dc-pdf-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let path = dir.join("out.pdf");
+ let r = s.execute("file.exportPdf", &json!({"path": path.to_string_lossy(), "pages": "2-3", "spreads": true})).unwrap();
+ assert_eq!(r["pages"], 1, "pages 2–3 are one spread");
+ assert!(std::fs::read(&path).unwrap().starts_with(b"%PDF-"));
+ std::fs::remove_dir_all(&dir).ok();
+ assert!(s.execute("file.exportPdf", &json!({"pages": "9"})).is_err());
+ assert!(s.execute("file.exportPdf", &json!({"standard": "bogus"})).is_err());
+}
diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rs
index 28c1167dc..5cade71bb 100644
--- a/crates/fonts/src/fontdb.rs
+++ b/crates/fonts/src/fontdb.rs
@@ -78,6 +78,10 @@ impl FontFace {
pub fn hb(&self) -> Option<harfrust::FontRef<'_>> {
harfrust::FontRef::from_index(self.data(), self.index).ok()
}
+ /// Face index within the font file (collections); 0 for plain fonts.
+ pub fn index(&self) -> u32 {
+ self.index
+ }
/// Unique id of this face within the process.
pub fn id(&self) -> u32 {
self.id
diff --git a/crates/pdf/Cargo.toml b/crates/pdf/Cargo.toml
new file mode 100644
index 000000000..f9aaa8244
--- /dev/null
+++ b/crates/pdf/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "designcraft-pdf"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "DesignCraft PDF export (krilla): real text with embedded font subsets, CMYK/spot colour, bleed and printer's marks"
+
+[lints]
+workspace = true
+
+[dependencies]
+designcraft-geom = { workspace = true }
+designcraft-color = { workspace = true }
+designcraft-doc = { workspace = true }
+designcraft-fonts = { workspace = true }
+designcraft-compose = { workspace = true }
+krilla = { workspace = true }
+image = { workspace = true }
+thiserror = { workspace = true }
+log = { workspace = true }
+
+[dev-dependencies]
+hayro-syntax = "0.7.2"
+hayro-interpret = { version = "0.7.0", default-features = false, features = ["embed-fonts"] }
+hayro-cmap = "0.1"
+kurbo = { workspace = true }
diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rs
new file mode 100644
index 000000000..1ad75b508
--- /dev/null
+++ b/crates/pdf/src/export.rs
@@ -0,0 +1,659 @@
+//! Document → PDF. The item walk mirrors `designcraft-render`'s `draw_spread` / `draw_item`.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use designcraft_color::swatch::{ColorType, SwatchValue};
+use designcraft_color::{BlendMode as DcBlend, Color, GradientKind};
+use designcraft_compose::Cache;
+use designcraft_doc::{AssetId, Content, Document, Item, PageSide, Spread, StrokeAlign, StrokeType};
+use designcraft_geom::kurbo::{PathEl, Shape as _};
+use designcraft_geom::{Affine, BezPath, Rect, Vec2, corners};
+use krilla::color::{cmyk, luma, rgb};
+use krilla::configure::{Archival, ConfigurationBuilder, PdfVersion};
+use krilla::geom::{Path, PathBuilder, Size, Transform};
+use krilla::image::Image;
+use krilla::metadata::Metadata;
+use krilla::num::NormalizedF32;
+use krilla::page::PageSettings;
+use krilla::paint::{Fill, FillRule, LinearGradient, RadialGradient, SpreadMethod, Stop, Stroke, StrokeDash};
+use krilla::surface::Surface;
+
+use crate::{ExportReport, PdfError, PdfOptions, Result, Standard};
+
+/// Export `doc` as PDF bytes.
+pub fn export_pdf(doc: &Document, cache: &Cache, opts: &PdfOptions) -> Result<Vec<u8>> {
+ export_pdf_with_report(doc, cache, opts).map(|r| r.bytes)
+}
+
+/// One output page: a document page or a spread, in spread coordinates.
+pub(crate) struct Sheet {
+ pub spread: usize,
+ pub trim: Rect,
+ pub bleed: Rect,
+ pub media: Rect,
+ /// Page name(s) for the page-information mark.
+ pub label: String,
+}
+
+pub(crate) const MARK_LEN: f64 = 18.0;
+
+fn bleed_lr(side: PageSide, b: [f64; 4]) -> (f64, f64) {
+ // Bleed is top, bottom, inside, outside; single-sided pages read inside as left.
+ if side == PageSide::Left { (b[3], b[2]) } else { (b[2], b[3]) }
+}
+
+fn sheets(doc: &Document, opts: &PdfOptions) -> Result<Vec<Sheet>> {
+ let count = doc.page_count();
+ let pages: Vec<usize> = match &opts.pages {
+ Some(v) => v.clone(),
+ None => (0..count).collect(),
+ };
+ if pages.is_empty() {
+ return Err(PdfError::NoPages);
+ }
+ if let Some(bad) = pages.iter().find(|p| **p >= count) {
+ return Err(PdfError::BadPage(bad + 1));
+ }
+ let b = doc.settings.bleed.map(|v| if opts.bleed { v.max(0.0) } else { 0.0 });
+ let mut out: Vec<Sheet> = Vec::new();
+ let mut seen_spreads: Vec<usize> = Vec::new();
+ for abs in pages {
+ let (si, pi) = doc.page_loc(abs).ok_or(PdfError::BadPage(abs + 1))?;
+ let sp: &Spread = &doc.spreads[si];
+ let (trim, l, r, label) = if opts.spreads {
+ if seen_spreads.contains(&si) {
+ continue;
+ }
+ seen_spreads.push(si);
+ let first = doc.first_page_of_spread(si);
+ let (l, _) = sp.pages.first().map(|p| bleed_lr(p.side, b)).unwrap_or((b[2], b[3]));
+ let (_, r) = sp.pages.last().map(|p| bleed_lr(p.side, b)).unwrap_or((b[2], b[3]));
+ let names: Vec<String> = (0..sp.pages.len()).map(|i| doc.page_name(first + i)).collect();
+ (sp.bounds(), l, r, names.join("–"))
+ } else {
+ let p = &sp.pages[pi];
+ let (l, r) = bleed_lr(p.side, b);
+ (p.bounds(), l, r, doc.page_name(abs))
+ };
+ let bleed = Rect::new(trim.x0 - l, trim.y0 - b[0], trim.x1 + r, trim.y1 + b[1]);
+ let media = if opts.marks.any() {
+ let m = mark_start(opts, b) + MARK_LEN + 6.0;
+ trim.inflate(m, m)
+ } else {
+ bleed
+ };
+ out.push(Sheet { spread: si, trim, bleed, media, label });
+ }
+ Ok(out)
+}
+
+/// Distance from the trim edge where marks start: the offset, but never inside the bleed.
+pub(crate) fn mark_start(opts: &PdfOptions, bleed: [f64; 4]) -> f64 {
+ bleed.iter().copied().fold(opts.marks.offset.max(0.0), f64::max)
+}
+
+/// Like [`export_pdf`], also returning warnings about approximated or dropped features.
+pub fn export_pdf_with_report(doc: &Document, cache: &Cache, opts: &PdfOptions) -> Result<ExportReport> {
+ let sheets = sheets(doc, opts)?;
+ let mut warnings = Vec::new();
+ let (version, archival) = match opts.standard {
+ Standard::None => (PdfVersion::Pdf17, None),
+ Standard::PdfX4 => {
+ warnings.push(
+ "PDF/X-4: the output intent and PDF/X identification are not written yet; the file is PDF 1.6 with trim and bleed boxes".to_string(),
+ );
+ (PdfVersion::Pdf16, None)
+ }
+ Standard::PdfA2b => (PdfVersion::Pdf17, Some(Archival::A2_B)),
+ };
+ let mut cb = ConfigurationBuilder::new().with_version(version);
+ if let Some(a) = archival {
+ cb = cb.with_archival_validator(a);
+ }
+ let configuration = cb.finish().map_err(|e| PdfError::Write(format!("{e:?}")))?;
+ let settings = krilla::SerializeSettings { compress_content_streams: opts.compress, configuration, ..Default::default() };
+ let mut pdf = krilla::Document::new_with(settings);
+
+ let title = opts.title.clone().unwrap_or_else(|| doc.title.clone());
+ let mut meta = Metadata::new().creator("DesignCraft".into()).producer("DesignCraft".into());
+ if !title.is_empty() {
+ meta = meta.title(title.clone());
+ }
+ if let Some(a) = &opts.author {
+ meta = meta.authors(vec![a.clone()]);
+ }
+ let created = opts.created.or_else(now_unix);
+ if let Some(t) = created {
+ let c = civil(t);
+ meta = meta.creation_date(
+ krilla::metadata::DateTime::new(c.0.clamp(0, 9999) as u16)
+ .month(c.1)
+ .day(c.2)
+ .hour(c.3)
+ .minute(c.4)
+ .second(c.5)
+ .utc_offset_hour(0)
+ .utc_offset_minute(0),
+ );
+ }
+ pdf.set_metadata(meta);
+
+ let mut ex = Exporter {
+ doc,
+ cache,
+ opts,
+ clip: Rect::ZERO,
+ warnings,
+ images: HashMap::new(),
+ fonts: HashMap::new(),
+ reverse_cmaps: HashMap::new(),
+ rgb_only: archival.is_some(),
+ };
+ if ex.rgb_only {
+ ex.warn("PDF/A: CMYK colours were converted to RGB (no CMYK output intent profile is available yet)");
+ }
+ for sh in &sheets {
+ let size = Size::from_wh(sh.media.width().max(1.0) as f32, sh.media.height().max(1.0) as f32).ok_or(PdfError::NoPages)?;
+ let local = |r: Rect| {
+ krilla::geom::Rect::from_ltrb(
+ (r.x0 - sh.media.x0) as f32,
+ (r.y0 - sh.media.y0) as f32,
+ (r.x1 - sh.media.x0) as f32,
+ (r.y1 - sh.media.y0) as f32,
+ )
+ };
+ let settings = PageSettings::new(size).with_trim_box(local(sh.trim)).with_bleed_box(local(sh.bleed));
+ let mut page = pdf.start_page_with(settings);
+ let mut s = page.surface();
+ s.push_transform(&tf(Affine::translate(-sh.media.origin().to_vec2())));
+ ex.clip = sh.bleed;
+ if let Some(clip) = to_path(&sh.bleed.to_path(0.1)) {
+ s.push_clip_path(&clip, &FillRule::NonZero);
+ ex.spread(&mut s, sh.spread);
+ s.pop();
+ }
+ ex.marks(&mut s, sh, &title, created);
+ s.pop();
+ s.finish();
+ page.finish();
+ }
+ let bytes = pdf.finish().map_err(|e| PdfError::Write(format!("{e:?}")))?;
+ let mut warnings = ex.warnings;
+ warnings.dedup();
+ Ok(ExportReport { bytes, pages: sheets.len(), warnings })
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn now_unix() -> Option<i64> {
+ use std::time::{SystemTime, UNIX_EPOCH};
+ SystemTime::now().duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs() as i64)
+}
+#[cfg(target_arch = "wasm32")]
+fn now_unix() -> Option<i64> {
+ None
+}
+
+/// Unix seconds (UTC) → (year, month, day, hour, minute, second), proleptic Gregorian.
+pub(crate) fn civil(t: i64) -> (i64, u8, u8, u8, u8, u8) {
+ let days = t.div_euclid(86_400);
+ let secs = t.rem_euclid(86_400);
+ let z = days + 719_468;
+ let era = z.div_euclid(146_097);
+ let doe = z - era * 146_097;
+ let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+ let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+ let mp = (5 * doy + 2) / 153;
+ let day = doy - (153 * mp + 2) / 5 + 1;
+ let month = if mp < 10 { mp + 3 } else { mp - 9 };
+ let year = yoe + era * 400 + i64::from(month <= 2);
+ (year, month as u8, day as u8, (secs / 3600) as u8, (secs / 60 % 60) as u8, (secs % 60) as u8)
+}
+
+pub(crate) struct Exporter<'a> {
+ pub doc: &'a Document,
+ pub cache: &'a Cache,
+ pub opts: &'a PdfOptions,
+ /// Current sheet's visible area (spread space) for culling.
+ pub clip: Rect,
+ pub warnings: Vec<String>,
+ images: HashMap<AssetId, Option<Image>>,
+ pub fonts: HashMap<u32, Option<krilla::text::Font>>,
+ pub reverse_cmaps: HashMap<u32, Arc<HashMap<u32, char>>>,
+ /// Convert CMYK to RGB (PDF/A: krilla needs a CMYK output profile we don't ship yet).
+ pub rgb_only: bool,
+}
+
+pub(crate) fn tf(a: Affine) -> Transform {
+ let c = a.as_coeffs();
+ Transform::from_row(c[0] as f32, c[1] as f32, c[2] as f32, c[3] as f32, c[4] as f32, c[5] as f32)
+}
+
+pub(crate) fn to_path(bp: &BezPath) -> Option<Path> {
+ let mut pb = PathBuilder::new();
+ for el in bp.elements() {
+ match *el {
+ PathEl::MoveTo(p) => pb.move_to(p.x as f32, p.y as f32),
+ PathEl::LineTo(p) => pb.line_to(p.x as f32, p.y as f32),
+ PathEl::QuadTo(a, p) => pb.quad_to(a.x as f32, a.y as f32, p.x as f32, p.y as f32),
+ PathEl::CurveTo(a, b, p) => pb.cubic_to(a.x as f32, a.y as f32, b.x as f32, b.y as f32, p.x as f32, p.y as f32),
+ PathEl::ClosePath => pb.close(),
+ }
+ }
+ pb.finish()
+}
+
+pub(crate) fn norm(v: f32) -> NormalizedF32 {
+ NormalizedF32::new(if v.is_finite() { v.clamp(0.0, 1.0) } else { 1.0 }).unwrap_or(NormalizedF32::ONE)
+}
+
+fn q(v: f32) -> u8 {
+ (v.clamp(0.0, 1.0) * 255.0).round() as u8
+}
+
+fn regular(c: &Color, rgb_only: bool) -> krilla::color::RegularColor {
+ use krilla::color::RegularColor as R;
+ if rgb_only && matches!(c, Color::Cmyk { .. }) {
+ let [r, g, b] = c.to_rgb();
+ return R::Rgb(rgb::Color::new(q(r), q(g), q(b)));
+ }
+ match *c {
+ Color::Rgb { r, g, b } => R::Rgb(rgb::Color::new(q(r), q(g), q(b))),
+ Color::Cmyk { c, m, y, k } => R::Cmyk(cmyk::Color::new(q(c), q(m), q(y), q(k))),
+ // DesignCraft grey is ink coverage (0 = white); PDF DeviceGray is lightness.
+ Color::Gray { k } => R::Luma(luma::Color::new(q(1.0 - k))),
+ }
+}
+
+/// A process colour in its own device space (CMYK → DeviceCMYK, RGB → DeviceRGB, Gray → DeviceGray).
+/// `rgb_only` converts CMYK to RGB (PDF/A without a CMYK output profile).
+pub(crate) fn device(c: &Color, rgb_only: bool) -> krilla::color::Color {
+ match regular(c, rgb_only) {
+ krilla::color::RegularColor::Rgb(v) => v.into(),
+ krilla::color::RegularColor::Cmyk(v) => v.into(),
+ krilla::color::RegularColor::Luma(v) => v.into(),
+ }
+}
+
+/// `[Registration]` prints on every plate: `/Separation /All`.
+pub(crate) fn registration(tint: f32, rgb_only: bool) -> krilla::color::Color {
+ use krilla::color::separation::{Color as SepColor, SeparationColorant, SeparationSpace};
+ let alt = regular(&Color::cmyk(1.0, 1.0, 1.0, 1.0), rgb_only);
+ SepColor::new(q(tint), SeparationSpace::new(SeparationColorant::AllColorants, alt)).into()
+}
+
+fn blend(b: DcBlend) -> krilla::blend::BlendMode {
+ use krilla::blend::BlendMode as K;
+ match b {
+ DcBlend::Normal => K::Normal,
+ DcBlend::Darken => K::Darken,
+ DcBlend::Multiply => K::Multiply,
+ DcBlend::ColorBurn => K::ColorBurn,
+ DcBlend::Lighten => K::Lighten,
+ DcBlend::Screen => K::Screen,
+ DcBlend::ColorDodge => K::ColorDodge,
+ DcBlend::Overlay => K::Overlay,
+ DcBlend::SoftLight => K::SoftLight,
+ DcBlend::HardLight => K::HardLight,
+ DcBlend::Difference => K::Difference,
+ DcBlend::Exclusion => K::Exclusion,
+ DcBlend::Hue => K::Hue,
+ DcBlend::Saturation => K::Saturation,
+ DcBlend::Color => K::Color,
+ DcBlend::Luminosity => K::Luminosity,
+ }
+}
+
+fn rects_overlap(a: Rect, b: Rect) -> bool {
+ a.x0 <= b.x1 && b.x0 <= a.x1 && a.y0 <= b.y1 && b.y0 <= a.y1
+}
+
+pub(crate) fn solid_fill(c: krilla::color::Color, opacity: f32) -> Fill {
+ Fill { paint: c.into(), opacity: norm(opacity), rule: FillRule::NonZero }
+}
+
+impl Exporter<'_> {
+ pub(crate) fn warn(&mut self, w: impl Into<String>) {
+ let w = w.into();
+ if !self.warnings.contains(&w) {
+ self.warnings.push(w);
+ }
+ }
+
+ /// A swatch + tint as a PDF colour: spot swatches (and tints of them) become `/Separation`
+ /// with the swatch's values as the alternate space; process colours stay in their device space.
+ pub(crate) fn swatch_color(&self, name: &str, tint: f32) -> Option<krilla::color::Color> {
+ use krilla::color::separation::{Color as SepColor, SeparationColorant, SeparationSpace};
+ let mut n = name;
+ let mut t = tint;
+ for _ in 0..8 {
+ let sw = self.doc.swatch(n)?;
+ match &sw.value {
+ SwatchValue::None => return None,
+ SwatchValue::Tint { base, tint: bt } => {
+ t *= bt;
+ n = base;
+ }
+ SwatchValue::Registration => return Some(registration(t, self.rgb_only)),
+ SwatchValue::Color { color, color_type: ColorType::Spot } => {
+ let space = SeparationSpace::new(SeparationColorant::Custom(sw.name.clone()), regular(color, self.rgb_only));
+ return Some(SepColor::new(q(t), space).into());
+ }
+ _ => break,
+ }
+ }
+ self.doc.resolve_color(name, tint).map(|c| device(&c, self.rgb_only))
+ }
+
+ fn spread(&mut self, s: &mut Surface, si: usize) {
+ let doc = self.doc;
+ let Some(sp) = doc.spreads.get(si) else { return };
+ let first = doc.first_page_of_spread(si);
+ for layer in doc.layers.iter().rev() {
+ if !layer.visible || !layer.printable {
+ continue;
+ }
+ for (pi, page) in sp.pages.iter().enumerate() {
+ if !page.show_parent_items {
+ continue;
+ }
+ let Some((ppi, ppage)) = doc.parent_page_for(first + pi) else { continue };
+ let parent = &doc.parents[ppi];
+ let dx = page.x - parent.pages[ppage].x;
+ let page_name = doc.page_name(first + pi);
+ for it in &parent.items {
+ if it.layer != layer.id || page.overridden.contains(&it.id) {
+ continue;
+ }
+ // Parent items belong to the parent page they sit on.
+ if parent.page_at_x(it.bounds().center().x) != Some(ppage) && parent.pages.len() > 1 {
+ continue;
+ }
+ self.item(s, it, Affine::translate((dx, 0.0)), Some(&page_name));
+ }
+ }
+ for it in &sp.items {
+ if it.layer == layer.id {
+ self.item(s, it, Affine::IDENTITY, None);
+ }
+ }
+ }
+ }
+
+ /// Push blend/opacity for an item drawn as a group. Returns the number of pushes.
+ fn push_group(s: &mut Surface, opacity: f32, mode: DcBlend) -> usize {
+ let mut n = 0;
+ if mode != DcBlend::Normal {
+ s.push_blend_mode(blend(mode));
+ n += 1;
+ }
+ if opacity < 0.999 {
+ s.push_opacity(norm(opacity));
+ n += 1;
+ } else if mode != DcBlend::Normal {
+ s.push_isolated();
+ n += 1;
+ }
+ n
+ }
+
+ fn item(&mut self, s: &mut Surface, it: &Item, parent: Affine, page_name: Option<&str>) {
+ if it.hidden || it.nonprinting {
+ return;
+ }
+ let ds = &it.effects.drop_shadow;
+ let grow = it.stroke.weight + 2.0 + if ds.on { ds.distance.abs() + ds.size.abs() } else { 0.0 };
+ let vb = parent.transform_rect_bbox(it.bounds()).inflate(grow, grow);
+ if !rects_overlap(vb, self.clip) {
+ return;
+ }
+ let xf = parent * it.xf;
+ if !it.children().is_empty() {
+ let pushes = Self::push_group(s, it.opacity, it.blend);
+ for c in it.children() {
+ self.item(s, c, xf, page_name);
+ }
+ for _ in 0..pushes {
+ s.pop();
+ }
+ return;
+ }
+ let doc = self.doc;
+ let bp = if it.corners.is_none() { it.path.to_bezpath() } else { corners::apply(&it.path, &it.corners) };
+ let path = to_path(&bp);
+ let pushes = Self::push_group(s, it.opacity, it.blend);
+ // Drop shadow (simple offset silhouette, like the renderer).
+ if ds.on
+ && let Some(p) = &path
+ && let Some(c) = self.swatch_color(&ds.color, 1.0)
+ {
+ let a = ds.angle.to_radians();
+ let off = Vec2::new(-a.cos() * ds.distance, a.sin() * ds.distance);
+ s.push_transform(&tf(Affine::translate(off) * xf));
+ s.set_stroke(None);
+ s.set_fill(Some(solid_fill(c, ds.opacity)));
+ s.draw_path(p);
+ s.set_fill(None);
+ s.pop();
+ }
+ s.push_transform(&tf(xf));
+ // Fill.
+ if !it.fill.is_none()
+ && it.path.is_closed()
+ && let Some(p) = &path
+ && let Some(paint) = self.fill_paint(&it.fill.swatch, it.fill.tint, bp.bounding_box(), it.fill.gradient_angle)
+ {
+ if it.fill.overprint {
+ self.warn("overprint is not exported yet");
+ }
+ s.set_stroke(None);
+ s.set_fill(Some(Fill { paint, opacity: NormalizedF32::ONE, rule: FillRule::NonZero }));
+ s.draw_path(p);
+ s.set_fill(None);
+ }
+ // Content.
+ match &it.content {
+ Content::Graphic(g) => {
+ if let Some(p) = &path {
+ s.push_clip_path(p, &FillRule::NonZero);
+ self.graphic(s, g);
+ s.pop();
+ }
+ }
+ Content::Text(tfr) => {
+ let cs = self.cache.get(doc, tfr.story, page_name);
+ if let Some(ft) = cs.frame(it.id) {
+ let text = doc.story(tfr.story).map(|st| st.text.as_str()).unwrap_or("");
+ self.frame_text(s, &cs, ft, text);
+ }
+ }
+ _ => {}
+ }
+ // Stroke.
+ if !it.stroke.is_none()
+ && let Some(p) = &path
+ {
+ self.stroke(s, it, &bp, p);
+ }
+ s.pop();
+ for _ in 0..pushes {
+ s.pop();
+ }
+ }
+
+ /// A swatch fill (solid or gradient) in the item's inner space. `None` for [None]/unknown.
+ fn fill_paint(&self, swatch: &str, tint: f32, bounds: Rect, angle: Option<f64>) -> Option<krilla::paint::Paint> {
+ if let Some(g) = designcraft_color::swatch::resolve_gradient(&self.doc.swatches, swatch) {
+ let mut stops: Vec<Stop> = Vec::new();
+ let mut last = 0.0f32;
+ for (o, c, a) in g.expanded_stops() {
+ let o = o.clamp(last, 1.0);
+ last = o;
+ stops.push(Stop { offset: norm(o), color: device(&c, self.rgb_only), opacity: norm(a) });
+ }
+ if stops.is_empty() {
+ return None;
+ }
+ let c = bounds.center();
+ return Some(match g.kind {
+ GradientKind::Radial => {
+ let r = (bounds.width().max(bounds.height()) / 2.0).max(1e-3) as f32;
+ let (cx, cy) = (c.x as f32, c.y as f32);
+ RadialGradient {
+ fx: cx,
+ fy: cy,
+ fr: 0.0,
+ cx,
+ cy,
+ cr: r,
+ transform: Transform::identity(),
+ spread_method: SpreadMethod::Pad,
+ stops,
+ anti_alias: false,
+ }
+ .into()
+ }
+ _ => {
+ let a = angle.unwrap_or(0.0).to_radians();
+ let half = ((bounds.width() * a.cos().abs() + bounds.height() * a.sin().abs()) / 2.0).max(1e-3);
+ let d = Vec2::new(a.cos(), -a.sin()) * half;
+ let (p0, p1) = (c - d, c + d);
+ LinearGradient {
+ x1: p0.x as f32,
+ y1: p0.y as f32,
+ x2: p1.x as f32,
+ y2: p1.y as f32,
+ transform: Transform::identity(),
+ spread_method: SpreadMethod::Pad,
+ stops,
+ anti_alias: false,
+ }
+ .into()
+ }
+ });
+ }
+ self.swatch_color(swatch, tint).map(Into::into)
+ }
+
+ fn stroke(&mut self, s: &mut Surface, it: &Item, bp: &BezPath, path: &Path) {
+ let st = &it.stroke;
+ let Some(c) = self.swatch_color(&st.swatch, st.tint) else { return };
+ let closed = it.path.is_closed();
+ let mut cap = match st.cap {
+ designcraft_doc::Cap::Butt => krilla::paint::LineCap::Butt,
+ designcraft_doc::Cap::Round => krilla::paint::LineCap::Round,
+ designcraft_doc::Cap::Projecting => krilla::paint::LineCap::Square,
+ };
+ let dash = match &st.kind {
+ StrokeType::Dashed { pattern } if pattern.iter().any(|v| *v > 0.0) => {
+ let mut pat: Vec<f32> = pattern.iter().map(|v| v.max(0.0) as f32).collect();
+ if pat.len() % 2 == 1 {
+ pat.extend(pat.clone());
+ }
+ Some(StrokeDash { array: pat, offset: 0.0 })
+ }
+ StrokeType::Dotted => {
+ cap = krilla::paint::LineCap::Round;
+ Some(StrokeDash { array: vec![0.0, (st.weight * 2.0) as f32], offset: 0.0 })
+ }
+ StrokeType::Solid | StrokeType::Dashed { .. } => None,
+ _ => {
+ self.warn("striped stroke types are exported as solid strokes");
+ None
+ }
+ };
+ let aligned = closed && st.align != StrokeAlign::Center;
+ let width = if aligned { st.weight * 2.0 } else { st.weight };
+ let mut pushes = 0;
+ match st.align {
+ StrokeAlign::Inside if closed => {
+ s.push_clip_path(path, &FillRule::NonZero);
+ pushes += 1;
+ }
+ StrokeAlign::Outside if closed => {
+ // Clip to everything outside the path: a big frame plus the path, even-odd.
+ let b = bp.bounding_box().inflate(width * 2.0 + 10.0, width * 2.0 + 10.0);
+ let mut outside = b.to_path(0.1);
+ outside.extend(bp.iter());
+ if let Some(p) = to_path(&outside) {
+ s.push_clip_path(&p, &FillRule::EvenOdd);
+ pushes += 1;
+ }
+ }
+ _ => {}
+ }
+ s.set_fill(None);
+ s.set_stroke(Some(Stroke {
+ paint: c.into(),
+ width: width as f32,
+ miter_limit: st.miter_limit.max(1.0) as f32,
+ line_cap: cap,
+ line_join: match st.join {
+ designcraft_doc::Join::Miter => krilla::paint::LineJoin::Miter,
+ designcraft_doc::Join::Round => krilla::paint::LineJoin::Round,
+ designcraft_doc::Join::Bevel => krilla::paint::LineJoin::Bevel,
+ },
+ opacity: NormalizedF32::ONE,
+ dash,
+ }));
+ s.draw_path(path);
+ s.set_stroke(None);
+ for _ in 0..pushes {
+ s.pop();
+ }
+ }
+
+ fn load_image(&mut self, id: AssetId) -> Option<Image> {
+ if let Some(i) = self.images.get(&id) {
+ return i.clone();
+ }
+ let asset = self.doc.assets.get(&id)?.clone();
+ let data = asset.data.clone();
+ let fmt = image::guess_format(&data).ok();
+ let img = match fmt {
+ Some(image::ImageFormat::Jpeg) => Image::from_jpeg(data.clone().into(), true).ok(),
+ _ if self.opts.compress_images => recompress(&data).or_else(|| lossless(&data, fmt)),
+ _ => lossless(&data, fmt),
+ };
+ if img.is_none() {
+ self.warn(format!("image `{}` could not be decoded and was skipped", asset.name));
+ }
+ self.images.insert(id, img.clone());
+ img
+ }
+
+ fn graphic(&mut self, s: &mut Surface, g: &designcraft_doc::Graphic) {
+ let Some(img) = self.load_image(g.asset) else { return };
+ let Some(size) = Size::from_wh(g.size.0.max(1e-3) as f32, g.size.1.max(1e-3) as f32) else { return };
+ s.push_transform(&tf(g.xf));
+ s.draw_image(img, size);
+ s.pop();
+ }
+}
+
+fn lossless(data: &Arc<Vec<u8>>, fmt: Option<image::ImageFormat>) -> Option<Image> {
+ let direct = match fmt {
+ Some(image::ImageFormat::Png) => Image::from_png(data.clone().into(), true).ok(),
+ Some(image::ImageFormat::Gif) => Image::from_gif(data.clone().into(), true).ok(),
+ Some(image::ImageFormat::WebP) => Image::from_webp(data.clone().into(), true).ok(),
+ _ => None,
+ };
+ direct.or_else(|| {
+ let rgba = image::load_from_memory(data).ok()?.to_rgba8();
+ let (w, h) = rgba.dimensions();
+ Some(Image::from_rgba8(rgba.into_raw(), w, h))
+ })
+}
+
+/// Opaque raster → JPEG (quality 90). `None` when the image has transparency or can't be decoded.
+fn recompress(data: &[u8]) -> Option<Image> {
+ let img = image::load_from_memory(data).ok()?;
+ if img.color().has_alpha() && img.to_rgba8().pixels().any(|p| p[3] < 255) {
+ return None;
+ }
+ let rgb = img.to_rgb8();
+ let mut buf = Vec::new();
+ let enc = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut buf, 90);
+ image::ImageEncoder::write_image(enc, rgb.as_raw(), rgb.width(), rgb.height(), image::ExtendedColorType::Rgb8).ok()?;
+ Image::from_jpeg(buf.into(), true).ok()
+}
diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs
new file mode 100644
index 000000000..0c645c107
--- /dev/null
+++ b/crates/pdf/src/lib.rs
@@ -0,0 +1,188 @@
+//! DesignCraft PDF export (print), written with `krilla`.
+//!
+//! [`export_pdf`] writes one PDF page per document page (or per spread) and mirrors the renderer's
+//! walk (`designcraft-render`): layers back to front, parent items first (with page-number markers
+//! resolved for each page), then the spread's own items. What goes into the file:
+//!
+//! - **Boxes:** MediaBox = trim + bleed (+ room for printer's marks), TrimBox = the page, BleedBox =
+//! page + document bleed. Content is clipped to the bleed box.
+//! - **Vectors:** fills (solid and gradient swatches), strokes with alignment, dashes, caps, joins
+//! and miter limits, corner options, opacity and blend modes (transparency groups), the simple
+//! drop shadow.
+//! - **Colour:** CMYK as DeviceCMYK, RGB as DeviceRGB, Gray as DeviceGray, spot swatches (and their
+//! tints) as `/Separation` with the swatch's own values as the alternate space, `[Registration]`
+//! as `/Separation /All`.
+//! - **Images:** clipped to their frame; JPEG data is passed through, PNG/GIF/WebP are embedded
+//! losslessly (or re-encoded as JPEG with [`PdfOptions::compress_images`]).
+//! - **Text as real text:** the composed glyph runs are emitted with embedded, subsetted fonts and a
+//! Unicode mapping taken from the story text (ligatures, page numbers and inserted hyphens get the
+//! right characters), so text is selectable and searchable.
+//! - **Marks:** crop marks, bleed marks and a page-information line, drawn in `[Registration]`.
+//! - **Standards:** PDF/A-2b through krilla's validator. PDF/X-4 writes PDF 1.6 with trim/bleed
+//! boxes, but the PDF/X output intent and identification are not written yet (krilla 0.8 has no
+//! PDF/X support) — the export report says so.
+//!
+//! Not yet: tagged PDF, bookmarks, hyperlinks, overprint, layers as optional content.
+#![forbid(unsafe_code)]
+
+mod export;
+mod marks;
+mod text;
+
+pub use export::{export_pdf, export_pdf_with_report};
+
+/// PDF standard to target.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Standard {
+ /// Plain PDF 1.7.
+ #[default]
+ None,
+ /// PDF/X-4 (PDF 1.6, trim/bleed boxes). TODO: OutputIntent + GTS_PDFXVersion once krilla
+ /// supports PDF/X.
+ PdfX4,
+ /// PDF/A-2b (archival; validated by krilla).
+ PdfA2b,
+}
+
+impl Standard {
+ /// `none`, `x4` / `pdfx4` / `PDF/X-4`, `a2b` / `pdfa2b` / `PDF/A-2b`.
+ pub fn parse(s: &str) -> Option<Self> {
+ let k: String = s.chars().filter(|c| c.is_ascii_alphanumeric()).collect::<String>().to_ascii_lowercase();
+ match k.as_str() {
+ "" | "none" => Some(Self::None),
+ "x4" | "pdfx4" | "pdfx42008" | "pdfx42010" => Some(Self::PdfX4),
+ "a2b" | "pdfa2b" => Some(Self::PdfA2b),
+ _ => None,
+ }
+ }
+}
+
+/// Printer's marks (Export PDF › Marks and Bleeds).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Marks {
+ pub crop: bool,
+ pub bleed: bool,
+ /// Document title, page name, date — in the slug area under the page.
+ pub page_info: bool,
+ /// Line weight in points (0.25 default).
+ pub weight: f64,
+ /// Distance of the marks from the trim edge in points (6 default). Marks never start inside
+ /// the bleed.
+ pub offset: f64,
+}
+
+impl Marks {
+ pub const NONE: Marks = Marks { crop: false, bleed: false, page_info: false, weight: 0.25, offset: 6.0 };
+ pub const ALL: Marks = Marks { crop: true, bleed: true, page_info: true, weight: 0.25, offset: 6.0 };
+ pub fn any(&self) -> bool {
+ self.crop || self.bleed || self.page_info
+ }
+}
+
+impl Default for Marks {
+ fn default() -> Self {
+ Self::NONE
+ }
+}
+
+/// Export options.
+#[derive(Clone, Debug)]
+pub struct PdfOptions {
+ /// 0-based absolute page indices to export, in order; `None` = all pages.
+ pub pages: Option<Vec<usize>>,
+ /// One PDF page per spread (spreads containing any chosen page) instead of per page.
+ pub spreads: bool,
+ /// Include the document bleed (`DocSettings::bleed`) around each page.
+ pub bleed: bool,
+ pub marks: Marks,
+ pub standard: Standard,
+ /// Re-encode non-JPEG raster images as JPEG (quality 90) when they have no transparency.
+ /// Off = lossless (JPEG data is always passed through unchanged).
+ pub compress_images: bool,
+ /// Flate-compress content streams.
+ pub compress: bool,
+ /// Title for the metadata; `None` = the document title.
+ pub title: Option<String>,
+ pub author: Option<String>,
+ /// Creation date as Unix seconds (UTC); `None` = now (native) / omitted (wasm).
+ pub created: Option<i64>,
+}
+
+impl Default for PdfOptions {
+ fn default() -> Self {
+ Self {
+ pages: None,
+ spreads: false,
+ bleed: false,
+ marks: Marks::NONE,
+ standard: Standard::None,
+ compress_images: false,
+ compress: true,
+ title: None,
+ author: None,
+ created: None,
+ }
+ }
+}
+
+/// Bytes plus non-fatal warnings (features approximated or dropped).
+#[derive(Clone, Debug)]
+pub struct ExportReport {
+ pub bytes: Vec<u8>,
+ pub pages: usize,
+ pub warnings: Vec<String>,
+}
+
+#[derive(Debug, thiserror::Error, PartialEq)]
+pub enum PdfError {
+ #[error("nothing to export (no pages selected)")]
+ NoPages,
+ #[error("page {0} does not exist")]
+ BadPage(usize),
+ #[error("bad page range `{0}`")]
+ BadRange(String),
+ #[error("PDF writer error: {0}")]
+ Write(String),
+}
+
+pub type Result<T> = std::result::Result<T, PdfError>;
+
+/// Parse a 1-based page range like `"1-3, 5, 8-"` into 0-based indices (`count` pages in the
+/// document). `""` / `"all"` = every page.
+pub fn parse_page_range(s: &str, count: usize) -> Result<Vec<usize>> {
+ let t = s.trim();
+ if t.is_empty() || t.eq_ignore_ascii_case("all") {
+ return Ok((0..count).collect());
+ }
+ let bad = || PdfError::BadRange(s.to_string());
+ let num = |v: &str| v.trim().parse::<usize>().map_err(|_| bad());
+ let mut out = Vec::new();
+ for part in t.split(',').map(str::trim).filter(|p| !p.is_empty()) {
+ let (a, b) = match part.split_once('-') {
+ Some((a, b)) => {
+ let a = if a.trim().is_empty() { 1 } else { num(a)? };
+ let b = if b.trim().is_empty() { count } else { num(b)? };
+ (a, b)
+ }
+ None => {
+ let v = num(part)?;
+ (v, v)
+ }
+ };
+ if a == 0 || b == 0 || a > b {
+ return Err(bad());
+ }
+ for p in a..=b {
+ if p > count {
+ return Err(PdfError::BadPage(p));
+ }
+ if !out.contains(&(p - 1)) {
+ out.push(p - 1);
+ }
+ }
+ }
+ Ok(out)
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/pdf/src/marks.rs b/crates/pdf/src/marks.rs
new file mode 100644
index 000000000..a2dab3356
--- /dev/null
+++ b/crates/pdf/src/marks.rs
@@ -0,0 +1,68 @@
+//! Printer's marks drawn in the slug area: crop marks at the trim corners, bleed marks at the bleed
+//! corners, and a page-information line. All marks use `[Registration]` (every plate).
+
+use designcraft_geom::{BezPath, Point};
+use krilla::num::NormalizedF32;
+use krilla::paint::{LineCap, LineJoin, Stroke};
+use krilla::surface::Surface;
+
+use crate::export::{Exporter, MARK_LEN, Sheet, civil, mark_start, registration, to_path};
+
+impl Exporter<'_> {
+ pub(crate) fn marks(&mut self, s: &mut Surface, sh: &Sheet, title: &str, created: Option<i64>) {
+ let m = self.opts.marks;
+ if !m.any() {
+ return;
+ }
+ let bleed = if self.opts.bleed { self.doc.settings.bleed.map(|v| v.max(0.0)) } else { [0.0; 4] };
+ let start = mark_start(self.opts, bleed);
+ let t = sh.trim;
+ let mut bp = BezPath::new();
+ let mut seg = |a: (f64, f64), b: (f64, f64)| {
+ bp.move_to(Point::new(a.0, a.1));
+ bp.line_to(Point::new(b.0, b.1));
+ };
+ if m.crop {
+ // Each trim corner: a horizontal mark beside it and a vertical one above/below it.
+ for (x, sx) in [(t.x0, -1.0), (t.x1, 1.0)] {
+ for (y, sy) in [(t.y0, -1.0), (t.y1, 1.0)] {
+ seg((x + sx * start, y), (x + sx * (start + MARK_LEN), y));
+ seg((x, y + sy * start), (x, y + sy * (start + MARK_LEN)));
+ }
+ }
+ }
+ let b = sh.bleed;
+ if m.bleed && (b.x0 < t.x0 || b.y0 < t.y0 || b.x1 > t.x1 || b.y1 > t.y1) {
+ // Shorter marks on the bleed lines, outside the crop-mark start.
+ let len = MARK_LEN / 2.0;
+ for (x, bx, sx) in [(t.x0, b.x0, -1.0), (t.x1, b.x1, 1.0)] {
+ for (y, by, sy) in [(t.y0, b.y0, -1.0), (t.y1, b.y1, 1.0)] {
+ seg((x + sx * start, by), (x + sx * (start + len), by));
+ seg((bx, y + sy * start), (bx, y + sy * (start + len)));
+ }
+ }
+ }
+ if let Some(p) = to_path(&bp) {
+ s.set_fill(None);
+ s.set_stroke(Some(Stroke {
+ paint: registration(1.0, self.rgb_only).into(),
+ width: m.weight.max(0.05) as f32,
+ miter_limit: 4.0,
+ line_cap: LineCap::Butt,
+ line_join: LineJoin::Miter,
+ opacity: NormalizedF32::ONE,
+ dash: None,
+ }));
+ s.draw_path(&p);
+ s.set_stroke(None);
+ }
+ if m.page_info {
+ let mut info = format!("{title} Page {}", sh.label);
+ if let Some(c) = created.map(civil) {
+ info.push_str(&format!(" {:04}-{:02}-{:02} {:02}:{:02} UTC", c.0, c.1, c.2, c.3, c.4));
+ }
+ let at = (t.x0 + start + 6.0, t.y1 + start + 10.0);
+ self.plain_text(s, &info, at, 6.0, registration(1.0, self.rgb_only));
+ }
+ }
+}
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
new file mode 100644
index 000000000..4697e3e57
--- /dev/null
+++ b/crates/pdf/src/tests.rs
@@ -0,0 +1,161 @@
+use designcraft_color::swatch::{ColorType, SwatchValue};
+use designcraft_color::{Color, Swatch};
+use designcraft_compose::Cache;
+use designcraft_doc::build::NewDocument;
+use designcraft_doc::{Document, Fill, Item, ItemId, ParaFormat, SpreadRef};
+use designcraft_geom::Rect;
+
+use crate::*;
+
+fn doc_with_text(text: &str) -> Document {
+ let mut d = Document::new(&NewDocument { pages: 2, ..NewDocument::default() });
+ let lid = d.default_layer();
+ d.add_text_frame(SpreadRef::Doc(0), Rect::new(36.0, 36.0, 576.0, 300.0), lid, text, ParaFormat::default()).unwrap();
+ d
+}
+
+fn add_box(d: &mut Document, r: Rect, swatch: &str) {
+ let lid = d.default_layer();
+ let id = ItemId(d.alloc());
+ let mut b = Item::new(id, lid, designcraft_doc::Shape::Rectangle, designcraft_geom::shapes::rectangle(r));
+ b.fill = Fill::swatch(swatch);
+ d.insert_item(SpreadRef::Doc(0), b, None).unwrap();
+}
+
+fn uncompressed(d: &Document, opts: PdfOptions) -> String {
+ let bytes = export_pdf(d, &Cache::new(), &PdfOptions { compress: false, ..opts }).expect("export");
+ String::from_utf8_lossy(&bytes).into_owned()
+}
+
+/// Text of every page through hayro's interpreter (glyph → Unicode via ToUnicode / ActualText).
+pub(crate) fn extract_text(bytes: &[u8]) -> Vec<String> {
+ use hayro_interpret::font::Glyph;
+ use hayro_interpret::{
+ BlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, Paint, PathDrawMode, SoftMask,
+ interpret_page,
+ };
+ use hayro_syntax::Pdf;
+ struct Ex(String);
+ impl Device<'_> for Ex {
+ fn set_soft_mask(&mut self, _: Option<SoftMask<'_>>) {}
+ fn set_blend_mode(&mut self, _: BlendMode) {}
+ fn draw_path(&mut self, _: &kurbo::BezPath, _: kurbo::Affine, _: &Paint<'_>, _: &PathDrawMode) {}
+ fn push_clip_path(&mut self, _: &ClipPath) {}
+ fn push_transparency_group(&mut self, _: f32, _: Option<SoftMask<'_>>, _: BlendMode) {}
+ fn draw_glyph(&mut self, g: &Glyph<'_>, _: kurbo::Affine, _: kurbo::Affine, _: &Paint<'_>, _: &GlyphDrawMode) {
+ match g.as_unicode() {
+ Some(hayro_cmap::BfString::Char(c)) => self.0.push(c),
+ Some(hayro_cmap::BfString::String(s)) => self.0.push_str(&s),
+ None => self.0.push('\u{FFFD}'),
+ }
+ }
+ fn draw_image(&mut self, _: Image<'_, '_>, _: kurbo::Affine) {}
+ fn pop_clip_path(&mut self) {}
+ fn pop_transparency_group(&mut self) {}
+ }
+ let pdf = Pdf::new(bytes.to_vec()).expect("parse");
+ let cache = InterpreterCache::new();
+ pdf.pages()
+ .iter()
+ .map(|page| {
+ let mut ctx =
+ Context::new(kurbo::Affine::IDENTITY, kurbo::Rect::new(0.0, 0.0, 1.0, 1.0), &cache, pdf.xref(), InterpreterSettings::default());
+ let mut ex = Ex(String::new());
+ interpret_page(page, &mut ctx, &mut ex);
+ ex.0
+ })
+ .collect()
+}
+
+#[test]
+fn exports_valid_pdf_with_one_page_per_page() {
+ let d = doc_with_text("Hello DesignCraft");
+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap();
+ assert!(bytes.starts_with(b"%PDF-1.7"));
+ let pdf = hayro_syntax::Pdf::new(bytes.clone()).expect("parse");
+ assert_eq!(pdf.pages().len(), 2);
+}
+
+#[test]
+fn text_is_real_text() {
+ let d = doc_with_text("Hello DesignCraft — efficient affine");
+ let s = uncompressed(&d, PdfOptions::default());
+ assert!(s.contains("/FontFile2") || s.contains("/FontFile3"), "font embedded");
+ assert!(s.contains("/ToUnicode"));
+ assert!(s.contains(")Tj") || s.contains("]TJ"), "text operators");
+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions::default()).unwrap();
+ let text = extract_text(&bytes);
+ let flat: String = text[0].split_whitespace().collect::<Vec<_>>().join(" ");
+ assert!(flat.contains("Hello"), "{flat}");
+ assert!(text[0].contains("DesignCraft"), "{text:?}");
+ assert!(text[0].contains("efficient") && text[0].contains("affine"), "ligatures map back: {text:?}");
+}
+
+#[test]
+fn colours_keep_their_space() {
+ let mut d = doc_with_text("x");
+ add_box(&mut d, Rect::new(36.0, 400.0, 136.0, 500.0), "C=100 M=0 Y=0 K=0");
+ d.swatches.push(Swatch::color("Brand Red", Color::rgb(0.9, 0.1, 0.1)));
+ add_box(&mut d, Rect::new(200.0, 400.0, 300.0, 500.0), "Brand Red");
+ d.swatches.push(Swatch {
+ name: "PANTONE Test".into(),
+ value: SwatchValue::Color { color: Color::cmyk(0.0, 0.5, 1.0, 0.0), color_type: ColorType::Spot },
+ locked: false,
+ named: true,
+ });
+ add_box(&mut d, Rect::new(320.0, 400.0, 420.0, 500.0), "PANTONE Test");
+ let s = uncompressed(&d, PdfOptions::default());
+ assert!(s.contains("1 0 0 0 k"), "DeviceCMYK fill");
+ assert!(s.contains(" rg"), "DeviceRGB fill");
+ assert!(s.contains("/Separation") && s.contains("/PANTONE#20Test"), "spot as Separation");
+}
+
+#[test]
+fn boxes_bleed_and_marks() {
+ let mut d = doc_with_text("x");
+ d.settings.bleed = [9.0; 4];
+ let s = uncompressed(&d, PdfOptions { bleed: true, ..Default::default() });
+ assert!(s.contains("/TrimBox[9 9 621 801]"), "{}", &s[..s.len().min(4000)]);
+ assert!(s.contains("/MediaBox[0 0 630 810]"));
+ assert!(s.contains("/BleedBox[0 0 630 810]"));
+ let s = uncompressed(&d, PdfOptions { bleed: true, marks: Marks::ALL, pages: Some(vec![1]), ..Default::default() });
+ // margin = max(offset 6, bleed 9) + 18 + 6 = 33
+ assert!(s.contains("/MediaBox[0 0 678 858]"), "marks area");
+ assert!(s.contains("/All"), "registration colour");
+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions { marks: Marks::ALL, pages: Some(vec![1]), ..Default::default() }).unwrap();
+ let t = extract_text(&bytes);
+ assert_eq!(t.len(), 1);
+ assert!(t[0].contains("Page 2"), "{t:?}");
+}
+
+#[test]
+fn spreads_and_ranges() {
+ let mut d = Document::new(&NewDocument { pages: 4, facing_pages: true, ..NewDocument::default() });
+ let _ = &mut d;
+ let n = d.page_count();
+ assert_eq!(n, 4);
+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions { spreads: true, ..Default::default() }).unwrap();
+ let pages = hayro_syntax::Pdf::new(bytes).unwrap().pages().len();
+ assert_eq!(pages, d.spreads.len());
+ assert_eq!(parse_page_range("1-2, 4", 4).unwrap(), vec![0, 1, 3]);
+ assert_eq!(parse_page_range("3-", 4).unwrap(), vec![2, 3]);
+ assert_eq!(parse_page_range("", 2).unwrap(), vec![0, 1]);
+ assert!(parse_page_range("5", 4).is_err());
+ assert!(parse_page_range("x", 4).is_err());
+ let bytes = export_pdf(&d, &Cache::new(), &PdfOptions { pages: Some(vec![1, 2]), ..Default::default() }).unwrap();
+ assert_eq!(hayro_syntax::Pdf::new(bytes).unwrap().pages().len(), 2);
+ assert_eq!(export_pdf(&d, &Cache::new(), &PdfOptions { pages: Some(vec![9]), ..Default::default() }), Err(PdfError::BadPage(10)));
+}
+
+#[test]
+fn standards() {
+ let d = doc_with_text("Archive me");
+ let r = export_pdf_with_report(&d, &Cache::new(), &PdfOptions { standard: Standard::PdfA2b, created: Some(1_700_000_000), ..Default::default() });
+ let r = r.expect("PDF/A-2b export");
+ assert!(String::from_utf8_lossy(&r.bytes).contains("pdfaid"));
+ let r = export_pdf_with_report(&d, &Cache::new(), &PdfOptions { standard: Standard::PdfX4, ..Default::default() }).unwrap();
+ assert!(r.bytes.starts_with(b"%PDF-1.6"));
+ assert!(!r.warnings.is_empty());
+ assert_eq!(Standard::parse("PDF/X-4"), Some(Standard::PdfX4));
+ assert_eq!(Standard::parse("pdfa-2b"), Some(Standard::PdfA2b));
+}
diff --git a/crates/pdf/src/text.rs b/crates/pdf/src/text.rs
new file mode 100644
index 000000000..d36bd9618
--- /dev/null
+++ b/crates/pdf/src/text.rs
@@ -0,0 +1,256 @@
+//! Composed text → PDF text objects with embedded (subsetted) fonts.
+//!
+//! Each line is split into runs of glyphs sharing face, style, scale and baseline offset. A run is
+//! drawn with one `draw_glyphs` call: the run origin, horizontal scale and skew go into the
+//! transform, glyph advances are taken from the composed x positions (so justification, tracking
+//! and kerning are exact), and every glyph carries the story text it came from so viewers can
+//! select, search and copy it.
+
+use std::collections::HashMap;
+use std::ops::Range;
+use std::sync::Arc;
+
+use designcraft_compose::{ComposedStory, FrameText, PlacedGlyph};
+use designcraft_fonts::{FontDb, FontFace};
+use designcraft_geom::kurbo::Shape as _;
+use designcraft_geom::{Affine, BezPath, Rect};
+use krilla::geom::Point;
+use krilla::paint::Stroke;
+use krilla::surface::Surface;
+use krilla::text::{Font, GlyphId, KrillaGlyph};
+
+use crate::export::{Exporter, solid_fill, tf, to_path};
+
+/// Private-use characters DesignCraft stores for markers (page numbers, section markers, breaks).
+fn is_marker(c: char) -> bool {
+ ('\u{E000}'..='\u{E0FF}').contains(&c)
+}
+
+fn same_run(a: &PlacedGlyph, b: &PlacedGlyph) -> bool {
+ b.visible
+ && a.face.id() == b.face.id()
+ && a.style == b.style
+ && (a.sx - b.sx).abs() < 1e-9
+ && (a.sy - b.sy).abs() < 1e-9
+ && (a.y - b.y).abs() < 1e-6
+}
+
+impl Exporter<'_> {
+ pub(crate) fn font(&mut self, face: &FontFace) -> Option<Font> {
+ self.fonts.entry(face.id()).or_insert_with(|| Font::new(face.data().to_vec().into(), face.index())).clone()
+ }
+
+ fn reverse_cmap(&mut self, face: &FontFace) -> Arc<HashMap<u32, char>> {
+ self.reverse_cmaps
+ .entry(face.id())
+ .or_insert_with(|| {
+ let mut m = HashMap::new();
+ // Sorted by code point: the lowest code point wins (`-` before U+2010).
+ for (c, g) in face.chars() {
+ m.entry(g).or_insert(c);
+ }
+ Arc::new(m)
+ })
+ .clone()
+ }
+
+ pub(crate) fn frame_text(&mut self, s: &mut Surface, cs: &ComposedStory, ft: &FrameText, story: &str) {
+ // Paragraph shading and rules under the text.
+ for d in &ft.decos {
+ if let Some(c) = self.swatch_color(&d.color, d.tint) {
+ self.fill_rect(s, d.rect, c);
+ }
+ }
+ let mut deco: Vec<(u32, Rect)> = Vec::new();
+ for l in &ft.lines {
+ let gs = &l.glyphs;
+ let mut i = 0;
+ while i < gs.len() {
+ let g = &gs[i];
+ if !g.visible || g.sx <= 0.0 || g.sy <= 0.0 {
+ i += 1;
+ continue;
+ }
+ let mut j = i + 1;
+ while j < gs.len() && same_run(g, &gs[j]) {
+ j += 1;
+ }
+ self.run(s, cs, &gs[i..j], l.baseline, story);
+ i = j;
+ }
+ // Underline / strikethrough, merged per style along the line.
+ for g in gs.iter().filter(|g| g.visible) {
+ let st = &cs.styles[g.style as usize];
+ let w = st.size / 14.0;
+ let mut add = |y: f64| {
+ let r = Rect::new(g.x, y, g.x + g.adv, y + w);
+ match deco.last_mut() {
+ Some((si, last)) if *si == g.style && (last.y0 - r.y0).abs() < 1e-6 && (r.x0 - last.x1).abs() < 0.5 => last.x1 = r.x1,
+ _ => deco.push((g.style, r)),
+ }
+ };
+ if st.underline {
+ add(l.baseline + st.size * 0.12);
+ }
+ if st.strikethrough {
+ add(l.baseline - st.size * 0.3);
+ }
+ }
+ }
+ for (si, r) in deco {
+ let st = &cs.styles[si as usize];
+ if let Some(c) = self.swatch_color(&st.fill, st.fill_tint) {
+ self.fill_rect(s, r, c);
+ }
+ }
+ }
+
+ fn fill_rect(&self, s: &mut Surface, r: Rect, c: krilla::color::Color) {
+ if let Some(p) = to_path(&r.to_path(0.1)) {
+ s.set_stroke(None);
+ s.set_fill(Some(solid_fill(c, 1.0)));
+ s.draw_path(&p);
+ s.set_fill(None);
+ }
+ }
+
+ /// Unicode text for a run's glyphs: (text, per-glyph byte range into it).
+ fn run_text(&mut self, glyphs: &[PlacedGlyph], story: &str) -> (String, Vec<Range<usize>>) {
+ let cmap = self.reverse_cmap(&glyphs[0].face);
+ let mut text = String::new();
+ let mut ranges: Vec<Range<usize>> = Vec::with_capacity(glyphs.len());
+ // Byte of the previous glyph when it came straight from the story (cluster continuation).
+ let mut prev_src: Option<usize> = None;
+ for g in glyphs {
+ let src = story.get(g.byte..g.byte + g.len).filter(|t| !t.is_empty() && !t.chars().any(is_marker));
+ let range = if let Some(t) = src {
+ prev_src = Some(g.byte);
+ let a = text.len();
+ text.push_str(t);
+ a..text.len()
+ } else if g.len == 0 && prev_src == Some(g.byte) && !ranges.is_empty() {
+ // Second glyph of a multi-glyph cluster: share the cluster's text.
+ ranges[ranges.len() - 1].clone()
+ } else {
+ // Inserted glyphs (page numbers, list labels, hyphens): map back through the font.
+ prev_src = None;
+ match cmap.get(&g.gid) {
+ Some(c) => {
+ let a = text.len();
+ text.push(*c);
+ a..text.len()
+ }
+ None => match ranges.last() {
+ Some(r) => r.clone(),
+ None => {
+ text.push('\u{FFFD}');
+ 0..text.len()
+ }
+ },
+ }
+ };
+ ranges.push(range);
+ }
+ (text, ranges)
+ }
+
+ fn run(&mut self, s: &mut Surface, cs: &ComposedStory, glyphs: &[PlacedGlyph], baseline: f64, story: &str) {
+ let g0 = &glyphs[0];
+ let st = &cs.styles[g0.style as usize];
+ let fill = self.swatch_color(&st.fill, st.fill_tint);
+ let stroke =
+ if st.stroke != designcraft_color::swatch::NONE && st.stroke_weight > 0.0 { self.swatch_color(&st.stroke, st.stroke_tint) } else { None };
+ if fill.is_none() && stroke.is_none() {
+ return;
+ }
+ let face = g0.face.clone();
+ let size = g0.sy * face.upem;
+ let hs = g0.sx / g0.sy;
+ let skew = if st.skew != 0.0 { Affine::new([1.0, 0.0, -st.skew.to_radians().tan(), 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };
+ let origin = Affine::translate((g0.x, baseline + g0.y)) * skew * Affine::scale_non_uniform(hs, 1.0);
+ let Some(font) = self.font(&face) else {
+ self.warn(format!("font `{} {}` could not be embedded; its text was drawn as outlines", face.family, face.style));
+ self.outline_run(s, glyphs, origin, size, fill, stroke, st.stroke_weight);
+ return;
+ };
+ let (text, ranges) = self.run_text(glyphs, story);
+ let k = 1.0 / (hs * size);
+ let kg: Vec<KrillaGlyph> = glyphs
+ .iter()
+ .zip(ranges)
+ .enumerate()
+ .map(|(i, (g, r))| {
+ let next = glyphs.get(i + 1).map_or(g.x + g.adv, |n| n.x);
+ KrillaGlyph::new(GlyphId::new(g.gid), ((next - g.x) * k) as f32, 0.0, 0.0, 0.0, r, None)
+ })
+ .collect();
+ s.push_transform(&tf(origin));
+ s.set_fill(fill.map(|c| solid_fill(c, 1.0)));
+ s.set_stroke(stroke.map(|c| Stroke { paint: c.into(), width: st.stroke_weight as f32, ..Default::default() }));
+ s.draw_glyphs(Point::from_xy(0.0, 0.0), &kg, font, &text, size as f32, false);
+ s.set_fill(None);
+ s.set_stroke(None);
+ s.pop();
+ }
+
+ /// Fallback for faces krilla can't embed: glyph outlines as paths.
+ #[allow(clippy::too_many_arguments)]
+ fn outline_run(
+ &mut self,
+ s: &mut Surface,
+ glyphs: &[PlacedGlyph],
+ origin: Affine,
+ size: f64,
+ fill: Option<krilla::color::Color>,
+ stroke: Option<krilla::color::Color>,
+ stroke_weight: f64,
+ ) {
+ let db = FontDb::global();
+ let g0 = &glyphs[0];
+ let k = size / g0.face.upem;
+ let mut bp = BezPath::new();
+ for g in glyphs {
+ let a = Affine::translate(((g.x - g0.x) / (g0.sx / g0.sy), 0.0)) * Affine::scale(k);
+ let mut o = (*db.outline(&g.face, g.gid)).clone();
+ o.apply_affine(a);
+ bp.extend(o.iter());
+ }
+ let Some(p) = to_path(&bp) else { return };
+ s.push_transform(&tf(origin));
+ s.set_fill(fill.map(|c| solid_fill(c, 1.0)));
+ s.set_stroke(stroke.map(|c| Stroke { paint: c.into(), width: stroke_weight as f32, ..Default::default() }));
+ s.draw_path(&p);
+ s.set_fill(None);
+ s.set_stroke(None);
+ s.pop();
+ }
+
+ /// One line of plain text in the bundled UI face (page information mark).
+ pub(crate) fn plain_text(&mut self, s: &mut Surface, text: &str, at: (f64, f64), size: f64, color: krilla::color::Color) {
+ let face = FontDb::global().face(designcraft_fonts::FALLBACK_FAMILY, "Regular");
+ let Some(font) = self.font(&face) else { return };
+ let shaped = designcraft_fonts::shape(&face, text, &[], |c| c);
+ let upem = face.upem as f32;
+ let glyphs: Vec<KrillaGlyph> = shaped
+ .iter()
+ .enumerate()
+ .map(|(i, g)| {
+ let end = shaped.iter().skip(i + 1).map(|n| n.cluster).find(|c| *c != g.cluster).unwrap_or(text.len());
+ let end = if end > g.cluster { end } else { text.len() };
+ KrillaGlyph::new(
+ GlyphId::new(g.gid),
+ g.x_advance as f32 / upem,
+ g.x_offset as f32 / upem,
+ g.y_offset as f32 / upem,
+ 0.0,
+ g.cluster..end,
+ None,
+ )
+ })
+ .collect();
+ s.set_stroke(None);
+ s.set_fill(Some(solid_fill(color, 1.0)));
+ s.draw_glyphs(Point::from_xy(at.0 as f32, at.1 as f32), &glyphs, font, text, size as f32, false);
+ s.set_fill(None);
+ }
+}
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index e78678a3c..156b8ce96 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -12,6 +12,7 @@ pub const UI_COMMANDS: &[(&str, &str, Option<&str>, &str)] = &[
("app.saveDialog", "Save As…", Some("Cmd+Shift+S"), "{}"),
("app.save", "Save", Some("Cmd+S"), "{}"),
("app.exportPng", "Export Page as PNG…", Some("Cmd+E"), "{}"),
+ ("app.exportPdf", "Export PDF…", None, "{path?, …file.exportPdf options} — asks for a path when none is given"),
("app.palette", "Command Palette…", Some("Cmd+K"), "{}"),
("view.zoomIn", "Zoom In", Some("Cmd+="), "{}"),
("view.zoomOut", "Zoom Out", Some("Cmd+-"), "{}"),
@@ -54,6 +55,7 @@ pub const MENUS: &[(&str, &[&str])] = &[
"-",
"ui:app.placeDialog",
"-",
+ "ui:app.exportPdf",
"ui:app.exportPng",
"-",
"cmd:layout.documentSetup",
@@ -197,6 +199,7 @@ pub fn run_ui(app: &mut DesignApp, id: &str, p: &Value) -> Option<Result<Value,
Ok(Value::Null)
}
"app.exportPng" => export_png(app, p),
+ "app.exportPdf" => export_pdf(app, p),
"app.palette" => {
app.ui.palette = Some(String::new());
Ok(Value::Null)
@@ -311,6 +314,31 @@ fn export_png(app: &mut DesignApp, p: &Value) -> Result<Value, String> {
}
}
+/// File › Export PDF…: ask for a path, export through `file.exportPdf` and write the bytes with the
+/// platform writer (a download on the web).
+fn export_pdf(app: &mut DesignApp, p: &Value) -> Result<Value, String> {
+ let st = app.session.active().ok_or("no document")?;
+ let path = match p.get("path").and_then(Value::as_str) {
+ Some(s) => Some(s.to_string()),
+ None => {
+ let name = format!("{}.pdf", st.doc.title);
+ app.services.pick_save.as_mut().and_then(|f| f(&name))
+ }
+ };
+ let Some(path) = path else { return Ok(Value::Null) };
+ let mut params = if p.is_object() { p.clone() } else { json!({}) };
+ if let Some(o) = params.as_object_mut() {
+ o.remove("path");
+ o.entry("bleed").or_insert(json!(true));
+ }
+ let r = app.run("file.exportPdf", params)?;
+ let bytes = designcraft_engine::cmd::base64_decode(r["base64"].as_str().unwrap_or_default());
+ match app.services.write.as_mut() {
+ Some(w) => w(&path, &bytes).map(|_| json!({"path": path, "bytes": bytes.len(), "pages": r["pages"], "warnings": r["warnings"]})),
+ None => Err("no writer".into()),
+ }
+}
+
/// Is a command enabled (for menu greying)?
pub fn enabled(app: &DesignApp, id: &str) -> bool {
match designcraft_engine::find_command(id) {