use std::collections::BTreeMap;
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 source_page: (usize, ObjectRef),
}
fn resolve_overlay_xobject<R: Read + Seek, RS: Read + Seek>(
dest: &mut Pdf<R>,
source_page: (usize, ObjectRef),
imported_sources: &mut BTreeMap<(usize, ObjectRef), ObjectRef>,
source_documents: &mut [&mut Pdf<RS>],
) -> Result<ObjectRef> {
let (source_index, source_page_ref) = source_page;
if let Some(&xobject_ref) = imported_sources.get(&(source_index, source_page_ref)) {
return Ok(xobject_ref);
}
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 mut source_page = PageObjectHelper::new(source_page_ref, source);
let source_form = source_page.get_form_xobject_for_page(true)?;
let copied = dest.copy_foreign_object(&source_form)?;
let xobject_ref = copied
.object_ref()
.ok_or_else(|| Error::Unsupported("imported Form XObject is not indirect".into()))?;
imported_sources.insert((source_index, source_page_ref), xobject_ref);
Ok(xobject_ref)
}
fn under_overlay_for_page<R: Read + Seek, RS: Read + Seek>(
dest: &mut Pdf<R>,
dest_page_ref: ObjectRef,
sources: &[OverlaySource],
imported_sources: &mut BTreeMap<(usize, ObjectRef), ObjectRef>,
source_documents: &mut [&mut Pdf<RS>],
) -> Result<()> {
type PlacementEntry = (usize, ObjectRef);
let mut underlays: Vec<PlacementEntry> = Vec::new();
let mut overlays: Vec<PlacementEntry> = Vec::new();
for src in sources {
let entry = 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;
let trim_rect = normalize_rectangle(trim_box);
let media_rect = normalize_rectangle(media_box);
let mut content = String::new();
for source_page in &underlays {
let xref = resolve_overlay_xobject(dest, *source_page, imported_sources, source_documents)?;
let name = format!("Fx{next_index}");
xobject_entries.push((name.as_bytes().to_vec(), dest.get_object_handle(xref)));
let (fragment, cm) = place_form_xobject_canonical(
dest,
dest_page_ref,
xref,
trim_rect,
true,
true,
false,
&name,
)?;
content.push_str(&fragment);
{
let (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)?;
}
next_index += 1;
}
{
let (fragment, _cm) = place_form_xobject_canonical(
dest,
dest_page_ref,
fx0_ref,
media_rect,
true,
false,
false,
"Fx0",
)?;
content.push_str(&fragment);
}
for source_page in &overlays {
let xref = resolve_overlay_xobject(dest, *source_page, imported_sources, source_documents)?;
let name = format!("Fx{next_index}");
xobject_entries.push((name.as_bytes().to_vec(), dest.get_object_handle(xref)));
let (fragment, cm) = place_form_xobject_canonical(
dest,
dest_page_ref,
xref,
trim_rect,
true,
true,
false,
&name,
)?;
content.push_str(&fragment);
{
let (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)?;
}
next_index += 1;
}
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)?;
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>(
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,
{
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)?;
pairs
.iter()
.map(|&(dest_page, source_page)| {
Ok((
dest_page,
OverlaySource {
kind,
source_page: (
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()?;
let mut imported_sources = BTreeMap::new();
for (dest_page, sources) in by_page {
let dest_ref = page_ref_for(&dest_pages, dest_page, "destination")?;
under_overlay_for_page(
dest,
dest_ref,
&sources,
&mut imported_sources,
source_documents,
)?; }
Ok(())
}
pub fn handle_under_overlay<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());
if n_dest == 0 {
return Ok(());
}
let mut entries: Vec<(u32, OverlaySource)> = Vec::new();
for (spec_index, spec) in specs.iter_mut().enumerate() {
let sources = spec_page_sources(
&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.try_is_null()? {
return Err(Error::Unsupported(format!(
"destination page {page_ref} has no usable placement box"
)));
}
let rectangle = rectangle_from_handle(&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);
page.try_dereference()?;
if !page.try_is_dictionary()? {
return Err(Error::Unsupported(format!(
"page {page_ref} is not a dictionary"
)));
}
Ok(page)
}
#[cfg(all(test, feature = "qpdf-zlib-compat"))]
mod byte_gate {
use super::{handle_under_overlay, OverlayKind, OverlaySpec};
use crate::pages::page_refs;
use crate::PageRange;
use crate::{ObjectHandle, Pdf, PdfWriter};
use std::io::{Read, Seek};
use std::path::Path;
fn fixture(name: &str) -> Pdf<std::io::BufReader<std::fs::File>> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(name);
let file = std::fs::File::open(&path).unwrap_or_else(|e| panic!("open {path:?}: {e}"));
Pdf::open(std::io::BufReader::new(file)).unwrap()
}
fn write_qpdf<R, F>(dest: &mut Pdf<R>, configure: F) -> Vec<u8>
where
R: Read + Seek + 'static,
F: FnOnce(&mut PdfWriter<'_, R>),
{
let mut writer = PdfWriter::new(dest);
configure(&mut writer);
writer.set_output_memory().unwrap();
writer.write().unwrap();
writer.get_buffer().unwrap()
}
fn write_qdf_nooid<R: Read + Seek + 'static>(dest: &mut Pdf<R>) -> Vec<u8> {
write_qpdf(dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
})
}
fn golden(name: &str) -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/golden/references/overlay")
.join(name);
std::fs::read(&path).unwrap_or_else(|e| panic!("read golden {path:?}: {e}"))
}
fn pr(input: &str) -> PageRange {
if input.is_empty() {
PageRange::all()
} else {
PageRange::parse_numrange(input).unwrap_or_else(|e| panic!("parse {input:?}: {e}"))
}
}
fn first_diff(a: &[u8], b: &[u8]) -> Option<usize> {
if a == b {
return None;
}
let common = a.len().min(b.len());
(0..common).find(|&i| a[i] != b[i]).or(Some(common))
}
fn assert_byte_identical(actual: &[u8], golden_name: &str) {
let expected = golden(golden_name);
if let Some(off) = first_diff(actual, &expected) {
let lo = off.saturating_sub(24);
let g = expected.get(off).copied().unwrap_or(0);
let f = actual.get(off).copied().unwrap_or(0);
panic!(
"overlay output not byte-identical to qpdf golden {golden_name} \
(flpdf={} bytes, golden={} bytes)\n\
first diff at offset {off} (golden=0x{g:02x} flpdf=0x{f:02x})\n\
golden[{lo}..]: {:?}\nflpdf [{lo}..]: {:?}",
actual.len(),
expected.len(),
String::from_utf8_lossy(&expected[lo..(off + 24).min(expected.len())]),
String::from_utf8_lossy(&actual[lo..(off + 24).min(actual.len())]),
);
}
}
fn accumulate_max<R1: Read + Seek, R2: Read + Seek>(
a: &mut Pdf<R1>,
b: &mut Pdf<R2>,
) -> crate::PdfVersion {
let a_version =
crate::parse_pdf_version(a.version()).unwrap_or(crate::PdfVersion::new(1, 0, 0));
let b_version =
crate::parse_pdf_version(b.version()).unwrap_or(crate::PdfVersion::new(1, 0, 0));
let mut best = crate::PdfVersion::new(
a_version.major(),
a_version.minor(),
a.adobe_extension_level().unwrap_or(None).unwrap_or(0),
);
best.update_if_greater(crate::PdfVersion::new(
b_version.major(),
b_version.minor(),
b.adobe_extension_level().unwrap_or(None).unwrap_or(0),
));
best
}
fn page_annots<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: crate::ObjectRef,
) -> Option<Vec<ObjectHandle>> {
let page = pdf.get_object_handle(page_ref);
page.try_dereference().unwrap();
page.try_get_key(b"/Annots")
.unwrap()
.try_as_array()
.unwrap()
}
#[test]
fn overlay_copy_annotations_fxo_red_repeat1_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red.pdf");
let mut src = fixture("form-fields-and-annotations.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src).get_version();
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: Some(pr("1")),
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-copy-annotations.pdf");
}
#[test]
fn overlay_copy_annotations_two_specs_same_page_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red.pdf");
let mut src1 = fixture("form-fields-and-annotations.pdf");
let src2 = fixture("form-fields-and-annotations.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src1).get_version();
let mut specs = vec![
OverlaySpec {
source: src1,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr("1"),
repeat: None,
},
OverlaySpec {
source: src2,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr("1"),
repeat: None,
},
];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-copy-annotations-two-specs-same-page.pdf");
}
#[test]
fn overlay_copy_annotations_source_p_and_inline_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red.pdf");
let mut src = fixture("form-fields-and-annotations-p-and-inline.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src).get_version();
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: Some(pr("1")),
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-source-p-and-inline.pdf");
}
#[test]
fn overlay_copy_annotations_source_no_acroform_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red.pdf");
let mut src = fixture("link-annot-no-acroform.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src).get_version();
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: Some(pr("1")),
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-link-annot-no-acroform.pdf");
}
#[test]
fn overlay_destination_existing_annotation_is_byte_identical_qdf() {
let mut dest = fixture("link-annot-no-acroform.pdf");
let source = fixture("one-page.pdf");
let dest_page = page_refs(&mut dest).unwrap()[0];
let before = page_annots(&mut dest, dest_page)
.expect("destination fixture must have an annotation array");
let mut specs = vec![OverlaySpec {
source,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr("1"),
repeat: None,
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let after = page_annots(&mut dest, dest_page)
.expect("destination annotations must survive the overlay rewrite");
assert_eq!(
after.len(),
before.len(),
"overlay must preserve destination annotations"
);
for (a, b) in after.iter().zip(before.iter()) {
assert!(
a.is_same_object_as(b),
"overlay must not rebind a destination annotation handle"
);
}
let actual = write_qdf_nooid(&mut dest);
assert_byte_identical(&actual, "overlay-destination-existing-annotation.pdf");
}
#[test]
fn overlay_copy_annotations_onto_indirect_fields_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red-indirect-fields.pdf");
let mut src = fixture("form-fields-and-annotations.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src).get_version();
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: Some(pr("1")),
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-onto-indirect-fields.pdf");
}
#[test]
fn overlay_copy_annotations_source_direct_dr_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red.pdf");
let mut src = fixture("form-fields-and-annotations-direct-dr.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src).get_version();
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: Some(pr("1")),
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-source-direct-dr.pdf");
}
#[test]
fn overlay_copy_annotations_onto_existing_acroform_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red-with-existing-acroform.pdf");
let mut src = fixture("form-fields-and-annotations.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src).get_version();
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: Some(pr("1")),
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-onto-existing-acroform.pdf");
}
#[test]
fn overlay_copy_annotations_onto_existing_acroform_dr_is_byte_identical_qdf() {
let mut dest = fixture("fxo-red-with-existing-acroform-dr.pdf");
let mut src = fixture("form-fields-and-annotations.pdf");
let (version, max_ext) = accumulate_max(&mut dest, &mut src).get_version();
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: Some(pr("1")),
}];
handle_under_overlay(&mut dest, &mut specs).unwrap();
let actual = write_qpdf(&mut dest, |writer| {
writer.set_static_id(true);
writer.set_qdf_mode(true);
writer.set_suppress_original_object_ids(true);
writer.set_minimum_pdf_version(version, max_ext);
});
assert_byte_identical(&actual, "overlay-onto-existing-acroform-dr.pdf");
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
fn pdf_from_objects(catalog_ref: u32, objects: &[(u32, String)]) -> Vec<u8> {
let mut data: Vec<u8> = b"%PDF-1.4\n".to_vec();
let mut offsets: Vec<u64> = Vec::with_capacity(objects.len());
for (num, body) in objects {
offsets.push(data.len() as u64);
data.extend_from_slice(format!("{num} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = data.len() as u64;
let total = objects.len() + 1;
let mut xref = format!("xref\n0 {total}\n0000000000 65535 f \n");
for off in &offsets {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
data.extend_from_slice(xref.as_bytes());
let trailer = format!(
"trailer\n<< /Size {total} /Root {catalog_ref} 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
);
data.extend_from_slice(trailer.as_bytes());
data
}
#[test]
fn page_box_or_err_rejects_a_page_with_no_media_box_in_its_ancestry() {
let objects = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string()),
(3, "<< /Type /Page /Parent 2 0 R >>".to_string()),
];
let bytes = pdf_from_objects(1, &objects);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let error = page_box_or_err(&mut pdf, page_ref, BoxKind::Media)
.expect_err("a page with no /MediaBox anywhere in its ancestry has no usable box");
assert!(
error.to_string().contains("has no usable placement box"),
"unexpected error: {error}"
);
}
#[test]
fn page_box_or_err_accepts_a_page_with_a_media_box() {
let objects = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string()),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>".to_string(),
),
];
let bytes = pdf_from_objects(1, &objects);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let page_box = page_box_or_err(&mut pdf, page_ref, BoxKind::Media)
.expect("a page with a direct /MediaBox has a usable box");
assert_eq!(page_box, PageBox::new(0.0, 0.0, 612.0, 792.0));
}
}