blitz-pdf 0.1.0 → 0.1.2

package/vendor/krilla/src/graphics/shading_pattern.rs

@@ -0,0 +1,60 @@
+use std::hash::Hash;
+use std::sync::Arc;
+
+use pdf_writer::{Finish, Name, Ref};
+
+use crate::chunk_container::ChunkContainer;
+use crate::geom::Transform;
+use crate::graphics::shading_function::{GradientProperties, ShadingFunction};
+use crate::resource;
+use crate::resource::Resourceable;
+use crate::serialize::{Cacheable, SerializeContext};
+
+#[derive(Debug, PartialEq)]
+struct Repr {
+    shading_function: ShadingFunction,
+    shading_transform: Transform,
+}
+
+impl Eq for Repr {}
+
+impl Hash for Repr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.shading_function.hash(state);
+        self.shading_transform.hash(state);
+    }
+}
+
+#[derive(Debug, Hash, Eq, PartialEq, Clone)]
+pub(crate) struct ShadingPattern(Arc<Repr>);
+
+impl ShadingPattern {
+    pub fn new(gradient_properties: GradientProperties, shading_transform: Transform) -> Self {
+        Self(Arc::new(Repr {
+            // CTM doesn't need to be included to calculate the domain of the shading function
+            shading_function: ShadingFunction::new(gradient_properties, false),
+            shading_transform,
+        }))
+    }
+}
+
+impl Cacheable for ShadingPattern {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let shading_ref = sc.register_cacheable(chunk_container, self.0.shading_function.clone());
+        let chunk = &mut chunk_container.non_stream.patterns;
+        let mut shading_pattern = chunk.shading_pattern(root_ref);
+        shading_pattern.pair(Name(b"Shading"), shading_ref);
+        shading_pattern.matrix(self.0.shading_transform.to_pdf_transform());
+
+        shading_pattern.finish();
+    }
+}
+
+impl Resourceable for ShadingPattern {
+    type Resource = resource::Pattern;
+}

package/vendor/krilla/src/graphics/tiling_pattern.rs

@@ -0,0 +1,119 @@
+//! Tiling patterns.
+
+use std::hash::{Hash, Hasher};
+use std::ops::DerefMut;
+
+use pdf_writer::types::{PaintType, TilingType};
+use pdf_writer::{Finish, Ref};
+
+use crate::chunk_container::ChunkContainer;
+use crate::geom::Transform;
+use crate::num::NormalizedF32;
+use crate::resource;
+use crate::resource::Resourceable;
+use crate::serialize::{Cacheable, SerializeContext};
+use crate::stream::StreamBuilder;
+use crate::stream::{FilterStreamBuilder, Stream};
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct TilingPattern {
+    stream: Stream,
+    transform: Transform,
+    base_opacity: NormalizedF32,
+    width: f32,
+    height: f32,
+}
+
+impl Eq for TilingPattern {}
+
+impl Hash for TilingPattern {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.stream.hash(state);
+        self.transform.hash(state);
+        self.base_opacity.hash(state);
+        self.width.to_bits().hash(state);
+        self.height.to_bits().hash(state);
+    }
+}
+
+impl TilingPattern {
+    pub(crate) fn new(
+        stream: Stream,
+        transform: Transform,
+        base_opacity: NormalizedF32,
+        width: f32,
+        height: f32,
+        serializer_context: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+    ) -> Self {
+        // stroke/fill opacity doesn't work consistently across different viewers for patterns,
+        // so instead we simulate it ourselves.
+        let pattern_stream = if base_opacity == NormalizedF32::ONE {
+            stream
+        } else {
+            let stream = {
+                let mut builder = StreamBuilder::new(serializer_context, chunk_container);
+                let mut surface = builder.surface();
+                surface.draw_opacified_stream(base_opacity, stream);
+                surface.finish();
+                builder.finish()
+            };
+
+            stream
+        };
+
+        Self {
+            stream: pattern_stream,
+            transform,
+            base_opacity,
+            width,
+            height,
+        }
+    }
+}
+
+impl Cacheable for TilingPattern {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let mut chunk = sc.new_chunk();
+
+        for validation_error in self.stream.validation_errors {
+            sc.register_validation_error(validation_error);
+        }
+
+        let pattern_stream = FilterStreamBuilder::new_from_content_stream(
+            &self.stream.content,
+            &sc.serialize_settings(),
+        )
+        .finish(&sc.serialize_settings());
+        let mut tiling_pattern = chunk.tiling_pattern(root_ref, pattern_stream.encoded_data());
+        pattern_stream.write_filters(tiling_pattern.deref_mut().deref_mut());
+
+        self.stream.resource_dictionary.to_pdf_resources(
+            &mut tiling_pattern,
+            sc,
+            &mut chunk_container.non_stream.resource_dictionaries,
+        );
+
+        let final_bbox = pdf_writer::Rect::new(0.0, 0.0, self.width, self.height);
+
+        tiling_pattern
+            .tiling_type(TilingType::ConstantSpacing)
+            .paint_type(PaintType::Colored)
+            .bbox(final_bbox)
+            .matrix(self.transform.to_pdf_transform())
+            .x_step(final_bbox.x2 - final_bbox.x1)
+            .y_step(final_bbox.y2 - final_bbox.y1);
+
+        tiling_pattern.finish();
+        chunk_container.streams.patterns.push(chunk);
+    }
+}
+
+impl Resourceable for TilingPattern {
+    type Resource = resource::Pattern;
+}

