blitz-pdf 0.1.1 → 0.1.2

package/vendor/krilla/src/interactive/destination.rs

@@ -0,0 +1,289 @@
+//! Destinations in a PDF document.
+//!
+//! In some cases, you might want to refer to other locations within the same document, for
+//! example when defining the outline, or when link to a different section in the document
+//! from a link. To achieve this, you can use destinations, which are associated with a page
+//! and a specific location on that page.
+
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use pdf_writer::{Obj, Ref, Str};
+use tiny_skia_path::Transform;
+
+use crate::chunk_container::ChunkContainer;
+use crate::error::{KrillaError, KrillaResult};
+use crate::geom::Point;
+use crate::serialize::{PageInfo, SerializeContext};
+
+/// The type of destination.
+#[derive(Hash)]
+pub enum Destination {
+    /// An XYZ destination.
+    Xyz(XyzDestination),
+    /// A named destination.
+    Named(NamedDestination),
+}
+
+impl Destination {
+    pub(crate) fn serialize(&self, sc: &mut SerializeContext, buffer: Obj) -> KrillaResult<()> {
+        match self {
+            Destination::Xyz(xyz) => {
+                let ref_ = sc.register_xyz_destination(xyz.clone());
+                buffer.primitive(ref_);
+
+                Ok(())
+            }
+            Destination::Named(named) => named.serialize(sc, buffer),
+        }
+    }
+}
+
+/// A destination associated with a name.
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub struct NamedDestination {
+    pub(crate) name: Arc<String>,
+    pub(crate) xyz_dest: Arc<XyzDestination>,
+}
+
+impl From<NamedDestination> for Destination {
+    fn from(val: NamedDestination) -> Self {
+        Destination::Named(val)
+    }
+}
+
+impl NamedDestination {
+    /// Create a new named destination.
+    ///
+    /// When used as part of a link annotation, the destination will be automatically registered
+    /// with the [`Document`](crate::Document).
+    ///
+    /// That said, you can also manually register a destination without linking to it by calling
+    /// [`Document::register_named_destination`](crate::Document::register_named_destination).
+    pub fn new(name: String, xyz_dest: XyzDestination) -> Self {
+        Self {
+            name: Arc::new(name),
+            xyz_dest: Arc::new(xyz_dest),
+        }
+    }
+
+    pub(crate) fn serialize(
+        &self,
+        sc: &mut SerializeContext,
+        destination: Obj,
+    ) -> KrillaResult<()> {
+        sc.register_named_destination(self.clone())
+            .ok_or_else(|| KrillaError::DuplicateNamedDestination(Arc::clone(&self.name)))?;
+        destination.primitive(Str(self.name.as_bytes()));
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct XyzDestRepr {
+    page_index: usize,
+    point: Point,
+}
+
+impl Hash for XyzDestRepr {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.page_index.hash(state);
+        self.point.x.to_bits().hash(state);
+        self.point.y.to_bits().hash(state);
+    }
+}
+
+impl PartialEq for XyzDestRepr {
+    fn eq(&self, other: &Self) -> bool {
+        self.page_index == other.page_index
+            && self.point.x == other.point.x
+            && self.point.y == other.point.y
+    }
+}
+
+impl Eq for XyzDestRepr {}
+
+/// A destination pointing to a specific location at a specific page.
+#[derive(Clone, Hash, PartialEq, Eq, Debug)]
+pub struct XyzDestination(Arc<XyzDestRepr>);
+
+impl From<XyzDestination> for Destination {
+    fn from(val: XyzDestination) -> Self {
+        Destination::Xyz(val)
+    }
+}
+
+impl XyzDestination {
+    /// Create a new XYZ destination. `page_index` should be the index (i.e. number) of the
+    /// target page, and point indicates the specific location on that page that should be
+    /// targeted. If the `page_index` is out of range, export will panic.
+    pub fn new(page_index: usize, point: Point) -> Self {
+        Self(Arc::new(XyzDestRepr { page_index, point }))
+    }
+
+    pub(crate) fn serialize(
+        &self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let chunk = &mut chunk_container.non_stream.destinations;
+        let destination = chunk.destination(root_ref);
+
+        let page_info = sc.page_infos().get(self.0.page_index).unwrap_or_else(|| {
+            panic!(
+                "attempted to link to page {}, but document only has {} pages",
+                self.0.page_index + 1,
+                sc.page_infos().len()
+            )
+        });
+
+        let (ref_, surface_size) = match page_info {
+            PageInfo::Krilla {
+                ref_, surface_size, ..
+            } => (ref_, surface_size),
+            PageInfo::Pdf { ref_, size, .. } => (ref_, size),
+        };
+
+        let page_ref = *ref_;
+        let page_size = surface_size.height();
+
+        let mut mapped_point = self.0.point.to_tsp();
+        // Convert to PDF coordinates
+        let invert_transform = Transform::from_row(1.0, 0.0, 0.0, -1.0, 0.0, page_size);
+        invert_transform.map_point(&mut mapped_point);
+
+        destination
+            .page(page_ref)
+            .xyz(mapped_point.x, mapped_point.y, None);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use crate::annotation::{LinkAnnotation, Target};
+    use crate::error::KrillaError;
+    use crate::geom::{Point, Rect};
+    use crate::Document;
+
+    use super::{NamedDestination, XyzDestination};
+
+    #[test]
+    fn named_duplicate_rejected() {
+        let mut document = Document::new();
+        assert_eq!(
+            document.register_named_destination(NamedDestination::new(
+                "same".to_string(),
+                XyzDestination::new(0, Point::from_xy(0.0, 0.0)),
+            )),
+            Some(())
+        );
+        assert_eq!(
+            document.register_named_destination(NamedDestination::new(
+                "same".to_string(),
+                XyzDestination::new(0, Point::from_xy(100.0, 100.0)),
+            )),
+            None
+        );
+    }
+
+    #[test]
+    fn named_duplicate_same_location_allowed() {
+        let mut document = Document::new();
+        assert_eq!(
+            document.register_named_destination(NamedDestination::new(
+                "same".to_string(),
+                XyzDestination::new(0, Point::from_xy(0.0, 0.0)),
+            )),
+            Some(())
+        );
+        assert_eq!(
+            document.register_named_destination(NamedDestination::new(
+                "same".to_string(),
+                XyzDestination::new(0, Point::from_xy(0.0, 0.0)),
+            )),
+            Some(())
+        );
+
+        assert!(document.finish().is_ok());
+    }
+
+    #[test]
+    fn named_duplicate_annotation_rejected() {
+        let mut document = Document::new();
+        let mut page = document.start_page();
+
+        page.add_annotation(
+            LinkAnnotation::new(
+                Rect::from_xywh(0.0, 0.0, 100.0, 100.0).unwrap(),
+                Target::Destination(
+                    NamedDestination::new(
+                        "same".to_string(),
+                        XyzDestination::new(0, Point::from_xy(0.0, 0.0)),
+                    )
+                    .into(),
+                ),
+            )
+            .into(),
+        );
+        page.add_annotation(
+            LinkAnnotation::new(
+                Rect::from_xywh(0.0, 100.0, 100.0, 100.0).unwrap(),
+                Target::Destination(
+                    NamedDestination::new(
+                        "same".to_string(),
+                        XyzDestination::new(0, Point::from_xy(100.0, 100.0)),
+                    )
+                    .into(),
+                ),
+            )
+            .into(),
+        );
+        drop(page);
+
+        assert_eq!(
+            document.finish(),
+            Err(KrillaError::DuplicateNamedDestination(Arc::new(
+                "same".to_string()
+            )))
+        );
+    }
+
+    #[test]
+    fn named_duplicate_manual_then_annotation_rejected() {
+        let mut document = Document::new();
+        assert_eq!(
+            document.register_named_destination(NamedDestination::new(
+                "same".to_string(),
+                XyzDestination::new(0, Point::from_xy(0.0, 0.0)),
+            )),
+            Some(())
+        );
+
+        let mut page = document.start_page();
+        page.add_annotation(
+            LinkAnnotation::new(
+                Rect::from_xywh(0.0, 0.0, 100.0, 100.0).unwrap(),
+                Target::Destination(
+                    NamedDestination::new(
+                        "same".to_string(),
+                        XyzDestination::new(0, Point::from_xy(100.0, 100.0)),
+                    )
+                    .into(),
+                ),
+            )
+            .into(),
+        );
+        drop(page);
+
+        assert_eq!(
+            document.finish(),
+            Err(KrillaError::DuplicateNamedDestination(Arc::new(
+                "same".to_string()
+            )))
+        );
+    }
+}

package/vendor/krilla/src/interactive/mod.rs

@@ -0,0 +1,3 @@
+pub mod action;
+pub mod annotation;
+pub mod destination;

package/vendor/krilla/src/interchange/embed.rs

@@ -0,0 +1,240 @@
+//! Embedding attachments to a PDF file.
+
+use std::ops::DerefMut;
+
+use pdf_writer::{Finish, Name, Ref, Str, TextStr};
+
+use crate::chunk_container::ChunkContainer;
+use crate::configure::{PdfVersion, ValidationError};
+use crate::interchange::metadata::pdf_date;
+use crate::metadata::DateTime;
+use crate::serialize::{Cacheable, SerializeContext};
+use crate::stream::FilterStreamBuilder;
+use crate::surface::Location;
+use crate::util::NameExt;
+use crate::Data;
+
+/// An error while embedding the file.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum EmbedError {
+    /// The selected standard does not support embedding files.
+    Existence,
+    /// The document doesn't contain a modification date, which is required for embedded files
+    /// in some export modes.
+    MissingDate,
+    /// The embedded file is missing a human-readable description.
+    MissingDescription,
+    /// The mime type of the embedded file is missing.
+    MissingMimeType,
+}
+
+/// An embedded file.
+#[derive(Debug, Clone, Hash)]
+pub struct EmbeddedFile {
+    /// The name of the embedded file.
+    pub path: String,
+    /// The mime type of the embedded file.
+    pub mime_type: Option<MimeType>,
+    /// A description of the embedded file.
+    pub description: Option<String>,
+    /// The association kind of the embedded file.
+    pub association_kind: AssociationKind,
+    /// The raw data of the embedded file.
+    pub data: Data,
+    /// The modification date of the embedded file.
+    pub modification_date: Option<DateTime>,
+    /// Whether the embedded file should be compressed (recommended to turn off if the
+    /// original file already has compression). If `None`, krilla will use its own logic
+    /// for determining whether to compress the file or not.
+    pub compress: Option<bool>,
+    /// The location of the embedded file.
+    pub location: Option<Location>,
+}
+
+impl Cacheable for EmbeddedFile {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        sc.register_validation_error(ValidationError::EmbeddedFile(
+            EmbedError::Existence,
+            self.location,
+        ));
+
+        let chunk = &mut chunk_container.non_stream.embedded_files;
+        let mut stream_chunk = sc.new_chunk();
+        let stream_ref = sc.new_ref();
+
+        let file_stream = match self.compress {
+            Some(true) => FilterStreamBuilder::new_from_binary_data(self.data.as_ref()),
+            Some(false) => FilterStreamBuilder::new_from_uncompressed(self.data.as_ref()),
+            None => FilterStreamBuilder::new_auto_compressed(self.data.as_ref()),
+        }
+        .finish(&sc.serialize_settings());
+
+        let mut embedded_file_stream =
+            stream_chunk.embedded_file(stream_ref, file_stream.encoded_data());
+        file_stream.write_filters(embedded_file_stream.deref_mut().deref_mut());
+
+        if let Some(mime_type) = &self.mime_type {
+            embedded_file_stream.subtype(mime_type.0.to_pdf_name());
+        } else {
+            sc.register_validation_error(ValidationError::EmbeddedFile(
+                EmbedError::MissingMimeType,
+                self.location,
+            ));
+        }
+
+        let mut params = embedded_file_stream.params();
+        params.size(self.data.as_ref().len() as i32);
+
+        if let Some(date_time) = &self.modification_date {
+            let date = pdf_date(*date_time);
+            params.modification_date(date);
+        } else {
+            sc.register_validation_error(ValidationError::EmbeddedFile(
+                EmbedError::MissingDate,
+                self.location,
+            ));
+        }
+
+        params.finish();
+        embedded_file_stream.finish();
+
+        let mut file_spec = chunk.file_spec(root_ref);
+        file_spec.path(Str(self.path.as_bytes()));
+
+        if sc.serialize_settings().pdf_version() >= PdfVersion::Pdf17 {
+            file_spec.unic_file(TextStr(&self.path));
+        }
+
+        let mut ef = file_spec.insert(Name(b"EF")).dict();
+        ef.pair(Name(b"F"), stream_ref);
+
+        if sc.serialize_settings().pdf_version() >= PdfVersion::Pdf17 {
+            ef.pair(Name(b"UF"), stream_ref);
+        }
+
+        ef.finish();
+
+        if sc.serialize_settings().supports_associated_files() {
+            file_spec.association_kind(self.association_kind.to_pdf());
+        }
+
+        if let Some(description) = self.description {
+            file_spec.description(TextStr(&description));
+        } else {
+            sc.register_validation_error(ValidationError::EmbeddedFile(
+                EmbedError::MissingDescription,
+                self.location,
+            ));
+        }
+
+        file_spec.finish();
+        chunk_container.streams.embedded_files.push(stream_chunk);
+    }
+}
+
+/// How an embedded file relates to the PDF document it is embedded in.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum AssociationKind {
+    /// The PDF document was created from this source file.
+    Source,
+    /// This file was used to derive a visual presentation in the PDF.
+    Data,
+    /// An alternative representation of this document.
+    Alternative,
+    /// Additional resources for this document.
+    Supplement,
+    /// There is no clear relationship or it is not known.
+    Unspecified,
+}
+
+impl AssociationKind {
+    fn to_pdf(self) -> pdf_writer::types::AssociationKind {
+        match self {
+            AssociationKind::Source => pdf_writer::types::AssociationKind::Source,
+            AssociationKind::Data => pdf_writer::types::AssociationKind::Data,
+            AssociationKind::Alternative => pdf_writer::types::AssociationKind::Alternative,
+            AssociationKind::Supplement => pdf_writer::types::AssociationKind::Supplement,
+            AssociationKind::Unspecified => pdf_writer::types::AssociationKind::Unspecified,
+        }
+    }
+}
+
+/// A mime type.
+#[derive(Debug, Clone, Hash)]
+pub struct MimeType(String);
+
+impl MimeType {
+    /// Create a new mime type.
+    ///
+    /// Returns `None` if the mime type is invalid.
+    pub fn new(mime_type: &str) -> Option<Self> {
+        if valid_mime_type(mime_type) {
+            Some(Self(mime_type.to_string()))
+        } else {
+            None
+        }
+    }
+}
+
+fn valid_mime_type(mime_type: &str) -> bool {
+    let parts: Vec<&str> = mime_type.split('/').collect();
+    if parts.len() != 2 {
+        return false;
+    }
+
+    let (type_part, subtype_part) = (parts[0], parts[1]);
+
+    valid_mime_part(type_part) && valid_mime_part(subtype_part)
+}
+
+fn valid_mime_part(part: &str) -> bool {
+    if part.is_empty() {
+        return false;
+    }
+
+    part.chars()
+        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '+' || c == '.')
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn valid_mime_types() {
+        assert!(valid_mime_type("text/plain"));
+        assert!(valid_mime_type("application/pdf"));
+        assert!(valid_mime_type("image/jpeg"));
+        assert!(valid_mime_type("application/octet-stream"));
+        assert!(valid_mime_type("text/html"));
+        assert!(valid_mime_type("application/json"));
+        assert!(valid_mime_type("image/png"));
+        assert!(valid_mime_type("video/mp4"));
+        assert!(valid_mime_type("audio/mpeg"));
+        assert!(valid_mime_type("application/vnd.ms-excel"));
+        assert!(valid_mime_type("text/css"));
+        assert!(valid_mime_type("application/x-www-form-urlencoded"));
+        assert!(valid_mime_type("multipart/form-data"));
+        assert!(valid_mime_type("application/xml+svg"));
+        assert!(valid_mime_type("text/plain+charset"));
+    }
+
+    #[test]
+    fn invalid_mime_types() {
+        assert!(!valid_mime_type("source"));
+        assert!(!valid_mime_type("text/"));
+        assert!(!valid_mime_type("/plain"));
+        assert!(!valid_mime_type(""));
+        assert!(!valid_mime_type("text"));
+        assert!(!valid_mime_type("text/plain/extra"));
+        assert!(!valid_mime_type("text plain"));
+        assert!(!valid_mime_type("text\\plain"));
+        assert!(!valid_mime_type("text@plain"));
+        assert!(!valid_mime_type("text/plain*"));
+    }
+}