use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use std::rc::Rc;
use super::page_range::PageRange;
use crate::page_document_helper::PageDocumentHelper;
use crate::page_form_xobject::get_form_xobject_for_page;
use crate::page_object_helper::{rectangle_from_handle, PageBox, PageObjectHelper};
use crate::{Error, Matrix, ObjectHandle, ObjectRef, Pdf, Rectangle, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OverlayKind {
Underlay,
Overlay,
}
#[derive(Debug, Clone)]
pub(crate) struct OverlaySource {
pub kind: OverlayKind,
pub xobject_ref: ObjectRef,
pub source_page: Option<(usize, ObjectRef)>,
}
fn apply_overlays_to_page_with_sources<R: Read + Seek, RS: Read + Seek>(
dest: &mut Pdf<R>,
dest_page_ref: ObjectRef,
sources: &[OverlaySource],
source_documents: &mut [&mut Pdf<RS>],
) -> Result<()> {
type PlacementEntry = (ObjectRef, Option<(usize, ObjectRef)>);
let mut underlays: Vec<PlacementEntry> = Vec::new();
let mut overlays: Vec<PlacementEntry> = Vec::new();
for src in sources {
let entry = (src.xobject_ref, src.source_page);
match src.kind {
OverlayKind::Underlay => underlays.push(entry),
OverlayKind::Overlay => overlays.push(entry),
}
}
let media_box = page_box_or_err(dest, dest_page_ref, BoxKind::Media)?;
let trim_box = page_box_or_err(dest, dest_page_ref, BoxKind::Trim)?;
let fx0_ref = get_form_xobject_for_page(dest, dest_page_ref)?;
let mut xobject_entries: Vec<(Vec<u8>, ObjectHandle)> =
Vec::with_capacity(1 + underlays.len() + overlays.len());
xobject_entries.push((b"/Fx0".to_vec(), dest.get_object_handle(fx0_ref)));
let mut next_index = 1u32;
type NamedPlacement = (String, ObjectRef, Option<(usize, ObjectRef)>);
let mut underlay_names: Vec<NamedPlacement> = Vec::new();
let mut overlay_names: Vec<NamedPlacement> = Vec::new();
for (xref, template) in &underlays {
let name = format!("Fx{next_index}");
xobject_entries.push((name.as_bytes().to_vec(), dest.get_object_handle(*xref)));
underlay_names.push((name, *xref, *template));
next_index += 1;
}
for (xref, template) in &overlays {
let name = format!("Fx{next_index}");
xobject_entries.push((name.as_bytes().to_vec(), dest.get_object_handle(*xref)));
overlay_names.push((name, *xref, *template));
next_index += 1;
}
let trim_rect = normalize_rectangle(trim_box);
let media_rect = normalize_rectangle(media_box);
let mut content = String::new();
for (name, xref, source_page) in &underlay_names {
let (fragment, cm) = place_form_xobject_canonical(
dest,
dest_page_ref,
*xref,
trim_rect,
true,
true,
false,
name,
)?;
content.push_str(&fragment);
if let Some((source_index, source_page_ref)) = source_page {
let source = source_documents.get_mut(*source_index).ok_or_else(|| {
Error::Unsupported(format!(
"overlay source document index {} is out of range",
source_index
))
})?;
let source_page = source.get_object_handle(*source_page_ref);
let mut destination_page = PageObjectHelper::new(dest_page_ref, dest);
destination_page.copy_annotations_from(source_page, cm, source)?;
}
}
{
let (fragment, _cm) = place_form_xobject_canonical(
dest,
dest_page_ref,
fx0_ref,
media_rect,
true,
false,
false,
"Fx0",
)?;
content.push_str(&fragment);
}
for (name, xref, source_page) in &overlay_names {
let (fragment, cm) = place_form_xobject_canonical(
dest,
dest_page_ref,
*xref,
trim_rect,
true,
true,
false,
name,
)?;
content.push_str(&fragment);
if let Some((source_index, source_page_ref)) = source_page {
let source = source_documents.get_mut(*source_index).ok_or_else(|| {
Error::Unsupported(format!(
"overlay source document index {} is out of range",
source_index
))
})?;
let source_page = source.get_object_handle(*source_page_ref);
let mut destination_page = PageObjectHelper::new(dest_page_ref, dest);
destination_page.copy_annotations_from(source_page, cm, source)?;
}
}
let contents_stream = dest.new_stream_with_data(Rc::new(content.into_bytes()))?;
let overlay_page = overlay_page_handle(dest, dest_page_ref)?;
let resources = ObjectHandle::dictionary(vec![(
b"/XObject".to_vec(),
ObjectHandle::dictionary(xobject_entries),
)]);
overlay_page.replace_key(b"/Resources", resources)?;
overlay_page.replace_key(b"/Contents", contents_stream)?;
dest.mark_object_handle_dirty(&overlay_page)?;
Ok(())
}
fn map_overlay_pages(
from_pages: &[u32],
to_pages: &[u32],
repeat_pages: &[u32],
) -> Vec<(u32, u32)> {
let mut pairs = Vec::new();
for (i, &dest) in to_pages.iter().enumerate() {
let source = if i < from_pages.len() {
from_pages[i]
} else if !repeat_pages.is_empty() {
repeat_pages[(i - from_pages.len()) % repeat_pages.len()]
} else {
continue;
};
pairs.push((dest, source));
}
pairs
}
#[allow(
clippy::too_many_arguments,
reason = "mirrors qpdf's per-spec page mapping inputs and retains source identity"
)]
fn spec_page_sources<RS, RT>(
dest: &mut Pdf<RT>,
source: &mut Pdf<RS>,
kind: OverlayKind,
from: &PageRange,
to: &PageRange,
repeat: Option<&PageRange>,
n_dest: u32,
source_document_index: usize,
) -> Result<Vec<(u32, OverlaySource)>>
where
RS: Read + Seek,
RT: Read + Seek,
{
let source_pages = PageDocumentHelper::new(source).get_all_pages()?;
let n_source = u32_len(source_pages.len());
let pairs = resolve_spec_pairs(n_source, from, to, repeat, n_dest)?;
let mut distinct_sources: Vec<u32> = Vec::new();
let mut seen = BTreeSet::new();
for &(_dest_page, source_page) in &pairs {
if seen.insert(source_page) {
distinct_sources.push(source_page);
}
}
let source_refs: Vec<ObjectRef> = distinct_sources
.iter()
.map(|&p| page_ref_for(&source_pages, p, "source"))
.collect::<Result<_>>()?;
let mut imported_xobject_refs = Vec::with_capacity(source_refs.len());
for &page_ref in &source_refs {
let mut source_page = PageObjectHelper::new(page_ref, source);
let source_form = source_page.get_form_xobject_for_page(true)?;
let imported = dest.copy_foreign_object(&source_form)?;
imported_xobject_refs.push(imported.object_ref().ok_or_else(|| {
Error::Unsupported("imported Form XObject is not indirect".to_string())
})?);
}
let imported: BTreeMap<u32, ObjectRef> = distinct_sources
.iter()
.copied()
.zip(imported_xobject_refs)
.collect();
pairs
.iter()
.map(|&(dest_page, source_page)| {
let xobject_ref = imported[&source_page];
Ok((
dest_page,
OverlaySource {
kind,
xobject_ref,
source_page: Some((
source_document_index,
page_ref_for(&source_pages, source_page, "source")?,
)),
},
))
})
.collect()
}
pub(crate) fn resolve_spec_pairs(
n_source: u32,
from: &PageRange,
to: &PageRange,
repeat: Option<&PageRange>,
n_dest: u32,
) -> Result<Vec<(u32, u32)>> {
let from_pages = from.resolve(n_source)?;
let to_pages = to.resolve(n_dest)?;
let repeat_pages = match repeat {
Some(pr) => pr.resolve(n_source)?,
None => Vec::new(),
};
Ok(map_overlay_pages(&from_pages, &to_pages, &repeat_pages))
}
pub struct OverlaySpec<RS: Read + Seek + 'static> {
pub source: Pdf<RS>,
pub kind: OverlayKind,
pub from: PageRange,
pub to: PageRange,
pub repeat: Option<PageRange>,
}
fn group_sources_by_dest_page(
entries: &[(u32, OverlaySource)],
) -> BTreeMap<u32, Vec<OverlaySource>> {
let mut by_page: BTreeMap<u32, Vec<OverlaySource>> = BTreeMap::new();
for (dest_page, source) in entries {
by_page.entry(*dest_page).or_default().push(source.clone());
}
by_page
}
pub(crate) fn kind_stable_partition<T, F>(entries: Vec<T>, kind_of: F) -> Vec<T>
where
F: Fn(&T) -> OverlayKind,
{
let (underlays, overlays): (Vec<T>, Vec<T>) = entries
.into_iter()
.partition(|e| matches!(kind_of(e), OverlayKind::Underlay));
let mut out = underlays;
out.extend(overlays);
out
}
fn apply_aggregated_sources<R: Read + Seek, RS: Read + Seek>(
dest: &mut Pdf<R>,
by_page: BTreeMap<u32, Vec<OverlaySource>>,
source_documents: &mut [&mut Pdf<RS>],
) -> Result<()> {
let dest_pages = PageDocumentHelper::new(dest).get_all_pages()?;
for (dest_page, sources) in by_page {
let dest_ref = page_ref_for(&dest_pages, dest_page, "destination")?;
apply_overlays_to_page_with_sources(dest, dest_ref, &sources, source_documents)?;
}
Ok(())
}
pub fn apply_overlay_specs<RS, RT>(dest: &mut Pdf<RT>, specs: &mut [OverlaySpec<RS>]) -> Result<()>
where
RS: Read + Seek,
RT: Read + Seek,
{
if specs.is_empty() {
return Ok(());
}
let n_dest = u32_len(PageDocumentHelper::new(dest).get_all_pages()?.len());
let mut entries: Vec<(u32, OverlaySource)> = Vec::new();
for (spec_index, spec) in specs.iter_mut().enumerate() {
let sources = spec_page_sources(
dest,
&mut spec.source,
spec.kind,
&spec.from,
&spec.to,
spec.repeat.as_ref(),
n_dest,
spec_index,
)?;
entries.extend(sources);
}
let mut source_documents: Vec<&mut Pdf<RS>> =
specs.iter_mut().map(|spec| &mut spec.source).collect();
apply_aggregated_sources(
dest,
group_sources_by_dest_page(&entries),
&mut source_documents,
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct OverlayVerboseSource {
pub spec_index: usize,
pub kind: OverlayKind,
pub src_page: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OverlayVerbosePage {
pub dest_page: u32,
pub sources: Vec<OverlayVerboseSource>,
}
pub fn overlay_verbose_report<RS, RT>(
dest: &mut Pdf<RT>,
specs: &mut [OverlaySpec<RS>],
) -> Result<Vec<OverlayVerbosePage>>
where
RS: Read + Seek,
RT: Read + Seek,
{
let n_dest = u32_len(PageDocumentHelper::new(dest).get_all_pages()?.len());
let mut flat: Vec<(u32, OverlayVerboseSource)> = Vec::new();
for (spec_index, spec) in specs.iter_mut().enumerate() {
let n_source = u32_len(
PageDocumentHelper::new(&mut spec.source)
.get_all_pages()?
.len(),
);
let pairs =
resolve_spec_pairs(n_source, &spec.from, &spec.to, spec.repeat.as_ref(), n_dest)?;
for (dest_page, src_page) in pairs {
flat.push((
dest_page,
OverlayVerboseSource {
spec_index,
kind: spec.kind,
src_page,
},
));
}
}
let mut by_page: BTreeMap<u32, Vec<OverlayVerboseSource>> = BTreeMap::new();
for (dest_page, src) in flat {
by_page.entry(dest_page).or_default().push(src);
}
let mut out = Vec::with_capacity(n_dest as usize);
for dest_page in 1..=n_dest {
let sources = by_page.remove(&dest_page).unwrap_or_default();
let sources = kind_stable_partition(sources, |s| s.kind);
out.push(OverlayVerbosePage { dest_page, sources });
}
Ok(out)
}
fn u32_len(len: usize) -> u32 {
u32::try_from(len).unwrap_or(u32::MAX)
}
fn page_ref_for(pages: &[ObjectRef], page: u32, which: &str) -> Result<ObjectRef> {
let idx = (page as usize)
.checked_sub(1)
.filter(|&i| i < pages.len())
.ok_or_else(|| {
Error::Unsupported(format!(
"{which} page {page} is out of range (document has {} page(s))",
pages.len()
))
})?;
Ok(pages[idx])
}
#[derive(Clone, Copy)]
enum BoxKind {
Media,
Trim,
}
fn page_box_or_err<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
kind: BoxKind,
) -> Result<PageBox> {
let mut helper = PageObjectHelper::new(page_ref, pdf);
let value = match kind {
BoxKind::Media => helper.get_media_box(false)?,
BoxKind::Trim => helper.get_trim_box(false, false)?,
};
if value.is_null() {
return Err(Error::Unsupported(format!(
"destination page {page_ref} has no usable placement box"
)));
}
let rectangle = rectangle_from_handle(pdf, &value)?.unwrap_or_default();
Ok(PageBox::new(
rectangle.llx,
rectangle.lly,
rectangle.urx,
rectangle.ury,
))
}
#[allow(
clippy::too_many_arguments,
reason = "mirrors qpdf placement inputs while retaining overlay naming and ordering"
)]
fn place_form_xobject_canonical<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest_page_ref: ObjectRef,
form_ref: ObjectRef,
rect: Rectangle,
invert_transformations: bool,
allow_shrink: bool,
allow_expand: bool,
name: &str,
) -> Result<(String, Matrix)> {
let form = pdf.get_object_handle(form_ref);
let mut helper = PageObjectHelper::new(dest_page_ref, pdf);
let resource_name = format!("/{name}");
helper.place_form_xobject(
form,
&resource_name,
rect,
invert_transformations,
allow_shrink,
allow_expand,
)
}
fn normalize_rectangle(rectangle: PageBox) -> Rectangle {
Rectangle::new(
rectangle.llx.min(rectangle.urx),
rectangle.lly.min(rectangle.ury),
rectangle.llx.max(rectangle.urx),
rectangle.lly.max(rectangle.ury),
)
}
fn overlay_page_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<ObjectHandle> {
let page = pdf.get_object_handle(page_ref);
pdf.resolve(&page)?;
if page.try_as_dictionary()?.is_none() {
return Err(Error::Unsupported(format!(
"page {page_ref} is not a dictionary"
)));
}
Ok(page)
}