package/vendor/krilla/src/graphics/xobject.rs

@@ -0,0 +1,150 @@
+use std::ops::DerefMut;
+use std::sync::Arc;
+
+use pdf_writer::{Finish, Name, Ref};
+
+use crate::chunk_container::ChunkContainer;
+use crate::configure::ValidationError;
+use crate::geom::Rect;
+use crate::graphics::color::{rgb, DEVICE_RGB};
+use crate::resource;
+use crate::resource::{Resource, Resourceable};
+use crate::serialize::{Cacheable, MaybeDeviceColorSpace, SerializeContext};
+use crate::stream::{FilterStreamBuilder, Stream};
+use crate::util::{NameExt, Prehashed};
+
+#[derive(Debug, Hash, Eq, PartialEq)]
+struct Repr {
+    stream: Stream,
+    isolated: bool,
+    transparency_group_color_space: bool,
+    custom_bbox: Option<Rect>,
+}
+
+#[derive(Debug, Hash, Clone, Eq, PartialEq)]
+pub(crate) struct XObject(Arc<Prehashed<Repr>>);
+
+impl XObject {
+    pub(crate) fn new(
+        stream: Stream,
+        isolated: bool,
+        mut transparency_group_color_space: bool,
+        custom_bbox: Option<Rect>,
+    ) -> Self {
+        // In case a mask was invoked in the content stream, we _always_ create
+        // a new transparency group. Please see <https://github.com/typst/typst/issues/5509>.
+        // Just to provide a brief explanation: I have not found any mention
+        // of a transparency group being required when using a soft mask in the
+        // PDF spec. However, Apple Preview (and only them!) have a weird bug
+        // where if you transform an XObject with a soft mask but not transparency
+        // group, the transform gets applied twice to the mask, resulting in
+        // rendering issues. Using a transparency group in this case seems to
+        // fix the issue.
+        // TODO: Apply group transparency to page as well.
+        transparency_group_color_space |= stream.uses_mask;
+
+        Self(Arc::new(Prehashed::new(Repr {
+            stream,
+            isolated,
+            transparency_group_color_space,
+            custom_bbox,
+        })))
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.0.stream.is_empty()
+    }
+
+    pub(crate) fn bbox(&self) -> Rect {
+        self.0.custom_bbox.unwrap_or(self.0.stream.bbox)
+    }
+}
+
+impl Cacheable for XObject {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let mut chunk = sc.new_chunk();
+
+        for validation_error in &self.0.stream.validation_errors {
+            sc.register_validation_error(validation_error.clone());
+        }
+
+        let use_transparency_group = self.0.isolated || self.0.transparency_group_color_space;
+
+        if use_transparency_group {
+            sc.register_validation_error(ValidationError::Transparency(sc.location));
+        }
+
+        let serialize_settings = sc.serialize_settings();
+
+        // "Ordinarily, the CS entry may be present only for isolated transparency groups (those
+        // for which I is true), and even then it is optional. However, this entry shall be present in
+        // the group attributes dictionary for any transparency group XObject that has no parent
+        // group or page from which to inherit."
+        //
+        // So while we don't technically always need to write it, let's just play it save
+        // and always add a group color space in case we have a transparency group.
+        let transparency_group_cs = if use_transparency_group {
+            Some(sc.register_colorspace(
+                chunk_container,
+                rgb::color_space(serialize_settings.no_device_cs).into(),
+            ))
+        } else {
+            None
+        };
+
+        let x_object_stream = FilterStreamBuilder::new_from_content_stream(
+            &self.0.stream.content,
+            &serialize_settings,
+        )
+        .finish(&serialize_settings);
+        let mut x_object = chunk.form_xobject(root_ref, x_object_stream.encoded_data());
+        x_object_stream.write_filters(x_object.deref_mut().deref_mut());
+
+        self.0.stream.resource_dictionary.to_pdf_resources(
+            &mut x_object,
+            sc,
+            &mut chunk_container.non_stream.resource_dictionaries,
+        );
+        x_object.bbox(
+            self.0
+                .custom_bbox
+                .unwrap_or(self.0.stream.bbox)
+                .to_pdf_rect(),
+        );
+
+        if use_transparency_group {
+            let mut group = x_object.group();
+            let transparency = group.transparency();
+
+            if self.0.isolated {
+                transparency.isolated(self.0.isolated);
+            }
+
+            if let Some(transparency_group_cs) = transparency_group_cs {
+                let pdf_cs = transparency.insert(Name(b"CS"));
+
+                match transparency_group_cs {
+                    MaybeDeviceColorSpace::DeviceRgb => pdf_cs.primitive(DEVICE_RGB.to_pdf_name()),
+                    // Can only be SRGB
+                    MaybeDeviceColorSpace::ColorSpace(cs) => pdf_cs.primitive(cs.get_ref()),
+                    _ => unreachable!(),
+                }
+            }
+
+            transparency.finish();
+            group.finish();
+        }
+
+        x_object.finish();
+        chunk_container.streams.x_objects.push(chunk);
+    }
+}
+
+impl Resourceable for XObject {
+    type Resource = resource::XObject;
+}

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

