1687a9c05b0c
lib.rs
//! PDF 1.7 drawing for GridCraft print/export, with shared object and xref framing.
//!
//! - The 14 standard fonts (no embedding) with WinAnsiEncoding, plus approximate width tables
//! ([`text_width`]) so callers can measure, align and wrap text. Characters outside
//! WinAnsiEncoding (CJK and other scripts) are set in a predefined, non-embedded Adobe-GB1 CID
//! font with the `UniGB-UTF16-H` CMap instead of being replaced by `?`. Symbol uses its own
//! built-in encoding ([`symbol_code`]), for Greek letters and mathematical operators.
//! - Arabic is shaped and set in embedded Type3 subsets, with exact shaped advances.
//! - Vector drawing: rectangles, lines (solid or dashed), polygons, circles (Bézier), clipping.
//! - RGBA images as RGB image XObjects with a soft mask for alpha (run-length encoded).
//! - Coordinates are points with a **top-left origin** (y grows down); text `y` is the baseline.
//!
//! Streams are written uncompressed (images use the RunLengthDecode filter).
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
mod arabic;
mod metrics;
mod symbol;
pub use symbol::{symbol_code, symbol_width};
/// Paragraph base direction. Context follows spreadsheet reading order: the first
/// non-whitespace character determines direction, including digits and punctuation.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum TextDirection {
#[default]
Auto,
Context,
LeftToRight,
RightToLeft,
}
impl TextDirection {
/// Resolve once for a paragraph before wrapping it into visual lines.
pub fn resolve(self, text: &str) -> Self {
use unicode_bidi::{BidiClass, BidiInfo, bidi_class};
let rtl = match self {
Self::Auto => BidiInfo::new(text, None).paragraphs.first().is_some_and(|p| p.level.is_rtl()),
Self::Context => text.chars().find(|ch| !ch.is_whitespace()).is_some_and(|ch| matches!(bidi_class(ch), BidiClass::R | BidiClass::AL)),
explicit => return explicit,
};
if rtl { Self::RightToLeft } else { Self::LeftToRight }
}
fn level(self) -> Option<unicode_bidi::Level> {
match self {
Self::Auto => None,
Self::LeftToRight | Self::Context => Some(unicode_bidi::Level::ltr()),
Self::RightToLeft => Some(unicode_bidi::Level::rtl()),
}
}
}
/// A PDF export could not preserve the requested text or serialize its object envelope.
#[derive(Clone, Debug)]
pub struct Error(String);
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for Error {}
impl From<craft_pdf::classic::Error> for Error {
fn from(error: craft_pdf::classic::Error) -> Self {
Self(error.to_string())
}
}
use std::collections::HashMap;
use std::collections::hash_map::DefaultHasher;
use std::fmt::Write as _;
use std::hash::{Hash, Hasher};
/// RGB colour, 0–255 per channel.
pub type Rgb = [u8; 3];
/// A point in page coordinates, measured from the top-left corner.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct Point {
pub x: f32,
pub y: f32,
}
impl Point {
pub const fn new(x: f32, y: f32) -> Self {
Self { x, y }
}
}
/// A text baseline origin and its clockwise rotation in radians.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct Baseline {
pub origin: Point,
pub angle: f32,
}
/// A page-space rectangle described by its top-left corner and extent.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct Rect {
pub x: f32,
pub y: f32,
pub width: f32,
pub height: f32,
}
impl Rect {
pub const fn new(x: f32, y: f32, width: f32, height: f32) -> Self {
Self { x, y, width, height }
}
}
/// The standard 14 fonts minus ZapfDingbats.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum Font {
#[default]
Helvetica,
HelveticaBold,
HelveticaOblique,
HelveticaBoldOblique,
TimesRoman,
TimesBold,
TimesItalic,
TimesBoldItalic,
Courier,
CourierBold,
CourierOblique,
CourierBoldOblique,
/// Greek letters and mathematical symbols, in the font's own encoding.
Symbol,
}
/// How many fonts a document can use.
const FONT_COUNT: usize = 13;
/// A font family for [`Font::styled`].
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Family {
#[default]
Sans,
Serif,
Mono,
}
impl Font {
pub const ALL: [Font; FONT_COUNT] = [
Font::Helvetica,
Font::HelveticaBold,
Font::HelveticaOblique,
Font::HelveticaBoldOblique,
Font::TimesRoman,
Font::TimesBold,
Font::TimesItalic,
Font::TimesBoldItalic,
Font::Courier,
Font::CourierBold,
Font::CourierOblique,
Font::CourierBoldOblique,
Font::Symbol,
];
/// PostScript base font name.
pub fn base_name(self) -> &'static str {
match self {
Font::Helvetica => "Helvetica",
Font::HelveticaBold => "Helvetica-Bold",
Font::HelveticaOblique => "Helvetica-Oblique",
Font::HelveticaBoldOblique => "Helvetica-BoldOblique",
Font::TimesRoman => "Times-Roman",
Font::TimesBold => "Times-Bold",
Font::TimesItalic => "Times-Italic",
Font::TimesBoldItalic => "Times-BoldItalic",
Font::Courier => "Courier",
Font::CourierBold => "Courier-Bold",
Font::CourierOblique => "Courier-Oblique",
Font::CourierBoldOblique => "Courier-BoldOblique",
Font::Symbol => "Symbol",
}
}
fn index(self) -> usize {
Font::ALL.iter().position(|f| *f == self).unwrap_or(0)
}
/// The face of `family` with the given weight and slant.
pub fn styled(family: Family, bold: bool, italic: bool) -> Font {
match (family, bold, italic) {
(Family::Sans, false, false) => Font::Helvetica,
(Family::Sans, true, false) => Font::HelveticaBold,
(Family::Sans, false, true) => Font::HelveticaOblique,
(Family::Sans, true, true) => Font::HelveticaBoldOblique,
(Family::Serif, false, false) => Font::TimesRoman,
(Family::Serif, true, false) => Font::TimesBold,
(Family::Serif, false, true) => Font::TimesItalic,
(Family::Serif, true, true) => Font::TimesBoldItalic,
(Family::Mono, false, false) => Font::Courier,
(Family::Mono, true, false) => Font::CourierBold,
(Family::Mono, false, true) => Font::CourierOblique,
(Family::Mono, true, true) => Font::CourierBoldOblique,
}
}
/// Picks a standard family for a font name: serif faces map to Times, monospaced ones to
/// Courier, everything else to Helvetica.
pub fn family_for(name: &str) -> Family {
let n = name.to_ascii_lowercase();
const SERIF: [&str; 10] = ["times", "cambria", "georgia", "garamond", "serif", "book", "palatino", "baskerville", "tinos", "caladea"];
const MONO: [&str; 8] = ["courier", "consolas", "mono", "menlo", "lucida console", "cousine", "code", "typewriter"];
if MONO.iter().any(|m| n.contains(m)) {
Family::Mono
} else if SERIF.iter().any(|s| n.contains(s)) && !n.contains("sans") {
Family::Serif
} else {
Family::Sans
}
}
/// Whether this font can show `c` by itself (in its own encoding; for the text faces,
/// without the CID fallback).
pub fn can_encode(self, c: char) -> bool {
match self {
Font::Symbol => symbol_code(c).is_some(),
_ => c == '?' || win_ansi(c) != b'?',
}
}
/// Advance width of a character in 1/1000 em.
pub fn char_width(self, c: char) -> u16 {
if self == Font::Symbol {
return symbol_code(c).and_then(symbol_width).unwrap_or(500);
}
let table: Option<&[u16; 95]> = match self {
Font::Helvetica | Font::HelveticaOblique => Some(&metrics::HELVETICA),
Font::HelveticaBold | Font::HelveticaBoldOblique => Some(&metrics::HELVETICA_BOLD),
Font::TimesRoman | Font::TimesItalic => Some(&metrics::TIMES),
Font::TimesBold | Font::TimesBoldItalic => Some(&metrics::TIMES_BOLD),
_ => None,
};
if needs_cid(c) {
return CID_WIDTH;
}
let Some(table) = table else { return 600 };
let ascii = |c: char| -> Option<u16> {
let i = (c as u32).checked_sub(32)? as usize;
table.get(i).copied()
};
if let Some(w) = ascii(c) {
return w;
}
match c {
'—' | '…' | '‰' | '™' => 1000,
_ => metrics::fold(c).and_then(ascii).unwrap_or(match self {
Font::TimesRoman | Font::TimesItalic | Font::TimesBold | Font::TimesBoldItalic => 500,
_ => 556,
}),
}
}
}
/// Whether [`text_width_with_direction`] is the sum of `text`'s character widths: not shaped,
/// not reordered right to left and holding no bidi controls. A prefix's width is then a running sum.
pub fn width_is_char_sum(font: Font, text: &str, direction: TextDirection) -> bool {
let direction = if direction == TextDirection::Context { direction.resolve(text) } else { direction };
!arabic::shaped(font, text) && arabic::is_logical_order(text, direction)
}
/// Width of `text` in points when set in `font` at `size` points.
/// Arabic uses shaped advances. If its font cannot render the text, measurement returns zero
/// and drawing that text causes [`PdfDoc::finish`] to return the rendering error.
pub fn text_width(font: Font, size: f32, text: &str) -> f32 {
text_width_with_direction(font, size, text, TextDirection::Auto)
}
/// Width measured with the same base direction as drawing.
pub fn text_width_with_direction(font: Font, size: f32, text: &str, direction: TextDirection) -> f32 {
let direction = if direction == TextDirection::Context { direction.resolve(text) } else { direction };
if arabic::shaped(font, text) {
return arabic::layout(font, text, direction).map(|layout| layout.width * size / 1000.0).unwrap_or(0.0);
}
// u64: a u32 sum overflows for ~8 million characters.
let Ok(visual) = arabic::latin_visual(text, direction) else { return 0.0 };
let units: u64 = visual.chars().map(|c| u64::from(font.char_width(c))).sum();
units as f32 * size / 1000.0
}
/// Unicode → WinAnsiEncoding (CP1252) byte; unmappable characters become `?`.
pub fn win_ansi(c: char) -> u8 {
let u = c as u32;
if (0x20..0x7F).contains(&u) || (0xA0..=0xFF).contains(&u) {
return u as u8;
}
match c {
'€' => 0x80,
'‚' => 0x82,
'ƒ' => 0x83,
'„' => 0x84,
'…' => 0x85,
'†' => 0x86,
'‡' => 0x87,
'ˆ' => 0x88,
'‰' => 0x89,
'Š' => 0x8A,
'‹' => 0x8B,
'Œ' => 0x8C,
'Ž' => 0x8E,
'‘' => 0x91,
'’' => 0x92,
'“' => 0x93,
'”' => 0x94,
'•' => 0x95,
'–' => 0x96,
'—' => 0x97,
'˜' => 0x98,
'™' => 0x99,
'š' => 0x9A,
'›' => 0x9B,
'œ' => 0x9C,
'ž' => 0x9E,
'Ÿ' => 0x9F,
'\t' => b' ',
_ => b'?',
}
}
/// Index of the CID font in a page's font flags (after the [`Font::ALL`] faces).
const CID_FONT: usize = Font::ALL.len();
/// Number of font resources a page can use.
const FONT_SLOTS: usize = CID_FONT + 1;
/// Base font of the CID font used for characters WinAnsiEncoding lacks.
const CID_BASE_FONT: &str = "STSong-Light";
/// Default glyph width of the CID font (full-width), in 1/1000 em.
const CID_WIDTH: u16 = 1000;
/// True when `c` has no WinAnsiEncoding byte and is drawn with the CID font.
fn needs_cid(c: char) -> bool {
!c.is_control() && c != '?' && win_ansi(c) == b'?'
}
/// A PDF hex string `< … >` of `text` in UTF-16BE (the `UniGB-UTF16-H` encoding).
fn pdf_utf16_string(text: &str) -> String {
let mut s = String::with_capacity(text.len() * 4 + 2);
s.push('<');
for unit in text.encode_utf16() {
let _ = write!(s, "{unit:04X}");
}
s.push('>');
s
}
/// A PDF literal string `( … )` for `text` in WinAnsiEncoding.
fn pdf_string(text: &str) -> String {
pdf_string_in(text, false)
}
/// A PDF literal string for `text` in WinAnsiEncoding, or in Symbol's encoding (where a
/// character Symbol lacks becomes `?`).
fn pdf_string_in(text: &str, symbol: bool) -> String {
let mut s = String::with_capacity(text.len() + 2);
s.push('(');
for c in text.chars() {
let b = if symbol { symbol_code(c).unwrap_or(b'?') } else { win_ansi(c) };
match b {
b'(' | b')' | b'\\' => {
s.push('\\');
s.push(b as char);
}
0x20..=0x7E => s.push(b as char),
_ => {
let _ = write!(s, "\\{b:03o}");
}
}
}
s.push(')');
s
}
/// URI actions use byte strings. Percent-encode non-ASCII UTF-8 before PDF string escaping.
fn pdf_uri_string(uri: &str) -> String {
let mut ascii = String::with_capacity(uri.len());
for byte in uri.bytes() {
if byte.is_ascii() {
ascii.push(byte as char);
} else {
let _ = write!(ascii, "%{byte:02X}");
}
}
pdf_string(&ascii)
}
/// A number for a content stream: finite, short.
fn n(v: f32) -> String {
let v = if v.is_finite() { v.clamp(-1.0e7, 1.0e7) } else { 0.0 };
let r = (v * 1000.0).round() / 1000.0;
if r == r.trunc() {
format!("{}", r as i64)
} else {
let s = format!("{r:.3}");
s.trim_end_matches('0').trim_end_matches('.').to_string()
}
}
/// Appends `v / 255` with at most three decimals, exactly what `n(v as f32 / 255.0)` gives, but
/// without a float round trip or an allocation per channel.
fn push_unit(s: &mut String, v: u8) {
let m = (u32::from(v) * 1000 + 127) / 255;
match m {
0 => s.push('0'),
1000 => s.push('1'),
_ => {
let _ = write!(s, "0.{m:03}");
while s.ends_with('0') {
s.pop();
}
}
}
}
/// Appends a colour operator line without the trailing newline: `r g b rg` (fill) or `r g b RG`.
fn push_rgb(s: &mut String, c: Rgb, stroke: bool) {
for v in c {
push_unit(s, v);
s.push(' ');
}
s.push_str(if stroke { "RG" } else { "rg" });
}
/// True when every value is finite (NaN and infinities are rejected).
fn finite(v: &[f32]) -> bool {
v.iter().all(|x| x.is_finite())
}
/// A positive, finite extent (a width, height or radius).
fn extent(v: f32) -> bool {
v > 0.0 && v.is_finite()
}
/// A stroke width: negative, NaN and infinite become 0 (the thinnest line).
fn stroke_width(w: f32) -> f32 {
if w.is_finite() { w.max(0.0) } else { 0.0 }
}
/// The entries of a dash array (`[on, off, …]`, at most 8). A pattern the PDF specification
/// forbids (any non-finite entry, or no entry that survives rounding to a positive number) is
/// replaced by an empty array, i.e. a solid line.
fn dash_values(dash: &[f32]) -> String {
let d: Vec<f32> = dash.iter().take(8).map(|v| if v.is_finite() { v.max(0.0) } else { f32::NAN }).collect();
if !finite(&d) || !d.iter().any(|v| (v.min(1.0e7) * 1000.0).round() > 0.0) {
return String::new();
}
d.iter().map(|v| n(*v)).collect::<Vec<_>>().join(" ")
}
struct ImageData {
width: u32,
height: u32,
rgb: Vec<u8>,
/// `None` when every pixel is fully opaque (no soft mask is written).
alpha: Option<Vec<u8>>,
/// Hash of all of the above, to find duplicates quickly; equality still compares the bytes.
hash: u64,
}
impl ImageData {
fn new(width: u32, height: u32, rgb: Vec<u8>, alpha: Option<Vec<u8>>) -> ImageData {
let mut h = DefaultHasher::new();
width.hash(&mut h);
height.hash(&mut h);
rgb.hash(&mut h);
alpha.hash(&mut h);
ImageData { width, height, rgb, alpha, hash: h.finish() }
}
/// Same pixels (a hash match alone is never trusted).
fn same(&self, o: &ImageData) -> bool {
self.hash == o.hash && self.width == o.width && self.height == o.height && self.rgb == o.rgb && self.alpha == o.alpha
}
}
/// The part of the graphics state the writer tracks so that a style operator is only emitted
/// when it changes. `None` = not set yet on this page (or since the last restore that undid it).
#[derive(Clone, Debug, Default, PartialEq)]
struct Style {
fill: Option<Rgb>,
stroke: Option<Rgb>,
/// Formatted line width.
width: Option<String>,
/// Formatted dash array contents.
dash: Option<String>,
/// Line join; PDF's initial value is 0 (miter).
join: u8,
}
enum LinkTarget {
Uri(String),
Page { index: usize, x: f32, y: f32 },
}
struct LinkAnnotation {
/// PDF coordinates, with the origin at the bottom left.
rect: [f32; 4],
target: LinkTarget,
}
/// A page under construction. Obtain one with [`PdfDoc::add_page`].
pub struct Page {
width: f32,
height: f32,
content: String,
fonts: [bool; FONT_SLOTS],
images: Vec<ImageData>,
/// Indexes into `images`, by content hash; a hash match is confirmed with [`ImageData::same`].
image_index: HashMap<u64, Vec<usize>>,
/// Pixel comparisons made while looking up duplicate pictures (test instrumentation).
#[cfg(test)]
image_comparisons: usize,
/// Style operators already in effect at the end of `content`.
style: Style,
/// One entry per accepted [`Page::save`], restored by [`Page::restore`].
saved: Vec<Style>,
/// `save` calls refused at the nesting limit; the same number of `restore` calls are ignored.
refused: u32,
links: Vec<LinkAnnotation>,
arabic: arabic::Subset,
error: Option<Error>,
missing_arabic_font: bool,
}
/// Most bytes of content per page before further drawing is dropped (keeps hostile inputs from
/// exhausting memory).
const MAX_PAGE_CONTENT: usize = 64 * 1024 * 1024;
/// Largest image (pixels) embedded.
const MAX_IMAGE_PIXELS: u64 = 40_000_000;
/// Deepest `q` nesting a PDF consumer must support (the PDF specification's implementation limits).
const MAX_SAVE_DEPTH: usize = 28;
/// Line join styles, as the `j` operator takes them.
const JOIN_MITER: u8 = 0;
const JOIN_ROUND: u8 = 1;
const MAX_PAGE_LINKS: usize = 4096;
const MAX_LINK_URI_BYTES: usize = 4096;
impl Page {
pub fn width(&self) -> f32 {
self.width
}
pub fn height(&self) -> f32 {
self.height
}
fn y(&self, y: f32) -> f32 {
self.height - y
}
fn full(&self) -> bool {
self.content.len() > MAX_PAGE_CONTENT
}
fn op(&mut self, s: &str) {
if !self.full() {
self.content.push_str(s);
self.content.push('\n');
}
}
/// Appends a fill colour operator to `s` unless that colour is already in effect.
fn set_fill(&mut self, s: &mut String, c: Rgb) {
if self.style.fill != Some(c) {
push_rgb(s, c, false);
s.push('\n');
self.style.fill = Some(c);
}
}
/// Appends the stroke colour, width, dash and join operators to `s` that differ from the
/// style already in effect.
fn set_stroke(&mut self, s: &mut String, c: Rgb, width: f32, dash: &str, join: u8) {
if self.style.stroke != Some(c) {
push_rgb(s, c, true);
s.push('\n');
self.style.stroke = Some(c);
}
let w = n(stroke_width(width));
if self.style.width.as_deref() != Some(w.as_str()) {
let _ = writeln!(s, "{w} w");
self.style.width = Some(w);
}
if self.style.dash.as_deref() != Some(dash) {
let _ = writeln!(s, "[{dash}] 0 d");
self.style.dash = Some(dash.to_string());
}
if self.style.join != join {
let _ = writeln!(s, "{join} j");
self.style.join = join;
}
}
fn link_rect(&self, rect: Rect) -> Option<[f32; 4]> {
let Rect { x, y, width, height } = rect;
if !finite(&[x, y, width, height]) || !extent(width) || !extent(height) || self.links.len() >= MAX_PAGE_LINKS {
return None;
}
let (right, bottom) = (x + width, y + height);
if !finite(&[right, bottom]) {
return None;
}
let (left, right) = (x.max(0.0), right.min(self.width));
let (top, bottom) = (y.max(0.0), bottom.min(self.height));
(right > left && bottom > top).then(|| [left, self.y(bottom), right, self.y(top)])
}
/// Adds an invisible clickable area for an external URI. Invalid or excessive links are ignored.
pub fn link_uri(&mut self, x: f32, y: f32, w: f32, h: f32, uri: &str) {
let allowed = uri
.split_once(':')
.is_some_and(|(scheme, rest)| matches!(scheme.to_ascii_lowercase().as_str(), "http" | "https" | "mailto") && !rest.is_empty());
if !allowed || uri.len() > MAX_LINK_URI_BYTES || uri.chars().any(char::is_control) {
return;
}
if let Some(rect) = self.link_rect(Rect::new(x, y, w, h)) {
self.links.push(LinkAnnotation { rect, target: LinkTarget::Uri(uri.to_string()) });
}
}
/// Adds a link to a location on another page of this document (zero-based page index).
pub fn link_page(&mut self, rect: Rect, page: usize, target: Point) {
if !finite(&[target.x, target.y]) {
return;
}
if let Some(rect) = self.link_rect(rect) {
self.links.push(LinkAnnotation { rect, target: LinkTarget::Page { index: page, x: target.x, y: target.y } });
}
}
/// Saves the graphics state (pair with [`Page::restore`]). Nesting is limited to 28 levels, the
/// depth every PDF consumer must support; a `save` beyond that is ignored, and so is the
/// `restore` that would have matched it.
pub fn save(&mut self) {
if self.saved.len() >= MAX_SAVE_DEPTH {
self.refused = self.refused.saturating_add(1);
return;
}
self.saved.push(self.style.clone());
self.content.push_str("q\n");
}
/// Restores the graphics state saved by [`Page::save`]; extra calls are ignored.
pub fn restore(&mut self) {
if self.refused > 0 {
self.refused -= 1;
} else if let Some(style) = self.saved.pop() {
self.style = style;
self.content.push_str("Q\n");
}
}
/// Intersects the clip with a rectangle (until the next [`Page::restore`]).
pub fn clip_rect(&mut self, x: f32, y: f32, w: f32, h: f32) {
let s = format!("{} {} {} {} re W n", n(x), n(self.y(y + h)), n(w.max(0.0)), n(h.max(0.0)));
self.op(&s);
}
pub fn fill_rect(&mut self, x: f32, y: f32, w: f32, h: f32, color: Rgb) {
if !(extent(w) && extent(h) && finite(&[x, y])) || self.full() {
return;
}
let mut s = String::new();
self.set_fill(&mut s, color);
let _ = write!(s, "{} {} {} {} re f", n(x), n(self.y(y + h)), n(w), n(h));
self.op(&s);
}
pub fn rect_stroke(&mut self, x: f32, y: f32, w: f32, h: f32, width: f32, color: Rgb) {
if !finite(&[x, y, w, h]) || self.full() {
return;
}
let mut s = String::new();
self.set_stroke(&mut s, color, width, "", JOIN_MITER);
let _ = write!(s, "{} {} {} {} re S", n(x), n(self.y(y + h)), n(w), n(h));
self.op(&s);
}
pub fn stroke_line(&mut self, x0: f32, y0: f32, x1: f32, y1: f32, width: f32, color: Rgb) {
self.stroke_line_dashed(Point::new(x0, y0), Point::new(x1, y1), width, color, &[]);
}
/// A line with a dash pattern (`[on, off, …]` in points; empty = solid).
pub fn stroke_line_dashed(&mut self, start: Point, end: Point, width: f32, color: Rgb, dash: &[f32]) {
if !finite(&[start.x, start.y, end.x, end.y]) || self.full() {
return;
}
let mut s = String::new();
self.set_stroke(&mut s, color, width, &dash_values(dash), JOIN_MITER);
let _ = write!(s, "{} {} m {} {} l S", n(start.x), n(self.y(start.y)), n(end.x), n(self.y(end.y)));
self.op(&s);
}
/// An open polyline (round joins).
pub fn polyline(&mut self, pts: &[[f32; 2]], width: f32, color: Rgb, dash: &[f32]) {
if pts.len() < 2 || !pts.iter().all(|p| finite(p)) || self.full() {
return;
}
let mut s = String::new();
self.set_stroke(&mut s, color, width, &dash_values(dash), JOIN_ROUND);
self.path(&mut s, pts, false);
s.push_str(" S");
self.op(&s);
}
fn path(&self, s: &mut String, pts: &[[f32; 2]], close: bool) {
for (i, p) in pts.iter().enumerate() {
let _ = write!(s, "{} {} {} ", n(p[0]), n(self.y(p[1])), if i == 0 { "m" } else { "l" });
}
if close {
s.push('h');
}
}
/// A closed polygon, filled and/or stroked (round joins).
pub fn polygon(&mut self, pts: &[[f32; 2]], fill: Option<Rgb>, stroke: Option<(Rgb, f32)>) {
if pts.len() < 2 || (fill.is_none() && stroke.is_none()) || !pts.iter().all(|p| finite(p)) || self.full() {
return;
}
let mut s = String::new();
if let Some(f) = fill {
self.set_fill(&mut s, f);
}
if let Some((c, w)) = stroke {
self.set_stroke(&mut s, c, w, "", JOIN_ROUND);
}
self.path(&mut s, pts, true);
s.push_str(match (fill.is_some(), stroke.is_some()) {
(true, true) => " B",
(true, false) => " f",
_ => " S",
});
self.op(&s);
}
/// A circle approximated by four cubic Béziers.
pub fn circle(&mut self, cx: f32, cy: f32, r: f32, fill: Option<Rgb>, stroke: Option<(Rgb, f32)>) {
if !extent(r) || !finite(&[cx, cy]) || (fill.is_none() && stroke.is_none()) || self.full() {
return;
}
const K: f32 = 0.552_284_8;
let k = r * K;
let y = self.y(cy);
let mut s = String::new();
if let Some(f) = fill {
self.set_fill(&mut s, f);
}
if let Some((c, w)) = stroke {
self.set_stroke(&mut s, c, w, "", JOIN_MITER);
}
let _ = write!(
s,
"{} {} m {} {} {} {} {} {} c {} {} {} {} {} {} c {} {} {} {} {} {} c {} {} {} {} {} {} c h",
n(cx + r),
n(y),
n(cx + r),
n(y + k),
n(cx + k),
n(y + r),
n(cx),
n(y + r),
n(cx - k),
n(y + r),
n(cx - r),
n(y + k),
n(cx - r),
n(y),
n(cx - r),
n(y - k),
n(cx - k),
n(y - r),
n(cx),
n(y - r),
n(cx + k),
n(y - r),
n(cx + r),
n(y - k),
n(cx + r),
n(y)
);
s.push_str(match (fill.is_some(), stroke.is_some()) {
(true, true) => " B",
(true, false) => " f",
_ => " S",
});
self.op(&s);
}
/// Arabic ink extents above and below the baseline, in points. Standard font text returns
/// `None`. Font errors are recorded for [`PdfDoc::finish`], just as when drawing text.
pub fn text_vertical_extents(&mut self, font: Font, size: f32, text: &str) -> Option<(f32, f32)> {
self.text_vertical_extents_with_direction(font, size, text, TextDirection::Auto)
}
/// Arabic ink extents with an explicit paragraph base direction.
pub fn text_vertical_extents_with_direction(&mut self, font: Font, size: f32, text: &str, direction: TextDirection) -> Option<(f32, f32)> {
if !arabic::shaped(font, text) {
return None;
}
match arabic::vertical_extents(font, text, direction) {
Ok((ascent, descent)) => Some((ascent * size / 1000.0, descent * size / 1000.0)),
Err(error) => {
self.error.get_or_insert(error);
None
}
}
}
/// Text with its baseline starting at `(x, y)`.
pub fn text(&mut self, x: f32, y: f32, size: f32, font: Font, color: Rgb, text: &str) {
self.text_with_direction(Point::new(x, y), size, font, color, text, TextDirection::Auto);
}
/// Text drawn with an explicit paragraph base direction.
pub fn text_with_direction(&mut self, origin: Point, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
self.text_rotated_with_direction(Baseline { origin, angle: 0.0 }, size, font, color, text, direction);
}
/// Text rotated by `angle` radians (clockwise on the page, like the y-down coordinate
/// system) about its baseline origin.
pub fn text_rotated(&mut self, origin: Point, size: f32, font: Font, color: Rgb, text: &str, angle: f32) {
self.text_rotated_with_direction(Baseline { origin, angle }, size, font, color, text, TextDirection::Auto);
}
/// Rotated text with an explicit paragraph base direction.
pub fn text_rotated_with_direction(&mut self, baseline: Baseline, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
let Baseline { origin, angle } = baseline;
if text.is_empty() || !extent(size) || !finite(&[origin.x, origin.y]) {
return;
}
let direction = if direction == TextDirection::Context { direction.resolve(text) } else { direction };
let (sn, cs) = if angle.is_finite() { angle.sin_cos() } else { (0.0, 1.0) };
// Clockwise in y-down = counter-clockwise negated in PDF's y-up space.
let matrix = format!("{} {} {} {} {} {}", n(cs), n(-sn), n(sn), n(cs), n(origin.x), n(self.y(origin.y)));
let size = size.min(10_000.0);
let shaping = arabic::shaping(font, text);
self.missing_arabic_font |= shaping == arabic::Shaping::NoFont;
if shaping == arabic::Shaping::Shaped {
self.shaped_text(&matrix, size, font, color, text, direction);
} else {
self.standard_text(&matrix, size, font, color, text, direction);
}
}
fn shaped_text(&mut self, matrix: &str, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
if self.saved.len() >= MAX_SAVE_DEPTH {
return;
}
let body = match self.arabic.text(font, text, size, direction) {
Ok(body) => body,
Err(error) => {
self.error.get_or_insert(error);
return;
}
};
for slot in [Some(font.index()), self.arabic.uses_cid.then_some(CID_FONT)].into_iter().flatten() {
if let Some(f) = self.fonts.get_mut(slot) {
*f = true;
}
}
let mut s = format!("q\n{matrix} cm\n");
push_rgb(&mut s, color, false);
s.push(' ');
push_rgb(&mut s, color, true);
let _ = write!(s, "\n{body}\nQ");
self.text_op(&s);
}
fn standard_text(&mut self, matrix: &str, size: f32, font: Font, color: Rgb, text: &str, direction: TextDirection) {
let visual = match arabic::latin_visual(text, direction) {
Ok(visual) => visual,
Err(error) => {
self.error.get_or_insert(error);
return;
}
};
let fi = font.index();
let size = n(size);
let mut runs = String::new();
// Runs of WinAnsi text use `font`; runs it cannot encode use the CID font. Each `Tj`
// advances the text position, so the runs follow each other on the baseline.
// Symbol text is one run in Symbol's own encoding (the CID font has no maths symbols).
let symbol = font == Font::Symbol;
let uses_cid = |c: char| !symbol && needs_cid(c);
let mut rest: &str = &visual;
while let Some(first) = rest.chars().next() {
let cid = uses_cid(first);
let end = rest.char_indices().find(|(_, c)| uses_cid(*c) != cid).map_or(rest.len(), |(i, _)| i);
let (run, tail) = rest.split_at(end);
let (slot, string) = if cid { (CID_FONT, pdf_utf16_string(run)) } else { (fi, pdf_string_in(run, symbol)) };
if let Some(f) = self.fonts.get_mut(slot) {
*f = true;
}
let first_run = runs.is_empty();
let _ = writeln!(runs, "/F{} {} Tf", slot + 1, size);
if first_run {
let _ = writeln!(runs, "{matrix} Tm");
}
let _ = writeln!(runs, "{string} Tj");
rest = tail;
}
let mut s = String::new();
self.set_fill(&mut s, color);
let _ = write!(s, "BT\n{runs}ET");
let s = if visual != text { format!("/Span << /ActualText {} >> BDC\n{s}\nEMC", arabic::unicode_string(text, true)) } else { s };
self.text_op(&s);
}
fn text_op(&mut self, s: &str) {
if self.content.len().saturating_add(s.len()).saturating_add(1) > MAX_PAGE_CONTENT {
self.error.get_or_insert_with(|| Error("PDF page text exceeds the size limit".into()));
} else {
self.op(s);
}
}
/// Draws an RGBA image (`pw`×`ph` pixels, row-major, straight alpha) into the box
/// `(x, y, w, h)`. Malformed or oversized buffers are ignored.
pub fn image_rgba(&mut self, destination: Rect, rgba: &[u8], pixel_size: [u32; 2]) {
let Rect { x, y, width: w, height: h } = destination;
let [pw, ph] = pixel_size;
let px = pw as u64 * ph as u64;
if pw == 0 || ph == 0 || px > MAX_IMAGE_PIXELS || (rgba.len() as u64) < px * 4 || !(extent(w) && extent(h) && finite(&[x, y])) {
return;
}
// The image is drawn inside its own q/Q, which counts towards the nesting limit.
if self.saved.len() >= MAX_SAVE_DEPTH {
return;
}
let px = px as usize;
let mut rgb = Vec::with_capacity(px * 3);
// The alpha plane is only allocated once a non-opaque pixel shows up.
let mut alpha: Option<Vec<u8>> = None;
for (i, p) in rgba.as_chunks::<4>().0.iter().take(px).enumerate() {
rgb.extend_from_slice(&[p[0], p[1], p[2]]);
match &mut alpha {
Some(a) => a.push(p[3]),
None if p[3] != 255 => {
let mut a = Vec::with_capacity(px);
a.resize(i, 255);
a.push(p[3]);
alpha = Some(a);
}
None => {}
}
}
let img = ImageData::new(pw, ph, rgb, alpha);
// The same picture drawn again on this page shares one XObject.
let candidates = self.image_index.entry(img.hash).or_default();
#[cfg(test)]
let comparisons = &mut self.image_comparisons;
let known = candidates.iter().copied().find(|&i| {
#[cfg(test)]
{
*comparisons += 1;
}
self.images.get(i).is_some_and(|o| o.same(&img))
});
let idx = match known {
Some(i) => i,
None => {
candidates.push(self.images.len());
self.images.push(img);
self.images.len() - 1
}
};
let s = format!("q {} 0 0 {} {} {} cm /Im{} Do Q", n(w), n(h), n(x), n(self.y(y + h)), idx + 1);
self.op(&s);
}
}
/// Document metadata.
#[derive(Clone, Debug, Default)]
pub struct Info {
pub title: String,
pub author: String,
pub creator: String,
}
/// A PDF document under construction.
#[derive(Default)]
pub struct PdfDoc {
pages: Vec<Page>,
pub info: Info,
}
/// PackBits-style run-length encoding (PDF `RunLengthDecode`).
fn run_length(data: &[u8]) -> Vec<u8> {
craft_stream_codecs::runlength::encode(data)
}
/// Longest Info string written, in characters; longer values are cut on a character boundary.
const MAX_INFO_CHARS: usize = 1024;
/// A PDF text string (document Info entries) for `text`: a literal `( … )` for printable ASCII,
/// otherwise UTF-16BE with a byte-order mark as a hex string (ISO 32000-1 7.9.2.2).
fn pdf_text_string(text: &str) -> String {
let text: String = text.chars().take(MAX_INFO_CHARS).collect();
if text.chars().all(|c| matches!(c, ' '..='~')) {
return pdf_string(&text);
}
let mut s = String::with_capacity(text.len() * 4 + 6);
s.push_str("<FEFF");
for unit in text.encode_utf16() {
let _ = write!(s, "{unit:04X}");
}
s.push('>');
s
}
impl PdfDoc {
pub fn new() -> PdfDoc {
PdfDoc::default()
}
/// Adds a page of `width_pt` × `height_pt` points and returns it for drawing.
pub fn add_page(&mut self, width_pt: f32, height_pt: f32) -> &mut Page {
let width = if width_pt.is_finite() { width_pt.clamp(3.0, 14_400.0) } else { 612.0 };
let height = if height_pt.is_finite() { height_pt.clamp(3.0, 14_400.0) } else { 792.0 };
self.pages.push(Page {
width,
height,
content: String::new(),
fonts: [false; FONT_SLOTS],
images: Vec::new(),
image_index: HashMap::new(),
#[cfg(test)]
image_comparisons: 0,
links: Vec::new(),
style: Style::default(),
saved: Vec::new(),
refused: 0,
arabic: arabic::Subset::default(),
error: None,
missing_arabic_font: false,
});
let i = self.pages.len() - 1;
&mut self.pages[i]
}
pub fn page_count(&self) -> usize {
self.pages.len()
}
/// The page at `i`, to keep drawing on it.
pub fn page_mut(&mut self, i: usize) -> Option<&mut Page> {
self.pages.get_mut(i)
}
/// Whether some Arabic text was set in the standard and CID fonts, which have no Arabic glyphs,
/// because no Arabic face was found for its weight.
pub fn missing_arabic_font(&self) -> bool {
self.pages.iter().any(|page| page.missing_arabic_font)
}
/// Serializes the document. A document without pages gets one blank Letter page.
///
/// Every object is written straight into the output buffer (nothing is staged in an
/// intermediate list of bodies); only the xref table needs the offset of each object id, and
/// the ids are contiguous from 1. Objects are therefore in the file in the order they are
/// numbered during writing (fonts, then per page its new images, content stream and page
/// dictionary), with the catalog, page tree and info dictionary last.
///
/// Returns an error if the Arabic font is unusable, text exceeds a size limit, or the
/// shared envelope writer refuses object counts, offsets or an allocation.
pub fn finish(mut self) -> Result<Vec<u8>, Error> {
if let Some(error) = self.pages.iter().find_map(|page| page.error.clone()) {
return Err(error);
}
if self.pages.is_empty() {
self.add_page(612.0, 792.0);
}
for page in &mut self.pages {
page.refused = 0;
while !page.saved.is_empty() {
page.restore();
}
}
// Object numbering: 1 catalog, 2 page tree, 3 info, then fonts, then per page.
let mut used = [false; FONT_SLOTS];
for p in &self.pages {
for (u, f) in used.iter_mut().zip(p.fonts.iter()) {
*u |= *f;
}
}
let mut next = 4u32;
let mut font_ids = [0u32; FONT_SLOTS];
for (i, u) in used.iter().enumerate() {
if *u {
font_ids[i] = next;
// The CID font also needs its descendant font and font descriptor.
next += if i == CID_FONT { 3 } else { 1 };
}
}
// Page contents are moved out so each one is freed as soon as it is in the output.
let contents: Vec<String> = self.pages.iter_mut().map(|p| std::mem::take(&mut p.content)).collect();
let page_links: Vec<Vec<LinkAnnotation>> = self.pages.iter_mut().map(|p| std::mem::take(&mut p.links)).collect();
let reserve = contents.iter().fold(4096usize, |acc, c| acc.saturating_add(c.len()).saturating_add(1024));
let mut out = craft_pdf::classic::Writer::with_capacity(reserve)?;
let mut kids = Vec::new();
let mut annotations = Vec::new();
let page_count = self.pages.len();
let mut font_dict = String::new();
for (i, id) in font_ids.iter().enumerate() {
if *id != 0 {
let _ = write!(font_dict, "/F{} {} 0 R ", i + 1, id);
if i == CID_FONT {
let (cid_id, desc_id) = (id + 1, id + 2);
out.object(
*id,
&format!(
"<< /Type /Font /Subtype /Type0 /BaseFont /{CID_BASE_FONT} /Encoding /UniGB-UTF16-H /DescendantFonts [{cid_id} 0 R] >>"
),
)?;
out.object(cid_id,
&format!(
"<< /Type /Font /Subtype /CIDFontType0 /BaseFont /{CID_BASE_FONT} /CIDSystemInfo << /Registry (Adobe) /Ordering (GB1) /Supplement 4 >> /FontDescriptor {desc_id} 0 R /DW {CID_WIDTH} >>"
),
)?;
out.object(desc_id,
&format!(
"<< /Type /FontDescriptor /FontName /{CID_BASE_FONT} /Flags 6 /FontBBox [-25 -254 1000 880] /ItalicAngle 0 /Ascent 880 /Descent -120 /CapHeight 880 /StemV 93 >>"
),
)?;
continue;
}
let name = Font::ALL.get(i).copied().unwrap_or_default().base_name();
let enc = if name.starts_with("Symbol") { "" } else { " /Encoding /WinAnsiEncoding" };
out.object(*id, &format!("<< /Type /Font /Subtype /Type1 /BaseFont /{name}{enc} >>"))?;
}
}
// Images already written, by content hash: (page, image, object id). A hash match is
// confirmed by comparing the pixels before an object is shared.
let mut written: HashMap<u64, Vec<(usize, usize, u32)>> = HashMap::new();
for (pi, ((page, content), links)) in self.pages.iter().zip(contents).zip(page_links).enumerate() {
let arabic_fonts = page.arabic.write_objects(&mut next, &mut out)?;
let page_fonts = format!("{font_dict}{arabic_fonts}");
let mut xobjects = String::new();
for (k, img) in page.images.iter().enumerate() {
let known = written.get(&img.hash).and_then(|c| {
c.iter().find_map(|(p, i, id)| {
let other = self.pages.get(*p)?.images.get(*i)?;
img.same(other).then_some(*id)
})
});
let img_id = match known {
Some(id) => id,
None => {
let img_id = next;
next += 1;
let mut dict = format!("/Type /XObject /Subtype /Image /Width {} /Height {} /BitsPerComponent 8", img.width, img.height);
let smask_id = img.alpha.as_ref().map(|_| {
let id = next;
next += 1;
id
});
dict.push_str(" /ColorSpace /DeviceRGB");
if let Some(id) = smask_id {
let _ = write!(dict, " /SMask {id} 0 R");
}
dict.push_str(" /Filter /RunLengthDecode");
out.stream(img_id, &dict, &run_length(&img.rgb))?;
if let (Some(id), Some(a)) = (smask_id, &img.alpha) {
let dict = format!(
"/Type /XObject /Subtype /Image /Width {} /Height {} /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /RunLengthDecode",
img.width, img.height
);
out.stream(id, &dict, &run_length(a))?;
}
written.entry(img.hash).or_default().push((pi, k, img_id));
img_id
}
};
let _ = write!(xobjects, "/Im{} {} 0 R ", k + 1, img_id);
}
let content_id = next;
let page_id = next + 1;
next += 2;
out.stream(content_id, "", content.as_bytes())?;
drop(content);
let xo = if xobjects.is_empty() { String::new() } else { format!(" /XObject << {xobjects}>>") };
let mut link_refs = String::new();
for link in links {
if matches!(&link.target, LinkTarget::Page { index, .. } if *index >= page_count) {
continue;
}
let id = next;
next += 1;
let _ = write!(link_refs, "{id} 0 R ");
annotations.push((id, link));
}
let annots = if link_refs.is_empty() { String::new() } else { format!(" /Annots [{link_refs}]") };
out.object(
page_id,
&format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {} {}] /Resources << /Font << {}>>{} >> /Contents {} 0 R{} >>",
n(page.width),
n(page.height),
page_fonts,
xo,
content_id,
annots
),
)?;
kids.push(page_id);
}
for (id, link) in annotations {
let [x0, y0, x1, y1] = link.rect;
let action = match link.target {
LinkTarget::Uri(uri) => format!("/A << /S /URI /URI {} >>", pdf_uri_string(&uri)),
LinkTarget::Page { index, x, y } => {
let Some(&page_id) = kids.get(index) else { continue };
let height = self.pages.get(index).map_or(0.0, |p| p.height);
format!("/Dest [{page_id} 0 R /XYZ {} {} null]", n(x), n(height - y))
}
};
out.object(id, &format!("<< /Type /Annot /Subtype /Link /Rect [{} {} {} {}] /Border [0 0 0] {action} >>", n(x0), n(y0), n(x1), n(y1)))?;
}
out.object(1, "<< /Type /Catalog /Pages 2 0 R >>")?;
let kids_s: Vec<String> = kids.iter().map(|k| format!("{k} 0 R")).collect();
out.object(2, &format!("<< /Type /Pages /Kids [{}] /Count {} >>", kids_s.join(" "), kids.len()))?;
let creator = if self.info.creator.is_empty() { "GridCraft" } else { &self.info.creator };
let mut info = format!("<< /Producer {} /Creator {}", pdf_text_string("GridCraft PDF"), pdf_text_string(creator));
if !self.info.title.is_empty() {
let _ = write!(info, " /Title {}", pdf_text_string(&self.info.title));
}
if !self.info.author.is_empty() {
let _ = write!(info, " /Author {}", pdf_text_string(&self.info.author));
}
info.push_str(" >>");
out.object(3, &info)?;
out.finish(1, Some(3)).map_err(Error::from)
}
}
#[cfg(test)]
mod tests;
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.