imprimatur 0.1.0 → 0.3.0

data/ext/imprimatur_native/core/src/pdf/layout.rs

@@ -8,13 +8,11 @@ use std::fmt::{self, Arguments, Write as _};
 
 use super::font::Face;
 use super::objects::{Num, push_string};
-use crate::doc::{PageSize, Paragraph, Table};
+use crate::doc::{Document, Paragraph, Picture, Table};
 use crate::style::{Align, Color};
 use crate::{Error, Result};
 use wrap::{Line, Look, wrap};
 
-/// One inch on every side.
-const MARGIN: f64 = 72.0;
 const BODY_SIZE: f64 = 11.0;
 const TABLE_SIZE: f64 = 10.0;
 /// Line height as a multiple of the font size.
@@ -32,6 +30,7 @@ const HEADINGS: [(f64, f64, Option<Color>); 3] =
 pub struct Layout {
     width: f64,
     height: f64,
+    margin: f64,
     pages: Vec<Vec<u8>>,
     /// The top of the free space on the current page, from the bottom edge.
     y: f64,
@@ -39,9 +38,15 @@ pub struct Layout {
 }
 
 impl Layout {
-    pub fn new(size: PageSize) -> Self {
-        let (width, height) = size.points();
-        Self { width, height, pages: vec![Vec::new()], y: height - MARGIN, blank: true }
+    /// The document's pages, between its margins.
+    ///
+    /// # Errors
+    /// [`Error::InvalidMargin`] when the margins leave no room.
+    pub fn new(document: &Document) -> Result<Self> {
+        document.room()?;
+        let (width, height) = document.page_size().points();
+        let margin = document.margin();
+        Ok(Self { width, height, margin, pages: vec![Vec::new()], y: height - margin, blank: true })
     }
 
     pub const fn page_size(&self) -> (f64, f64) {
@@ -49,7 +54,7 @@ impl Layout {
     }
 
     const fn content_width(&self) -> f64 {
-        (-2.0f64).mul_add(MARGIN, self.width)
+        (-2.0f64).mul_add(self.margin, self.width)
     }
 
     pub fn heading(&mut self, level: u8, text: &str) -> Result<()> {
@@ -105,7 +110,7 @@ impl Layout {
         }
 
         let header_height = rows.first().filter(|row| row.2).map_or(0.0, |row| row.1);
-        let room = (-2.0f64).mul_add(MARGIN, self.height) - header_height;
+        let room = (-2.0f64).mul_add(self.margin, self.height) - header_height;
         for (index, (cells, height, header)) in rows.iter().enumerate() {
             (*height <= room || *header).ok_or(Error::RowTooTall(*height))?;
             // A header needs the first body row beside it.
@@ -121,6 +126,25 @@ impl Layout {
         Ok(())
     }
 
+    /// Draws picture `index` (`/Im{index}`), on a new page when it does not
+    /// fit, as its alignment says.
+    pub fn picture(&mut self, picture: &Picture, index: usize) {
+        let room = (self.content_width(), (-2.0f64).mul_add(self.margin, self.height));
+        let (width, height) = picture.size(room);
+        self.ensure_room(height);
+        let x = self.margin
+            + match picture.align.unwrap_or(Align::Left) {
+                Align::Left => 0.0,
+                Align::Center => (room.0 - width) / 2.0,
+                Align::Right => room.0 - width,
+            };
+        self.y -= height;
+        let (width, height, x, y) = (Num(width), Num(height), Num(x), Num(self.y));
+        emit(self.current(), format_args!("q {width} 0 0 {height} {x} {y} cm /Im{index} Do Q\n"));
+        self.y -= PARAGRAPH_GAP;
+        self.blank = false;
+    }
+
     pub fn page_break(&mut self) {
         self.new_page();
     }
@@ -129,14 +153,14 @@ impl Layout {
     pub fn finish(mut self, page_numbers: bool) -> Vec<Vec<u8>> {
         if page_numbers {
             let total = self.pages.len();
-            let center = self.width / 2.0;
+            let (center, margin) = (self.width / 2.0, self.margin);
             for (index, page) in self.pages.iter_mut().enumerate() {
                 let bytes = format!("{} / {total}", index + 1).into_bytes();
                 let width = Face::Regular.width(&bytes, FOOTER_SIZE);
                 let look =
                     Look { face: Face::Regular, color: Some(FOOTER_COLOR), underline: false };
                 let label = wrap::Fragment { bytes, look, width };
-                draw_fragment(page, &label, FOOTER_SIZE, center - width / 2.0, MARGIN / 2.0);
+                draw_fragment(page, &label, FOOTER_SIZE, center - width / 2.0, margin / 2.0);
             }
         }
         self.pages
@@ -146,7 +170,7 @@ impl Layout {
     /// (or the page is still blank, where nothing would fit better).
     /// Returns whether it did.
     fn ensure_room(&mut self, needed: f64) -> bool {
-        let full = !self.blank && self.y - needed < MARGIN;
+        let full = !self.blank && self.y - needed < self.margin;
         if full {
             self.new_page();
         }
@@ -155,7 +179,7 @@ impl Layout {
 
     fn new_page(&mut self) {
         self.pages.push(Vec::new());
-        self.y = self.height - MARGIN;
+        self.y = self.height - self.margin;
         self.blank = true;
     }
 
@@ -174,7 +198,7 @@ impl Layout {
             self.ensure_room(leading);
             let baseline = self.y - baseline_offset(size);
             let slack = self.content_width() - line.width;
-            let x = MARGIN
+            let x = self.margin
                 + match align {
                     Align::Left => 0.0,
                     Align::Center => slack / 2.0,
@@ -188,9 +212,8 @@ impl Layout {
 
     /// One table row from the cursor down: fill, borders, then text.
     fn row(&mut self, cells: &[Vec<Line>], height: f64, column_width: f64, header: bool) {
-        let top = self.y;
+        let (top, mut x) = (self.y, self.margin);
         let page = self.current();
-        let mut x = MARGIN;
         for lines in cells {
             let rect = format_args!(
                 "{} {} {} {} re",

data/ext/imprimatur_native/core/src/pdf/objects.rs

@@ -1,6 +1,9 @@
 //! PDF file syntax: numbered objects, compressed streams, the
 //! cross-reference table and the trailer (ISO 32000-1, section 7).
 
+#[cfg(test)]
+mod tests;
+
 use std::fmt;
 use std::io::Write;
 
@@ -34,13 +37,34 @@ impl<W: Write> PdfWriter<W> {
         self.write_fmt(format_args!("{dictionary}\nendobj\n"))
     }
 
-    /// Writes a Flate-compressed stream object.
-    pub fn stream(&mut self, id: usize, data: &[u8]) -> Result<()> {
+    /// Writes a Flate-compressed stream object with optional dictionary entries.
+    /// Names omit the leading `/`; values are already PDF syntax. For example,
+    /// embedded TrueType fonts need `Length1` to hold the decoded byte count.
+    /// The writer supplies `Length` and `Filter`; entries must not repeat them.
+    pub fn stream(
+        &mut self,
+        id: usize,
+        data: &[u8],
+        entries: &[(&str, &dyn fmt::Display)],
+    ) -> Result<()> {
         let compressed = miniz_oxide::deflate::compress_to_vec_zlib(data, LEVEL);
+        let dictionary = fmt::from_fn(|f| {
+            f.write_str("/Filter /FlateDecode")?;
+            for (name, value) in entries {
+                write!(f, " /{name} {value}")?;
+            }
+            Ok(())
+        });
+        self.stored(id, format_args!("{dictionary}"), &compressed)
+    }
+
+    /// Writes a stream object as it is stored, `dictionary` following its
+    /// `/Length`.
+    pub fn stored(&mut self, id: usize, dictionary: fmt::Arguments<'_>, data: &[u8]) -> Result<()> {
         self.begin(id)?;
-        let length = compressed.len();
-        self.write_fmt(format_args!("<< /Length {length} /Filter /FlateDecode >>\nstream\n"))?;
-        self.write(&compressed)?;
+        let length = data.len();
+        self.write_fmt(format_args!("<< /Length {length} {dictionary} >>\nstream\n"))?;
+        self.write(data)?;
         self.write(b"\nendstream\nendobj\n")
     }
 

data/ext/imprimatur_native/core/src/pdf/picture.rs

@@ -0,0 +1,197 @@
+//! Pictures as image `XObject`s: a JPEG as it is; a PNG's compressed pixels
+//! as they are, PDF reading them with the PNG predictor, unless an alpha
+//! channel needs them decoded into a soft mask.
+
+use std::borrow::Cow;
+use std::fmt::Write as _;
+
+use crate::doc::Picture;
+use crate::doc::picture::{Kind, Png};
+use crate::{Error, Result};
+
+/// The most pixels a PNG with alpha may have: it is decoded in memory.
+const MAX_DECODED: u64 = 1 << 26;
+
+/// An image stream: its dictionary after `/Length`, and its data as stored.
+pub struct Stream<'a> {
+    pub dictionary: String,
+    pub data: Cow<'a, [u8]>,
+}
+
+/// Whether the picture has a soft mask, written right after it.
+pub const fn has_mask(picture: &Picture) -> bool {
+    match &picture.kind {
+        Kind::Png(png) => alpha(png),
+        Kind::Jpeg { .. } => false,
+    }
+}
+
+/// The image, then its soft mask when it has one; `mask` is the mask's
+/// object number.
+pub fn streams(picture: &Picture, mask: usize) -> Result<Vec<Stream<'_>>> {
+    let (width, height) = picture.pixels;
+    let head = format!("/Type /XObject /Subtype /Image /Width {width} /Height {height}");
+    match &picture.kind {
+        Kind::Jpeg { components, inverted } => {
+            let space = ["DeviceGray", "", "DeviceRGB", "DeviceCMYK"][usize::from(*components) - 1];
+            let decode = if *inverted { " /Decode [1 0 1 0 1 0 1 0]" } else { "" };
+            let dictionary = format!(
+                "{head} /ColorSpace /{space} /BitsPerComponent 8 /Filter /DCTDecode{decode}"
+            );
+            Ok(vec![Stream { dictionary, data: Cow::Borrowed(&picture.data) }])
+        }
+        Kind::Png(png) if alpha(png) => decoded(png, (width, height), &head, mask),
+        Kind::Png(png) => Ok(vec![predicted(png, width, &head)]),
+    }
+}
+
+/// Alpha that only a soft mask carries: an alpha channel, or a palette's.
+const fn alpha(png: &Png) -> bool {
+    matches!(png.color, 4 | 6) || (png.color == 3 && !png.transparency.is_empty())
+}
+
+/// The compressed pixels as stored, read through the PNG predictor; a
+/// transparent color becomes a color key mask.
+fn predicted<'a>(png: &'a Png, width: u32, head: &str) -> Stream<'a> {
+    let depth = png.depth;
+    let (colors, space) = match png.color {
+        0 => (1, "/DeviceGray".to_owned()),
+        2 => (3, "/DeviceRGB".to_owned()),
+        _ => (1, indexed(&png.palette)),
+    };
+    let mut dictionary = format!(
+        "{head} /ColorSpace {space} /BitsPerComponent {depth} /Filter /FlateDecode \
+         /DecodeParms << /Predictor 15 /Colors {colors} /BitsPerComponent {depth} \
+         /Columns {width} >>"
+    );
+    if !png.transparency.is_empty() {
+        dictionary.push_str(" /Mask [");
+        for key in png.transparency.as_chunks::<2>().0 {
+            let value = u16::from_be_bytes(*key);
+            // Writing to a String cannot fail.
+            let _ = write!(dictionary, "{value} {value} ");
+        }
+        dictionary.push(']');
+    }
+    Stream { dictionary, data: Cow::Borrowed(&png.compressed) }
+}
+
+/// `[/Indexed /DeviceRGB n <palette>]`.
+fn indexed(palette: &[u8]) -> String {
+    let mut space = format!("[/Indexed /DeviceRGB {} <", palette.len() / 3 - 1);
+    for byte in palette {
+        // Writing to a String cannot fail.
+        let _ = write!(space, "{byte:02X}");
+    }
+    space.push_str(">]");
+    space
+}
+
+/// The pixels decoded into 8-bit color and alpha, both compressed again.
+fn decoded<'a>(
+    png: &Png,
+    (width, height): (u32, u32),
+    head: &str,
+    mask: usize,
+) -> Result<Vec<Stream<'a>>> {
+    let damaged = || Error::InvalidImage("a damaged PNG");
+    (u64::from(width) * u64::from(height) <= MAX_DECODED)
+        .ok_or(Error::InvalidImage("a PNG with alpha of at most 67 million pixels"))?;
+    let channels = match png.color {
+        4 => 2,
+        6 => 4,
+        _ => 1,
+    };
+    let bits = channels * usize::from(png.depth);
+    let (width, height) = (width as usize, height as usize);
+    let stride = (width * bits).div_ceil(8);
+    let filtered = miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(
+        &png.compressed,
+        height * (stride + 1),
+    )
+    .map_err(|_| damaged())?;
+    let pixels = unfilter(&filtered, stride, bits.div_ceil(8), height).ok_or_else(damaged)?;
+    let gray = png.color == 4;
+    let (mut color, mut alpha) =
+        (Vec::with_capacity(width * height * 3), Vec::with_capacity(width * height));
+    for row in pixels.chunks_exact(stride) {
+        for x in 0..width {
+            if png.color == 3 {
+                let index = usize::from(sample(row, x, png.depth));
+                let rgb = png.palette.get(index * 3..index * 3 + 3).ok_or_else(damaged)?;
+                color.extend_from_slice(rgb);
+                alpha.push(png.transparency.get(index).copied().unwrap_or(u8::MAX));
+            } else {
+                // 16-bit samples keep their high byte.
+                let step = usize::from(png.depth / 8);
+                let at = |channel: usize| row[(x * channels + channel) * step];
+                color.extend((0..channels - 1).map(at));
+                alpha.push(at(channels - 1));
+            }
+        }
+    }
+    let space = if gray { "DeviceGray" } else { "DeviceRGB" };
+    let compress = |data: &[u8]| Cow::Owned(miniz_oxide::deflate::compress_to_vec_zlib(data, 6));
+    Ok(vec![
+        Stream {
+            dictionary: format!(
+                "{head} /ColorSpace /{space} /BitsPerComponent 8 /Filter /FlateDecode \
+                 /SMask {mask} 0 R"
+            ),
+            data: compress(&color),
+        },
+        Stream {
+            dictionary: format!(
+                "{head} /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /FlateDecode"
+            ),
+            data: compress(&alpha),
+        },
+    ])
+}
+
+/// The `x`th sample of a row of `depth`-bit samples.
+fn sample(row: &[u8], x: usize, depth: u8) -> u8 {
+    let depth = usize::from(depth);
+    let (byte, shift) = (x * depth / 8, 8 - depth - x * depth % 8);
+    (row[byte] >> shift) & (u8::MAX >> (8 - depth))
+}
+
+/// PNG's filters undone (ISO/IEC 15948, 9): rows of `stride` bytes, `bpp`
+/// bytes a pixel.
+fn unfilter(data: &[u8], stride: usize, bpp: usize, rows: usize) -> Option<Vec<u8>> {
+    let mut out = vec![0_u8; stride * rows];
+    for row in 0..rows {
+        let line = data.get(row * (stride + 1)..(row + 1) * (stride + 1))?;
+        let (done, rest) = out.split_at_mut(row * stride);
+        let previous = row.checked_sub(1).map(|_| &done[done.len() - stride..]);
+        let current = &mut rest[..stride];
+        for at in 0..stride {
+            let left = at.checked_sub(bpp).map_or(0, |at| current[at]);
+            let up = previous.map_or(0, |previous| previous[at]);
+            let up_left = at.checked_sub(bpp).and_then(|at| previous.map(|previous| previous[at]));
+            let predicted = match line[0] {
+                0 => 0,
+                1 => left,
+                2 => up,
+                3 => left.midpoint(up),
+                4 => paeth(left, up, up_left.unwrap_or(0)),
+                _ => return None,
+            };
+            current[at] = line[at + 1].wrapping_add(predicted);
+        }
+    }
+    Some(out)
+}
+
+/// The neighbor nearest `left + up - up_left`.
+fn paeth(left: u8, up: u8, up_left: u8) -> u8 {
+    let estimate = i16::from(left) + i16::from(up) - i16::from(up_left);
+    let distance = |byte: u8| (estimate - i16::from(byte)).abs();
+    if distance(left) <= distance(up) && distance(left) <= distance(up_left) {
+        left
+    } else if distance(up) <= distance(up_left) {
+        up
+    } else {
+        up_left
+    }
+}

data/ext/imprimatur_native/core/src/pdf.rs

@@ -7,6 +7,7 @@ mod layout;
 #[rustfmt::skip]
 pub mod metrics;
 mod objects;
+mod picture;
 #[cfg(test)]
 mod tests;
 
@@ -26,12 +27,17 @@ const FIRST_FONT: usize = 3;
 const INFO: usize = FIRST_FONT + Face::ALL.len();
 
 pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
-    let mut layout = Layout::new(document.page_size());
+    let mut layout = Layout::new(document)?;
+    let mut pictures = Vec::new();
     for block in document.blocks() {
         match block {
             Block::Heading { level, text } => layout.heading(*level, text)?,
             Block::Paragraph(paragraph) => layout.paragraph(paragraph)?,
             Block::Table(table) => layout.table(table)?,
+            Block::Picture(picture) => {
+                layout.picture(picture, pictures.len());
+                pictures.push(picture);
+            }
             Block::PageBreak => layout.page_break(),
         }
     }
@@ -67,6 +73,23 @@ pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
         }
         Ok(())
     });
+    // Pictures follow the pages: an image, then its soft mask if it has one.
+    let mut ids = Vec::with_capacity(pictures.len());
+    let mut next = page_id(pages.len());
+    for picture in &pictures {
+        ids.push(next);
+        next += 1 + usize::from(picture::has_mask(picture));
+    }
+    let images = fmt::from_fn(|f| {
+        if !ids.is_empty() {
+            f.write_str("/XObject << ")?;
+            for (index, id) in ids.iter().enumerate() {
+                write!(f, "/Im{index} {id} 0 R ")?;
+            }
+            f.write_str(">> ")?;
+        }
+        Ok(())
+    });
     let (width, height) = (Num(width), Num(height));
     for (index, content) in pages.iter().enumerate() {
         let id = page_id(index);
@@ -74,11 +97,16 @@ pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
             id,
             format_args!(
                 "<< /Type /Page /Parent {PAGES} 0 R /MediaBox [0 0 {width} {height}] \
-                 /Resources << /Font << {fonts}>> >> /Contents {} 0 R >>",
+                 /Resources << /Font << {fonts}>> {images}>> /Contents {} 0 R >>",
                 id + 1
             ),
         )?;
-        pdf.stream(id + 1, content)?;
+        pdf.stream(id + 1, content, &[])?;
+    }
+    for (picture, id) in pictures.into_iter().zip(ids) {
+        for (offset, stream) in (0..).zip(picture::streams(picture, id + 1)?) {
+            pdf.stored(id + offset, format_args!("{}", stream.dictionary), &stream.data)?;
+        }
     }
     pdf.finish(CATALOG, INFO)
 }

data/ext/imprimatur_native/core/src/read/content.rs

@@ -13,13 +13,17 @@ use super::span;
 use crate::xlsx::push_cell_reference;
 use crate::xlsx::{DateTime, cell_reference};
 
-/// A document's content, by format.
+/// A document's content, by format. Every workbook format holds sheets.
 #[derive(Debug, Clone, PartialEq)]
 #[non_exhaustive]
 pub enum Content {
     Pdf(Vec<Page>),
     Xlsx(Vec<Sheet>),
     Docx(Vec<Block>),
+    /// An `.ods` spreadsheet.
+    Ods(Vec<Sheet>),
+    /// A legacy Excel workbook (Excel 97 to 2003).
+    Xls(Vec<Sheet>),
 }
 
 impl Content {
@@ -30,6 +34,17 @@ impl Content {
             Self::Pdf(_) => super::Format::Pdf,
             Self::Xlsx(_) => super::Format::Xlsx,
             Self::Docx(_) => super::Format::Docx,
+            Self::Ods(_) => super::Format::Ods,
+            Self::Xls(_) => super::Format::Xls,
+        }
+    }
+
+    /// A workbook's sheets, whatever its format; `None` for documents.
+    #[must_use]
+    pub fn sheets(&self) -> Option<&[Sheet]> {
+        match self {
+            Self::Xlsx(sheets) | Self::Ods(sheets) | Self::Xls(sheets) => Some(sheets),
+            Self::Pdf(_) | Self::Docx(_) => None,
         }
     }
 }
@@ -129,13 +144,86 @@ pub struct Mark {
     pub link: Option<String>,
 }
 
-/// A workbook sheet: its cells, then its comments.
-#[derive(Debug, Clone, PartialEq)]
+/// A workbook sheet: its cells and comments and, from an XLSX workbook,
+/// its column widths, data validations and cell formats.
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct Sheet {
     pub name: String,
     pub hidden: bool,
     pub cells: Grid,
     pub comments: Vec<Note>,
+    pub columns: Vec<Columns>,
+    pub validations: Vec<Validation>,
+    /// The cells with a format of their own, empty ones included.
+    pub styles: Vec<Styled>,
+}
+
+/// A run of columns, from 0, and their width in characters.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Columns {
+    pub first: u32,
+    pub last: u32,
+    pub width: Option<f64>,
+    pub hidden: bool,
+}
+
+/// A data validation rule, as the workbook stores it.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct Validation {
+    /// The cells it applies to: `B2:B100 D2`.
+    pub range: String,
+    /// `list`, `whole`, `decimal`, `date`, `time`, `textLength`, `custom`,
+    /// or `none` for an input message alone.
+    pub kind: String,
+    pub operator: Option<String>,
+    pub formula1: Option<String>,
+    pub formula2: Option<String>,
+    pub allow_blank: bool,
+    /// Whether a list shows its in-cell drop-down arrow.
+    pub dropdown: bool,
+    /// `stop`, `warning` or `information`, when a wrong value is refused.
+    pub alert: Option<String>,
+    pub error_title: Option<String>,
+    pub error: Option<String>,
+    pub prompt_title: Option<String>,
+    pub prompt: Option<String>,
+}
+
+/// A cell with a format of its own, from 0.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Styled {
+    pub row: u32,
+    pub column: u32,
+    pub look: Arc<Look>,
+}
+
+impl Styled {
+    /// The cell's A1 reference: `B2`.
+    #[must_use]
+    pub fn reference(&self) -> String {
+        reference(self.row, self.column)
+    }
+}
+
+/// How a cell format shows a cell. Colors are ARGB (`FFFF0000`), and only
+/// those given as such: theme and indexed colors are left out.
+#[derive(Debug, Clone, Default, PartialEq)]
+#[expect(clippy::struct_excessive_bools, reason = "a format's switches, as Excel keeps them")]
+pub struct Look {
+    pub font: String,
+    /// In points.
+    pub size: f64,
+    pub bold: bool,
+    pub italic: bool,
+    pub underline: bool,
+    pub color: Option<String>,
+    pub fill: Option<String>,
+    pub align: Option<String>,
+    pub valign: Option<String>,
+    pub wrap: bool,
+    /// The left border's style: `thin`, `medium`, `thick`, `dashed`...
+    pub border: Option<String>,
+    pub number_format: String,
 }
 
 /// A comment on a cell.