blitz-pdf 0.1.1 → 0.1.2

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

@@ -0,0 +1,128 @@
+//! Alpha and luminosity masks.
+
+use pdf_writer::{Finish, Name, Ref};
+
+use crate::chunk_container::ChunkContainer;
+use crate::geom::{Rect, Transform};
+use crate::graphics::shading_function::{GradientProperties, ShadingFunction};
+use crate::graphics::xobject::XObject;
+use crate::resource;
+use crate::resource::Resourceable;
+use crate::serialize::{Cacheable, SerializeContext};
+use crate::stream::Stream;
+use crate::stream::StreamBuilder;
+
+/// A mask. Can be a luminance mask or an alpha mask.
+///
+/// IMPORTANT: Note that you must only use a mask in the document that you created it with!
+/// If you use it in a different document, you will end up with an invalid PDF file.
+// TODO: Maybe we can enfore the above somehow?
+#[derive(PartialEq, Eq, Debug, Hash)]
+pub struct Mask {
+    /// The stream of the mask.
+    stream: Stream,
+    /// The type of the mask.
+    mask_type: MaskType,
+    /// A custom bbox of the mask. The only reason we need this is that for gradients with
+    /// transparencies, we create a custom mask where we call the shading operator. In this case,
+    /// we want to manually set the bbox of the underlying XObject to match the shape that the
+    /// gradient is being applied to.
+    custom_bbox: Option<Rect>,
+}
+
+impl Mask {
+    /// Create a new mask. `stream` contains the content description
+    /// of the mask, and `mask_type` indicates the type of mask.
+    pub fn new(stream: Stream, mask_type: MaskType) -> Self {
+        Self {
+            stream,
+            mask_type,
+            custom_bbox: None,
+        }
+    }
+
+    /// Create a new mask for a shading to encode the opacity channels.
+    pub(crate) fn new_from_shading(
+        gradient_properties: GradientProperties,
+        shading_transform: Transform,
+        bbox: Rect,
+        serializer_context: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+    ) -> Option<Self> {
+        match &gradient_properties {
+            GradientProperties::RadialAxialGradient(rag) => {
+                if rag.stops.iter().all(|s| s.opacity.get() == 1.0) {
+                    return None;
+                }
+            }
+            GradientProperties::PostScriptGradient(psg) => {
+                if psg.stops.iter().all(|s| s.opacity.get() == 1.0) {
+                    return None;
+                }
+            }
+        }
+
+        let shading_function = ShadingFunction::new(gradient_properties, true);
+
+        let shading_stream = {
+            let mut builder = StreamBuilder::new(serializer_context, chunk_container);
+            let mut surface = builder.surface();
+            surface.push_transform(&shading_transform);
+            surface.draw_shading(&shading_function);
+            surface.pop();
+            surface.finish();
+            builder.finish()
+        };
+
+        Some(Self {
+            stream: shading_stream,
+            mask_type: MaskType::Luminosity,
+            custom_bbox: Some(bbox),
+        })
+    }
+}
+
+/// A mask type.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub enum MaskType {
+    /// A luminosity mask.
+    Luminosity,
+    /// An alpha mask.
+    Alpha,
+}
+
+impl MaskType {
+    /// Return the PDF name of the mask type.
+    pub(crate) fn to_name(self) -> Name<'static> {
+        match self {
+            MaskType::Alpha => Name(b"Alpha"),
+            MaskType::Luminosity => Name(b"Luminosity"),
+        }
+    }
+}
+
+impl Cacheable for Mask {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let x_object = sc.register_cacheable(
+            chunk_container,
+            XObject::new(self.stream, false, true, self.custom_bbox),
+        );
+
+        let chunk = &mut chunk_container.non_stream.masks;
+        let mut dict = chunk.indirect(root_ref).dict();
+        dict.pair(Name(b"Type"), Name(b"Mask"));
+        dict.pair(Name(b"S"), self.mask_type.to_name());
+        dict.pair(Name(b"G"), x_object);
+
+        dict.finish();
+    }
+}
+
+impl Resourceable for Mask {
+    type Resource = resource::XObject;
+}

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

