use std::collections::{BTreeMap, HashMap};
use std::rc::Rc;
use pdf_writer::types::BlendMode;
use crate::document::paint::geometry::PdfSize;
use crate::document::paint::images::RenderedImage;
use crate::document::paint::paths::{RenderedPath, RenderedPathCommand, RenderedPathFillRule};
use crate::document::paint::patterns::{RenderedImagePattern, RenderedImageSourceRect};
use crate::document::paint::shapes::RenderedRoundedRect;
use crate::document::paint::text::{RenderedGlyph, RenderedTextMatrix};
use crate::document::{DocumentFont, FontProgramKind};
use crate::{Bookmark, BookmarkState, CssColor, Document, DocumentMetadata, Page};
macro_rules! pdf_static_handle {
($name:ident) => {
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct $name(usize);
};
}
pdf_static_handle!(PdfFontHandle);
pdf_static_handle!(PdfImageHandle);
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct PdfImagePatternHandle {
page_index: usize,
pattern_index: usize,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct PdfPageExtGStateHandle {
page_index: usize,
resource_index: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum PdfColorSpaceHandle {
BuiltIn(crate::css::CssColorSpace),
EmbeddedRgb(Rc<[u8]>),
}
#[derive(Debug, Clone)]
struct PdfLoweredDocumentProgram {
pages: Vec<PageContentRender>,
dynamic_resources: PdfResourceRegistry,
}
impl PdfLoweredDocumentProgram {
fn debug_assert_well_formed(&self) {
let forms = self
.pages
.iter()
.flat_map(|page| &page.form_xobjects)
.map(|form| form.id)
.collect::<std::collections::BTreeSet<_>>();
for stream in self.pages.iter().map(|page| &page.stream).chain(
self.pages
.iter()
.flat_map(|page| page.form_xobjects.iter().map(|form| &form.stream)),
) {
for dependency in stream.resource_uses.xobjects.values() {
if let PdfXObjectHandle::Form(handle) = dependency {
debug_assert!(forms.contains(handle));
}
}
}
}
}
struct PdfDocumentProgram<'a> {
catalog_id: usize,
pages_id: usize,
pages: Vec<PdfPageProgram>,
dynamic_resources: PdfResourcePlanner,
color_plan: colors::PdfColorPlan,
fonts: Vec<EmbeddedFontPlan<'a>>,
images: PdfImageProgram,
page_ext_gstates: Vec<Vec<ExtGStateObjectPlan>>,
metadata: PdfMetadataProgram,
outline: Option<OutlinePlan>,
file_id: (Vec<u8>, Vec<u8>),
}
struct PdfPageProgram {
id: usize,
content_id: Option<usize>,
size: crate::document::paint::geometry::PaintSize,
rotation: i32,
annotations: Vec<PdfAnnotationProgram>,
render: PageContentRender,
}
struct PdfImageProgram {
prepared: Vec<PreparedImageResource>,
unique_object_ids: Vec<Option<ImageObjectIds>>,
page_patterns: Vec<Vec<PageImagePatternPlan>>,
}
struct PdfMetadataProgram {
info_id: usize,
xmp_id: Option<usize>,
source: DocumentMetadata,
producer: String,
}
struct PdfAnnotationProgram {
id: usize,
rect: crate::document::paint::geometry::PaintRect,
target: String,
}
impl PdfDocumentProgram<'_> {
fn debug_assert_resolved_references_are_unique(&self) {
let mut ids = std::collections::BTreeSet::new();
let mut insert = |id| {
debug_assert!(
ids.insert(id),
"resolved PDF object references must be unique"
);
};
insert(self.catalog_id);
insert(self.pages_id);
for page in &self.pages {
insert(page.id);
if let Some(content_id) = page.content_id {
insert(content_id);
}
}
for id in self.dynamic_resources.object_ids() {
insert(id);
}
for id in self.color_plan.object_ids() {
insert(id);
}
for font in &self.fonts {
insert(font.type0_id);
insert(font.cid_font_id);
insert(font.descriptor_id);
insert(font.file_id);
insert(font.to_unicode_id);
if let Some(id) = font.cid_set_id {
insert(id);
}
}
for ids_for_image in self.images.unique_object_ids.iter().flatten() {
insert(ids_for_image.image_id.0);
if let Some(alpha) = ids_for_image.alpha_mask_id {
insert(alpha.0);
}
}
for pattern in self.images.page_patterns.iter().flatten() {
insert(pattern.id);
}
for plan in self.page_ext_gstates.iter().flatten() {
insert(plan.id);
}
insert(self.metadata.info_id);
if let Some(id) = self.metadata.xmp_id {
insert(id);
}
for annotation in self.pages.iter().flat_map(|page| &page.annotations) {
insert(annotation.id);
}
if let Some(outline) = &self.outline {
insert(outline.root_id);
for node in &outline.nodes {
insert(node.id);
}
}
}
}
#[derive(Debug, Default, Clone, PartialEq)]
struct PdfStreamResourceUses {
fonts: BTreeMap<String, PdfFontHandle>,
xobjects: BTreeMap<String, PdfXObjectHandle>,
patterns: BTreeMap<String, PdfPatternResourceHandle>,
ext_gstates: BTreeMap<String, PdfExtGStateResourceHandle>,
color_spaces: BTreeMap<String, PdfColorSpaceHandle>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum PdfXObjectHandle {
Form(PdfFormHandle),
Image(PdfImageHandle),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum PdfPatternResourceHandle {
Dynamic(PdfPatternHandle),
Image(PdfImagePatternHandle),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum PdfExtGStateResourceHandle {
Dynamic(PdfExtGStateHandle),
Page(PdfPageExtGStateHandle),
}
#[derive(Debug, Clone, PartialEq)]
struct PdfStreamProgram {
bytes: Vec<u8>,
resource_uses: PdfStreamResourceUses,
resolved_resources: Option<PdfResolvedStreamResources>,
}
#[derive(Debug, Default, Clone, PartialEq)]
struct PdfResolvedStreamResources {
fonts: BTreeMap<String, PdfResolvedReference>,
xobjects: BTreeMap<String, PdfResolvedReference>,
patterns: BTreeMap<String, PdfResolvedReference>,
ext_gstates: BTreeMap<String, PdfResolvedReference>,
color_spaces: BTreeMap<String, PdfResolvedReference>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
struct PdfResolvedReference(usize);
impl PdfResolvedStreamResources {
fn is_empty(&self) -> bool {
self.fonts.is_empty()
&& self.xobjects.is_empty()
&& self.patterns.is_empty()
&& self.ext_gstates.is_empty()
&& self.color_spaces.is_empty()
}
}
struct PdfPageResourceBindings {
xobjects: BTreeMap<String, PdfXObjectHandle>,
fonts: BTreeMap<String, PdfFontHandle>,
patterns: BTreeMap<String, PdfPatternResourceHandle>,
ext_gstates: BTreeMap<String, PdfExtGStateResourceHandle>,
color_spaces: BTreeMap<String, PdfColorSpaceHandle>,
}
impl PdfPageResourceBindings {
fn record_uses(&self, stream: &mut PdfStreamProgram) {
let bytes = &stream.bytes;
let audited = PdfStreamResourceUses {
xobjects: self
.xobjects
.iter()
.filter(|(name, _)| stream_uses_named_operator(bytes, name, b"Do"))
.map(|(name, handle)| (name.clone(), *handle))
.collect(),
fonts: self
.fonts
.iter()
.filter(|(name, _)| stream_uses_named_operator(bytes, name, b"Tf"))
.map(|(name, handle)| (name.clone(), *handle))
.collect(),
patterns: self
.patterns
.iter()
.filter(|(name, _)| {
stream_uses_named_operator(bytes, name, b"scn")
|| stream_uses_named_operator(bytes, name, b"SCN")
})
.map(|(name, handle)| (name.clone(), *handle))
.collect(),
ext_gstates: self
.ext_gstates
.iter()
.filter(|(name, _)| stream_uses_named_operator(bytes, name, b"gs"))
.map(|(name, handle)| (name.clone(), *handle))
.collect(),
color_spaces: self
.color_spaces
.iter()
.filter(|(name, _)| {
stream_uses_named_operator(bytes, name, b"cs")
|| stream_uses_named_operator(bytes, name, b"CS")
})
.map(|(name, handle)| (name.clone(), handle.clone()))
.collect(),
};
debug_assert!(
stream
.resource_uses
.fonts
.iter()
.all(|entry| audited.fonts.get(entry.0) == Some(entry.1))
&& stream
.resource_uses
.xobjects
.iter()
.all(|entry| audited.xobjects.get(entry.0) == Some(entry.1))
&& stream
.resource_uses
.patterns
.iter()
.all(|entry| audited.patterns.get(entry.0) == Some(entry.1))
&& stream
.resource_uses
.ext_gstates
.iter()
.all(|entry| audited.ext_gstates.get(entry.0) == Some(entry.1))
&& stream
.resource_uses
.color_spaces
.iter()
.all(|entry| audited.color_spaces.get(entry.0) == Some(entry.1)),
"every declared lowered PDF resource binding must select its named resource operator"
);
stream.resource_uses = audited;
}
}
fn stream_uses_named_operator(bytes: &[u8], name: &str, operator: &[u8]) -> bool {
let mut name_token = Vec::with_capacity(name.len() + 1);
name_token.push(b'/');
name_token.extend_from_slice(name.as_bytes());
bytes
.split(|byte| *byte == b'\n' || *byte == b'\r')
.any(|line| contains_pdf_token(line, &name_token) && contains_pdf_token(line, operator))
}
fn contains_pdf_token(line: &[u8], token: &[u8]) -> bool {
line.windows(token.len())
.enumerate()
.any(|(index, window)| {
window == token
&& line
.get(index.wrapping_sub(1))
.is_none_or(u8::is_ascii_whitespace)
&& line
.get(index + token.len())
.is_none_or(u8::is_ascii_whitespace)
})
}
pub(super) const PROMOTE_SOLID_RASTER_IMAGES_TO_VECTOR_FILLS: bool = true;
impl From<crate::document::paint::effects::PaintBlendMode> for BlendMode {
fn from(mode: crate::document::paint::effects::PaintBlendMode) -> Self {
match mode {
crate::document::paint::effects::PaintBlendMode::Normal => Self::Normal,
crate::document::paint::effects::PaintBlendMode::Multiply => Self::Multiply,
crate::document::paint::effects::PaintBlendMode::Screen => Self::Screen,
crate::document::paint::effects::PaintBlendMode::Overlay => Self::Overlay,
crate::document::paint::effects::PaintBlendMode::Darken => Self::Darken,
crate::document::paint::effects::PaintBlendMode::Lighten => Self::Lighten,
crate::document::paint::effects::PaintBlendMode::ColorDodge => Self::ColorDodge,
crate::document::paint::effects::PaintBlendMode::ColorBurn => Self::ColorBurn,
crate::document::paint::effects::PaintBlendMode::HardLight => Self::HardLight,
crate::document::paint::effects::PaintBlendMode::SoftLight => Self::SoftLight,
crate::document::paint::effects::PaintBlendMode::Difference => Self::Difference,
crate::document::paint::effects::PaintBlendMode::Exclusion => Self::Exclusion,
crate::document::paint::effects::PaintBlendMode::Hue => Self::Hue,
crate::document::paint::effects::PaintBlendMode::Saturation => Self::Saturation,
crate::document::paint::effects::PaintBlendMode::Color => Self::Color,
crate::document::paint::effects::PaintBlendMode::Luminosity => Self::Luminosity,
}
}
}
#[derive(Debug, Clone, PartialEq)]
struct ImageResource {
pixel_width: u32,
pixel_height: u32,
interpolate: bool,
color_space: crate::color::RasterColorSpace,
sample_depth: crate::image_store::RasterSampleDepth,
payload: ImagePayload,
}
#[derive(Debug, Clone, PartialEq)]
enum PreparedImageResource {
Transparent,
Raster(ImageResource),
SolidFill(SolidImageFill),
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct SolidImageFill {
color_space: crate::color::RasterColorSpace,
components: [u8; 3],
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum ImagePayload {
Samples {
rgb: Vec<u8>,
alpha: Option<Vec<u8>>,
},
Jpeg(Rc<[u8]>),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum ImageResourceSource {
Stored {
image_id: crate::image_store::ImageId,
source_rect: RenderedImageSourceRect,
sampling: crate::document::paint::images::RasterSampling,
target_size: crate::units::RasterPixelSize,
},
Inline {
pixel_width: u32,
pixel_height: u32,
natural_size: crate::units::CssPixelSize,
source_rect: Option<RenderedImageSourceRect>,
sampling: crate::document::paint::images::RasterSampling,
target_size: crate::units::RasterPixelSize,
color_space: crate::color::RasterColorSpace,
sample_depth: crate::image_store::RasterSampleDepth,
rgb: Rc<[u8]>,
alpha: Option<Rc<[u8]>>,
},
}
impl ImageResourceSource {
fn raster_color_space(
&self,
image_store: &crate::image_store::DocumentImageStore,
) -> crate::color::RasterColorSpace {
match self {
Self::Stored { image_id, .. } => image_store
.color_space(*image_id)
.unwrap_or(crate::color::RasterColorSpace::SRGB),
Self::Inline { color_space, .. } => color_space.clone(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ImageObjectIds {
image_id: PdfImageObjectId,
alpha_mask_id: Option<PdfImageObjectId>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct PlannedImageIndex(usize);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct PdfImageObjectId(usize);
#[derive(Debug, Clone, PartialEq)]
struct ImageResourcePlan {
unique_images: Vec<ImageResourceSource>,
page_image_unique_indexes: Vec<Vec<PlannedImageIndex>>,
page_svg_pattern_image_unique_indexes: Vec<Vec<PlannedImageIndex>>,
page_pattern_tile_unique_indexes: Vec<Vec<PlannedImageIndex>>,
}
impl ImageResourcePlan {
fn built_in_color_spaces(
&self,
image_store: &crate::image_store::DocumentImageStore,
) -> Vec<crate::css::CssColorSpace> {
let mut spaces = Vec::new();
for source in &self.unique_images {
let color_space = source.raster_color_space(image_store);
let crate::color::RasterColorSpace::BuiltIn(space) = color_space else {
continue;
};
if !spaces.contains(&space) {
spaces.push(space);
}
}
spaces
}
fn embedded_rgb_profiles(
&self,
image_store: &crate::image_store::DocumentImageStore,
) -> Vec<Rc<[u8]>> {
let mut profiles: Vec<Rc<[u8]>> = Vec::new();
for source in &self.unique_images {
let crate::color::RasterColorSpace::EmbeddedRgb(profile) =
source.raster_color_space(image_store)
else {
continue;
};
if !profiles.iter().any(|existing| {
let existing: &[u8] = existing.as_ref();
existing == profile.as_ref()
}) {
profiles.push(profile);
}
}
profiles
}
fn solid_fill_eligibility(&self, document: &Document) -> Vec<bool> {
let mut eligible = vec![true; self.unique_images.len()];
for indexes in &self.page_pattern_tile_unique_indexes {
for index in indexes {
eligible[index.0] = false;
}
}
for indexes in &self.page_svg_pattern_image_unique_indexes {
for index in indexes {
eligible[index.0] = false;
}
}
for (page, indexes) in document.pages.iter().zip(&self.page_image_unique_indexes) {
for (image, index) in page.images.iter().zip(indexes) {
if image.transform.is_some() {
eligible[index.0] = false;
}
}
}
eligible
}
}
#[derive(Debug, Clone, PartialEq)]
struct PageImagePatternPlan {
handle: PdfImagePatternHandle,
id: usize,
name: String,
tile_image_id: PdfImageObjectId,
pattern: RenderedImagePattern,
stream: PdfStreamProgram,
}
#[derive(Debug, Clone, PartialEq)]
struct ExtGStateObjectPlan {
id: usize,
resource: ExtGStateResource,
}
#[derive(Debug, Clone, PartialEq)]
struct PageContentRender {
stream: PdfStreamProgram,
form_xobjects: Vec<FormXObjectRender>,
gradient_patterns: Vec<GradientPatternPlan>,
gradient_tiling_patterns: Vec<GradientTilingPatternPlan>,
svg_tiling_patterns: Vec<SvgTilingPatternPlan>,
svg_path_tiling_patterns: Vec<SvgPathTilingPatternPlan>,
}
#[derive(Debug, Clone, PartialEq)]
struct SvgTilingPatternPlan {
id: PdfPatternHandle,
name: String,
form_id: PdfFormHandle,
form_name: String,
pattern: crate::document::paint::patterns::RenderedSvgPattern,
transform: crate::document::paint::geometry::PaintTransform,
stream: PdfStreamProgram,
}
#[derive(Debug, Clone, PartialEq)]
struct SvgPathTilingPatternPlan {
id: PdfPatternHandle,
name: String,
pattern: crate::document::paint::paths::RenderedSvgPathPattern,
stream: PdfStreamProgram,
}
#[derive(Debug, Clone, PartialEq)]
struct GradientTilingPatternPlan {
id: PdfPatternHandle,
name: String,
shading_pattern_name: String,
alpha_gstate_name: Option<String>,
pattern: crate::document::paint::patterns::RenderedGradientPattern,
stream: PdfStreamProgram,
}
#[derive(Debug, Clone, PartialEq)]
struct GradientPatternPlan {
id: PdfPatternHandle,
name: String,
function_ids: Vec<PdfFunctionHandle>,
gradient: crate::document::paint::paths::RenderedGradient,
alpha: Option<GradientAlphaPlan>,
}
#[derive(Debug, Clone, PartialEq)]
struct GradientAlphaPlan {
pattern_id: PdfPatternHandle,
pattern_name: String,
function_ids: Vec<PdfFunctionHandle>,
form_id: PdfFormHandle,
ext_gstate_id: PdfExtGStateHandle,
ext_gstate_name: String,
page_size: PdfSize,
stream: PdfStreamProgram,
}
#[derive(Debug, Clone, PartialEq)]
struct FormXObjectRender {
id: PdfFormHandle,
name: String,
bbox: crate::document::paint::geometry::PaintClip,
stream: PdfStreamProgram,
kind: PdfFormKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PdfFormKind {
Ordinary,
TransparencyGroup {
blending_space: colors::PdfBlendColorSpace,
},
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
struct FormXObjectReference {
id: PdfFormHandle,
name: String,
}
#[cfg(test)]
mod resource_program_tests {
use super::*;
#[test]
fn symbolic_resources_resolve_to_unique_deterministic_object_references() {
let mut registry = PdfResourceRegistry::default();
let form = registry.form();
let pattern = registry.pattern();
let function = registry.function();
let gstate = registry.ext_gstate();
let planner = PdfResourcePlanner::from_object_ids(®istry, vec![41, 42, 43, 44]);
assert_eq!(planner.form(form), 41);
assert_eq!(planner.pattern(pattern), 42);
assert_eq!(planner.function(function), 43);
assert_eq!(planner.ext_gstate(gstate), 44);
}
#[test]
fn nested_form_dependencies_are_scoped_to_the_calling_stream() {
let mut registry = PdfResourceRegistry::default();
let parent = registry.form();
let child = registry.form();
let parent_form = FormXObjectRender {
id: parent,
name: "Fm1".into(),
bbox: crate::document::paint::geometry::PaintClip::new(0.0, 0.0, 1.0, 1.0),
stream: PdfStreamProgram {
bytes: Vec::new(),
resource_uses: PdfStreamResourceUses {
xobjects: [("Fm2".into(), PdfXObjectHandle::Form(child))].into(),
..PdfStreamResourceUses::default()
},
resolved_resources: None,
},
kind: PdfFormKind::TransparencyGroup {
blending_space: colors::PdfBlendColorSpace::Srgb,
},
};
let child_form = FormXObjectRender {
id: child,
name: "Fm2".into(),
bbox: crate::document::paint::geometry::PaintClip::new(0.0, 0.0, 1.0, 1.0),
stream: PdfStreamProgram {
bytes: Vec::new(),
resource_uses: PdfStreamResourceUses::default(),
resolved_resources: None,
},
kind: PdfFormKind::Ordinary,
};
let program = PdfLoweredDocumentProgram {
pages: vec![PageContentRender {
stream: PdfStreamProgram {
bytes: Vec::new(),
resource_uses: PdfStreamResourceUses {
xobjects: [("Fm1".into(), PdfXObjectHandle::Form(parent))].into(),
..PdfStreamResourceUses::default()
},
resolved_resources: None,
},
form_xobjects: vec![parent_form, child_form],
gradient_patterns: Vec::new(),
gradient_tiling_patterns: Vec::new(),
svg_tiling_patterns: Vec::new(),
svg_path_tiling_patterns: Vec::new(),
}],
dynamic_resources: registry,
};
program.debug_assert_well_formed();
assert_eq!(
program.pages[0].form_xobjects[0]
.stream
.resource_uses
.xobjects
.len(),
1
);
}
#[test]
fn final_operator_audit_scopes_each_named_resource_category() {
let mut registry = PdfResourceRegistry::default();
let form = registry.form();
let bindings = PdfPageResourceBindings {
xobjects: [
("Fm1".into(), PdfXObjectHandle::Form(form)),
("Im1".into(), PdfXObjectHandle::Image(PdfImageHandle(0))),
("Im2".into(), PdfXObjectHandle::Image(PdfImageHandle(1))),
]
.into(),
fonts: [
("F1".into(), PdfFontHandle(0)),
("F2".into(), PdfFontHandle(1)),
]
.into(),
patterns: [
(
"SG1".into(),
PdfPatternResourceHandle::Dynamic(registry.pattern()),
),
(
"P1".into(),
PdfPatternResourceHandle::Image(PdfImagePatternHandle {
page_index: 0,
pattern_index: 0,
}),
),
]
.into(),
ext_gstates: [
(
"GSalpha500".into(),
PdfExtGStateResourceHandle::Dynamic(registry.ext_gstate()),
),
(
"GSblendMultiply".into(),
PdfExtGStateResourceHandle::Page(PdfPageExtGStateHandle {
page_index: 0,
resource_index: 0,
}),
),
]
.into(),
color_spaces: [
(
"CSsRGB".into(),
PdfColorSpaceHandle::BuiltIn(crate::css::CssColorSpace::Srgb),
),
(
"CSDisplayP3".into(),
PdfColorSpaceHandle::BuiltIn(crate::css::CssColorSpace::DisplayP3),
),
]
.into(),
};
let mut stream = PdfStreamProgram {
bytes: b"/CSsRGB cs\n/F1 12 Tf\n/Im2 Do\n/SG1 scn\n/GSalpha500 gs\n/Fm1 Do\n".to_vec(),
resource_uses: PdfStreamResourceUses::default(),
resolved_resources: None,
};
bindings.record_uses(&mut stream);
assert_eq!(
stream
.resource_uses
.fonts
.keys()
.map(String::as_str)
.collect::<Vec<_>>(),
["F1"]
);
assert_eq!(
stream
.resource_uses
.xobjects
.keys()
.filter(|name| name.as_str() == "Im2")
.map(String::as_str)
.collect::<Vec<_>>(),
["Im2"]
);
assert_eq!(
stream
.resource_uses
.patterns
.keys()
.map(String::as_str)
.collect::<Vec<_>>(),
["SG1"]
);
assert_eq!(
stream
.resource_uses
.ext_gstates
.keys()
.map(String::as_str)
.collect::<Vec<_>>(),
["GSalpha500"]
);
assert_eq!(
stream
.resource_uses
.color_spaces
.keys()
.map(String::as_str)
.collect::<Vec<_>>(),
["CSsRGB"]
);
assert_eq!(
stream.resource_uses.xobjects.get("Fm1").copied(),
Some(PdfXObjectHandle::Form(form))
);
}
}
const EMBEDDED_FONT_OBJECTS: usize = 5;
const EMBEDDED_FONT_OBJECTS_WITH_CID_SET: usize = 6;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PdfTextSpaceWidth(i32);
impl PdfTextSpaceWidth {
const SCALE: i32 = 1000;
fn from_font_units(advance: u16, units_per_em: u16) -> Self {
let units_per_em = i64::from(units_per_em.max(1));
let numerator = i64::from(advance) * i64::from(Self::SCALE);
Self(((numerator as f64 / units_per_em as f64).round()) as i32)
}
fn points_at(self, font_size: f32) -> f32 {
self.0 as f32 * font_size / Self::SCALE as f32
}
fn as_pdf_number(self) -> f32 {
self.0 as f32
}
}
#[derive(Debug, Clone, PartialEq)]
struct EmbeddedFontPlan<'a> {
font: &'a DocumentFont,
resource_name: String,
base_name: String,
type0_id: usize,
cid_font_id: usize,
descriptor_id: usize,
file_id: usize,
to_unicode_id: usize,
cid_set_id: Option<usize>,
font_program_kind: FontProgramKind,
source_gid_to_cid: BTreeMap<u16, u16>,
source_gid_to_width: BTreeMap<u16, PdfTextSpaceWidth>,
used_cids: BTreeMap<u16, String>,
font_file_data: Vec<u8>,
embedding_kind: FontEmbeddingKind,
descriptor_metrics: FontDescriptorMetrics,
default_width: f32,
cid_set_data: Option<Vec<u8>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum FontEmbeddingKind {
SubsetCompactGids,
InstantiatedFullCoverage,
FullStandaloneFont,
ExtractedCollectionFace,
Rejected {
reason: String,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PdfFontValidationProfile {
Default,
PdfA,
}
impl PdfFontValidationProfile {
fn emits_cid_set(self) -> bool {
matches!(self, Self::PdfA)
}
fn embedded_font_object_count(self) -> usize {
if self.emits_cid_set() {
EMBEDDED_FONT_OBJECTS_WITH_CID_SET
} else {
EMBEDDED_FONT_OBJECTS
}
}
fn allows_full_font_fallback(self) -> bool {
matches!(self, Self::Default)
}
}
#[derive(Debug, Clone, PartialEq)]
struct FontDescriptorMetrics {
flags: u32,
bbox: [i32; 4],
italic_angle: f32,
ascent: f32,
descent: f32,
cap_height: f32,
x_height: Option<f32>,
stem_v: f32,
avg_width: Option<f32>,
max_width: Option<f32>,
missing_width: Option<f32>,
}
#[derive(Debug, Clone, PartialEq)]
struct EmbeddedFontPlans<'a> {
fonts: Vec<EmbeddedFontPlan<'a>>,
document_font_to_embedded_font: Vec<Option<usize>>,
document_font_synthesis: Vec<crate::document::DocumentFontSynthesis>,
}
impl EmbeddedFontPlans<'_> {
fn resolve_object_ids(&mut self, first_id: usize, profile: PdfFontValidationProfile) {
let object_count = profile.embedded_font_object_count();
for (index, font) in self.fonts.iter_mut().enumerate() {
let base_id = first_id + index * object_count;
font.type0_id = base_id;
font.cid_font_id = base_id + 1;
font.descriptor_id = base_id + 2;
font.file_id = base_id + 3;
font.to_unicode_id = base_id + 4;
font.cid_set_id = profile.emits_cid_set().then_some(base_id + 5);
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct EmbeddedFontCandidateKey {
program_len: usize,
face_index: u32,
program_kind: FontProgramKind,
variation_coordinates: crate::document::DocumentFontVariationCoordinates,
}
#[derive(Debug, Clone, PartialEq)]
struct BookmarkTreeNode {
bookmark: Bookmark,
children: Vec<BookmarkTreeNode>,
}
#[derive(Debug, Clone, PartialEq)]
struct OutlinePlan {
root_id: usize,
nodes: Vec<OutlineNodePlan>,
visible_count: i32,
}
#[derive(Debug, Clone, PartialEq)]
struct OutlineNodePlan {
id: usize,
label: String,
page_index: usize,
target: crate::document::paint::geometry::PaintPoint,
parent_id: usize,
prev_id: Option<usize>,
next_id: Option<usize>,
first_child_id: Option<usize>,
last_child_id: Option<usize>,
child_count: i32,
}
mod colors;
mod content;
mod font_subset;
mod fonts;
mod metadata;
mod outlines;
mod planner;
mod resources;
mod serialize;
mod text;
mod writer;
use content::*;
use font_subset::*;
use fonts::*;
use metadata::*;
use outlines::*;
use planner::*;
use resources::*;
use serialize::*;
use text::*;
pub(crate) use writer::write_document;
#[cfg(test)]
mod tests;