@@ -0,0 +1,68 @@
+//! PDF actions, allowing you to add interactivity to the document.
+//!
+//! PDF has the concept of "actions", which encompass things like navigating to a URL,
+//! opening some file on the system, and so on. The PDF reference defines a whole bunch
+//! of actions, but krilla does not expose nearly all of them, and never will. As of right now,
+//! the only available action is the link action, which allows you to specify a link that
+//! should be opened, when activating the action.
+
+use pdf_writer::types::ActionType;
+use pdf_writer::{Name, Str};
+
+use crate::error::KrillaResult;
+use crate::interactive::destination::Destination;
+use crate::serialize::SerializeContext;
+
+/// A type of action.
+pub enum Action {
+    /// A link action.
+    Link(LinkAction),
+    /// A go-to action.
+    Goto(Destination),
+}
+
+impl Action {
+    pub(crate) fn serialize(
+        &self,
+        sc: &mut SerializeContext,
+        mut action: pdf_writer::writers::Action,
+    ) -> KrillaResult<()> {
+        match self {
+            Action::Link(link) => {
+                link.serialize(action);
+
+                Ok(())
+            }
+            Action::Goto(dest) => {
+                let dest_entry = action.action_type(ActionType::GoTo).insert(Name(b"D"));
+                dest.serialize(sc, dest_entry)
+            }
+        }
+    }
+}
+
+/// A link action. Will open a link when clicked.
+pub struct LinkAction {
+    uri: String,
+}
+
+impl From<LinkAction> for Action {
+    fn from(value: LinkAction) -> Self {
+        Action::Link(value)
+    }
+}
+
+impl LinkAction {
+    /// Create a new link action that will open a URI when clicked.
+    pub fn new(uri: String) -> Self {
+        Self { uri }
+    }
+}
+
+impl LinkAction {
+    fn serialize(&self, mut action: pdf_writer::writers::Action) {
+        action
+            .action_type(ActionType::Uri)
+            .uri(Str(self.uri.as_bytes()));
+    }
+}

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

