use std::io::{Read, Seek};
use crate::page_object_helper::PageObjectHelper;
use crate::{Error, ObjectRef, Pdf, Result};
#[cfg(test)]
use crate::object_handle::ObjectHandle;
#[cfg(test)]
use crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH;
#[cfg(test)]
use crate::Matrix;
#[cfg(test)]
use std::collections::BTreeSet;
pub(crate) fn get_form_xobject_for_page<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<ObjectRef> {
let mut helper = PageObjectHelper::new(page_ref, pdf);
let form = helper.get_form_xobject_for_page(true)?;
form.object_ref().ok_or_else(|| {
Error::Internal(
"canonical Form XObject was not registered as an indirect object".to_owned(),
)
})
}
#[cfg(test)]
pub(crate) fn import_page_as_form_xobject<RS, RT>(
dest: &mut Pdf<RT>,
source: &mut Pdf<RS>,
source_page_ref: ObjectRef,
) -> Result<ObjectRef>
where
RS: Read + Seek,
RT: Read + Seek,
{
let xobject_ref = get_form_xobject_for_page(source, source_page_ref)?;
let source_handle = source.get_object_handle(xobject_ref);
let copied = dest.copy_foreign_object(&source_handle)?;
copied
.object_ref()
.ok_or_else(|| Error::Unsupported("imported Form XObject is not indirect".to_string()))
}
#[cfg(test)]
pub(crate) fn import_pages_as_form_xobjects<RS, RT>(
dest: &mut Pdf<RT>,
source: &mut Pdf<RS>,
source_page_refs: &[ObjectRef],
) -> Result<Vec<ObjectRef>>
where
RS: Read + Seek,
RT: Read + Seek,
{
let mut xobject_refs = Vec::with_capacity(source_page_refs.len());
for &page_ref in source_page_refs {
let xobject_ref = get_form_xobject_for_page(source, page_ref)?;
xobject_refs.push(xobject_ref);
}
xobject_refs
.iter()
.map(|xref| {
let source_handle = source.get_object_handle(*xref);
let copied = dest.copy_foreign_object(&source_handle)?;
let copied_ref = copied.object_ref();
if copied_ref.is_none() {
return Err(Error::Unsupported(
"imported Form XObject is not indirect".to_string(),
));
}
Ok(copied_ref.expect("copyForeignObject returned an indirect Form XObject"))
})
.collect()
}
#[cfg(test)]
fn effective_box_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<Vec<ObjectHandle>> {
if let Some(arr) = leaf_box_array(pdf, page_ref, b"TrimBox")? {
return Ok(arr);
}
for key in [b"CropBox".as_slice(), b"MediaBox".as_slice()] {
if let Some(arr) = inherited_box_array(pdf, page_ref, key)? {
return Ok(arr);
}
}
Err(Error::Unsupported(format!(
"page {page_ref} has no /TrimBox, /CropBox, or /MediaBox for the Form XObject /BBox"
)))
}
#[cfg(test)]
fn leaf_box_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
key: &[u8],
) -> Result<Option<Vec<ObjectHandle>>> {
let page = pdf.get_object_handle(page_ref);
page.try_is_scalar()?;
let Some(dict) = page.as_dictionary() else {
return Ok(None);
};
let lookup_key: Vec<u8> = [b"/".as_slice(), key].concat();
let val = match dict.get(lookup_key.as_slice()).cloned() {
None => return Ok(None),
Some(v) => v,
};
if val.is_null() {
return Ok(None);
}
resolve_rect_array(val, page_ref, key)
}
#[cfg(test)]
fn inherited_box_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
key: &[u8],
) -> Result<Option<Vec<ObjectHandle>>> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = page_ref;
let mut depth: usize = 0;
loop {
if depth >= DEFAULT_MAX_PAGE_TREE_DEPTH {
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {DEFAULT_MAX_PAGE_TREE_DEPTH} at {current}"
)));
}
if !seen.insert(current) {
return Ok(None);
}
let node = pdf.get_object_handle(current);
node.try_is_scalar()?;
let Some(dict) = node.as_dictionary() else {
return Ok(None);
};
let lookup_key: Vec<u8> = [b"/".as_slice(), key].concat();
let val = match dict.get(lookup_key.as_slice()).cloned() {
Some(v) if !v.is_null() => Some(v),
_ => None,
};
let parent_val = dict.get(b"/Parent".as_slice()).cloned();
if let Some(value) = val {
if let Some(array) = resolve_rect_array(value, current, key)? {
return Ok(Some(array));
}
}
match parent_val.and_then(|value| value.object_ref()) {
Some(r) => {
current = r;
depth += 1;
}
_ => return Ok(None),
}
}
}
#[cfg(test)]
fn resolve_rect_array(
val: ObjectHandle,
node: ObjectRef,
key: &[u8],
) -> Result<Option<Vec<ObjectHandle>>> {
if val.is_indirect() || val.object_ref().is_some() {
val.try_is_scalar()?;
}
let resolved = val;
let Some(arr) = resolved.as_array() else {
if resolved.is_null() {
return Ok(None);
}
return Err(Error::Unsupported(format!(
"/{} value on node {node} does not resolve to an array",
String::from_utf8_lossy(key)
)));
};
if arr.len() < 4 {
return Err(Error::Unsupported(format!(
"/{} rectangle on node {node} has {} elements, expected 4",
String::from_utf8_lossy(key),
arr.len()
)));
}
Ok(Some(arr))
}
#[cfg(test)]
fn handle_reference(handle: &ObjectHandle) -> Option<ObjectRef> {
handle.object_ref()
}
#[cfg(test)]
fn rectangle_dimensions(arr: &[ObjectHandle]) -> (f64, f64) {
let n = |o: &ObjectHandle| -> f64 {
o.as_integer()
.map(|value| value as f64)
.or_else(|| o.as_real())
.unwrap_or(0.0)
};
let llx = n(&arr[0]);
let lly = n(&arr[1]);
let urx = n(&arr[2]);
let ury = n(&arr[3]);
((urx - llx).abs(), (ury - lly).abs())
}
#[cfg(test)]
pub(crate) struct PageTransform {
pub rotate_present: bool,
pub rotate: i32,
pub uu_present: bool,
pub scale: f64,
}
#[cfg(test)]
fn inherited_rotate_attribute<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<(bool, i32)> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = page_ref;
let mut depth: usize = 0;
loop {
if depth >= DEFAULT_MAX_PAGE_TREE_DEPTH {
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {DEFAULT_MAX_PAGE_TREE_DEPTH} at {current}"
)));
}
if !seen.insert(current) {
return Ok((false, 0));
}
let (rotate_val, parent_val) = {
let node = pdf.get_object_handle(current);
node.try_is_scalar()?;
let Some(dict) = node.as_dictionary() else {
return Ok((false, 0));
};
(
dict.get(b"/Rotate".as_slice()).cloned(),
dict.get(b"/Parent".as_slice()).cloned(),
)
};
if let Some(val) = rotate_val {
if val.is_indirect() || val.object_ref().is_some() {
val.try_is_scalar()?;
}
let resolved = val;
if let Some(n) = resolved.as_integer() {
return Ok((true, n as i32));
}
if !resolved.is_null() {
return Ok((true, 0));
}
}
match parent_val.and_then(|value| handle_reference(&value)) {
Some(r) => {
current = r;
depth += 1;
}
_ => return Ok((false, 0)),
}
}
}
#[cfg(test)]
fn leaf_user_unit<R: Read + Seek>(pdf: &mut Pdf<R>, page_ref: ObjectRef) -> Result<(bool, f64)> {
let page = pdf.get_object_handle(page_ref);
page.try_is_scalar()?;
let Some(dict) = page.as_dictionary() else {
return Ok((false, 1.0));
};
let uu_val = dict.get(b"/UserUnit".as_slice()).cloned();
let Some(val) = uu_val else {
return Ok((false, 1.0));
};
if val.is_indirect() || val.object_ref().is_some() {
val.try_is_scalar()?;
}
let resolved = val;
if resolved.is_null() {
Ok((false, 1.0))
} else {
Ok((
true,
resolved
.as_integer()
.map(|value| value as f64)
.or_else(|| resolved.as_real())
.unwrap_or(1.0),
))
}
}
#[cfg(test)]
pub(crate) fn get_matrix_for_transformations(
t: &PageTransform,
width: f64,
height: f64,
invert: bool,
) -> Matrix {
if !(t.rotate_present || t.uu_present) {
return Matrix::default();
}
let mut scale = t.scale;
let mut rotate = t.rotate;
if invert {
if scale == 0.0 {
return Matrix::default();
}
scale = 1.0 / scale;
rotate = 360 - rotate;
}
match rotate {
90 => Matrix::new(0.0, -scale, scale, 0.0, 0.0, width * scale),
180 => Matrix::new(-scale, 0.0, 0.0, -scale, width * scale, height * scale),
270 => Matrix::new(0.0, scale, -scale, 0.0, height * scale, 0.0),
_ => Matrix::new(scale, 0.0, 0.0, scale, 0.0, 0.0),
}
}
#[cfg(test)]
fn page_group<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<Option<ObjectHandle>> {
let page = pdf.get_object_handle(page_ref);
page.try_is_scalar()?;
let Some(dict) = page.as_dictionary() else {
return Ok(None);
};
let group_val = dict.get(b"/Group".as_slice()).cloned();
match group_val {
None => Ok(None),
Some(value) if value.is_null() => Ok(None),
Some(value) if value.is_indirect() || value.object_ref().is_some() => {
value.try_is_scalar()?;
Ok(Some(value.shallow_copy()?))
}
Some(direct) => Ok(Some(direct.shallow_copy()?)),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::object_handle::canonical_dictionary_key;
#[derive(Clone)]
struct TestHandle(ObjectHandle);
impl TestHandle {
fn as_dict(&self) -> Option<TestDict> {
self.0.as_dictionary().map(TestDict)
}
fn as_array(&self) -> Option<Vec<Self>> {
self.0
.as_array()
.map(|items| items.into_iter().map(Self).collect())
}
fn as_name(&self) -> Option<Vec<u8>> {
self.0.as_name()
}
fn as_integer(&self) -> Option<i64> {
self.0.as_integer()
}
fn as_real(&self) -> Option<f64> {
self.0.as_real()
}
fn object_ref(&self) -> Option<ObjectRef> {
self.0.object_ref()
}
}
struct TestDict(std::collections::BTreeMap<Vec<u8>, ObjectHandle>);
impl TestDict {
fn get(&self, key: &str) -> Option<TestHandle> {
let key = canonical_dictionary_key(key.as_bytes());
self.0.get(&key).cloned().map(TestHandle)
}
fn iter(&self) -> impl Iterator<Item = (&Vec<u8>, &ObjectHandle)> {
self.0.iter()
}
}
struct TestStream {
dict: TestDict,
data: Vec<u8>,
}
fn build_pdf(objects: &[(u32, &str)], root: u32) -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let mut offsets: std::collections::BTreeMap<u32, u64> = std::collections::BTreeMap::new();
let max = objects.iter().map(|(n, _)| *n).max().unwrap_or(0);
for (n, body) in objects {
offsets.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = out.len() as u64;
let size = max + 1;
out.extend_from_slice(format!("xref\n0 {size}\n").as_bytes());
out.extend_from_slice(b"0000000000 65535 f \n");
for n in 1..=max {
let off = offsets
.get(&n)
.expect("test fixtures use contiguous object numbers");
out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
out.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root {root} 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
out
}
fn one_page_doc(page_extra: &str, content: &str, extra_objs: &[(u32, &str)]) -> Vec<u8> {
let page_body = format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R {page_extra} >>"
);
let content_body = format!(
"<< /Length {} >>\nstream\n{content}\nendstream",
content.len()
);
let mut objs: Vec<(u32, String)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string()),
(3, page_body),
(
4,
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".to_string(),
),
(5, content_body),
];
for (n, b) in extra_objs {
objs.push((*n, (*b).to_string()));
}
let borrowed: Vec<(u32, &str)> = objs.iter().map(|(n, b)| (*n, b.as_str())).collect();
build_pdf(&borrowed, 1)
}
fn open(bytes: Vec<u8>) -> Pdf<std::io::Cursor<Vec<u8>>> {
Pdf::open_mem_owned(bytes).unwrap()
}
fn form_stream<R: Read + Seek>(pdf: &mut Pdf<R>, xref: ObjectRef) -> TestStream {
let stream = pdf.get_object_handle(xref);
stream.try_is_scalar().unwrap();
let dict = stream
.as_stream_dict()
.expect("Form XObject must be a stream")
.as_dictionary()
.expect("Form XObject stream dictionary");
let data = stream
.as_stream_data()
.map(|data| data.as_ref().clone())
.or_else(|| {
stream
.get_raw_stream_data()
.ok()
.map(|data| data.as_ref().clone())
})
.expect("Form XObject stream data");
TestStream {
dict: TestDict(dict),
data,
}
}
fn numbers(arr: impl AsRef<[TestHandle]>) -> Vec<i64> {
arr.as_ref()
.iter()
.map(|handle| {
handle
.as_integer()
.or_else(|| handle.as_real().map(|r| r as i64))
.expect("numeric array element")
})
.collect()
}
#[test]
fn page_to_form_xobject_builds_expected_dict_and_stream() {
let mut pdf = open(one_page_doc("", "Hello content", &[]));
let page_ref = ObjectRef::new(3, 0);
let expected_content = crate::pages::page_content_bytes(&mut pdf, page_ref).unwrap();
let xref = get_form_xobject_for_page(&mut pdf, page_ref).unwrap();
let stream = form_stream(&mut pdf, xref);
let dict = &stream.dict;
let keys: BTreeSet<Vec<u8>> = dict
.iter()
.map(|(key, _)| key.strip_prefix(b"/").unwrap_or(key).to_vec())
.collect();
let expected: BTreeSet<Vec<u8>> = [
b"BBox".to_vec(),
b"Resources".to_vec(),
b"Subtype".to_vec(),
b"Type".to_vec(),
]
.into_iter()
.collect();
assert_eq!(keys, expected, "unexpected key set on Form XObject");
assert!(
dict.get("FormType").is_none(),
"qpdf getFormXObjectForPage must NOT add /FormType"
);
assert!(
dict.get("Matrix").is_none(),
"qpdf omits /Matrix when neither /Rotate nor /UserUnit is present"
);
assert_eq!(
dict.get("Subtype").unwrap().as_name(),
Some(b"Form".to_vec())
);
assert_eq!(
dict.get("Type").unwrap().as_name(),
Some(b"XObject".to_vec())
);
let bbox = dict.get("BBox").unwrap().as_array().unwrap();
assert_eq!(numbers(bbox), vec![0, 0, 612, 792]);
let res = dict.get("Resources").unwrap().as_dict().unwrap();
assert!(res.get("Font").is_some(), "Resources should carry /Font");
assert_eq!(stream.data, expected_content);
}
#[test]
fn page_to_form_xobject_uses_trimbox_when_present() {
let mut pdf = open(one_page_doc("/TrimBox [10 10 500.5 600]", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let bbox = stream.dict.get("BBox").unwrap().as_array().unwrap();
assert_eq!(bbox[0].as_integer(), Some(10));
assert_eq!(bbox[1].as_integer(), Some(10));
assert!((bbox[2].as_real().unwrap() - 500.5).abs() < 1e-9);
assert_eq!(bbox[3].as_integer(), Some(600));
}
#[test]
fn page_to_form_xobject_bbox_falls_back_to_inherited_cropbox() {
let page = "<< /Type /Page /Parent 2 0 R /Contents 4 0 R >>";
let pages = "<< /Type /Pages /Kids [3 0 R] /Count 1 \
/MediaBox [0 0 612 792] /CropBox [5 5 300 400] >>";
let content = "<< /Length 1 >>\nstream\nx\nendstream";
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, pages),
(3, page),
(4, content),
],
1,
));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let bbox = stream.dict.get("BBox").unwrap().as_array().unwrap();
assert_eq!(
numbers(bbox),
vec![5, 5, 300, 400],
"inherited CropBox must win over MediaBox for /BBox"
);
}
#[test]
fn page_to_form_xobject_bbox_resolves_indirect_box_array() {
let trimbox = (6u32, "[1 2 3 4]");
let mut pdf = open(one_page_doc("/TrimBox 6 0 R", "x", &[trimbox]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let bbox = stream.dict.get("BBox").unwrap().as_array().unwrap();
assert_eq!(numbers(bbox), vec![1, 2, 3, 4]);
}
#[test]
fn page_to_form_xobject_creates_form_for_short_box_array_with_warning() {
let mut pdf = open(one_page_doc("/TrimBox [0 0 5]", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert!(form_stream(&mut pdf, xref).dict.get("BBox").is_some());
}
#[test]
fn page_to_form_xobject_creates_form_for_non_array_box_with_warning() {
let mut pdf = open(one_page_doc("/TrimBox /NotARect", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert!(form_stream(&mut pdf, xref).dict.get("BBox").is_some());
}
#[test]
fn page_to_form_xobject_creates_form_for_box_ref_to_non_array_with_warning() {
let bad = (6u32, "<< /Type /Foo >>");
let mut pdf = open(one_page_doc("/CropBox 6 0 R", "x", &[bad]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert!(form_stream(&mut pdf, xref).dict.get("BBox").is_some());
}
#[test]
fn page_to_form_xobject_creates_form_when_no_box_exists_with_warning() {
let page = "<< /Type /Page /Parent 2 0 R /Contents 4 0 R >>";
let content = "<< /Length 1 >>\nstream\nx\nendstream";
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, page),
(4, content),
],
1,
));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert!(form_stream(&mut pdf, xref).dict.get("BBox").is_none());
}
#[test]
fn page_to_form_xobject_handles_non_numeric_box_element() {
let mut pdf = open(one_page_doc("/TrimBox [0 0 /X 100] /Rotate 0", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let bbox = stream.dict.get("BBox").unwrap().as_array().unwrap();
assert!(bbox[2].as_name().is_some());
let matrix = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(matrix), vec![1, 0, 0, 1, 0, 0]);
}
#[test]
fn rectangle_dimensions_normalizes_swapped_box() {
let swapped = [
ObjectHandle::integer(612),
ObjectHandle::integer(792),
ObjectHandle::integer(0),
ObjectHandle::integer(0),
];
assert_eq!(rectangle_dimensions(&swapped), (612.0, 792.0));
let ordered = [
ObjectHandle::integer(0),
ObjectHandle::integer(0),
ObjectHandle::integer(612),
ObjectHandle::integer(792),
];
assert_eq!(rectangle_dimensions(&ordered), (612.0, 792.0));
}
#[test]
fn page_to_form_xobject_rotate_90_matrix() {
let mut pdf = open(one_page_doc("/Rotate 90", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let matrix = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(matrix), vec![0, -1, 1, 0, 0, 612]);
}
#[test]
fn page_to_form_xobject_rotate_180_and_270() {
let mut pdf = open(one_page_doc("/Rotate 180", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![-1, 0, 0, -1, 612, 792]);
let mut pdf = open(one_page_doc("/Rotate 270", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![0, 1, -1, 0, 792, 0]);
}
#[test]
fn page_to_form_xobject_explicit_rotate_0_emits_identity_matrix() {
let mut pdf = open(one_page_doc("/Rotate 0", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![1, 0, 0, 1, 0, 0]);
}
#[test]
fn page_to_form_xobject_inherited_rotate_emits_matrix() {
let page = "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>";
let pages = "<< /Type /Pages /Kids [3 0 R] /Count 1 /Rotate 90 >>";
let content = "<< /Length 1 >>\nstream\nx\nendstream";
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, pages),
(3, page),
(4, content),
],
1,
));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![0, -1, 1, 0, 0, 612]);
}
#[test]
fn page_to_form_xobject_userunit_only_emits_scale_matrix() {
let mut pdf = open(one_page_doc("/UserUnit 2", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![2, 0, 0, 2, 0, 0]);
}
#[test]
fn page_to_form_xobject_userunit_and_rotate_90() {
let mut pdf = open(one_page_doc("/UserUnit 2 /Rotate 90", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![0, -2, 2, 0, 0, 1224]);
}
#[test]
fn page_to_form_xobject_present_non_integer_rotate_emits_identity() {
let mut pdf = open(one_page_doc("/Rotate /X", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![1, 0, 0, 1, 0, 0]);
}
#[test]
fn page_to_form_xobject_present_non_numeric_userunit_scale_one() {
let mut pdf = open(one_page_doc("/UserUnit /X", "x", &[]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let m = stream.dict.get("Matrix").unwrap().as_array().unwrap();
assert_eq!(numbers(m), vec![1, 0, 0, 1, 0, 0]);
}
#[test]
fn page_to_form_xobject_shallow_copies_indirect_group() {
let group_obj = (6u32, "<< /Type /Group /S /Transparency /CS /DeviceRGB >>");
let mut pdf = open(one_page_doc("/Group 6 0 R", "x", &[group_obj]));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let group = stream
.dict
.get("Group")
.expect("Group must be copied")
.as_dict()
.expect("indirect /Group must be shallow-copied to a direct dict");
assert_eq!(
group.get("Type").unwrap().as_name(),
Some(b"Group".to_vec())
);
assert_eq!(
group.get("S").unwrap().as_name(),
Some(b"Transparency".to_vec())
);
assert_eq!(
group.get("CS").unwrap().as_name(),
Some(b"DeviceRGB".to_vec())
);
}
#[test]
fn page_to_form_xobject_copies_direct_group_as_is() {
let mut pdf = open(one_page_doc(
"/Group << /Type /Group /S /Transparency >>",
"x",
&[],
));
let xref = get_form_xobject_for_page(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let stream = form_stream(&mut pdf, xref);
let group = stream.dict.get("Group").unwrap().as_dict().unwrap();
assert_eq!(
group.get("S").unwrap().as_name(),
Some(b"Transparency".to_vec())
);
}
#[test]
fn page_to_form_xobject_rejects_non_page() {
let mut pdf = open(one_page_doc("", "x", &[]));
let err = get_form_xobject_for_page(&mut pdf, ObjectRef::new(2, 0));
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn import_page_as_form_xobject_renumbers_foreign_refs() {
let mut source = open(one_page_doc("", "source content", &[]));
let source_page = ObjectRef::new(3, 0);
let mut dest = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 100] >>"),
],
1,
));
let imported = import_page_as_form_xobject(&mut dest, &mut source, source_page).unwrap();
let stream = form_stream(&mut dest, imported);
assert_eq!(
stream.dict.get("Subtype").unwrap().as_name(),
Some(b"Form".to_vec())
);
let res = stream.dict.get("Resources").unwrap().as_dict().unwrap();
let font_dict = res.get("Font").unwrap().as_dict().unwrap();
let font_ref = match font_dict.get("F1") {
Some(handle) => handle
.object_ref()
.expect("F1 should be an indirect handle"),
None => panic!("F1 should be a reference"), };
let font_obj = dest.get_object_handle(font_ref);
font_obj.try_is_scalar().unwrap();
let font = TestHandle(font_obj)
.as_dict()
.expect("font ref resolves to a dict in dest");
assert_eq!(font.get("Type").unwrap().as_name(), Some(b"Font".to_vec()));
assert_eq!(
font.get("BaseFont").unwrap().as_name(),
Some(b"Helvetica".to_vec())
);
}
#[test]
fn import_pages_as_form_xobjects_shares_one_copy_of_a_common_resource() {
let mut source = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 6 0 R] /Count 2 >>"),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>",
),
(4, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"),
(5, "<< /Length 3 >>\nstream\nfoo\nendstream"),
(
6,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Font << /F1 4 0 R >> >> /Contents 7 0 R >>",
),
(7, "<< /Length 3 >>\nstream\nbar\nendstream"),
],
1,
));
let mut dest = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 100] >>"),
],
1,
));
let imported = import_pages_as_form_xobjects(
&mut dest,
&mut source,
&[ObjectRef::new(3, 0), ObjectRef::new(6, 0)],
)
.unwrap();
assert_eq!(imported.len(), 2);
let stream0 = form_stream(&mut dest, imported[0]);
let res0 = stream0.dict.get("Resources").unwrap().as_dict().unwrap();
let font_ref0 = match res0.get("Font").unwrap().as_dict().unwrap().get("F1") {
Some(handle) => handle
.object_ref()
.expect("F1 should be an indirect handle"),
None => panic!("F1 should be a reference"), };
let stream1 = form_stream(&mut dest, imported[1]);
let res1 = stream1.dict.get("Resources").unwrap().as_dict().unwrap();
let font_ref1 = match res1.get("Font").unwrap().as_dict().unwrap().get("F1") {
Some(handle) => handle
.object_ref()
.expect("F1 should be an indirect handle"),
None => panic!("F1 should be a reference"), };
assert_eq!(
font_ref0, font_ref1,
"the shared font must be copied into dest exactly once"
);
let font_obj = dest.get_object_handle(font_ref0);
font_obj.try_is_scalar().unwrap();
let font = TestHandle(font_obj)
.as_dict()
.expect("font ref resolves to a dict in dest");
assert_eq!(
font.get("BaseFont").unwrap().as_name(),
Some(b"Helvetica".to_vec())
);
}
fn doc_with_non_dict_obj3() -> Pdf<std::io::Cursor<Vec<u8>>> {
open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [] /Count 0 >>"),
(3, "42"),
],
1,
))
}
#[test]
fn leaf_box_array_returns_none_for_non_dict() {
let mut pdf = doc_with_non_dict_obj3();
let got = leaf_box_array(&mut pdf, ObjectRef::new(3, 0), b"TrimBox").unwrap();
assert!(got.is_none());
}
#[test]
fn inherited_box_array_returns_none_for_non_dict() {
let mut pdf = doc_with_non_dict_obj3();
let got = inherited_box_array(&mut pdf, ObjectRef::new(3, 0), b"MediaBox").unwrap();
assert!(got.is_none());
}
#[test]
fn page_group_returns_none_for_non_dict() {
let mut pdf = doc_with_non_dict_obj3();
let got = page_group(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert!(got.is_none());
}
#[test]
fn inherited_box_array_breaks_on_parent_cycle() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 4 0 R >>"),
(4, "<< /Type /Pages /Parent 3 0 R >>"),
],
1,
));
let got = inherited_box_array(&mut pdf, ObjectRef::new(3, 0), b"MediaBox").unwrap();
assert!(got.is_none());
}
#[test]
fn inherited_box_array_skips_null_box_ref_and_climbs_to_parent() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R /CropBox 4 0 R >>"),
(4, "null"),
],
1,
));
let got = inherited_box_array(&mut pdf, ObjectRef::new(3, 0), b"CropBox").unwrap();
assert!(got.is_none());
}
#[test]
fn inherited_box_array_errors_on_parent_chain_too_deep() {
let total = DEFAULT_MAX_PAGE_TREE_DEPTH + 5;
let mut objs: Vec<(u32, String)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string()),
];
for n in 3..=(total as u32) {
objs.push((n, format!("<< /Type /Pages /Parent {} 0 R >>", n + 1)));
}
let borrowed: Vec<(u32, &str)> = objs.iter().map(|(n, b)| (*n, b.as_str())).collect();
let mut pdf = open(build_pdf(&borrowed, 1));
let err = inherited_box_array(&mut pdf, ObjectRef::new(3, 0), b"MediaBox");
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn resolve_rect_array_handles_ref_to_null() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [] /Count 0 >>"),
(3, "null"),
],
1,
));
let value = pdf.get_object_handle(ObjectRef::new(3, 0));
let got = resolve_rect_array(value, ObjectRef::new(1, 0), b"TrimBox").unwrap();
assert!(got.is_none());
}
#[test]
fn resolve_rect_array_errors_on_non_array_non_null_value() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [] /Count 0 >>"),
(3, "42"),
],
1,
));
let value = pdf.get_object_handle(ObjectRef::new(3, 0));
let err = resolve_rect_array(value, ObjectRef::new(1, 0), b"TrimBox");
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn effective_box_array_prefers_trimbox_over_inherited_boxes() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(
2,
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 612 792] >>",
),
(3, "<< /Type /Page /Parent 2 0 R /TrimBox [0 0 50 60] >>"),
],
1,
));
let got = effective_box_array(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert_eq!(got.len(), 4);
}
#[test]
fn leaf_box_array_returns_none_for_absent_key() {
let mut pdf = open(one_page_doc("", "x", &[]));
let got = leaf_box_array(&mut pdf, ObjectRef::new(3, 0), b"TrimBox").unwrap();
assert!(got.is_none());
}
#[test]
fn leaf_box_array_returns_none_for_direct_null() {
let mut pdf = open(one_page_doc("/TrimBox null", "x", &[]));
let got = leaf_box_array(&mut pdf, ObjectRef::new(3, 0), b"TrimBox").unwrap();
assert!(got.is_none());
}
#[test]
fn leaf_box_array_returns_array_for_present_direct_box() {
let mut pdf = open(one_page_doc("/TrimBox [0 0 100 200]", "x", &[]));
let got = leaf_box_array(&mut pdf, ObjectRef::new(3, 0), b"TrimBox")
.unwrap()
.expect("a present direct box array must resolve");
assert_eq!(got.len(), 4);
}
#[test]
fn inherited_box_array_finds_box_on_ancestor() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(
2,
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 612 792] >>",
),
(3, "<< /Type /Page /Parent 2 0 R >>"),
],
1,
));
let got = inherited_box_array(&mut pdf, ObjectRef::new(3, 0), b"MediaBox")
.unwrap()
.expect("ancestor MediaBox must be found");
assert_eq!(got.len(), 4);
}
#[test]
fn page_group_returns_none_for_absent_group() {
let mut pdf = open(one_page_doc("", "x", &[]));
let got = page_group(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert!(got.is_none());
}
#[test]
fn page_group_returns_none_for_null_group() {
let mut pdf = open(one_page_doc("/Group null", "x", &[]));
let got = page_group(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert!(got.is_none());
}
#[test]
fn page_group_returns_a_direct_dict() {
let mut pdf = open(one_page_doc(
"/Group << /Type /Group /S /Transparency >>",
"x",
&[],
));
let got = page_group(&mut pdf, ObjectRef::new(3, 0))
.unwrap()
.expect("a present direct /Group dict must be returned");
assert!(got.as_dictionary().is_some());
}
#[test]
fn page_group_shallow_copies_a_direct_group() {
let mut pdf = open(one_page_doc(
"/Group << /Type /Group /S /Transparency >>",
"x",
&[],
));
let got = page_group(&mut pdf, ObjectRef::new(3, 0))
.unwrap()
.expect("a present direct /Group dict must be returned");
got.replace_key(b"/S", ObjectHandle::name(b"Mutated".to_vec()))
.unwrap();
let page = pdf.get_object_handle(ObjectRef::new(3, 0));
page.try_is_scalar().unwrap();
let original_group = page.try_get_key(b"/Group").unwrap();
let original_s = original_group.try_get_key(b"/S").unwrap();
assert_eq!(
original_s.as_name(),
Some(b"Transparency".to_vec()),
"mutating the returned handle must not affect the page's own /Group"
);
}
#[test]
fn page_group_shallow_copies_indirect_group() {
let mut pdf = open(one_page_doc(
"/Group 6 0 R",
"x",
&[(6, "<< /Type /Group /S /Transparency >>")],
));
let got = page_group(&mut pdf, ObjectRef::new(3, 0))
.unwrap()
.expect("an indirect /Group must shallow-copy to a direct dict");
assert!(got.is_direct());
assert!(got.as_dictionary().is_some());
}
#[test]
fn inherited_rotate_attribute_returns_absent_for_non_dict() {
let mut pdf = doc_with_non_dict_obj3();
assert_eq!(
inherited_rotate_attribute(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(false, 0)
);
}
#[test]
fn inherited_rotate_attribute_resolves_indirect_reference() {
let mut pdf = open(one_page_doc("/Rotate 6 0 R", "x", &[(6, "90")]));
assert_eq!(
inherited_rotate_attribute(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(true, 90)
);
}
#[test]
fn inherited_rotate_attribute_treats_null_as_absent_and_climbs() {
let mut pdf = open(one_page_doc("/Rotate null", "x", &[]));
assert_eq!(
inherited_rotate_attribute(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(false, 0)
);
}
#[test]
fn inherited_rotate_attribute_present_non_integer_is_treated_as_present_zero() {
let mut pdf = open(one_page_doc("/Rotate /Weird", "x", &[]));
assert_eq!(
inherited_rotate_attribute(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(true, 0)
);
}
#[test]
fn inherited_rotate_attribute_breaks_on_parent_cycle() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 4 0 R >>"),
(4, "<< /Type /Pages /Parent 3 0 R >>"),
],
1,
));
assert_eq!(
inherited_rotate_attribute(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(false, 0)
);
}
#[test]
fn inherited_rotate_attribute_errors_on_parent_chain_too_deep() {
let total = DEFAULT_MAX_PAGE_TREE_DEPTH + 5;
let mut objs: Vec<(u32, String)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string()),
];
for n in 3..=(total as u32) {
objs.push((n, format!("<< /Type /Pages /Parent {} 0 R >>", n + 1)));
}
let borrowed: Vec<(u32, &str)> = objs.iter().map(|(n, b)| (*n, b.as_str())).collect();
let mut pdf = open(build_pdf(&borrowed, 1));
let err = inherited_rotate_attribute(&mut pdf, ObjectRef::new(3, 0));
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn leaf_user_unit_returns_absent_for_non_dict() {
let mut pdf = doc_with_non_dict_obj3();
assert_eq!(
leaf_user_unit(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(false, 1.0)
);
}
#[test]
fn leaf_user_unit_resolves_indirect_reference() {
let mut pdf = open(one_page_doc("/UserUnit 6 0 R", "x", &[(6, "3")]));
assert_eq!(
leaf_user_unit(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(true, 3.0)
);
}
#[test]
fn leaf_user_unit_treats_null_as_absent() {
let mut pdf = open(one_page_doc("/UserUnit null", "x", &[]));
assert_eq!(
leaf_user_unit(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(false, 1.0)
);
}
#[test]
fn leaf_user_unit_reads_real_value() {
let mut pdf = open(one_page_doc("/UserUnit 1.5", "x", &[]));
assert_eq!(
leaf_user_unit(&mut pdf, ObjectRef::new(3, 0)).unwrap(),
(true, 1.5)
);
}
#[test]
fn transformation_matrix_invert_zero_scale_is_identity() {
let t = PageTransform {
rotate_present: false,
rotate: 0,
uu_present: true,
scale: 0.0,
};
assert_eq!(
get_matrix_for_transformations(&t, 612.0, 792.0, true),
Matrix::default()
);
}
}