@@ -0,0 +1,14 @@
+pub mod blend;
+pub mod color;
+pub mod graphic;
+pub(crate) mod graphics_state;
+pub mod icc;
+#[cfg(feature = "raster-images")]
+pub mod image;
+pub mod mask;
+pub mod paint;
+pub(crate) mod separation;
+pub(crate) mod shading_function;
+pub(crate) mod shading_pattern;
+pub(crate) mod tiling_pattern;
+pub(crate) mod xobject;

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

@@ -0,0 +1,434 @@
+//! Paints that can be used for filling and stroking text or paths.
+
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use pdf_writer::types::{LineCapStyle, LineJoinStyle};
+
+use crate::color::SpecialColor;
+use crate::geom::Transform;
+use crate::graphics::color::{cmyk, luma, rgb, Color};
+use crate::num::NormalizedF32;
+use crate::stream::Stream;
+
+/// A linear gradient.
+#[derive(Debug, Clone, PartialEq)]
+pub struct LinearGradient {
+    /// The x coordinate of the first point.
+    pub x1: f32,
+    /// The y coordinate of the first point.
+    pub y1: f32,
+    /// The x coordinate of the second point.
+    pub x2: f32,
+    /// The y coordinate of the second point.
+    pub y2: f32,
+    /// A transform that should be applied to the linear gradient.
+    pub transform: Transform,
+    /// The spread method of the linear gradient.
+    pub spread_method: SpreadMethod,
+    /// The color stops of the linear gradient.
+    ///
+    /// Note that all stops need to be in the same color space.
+    pub stops: Vec<Stop>,
+    /// Whether the gradient should be anti-aliased.
+    pub anti_alias: bool,
+}
+
+impl Eq for LinearGradient {}
+
+impl Hash for LinearGradient {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.x1.to_bits().hash(state);
+        self.y1.to_bits().hash(state);
+        self.x2.to_bits().hash(state);
+        self.y2.to_bits().hash(state);
+        self.transform.hash(state);
+        self.spread_method.hash(state);
+        self.stops.hash(state);
+        self.anti_alias.hash(state);
+    }
+}
+
+/// A radial gradient.
+#[derive(Debug, Clone, PartialEq)]
+pub struct RadialGradient {
+    /// The x coordinate of the start circle.
+    pub fx: f32,
+    /// The y coordinate of the start circle.
+    pub fy: f32,
+    /// The radius of the start circle.
+    pub fr: f32,
+    /// The x coordinate of the end circle.
+    pub cx: f32,
+    /// The y coordinate of the end circle.
+    pub cy: f32,
+    /// The radius of the end circle.
+    pub cr: f32,
+    /// A transform that should be applied to the radial gradient.
+    pub transform: Transform,
+    /// The spread method of the radial gradient.
+    ///
+    /// _Note_: The spread methods `Repeat`/`Reflect` are currently not supported
+    /// for radial gradients, and will fall back to `Pad`.
+    pub spread_method: SpreadMethod,
+    /// The color stops of the radial gradient.
+    ///
+    /// Note that all stops need to be in the same color space.
+    pub stops: Vec<Stop>,
+    /// Whether the gradient should be anti-aliased.
+    pub anti_alias: bool,
+}
+
+impl Eq for RadialGradient {}
+
+impl Hash for RadialGradient {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.fx.to_bits().hash(state);
+        self.fy.to_bits().hash(state);
+        self.fr.to_bits().hash(state);
+        self.cx.to_bits().hash(state);
+        self.cy.to_bits().hash(state);
+        self.cr.to_bits().hash(state);
+        self.transform.hash(state);
+        self.spread_method.hash(state);
+        self.stops.hash(state);
+        self.anti_alias.hash(state);
+    }
+}
+
+/// A sweep gradient.
+///
+/// Angles start from the right and go counter-clockwise with increasing values.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SweepGradient {
+    /// The x coordinate of the center.
+    pub cx: f32,
+    /// The y coordinate of the center.
+    pub cy: f32,
+    /// The start angle.
+    pub start_angle: f32,
+    /// The end angle.
+    pub end_angle: f32,
+    /// A transform that should be applied to the sweep gradient.
+    pub transform: Transform,
+    /// The spread method of the sweep gradient.
+    pub spread_method: SpreadMethod,
+    /// The color stops of the sweep gradient.
+    ///
+    /// Note that all stops need to be in the same color space.
+    pub stops: Vec<Stop>,
+    /// Whether the gradient should be anti-aliased.
+    pub anti_alias: bool,
+}
+
+impl Eq for SweepGradient {}
+
+impl Hash for SweepGradient {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.cx.to_bits().hash(state);
+        self.cy.to_bits().hash(state);
+        self.start_angle.to_bits().hash(state);
+        self.end_angle.to_bits().hash(state);
+        self.transform.hash(state);
+        self.spread_method.hash(state);
+        self.stops.hash(state);
+        self.anti_alias.hash(state);
+    }
+}
+
+/// A pattern.
+///
+/// IMPORTANT: Note that you must only use a mask in the document that you created it with!
+/// If you use it in a different document, you will end up with an invalid PDF file.
+#[derive(Debug, PartialEq, Clone)]
+pub struct Pattern {
+    /// The stream of the pattern.
+    pub stream: Stream,
+    /// A transform that should be applied to the pattern.
+    pub transform: Transform,
+    /// The width of the pattern.
+    pub width: f32,
+    /// The height of the pattern.
+    pub height: f32,
+}
+
+impl Eq for Pattern {}
+
+impl Hash for Pattern {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.stream.hash(state);
+        self.transform.hash(state);
+        self.width.to_bits().hash(state);
+        self.height.to_bits().hash(state);
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub(crate) enum InnerPaint {
+    Color(Color),
+    LinearGradient(LinearGradient),
+    RadialGradient(RadialGradient),
+    SweepGradient(SweepGradient),
+    Pattern(Arc<Pattern>),
+}
+
+/// A paint.
+///
+/// You cannot construct this type directly, but instead can convert
+/// into it by calling `into` on the various types of paint, such as linear
+/// gradients and patterns.
+#[derive(Debug, Hash, Eq, PartialEq, Clone)]
+pub struct Paint(pub(crate) InnerPaint);
+
+impl Paint {
+    pub(crate) fn as_rgb(&self) -> Option<rgb::Color> {
+        match &self.0 {
+            InnerPaint::Color(c) => match c {
+                Color::Regular(c) => c.as_rgb(),
+                Color::Special(SpecialColor::Separation(c)) => c.space.fallback.as_rgb(),
+            },
+            _ => None,
+        }
+    }
+}
+
+impl From<rgb::Color> for Paint {
+    fn from(value: rgb::Color) -> Self {
+        Paint(InnerPaint::Color(value.into()))
+    }
+}
+
+impl From<luma::Color> for Paint {
+    fn from(value: luma::Color) -> Self {
+        Paint(InnerPaint::Color(value.into()))
+    }
+}
+
+impl From<cmyk::Color> for Paint {
+    fn from(value: cmyk::Color) -> Self {
+        Paint(InnerPaint::Color(value.into()))
+    }
+}
+
+impl From<Color> for Paint {
+    fn from(value: Color) -> Self {
+        Paint(InnerPaint::Color(value))
+    }
+}
+
+impl From<LinearGradient> for Paint {
+    fn from(value: LinearGradient) -> Self {
+        Paint(InnerPaint::LinearGradient(value))
+    }
+}
+
+impl From<RadialGradient> for Paint {
+    fn from(value: RadialGradient) -> Self {
+        Paint(InnerPaint::RadialGradient(value))
+    }
+}
+
+impl From<SweepGradient> for Paint {
+    fn from(value: SweepGradient) -> Self {
+        Paint(InnerPaint::SweepGradient(value))
+    }
+}
+
+impl From<Pattern> for Paint {
+    fn from(value: Pattern) -> Self {
+        Paint(InnerPaint::Pattern(Arc::new(value)))
+    }
+}
+
+/// A spread method.
+#[derive(Debug, Hash, Eq, PartialEq, Copy, Clone, Default)]
+pub enum SpreadMethod {
+    /// The pad spread method.
+    #[default]
+    Pad,
+    /// The reflect spread method.
+    Reflect,
+    /// The repeat spread method.
+    Repeat,
+}
+
+/// A color stop in a gradient.
+#[derive(Debug, Hash, Eq, PartialEq, Clone)]
+#[allow(private_bounds)]
+pub struct Stop {
+    /// The normalized offset of the stop.
+    pub offset: NormalizedF32,
+    /// The color of the stop.
+    pub color: Color,
+    /// The opacity of the stop.
+    pub opacity: NormalizedF32,
+}
+
+/// A line cap.
+#[derive(Eq, PartialEq, Debug, Clone, Copy, Default, Hash)]
+pub enum LineCap {
+    /// The butt line cap.
+    #[default]
+    Butt,
+    /// The round line cap.
+    Round,
+    /// The square line cap.
+    Square,
+}
+
+impl LineCap {
+    pub(crate) fn to_pdf_line_cap(self) -> LineCapStyle {
+        match self {
+            LineCap::Butt => LineCapStyle::ButtCap,
+            LineCap::Round => LineCapStyle::RoundCap,
+            LineCap::Square => LineCapStyle::ProjectingSquareCap,
+        }
+    }
+}
+
+/// A line join.
+#[derive(PartialEq, Eq, Debug, Clone, Copy, Default, Hash)]
+pub enum LineJoin {
+    /// The miter line join.
+    #[default]
+    Miter,
+    /// The round line join.
+    Round,
+    /// The bevel line join.
+    Bevel,
+}
+
+impl LineJoin {
+    pub(crate) fn to_pdf_line_join(self) -> LineJoinStyle {
+        match self {
+            LineJoin::Miter => LineJoinStyle::MiterJoin,
+            LineJoin::Round => LineJoinStyle::RoundJoin,
+            LineJoin::Bevel => LineJoinStyle::BevelJoin,
+        }
+    }
+}
+
+/// A stroke dash.
+#[derive(Debug, Clone, PartialEq)]
+pub struct StrokeDash {
+    /// The dash array.
+    pub array: Vec<f32>,
+    /// The offset of the dash.
+    pub offset: f32,
+}
+
+impl Eq for StrokeDash {}
+
+impl Hash for StrokeDash {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        for el in &self.array {
+            el.to_bits().hash(state);
+        }
+
+        self.offset.to_bits().hash(state);
+    }
+}
+
+/// A stroke.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Stroke {
+    /// The paint of the stroke.
+    pub paint: Paint,
+    /// The width of the stroke.
+    pub width: f32,
+    /// The miter limit of the stroke.
+    pub miter_limit: f32,
+    /// The line cap of the stroke.
+    pub line_cap: LineCap,
+    /// The line join of the stroke.
+    pub line_join: LineJoin,
+    /// The opacity of the stroke.
+    pub opacity: NormalizedF32,
+    /// The (optional) dash of the stroke.
+    pub dash: Option<StrokeDash>,
+}
+
+impl Eq for Stroke {}
+
+impl Hash for Stroke {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.paint.hash(state);
+        self.width.to_bits().hash(state);
+        self.miter_limit.to_bits().hash(state);
+        self.line_cap.hash(state);
+        self.line_join.hash(state);
+        self.opacity.hash(state);
+        self.dash.hash(state);
+    }
+}
+
+impl Default for Stroke {
+    fn default() -> Self {
+        Stroke {
+            paint: luma::Color::black().into(),
+            width: 1.0,
+            miter_limit: 10.0,
+            line_cap: LineCap::default(),
+            line_join: LineJoin::default(),
+            opacity: NormalizedF32::ONE,
+            dash: None,
+        }
+    }
+}
+
+impl Stroke {
+    pub(crate) fn into_tiny_skia(self) -> tiny_skia_path::Stroke {
+        let mut stroke = tiny_skia_path::Stroke {
+            width: self.width,
+            miter_limit: self.miter_limit,
+            line_cap: match self.line_cap {
+                LineCap::Butt => tiny_skia_path::LineCap::Butt,
+                LineCap::Round => tiny_skia_path::LineCap::Round,
+                LineCap::Square => tiny_skia_path::LineCap::Square,
+            },
+            line_join: match self.line_join {
+                LineJoin::Miter => tiny_skia_path::LineJoin::Miter,
+                LineJoin::Round => tiny_skia_path::LineJoin::Round,
+                LineJoin::Bevel => tiny_skia_path::LineJoin::Bevel,
+            },
+            dash: None,
+        };
+
+        if let Some(stroke_dash) = self.dash {
+            stroke.dash = tiny_skia_path::StrokeDash::new(stroke_dash.array, stroke_dash.offset);
+        }
+
+        stroke
+    }
+}
+
+/// A fill rule.
+#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash, Default)]
+pub enum FillRule {
+    /// The `non-zero` fill rule.
+    #[default]
+    NonZero,
+    /// The `even-odd` fill rule.
+    EvenOdd,
+}
+
+/// A fill.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Fill {
+    /// The paint of the fill.
+    pub paint: Paint,
+    /// The opacity of the fill.
+    pub opacity: NormalizedF32,
+    /// The fill rule that should be used when applying the fill.
+    pub rule: FillRule,
+}
+
+impl Default for Fill {
+    fn default() -> Self {
+        Fill {
+            paint: luma::Color::black().into(),
+            opacity: NormalizedF32::ONE,
+            rule: FillRule::default(),
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+use pdf_writer::writers::ExponentialFunction;
+use pdf_writer::{Finish, Name, Ref, Writer};
+
+use crate::chunk_container::ChunkContainer;
+use crate::color::separation::SeparationSpace;
+use crate::color::{DEVICE_CMYK, DEVICE_GRAY, DEVICE_RGB};
+use crate::resource::{self, Resource, Resourceable};
+use crate::serialize::{Cacheable, MaybeDeviceColorSpace, SerializeContext};
+
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub(crate) struct SeparationColorSpace {
+    space: SeparationSpace,
+}
+
+impl SeparationColorSpace {
+    pub fn new(space: SeparationSpace) -> Self {
+        Self { space }
+    }
+}
+
+impl Cacheable for SeparationColorSpace {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        // Delegate fallback color space registration to existing logic
+        let fallback_cs = self.space.fallback.color_space(sc);
+        let fallback_cs_resource = sc.register_colorspace(chunk_container, fallback_cs.into());
+
+        // Get fallback color components for tint function
+        let fallback_color = crate::color::Color::from(self.space.fallback).to_pdf_color();
+        let num_components = fallback_color.len();
+
+        // Determine C0 based on whether the fallback is subtractive or additive
+        // - Additive (RGB, Luma): tint 0.0 = white = [1.0, 1.0, 1.0]
+        // - Subtractive (CMYK): tint 0.0 = white = [0.0, 0.0, 0.0, 0.0]
+        let c0_value = if self.space.fallback.is_subtractive() {
+            0.0
+        } else {
+            1.0
+        };
+
+        if let Err(validation_error) = sc.validation_store().validate_separation(&self.space) {
+            sc.register_validation_error(validation_error);
+        }
+
+        let chunk = &mut chunk_container.non_stream.color_spaces;
+
+        // Write Separation color space array: [/Separation name alternateSpace tintTransform]
+        let mut array = chunk.indirect(root_ref).array();
+        array.item(Name(b"Separation"));
+
+        // Colorant name
+        array.item(self.space.colorant.to_pdf());
+
+        // Fallback color space - write as name for device CS, or ref for others
+        match fallback_cs_resource {
+            MaybeDeviceColorSpace::DeviceRgb => array.item(Name(DEVICE_RGB.as_bytes())),
+            MaybeDeviceColorSpace::DeviceGray => array.item(Name(DEVICE_GRAY.as_bytes())),
+            MaybeDeviceColorSpace::DeviceCMYK => array.item(Name(DEVICE_CMYK.as_bytes())),
+            MaybeDeviceColorSpace::ColorSpace(cs) => {
+                // Use get_ref() to extract the underlying Ref
+                array.item(cs.get_ref())
+            }
+        };
+
+        // Write Type 2 (Exponential) function for tint transform
+        // Maps tint [0.0-1.0] from white (no ink) to fallback color (full ink)
+        ExponentialFunction::start(array.push())
+            .domain([0.0, 1.0])
+            .range([0.0, 1.0].repeat(num_components))
+            // C0: white/no ink (tint = 0.0) - value depends on color space
+            .c0(vec![c0_value; num_components])
+            // C1: fallback color (tint = 1.0)
+            .c1(fallback_color)
+            .n(1.0);
+
+        array.finish();
+    }
+}
+
+impl Resourceable for SeparationColorSpace {
+    type Resource = resource::ColorSpace;
+}