@@ -0,0 +1,283 @@
+//! PDF annotations, allowing you to add extra "content" to specific pages.
+//!
+//! PDF has the concept of annotations, which allow you to associate certain regions of
+//! a page with an "annotation". The PDF reference defines many different actions, however,
+//! krilla does not and never will expose all of them. As of right now, the only annotations
+//! that are supported are "link annotations", which allow you associate a certain region of
+//! the page with a link.
+
+use core::f32;
+
+use pdf_writer::types::AnnotationFlags;
+use pdf_writer::{Finish, Name, Ref, TextStr};
+
+use crate::chunk_container::ChunkContainer;
+use crate::color::Color;
+use crate::configure::{PdfVersion, ValidationError};
+use crate::error::KrillaResult;
+use crate::geom::{Quadrilateral, Rect};
+use crate::interactive::action::Action;
+use crate::interactive::destination::Destination;
+use crate::page::page_root_transform;
+use crate::serialize::SerializeContext;
+use crate::surface::Location;
+
+/// An annotation.
+pub struct Annotation {
+    pub(crate) annotation_type: AnnotationType,
+    pub(crate) alt: Option<String>,
+    pub(crate) struct_parent: Option<i32>,
+    pub(crate) location: Option<Location>,
+}
+
+impl Annotation {
+    /// Create a new link annotation with some alt text.
+    ///
+    /// Note that the alt text might be required in some cases, for example
+    /// when exporting to PDF/UA.
+    pub fn new_link(annotation: LinkAnnotation, alt_text: Option<String>) -> Self {
+        Self {
+            annotation_type: AnnotationType::Link(annotation),
+            alt: alt_text,
+            struct_parent: None,
+            location: None,
+        }
+    }
+
+    /// Sets the location of the annotation.
+    pub fn with_location(mut self, location: Option<Location>) -> Self {
+        self.location = location;
+        self
+    }
+}
+
+impl From<LinkAnnotation> for Annotation {
+    fn from(value: LinkAnnotation) -> Self {
+        Self {
+            annotation_type: AnnotationType::Link(value),
+            alt: None,
+            struct_parent: None,
+            location: None,
+        }
+    }
+}
+
+impl Annotation {
+    pub(crate) fn serialize(
+        &self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+        page_height: f32,
+    ) -> KrillaResult<()> {
+        let chunk = &mut chunk_container.non_stream.annotations;
+        let mut annotation = chunk
+            .indirect(root_ref)
+            .start::<pdf_writer::writers::Annotation>();
+
+        self.annotation_type
+            .serialize_type(sc, &mut annotation, page_height)?;
+
+        let AnnotationType::Link(l) = &self.annotation_type;
+        // Only set the print flag when really necessary (only PDF/A). Don't
+        // set it by default, so annotations with color borders will be shown
+        // on a screen but not printed.
+        // TODO: No need to write the print flag even if it is `None`,
+        // only for PDF/A.
+        if l.border.is_none()
+            || sc
+                .serialize_settings()
+                .configuration
+                .validators()
+                .requires_annotation_flags()
+        {
+            annotation.flags(AnnotationFlags::PRINT);
+        }
+
+        if let Some(struct_parent) = self.struct_parent {
+            annotation.struct_parent(struct_parent);
+        }
+
+        if let Some(alt_text) = &self.alt {
+            annotation.contents(TextStr(alt_text));
+        }
+
+        if self.alt.as_ref().is_none_or(String::is_empty) {
+            sc.register_validation_error(ValidationError::MissingAnnotationAltText(self.location));
+        }
+
+        annotation.finish();
+
+        Ok(())
+    }
+}
+
+/// A type of annotation.
+pub enum AnnotationType {
+    /// A link annotation.
+    Link(LinkAnnotation),
+}
+
+impl AnnotationType {
+    fn serialize_type(
+        &self,
+        sc: &mut SerializeContext,
+        annotation: &mut pdf_writer::writers::Annotation,
+        page_height: f32,
+    ) -> KrillaResult<()> {
+        match self {
+            AnnotationType::Link(l) => l.serialize_type(sc, annotation, page_height),
+        }
+    }
+}
+
+/// An annotation target.
+pub enum Target {
+    /// A destination within the document.
+    Destination(Destination),
+    /// An action to be performed.
+    Action(Action),
+}
+
+/// Border of a link annotation.
+pub struct LinkBorder {
+    pub(crate) width: f32,
+    pub(crate) color: Color,
+}
+
+impl LinkBorder {
+    /// Create a new link annotation border.
+    ///
+    /// `width`: The width of the border in pt.
+    /// `color`: The color of the border.
+    pub fn new(width: f32, color: Color) -> Self {
+        Self { width, color }
+    }
+}
+
+/// A link annotation.
+pub struct LinkAnnotation {
+    pub(crate) rect: Rect,
+    pub(crate) quad_points: Option<Vec<Quadrilateral>>,
+    pub(crate) target: Target,
+    pub(crate) border: Option<LinkBorder>,
+}
+
+impl LinkAnnotation {
+    /// Create a new link annotation.
+    ///
+    /// `rect`: The bounding box of the link annotation that it should cover on the page.
+    /// `target`: The target of the link annotation.
+    pub fn new(rect: Rect, target: Target) -> Self {
+        Self {
+            rect,
+            quad_points: None,
+            target,
+            border: None,
+        }
+    }
+
+    /// Create a new link annotation.
+    ///
+    /// `target`: The target of the link annotation.
+    /// `quad_points`: An array of quadrilaterals that define where the link
+    /// annotation should be activated. This is useful if you for example have
+    /// a link annotation that is broken to one or multiple lines.
+    pub fn new_with_quad_points(quad_points: Vec<Quadrilateral>, target: Target) -> Self {
+        assert!(!quad_points.is_empty());
+
+        let mut min_x = f32::INFINITY;
+        let mut min_y = f32::INFINITY;
+        let mut max_x = f32::NEG_INFINITY;
+        let mut max_y = f32::NEG_INFINITY;
+
+        for point in quad_points.iter().flat_map(|q| q.0) {
+            min_x = min_x.min(point.x);
+            min_y = min_y.min(point.y);
+            max_x = max_x.max(point.x);
+            max_y = max_y.max(point.y);
+        }
+
+        // Expand the bounding box by a little. There is a bug in adobe acrobat
+        // that sometimes prevents the quadpoints from being used if the quad
+        // points lie exactly on the bounding rectangle.
+        const EPSILON: f32 = 0.001;
+        let rect = Rect::from_ltrb(
+            min_x - EPSILON,
+            min_y - EPSILON,
+            max_x + EPSILON,
+            max_y + EPSILON,
+        )
+        .unwrap();
+
+        Self {
+            rect,
+            quad_points: Some(quad_points),
+            target,
+            border: None,
+        }
+    }
+
+    /// Set a border for this link annotation. The border will be visible on
+    /// screen but not when printed, unless when exporting with PDF/A standard.
+    pub fn with_border(self, border: LinkBorder) -> Self {
+        Self {
+            border: Some(border),
+            ..self
+        }
+    }
+
+    fn serialize_type(
+        &self,
+        sc: &mut SerializeContext,
+        annotation: &mut pdf_writer::writers::Annotation,
+        page_height: f32,
+    ) -> KrillaResult<()> {
+        annotation.subtype(pdf_writer::types::AnnotationType::Link);
+
+        let actual_rect = self
+            .rect
+            .transform(page_root_transform(page_height))
+            .unwrap();
+        annotation.rect(actual_rect.to_pdf_rect());
+        annotation.border(
+            0.0,
+            0.0,
+            self.border.as_ref().map_or(0.0, |x| x.width),
+            None,
+        );
+
+        if let Some(border) = &self.border {
+            match border.color.to_regular() {
+                crate::color::RegularColor::Rgb(rgb) => {
+                    let [r, g, b] = rgb.to_pdf_color();
+                    annotation.color_rgb(r, g, b);
+                }
+                crate::color::RegularColor::Cmyk(cmyk) => {
+                    let [c, m, y, k] = cmyk.to_pdf_color();
+                    annotation.color_cmyk(c, m, y, k);
+                }
+                crate::color::RegularColor::Luma(gray) => {
+                    annotation.color_gray(gray.to_pdf_color());
+                }
+            }
+        }
+
+        if sc.serialize_settings().pdf_version() >= PdfVersion::Pdf16 {
+            self.quad_points.as_ref().map(|p| {
+                annotation.quad_points(p.iter().flat_map(|q| q.0).flat_map(|p| {
+                    let mut p = p.to_tsp();
+                    page_root_transform(page_height).to_tsp().map_point(&mut p);
+                    [p.x, p.y]
+                }))
+            });
+        }
+
+        match &self.target {
+            Target::Destination(destination) => {
+                destination.serialize(sc, annotation.insert(Name(b"Dest")))
+            }
+            Target::Action(action) => action.serialize(sc, annotation.action()),
+        }
+    }
+}