#![allow(dead_code)]
use std::collections::BTreeSet;
use std::io::{Read, Seek};
use crate::pages::{resolve_inherited_resources, DEFAULT_MAX_PAGE_TREE_DEPTH};
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result, Stream};
const MAX_XOBJECT_CLOSURE_DEPTH: usize = DEFAULT_MAX_PAGE_TREE_DEPTH;
pub(crate) fn page_to_form_xobject<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<ObjectRef> {
let bbox = effective_box_array(pdf, page_ref)?;
let transform = read_page_transform(pdf, page_ref)?;
let (bbox_w, bbox_h) = rectangle_dimensions(&bbox);
let resources = resolve_inherited_resources(pdf, page_ref)?;
let group = page_group(pdf, page_ref)?;
let content = crate::pages::page_content_bytes(pdf, page_ref)?;
let mut dict = Dictionary::new();
dict.insert("Type", Object::Name(b"XObject".to_vec()));
dict.insert("Subtype", Object::Name(b"Form".to_vec()));
dict.insert("BBox", Object::Array(bbox));
if transform.rotate_present || transform.uu_present {
let matrix = transformation_matrix(&transform, bbox_w, bbox_h, false);
dict.insert("Matrix", Object::Array(matrix_objects(&matrix)));
}
if let Some(res) = resources {
dict.insert("Resources", Object::Dictionary(res));
}
if let Some(g) = group {
dict.insert("Group", g);
}
let new_ref = next_object_ref(pdf)?;
pdf.set_object(new_ref, Object::Stream(Stream::new(dict, content)));
Ok(new_ref)
}
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 = page_to_form_xobject(source, source_page_ref)?;
let closure = xobject_object_closure(source, xobject_ref)?;
let map = crate::object_copy::copy_objects(source, dest, &closure)?;
map.get(&xobject_ref).copied().ok_or_else(|| {
Error::Unsupported("imported Form XObject reference missing from copy map".to_string())
})
}
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());
let mut union: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in source_page_refs {
let xobject_ref = page_to_form_xobject(source, page_ref)?;
union.extend(xobject_object_closure(source, xobject_ref)?);
xobject_refs.push(xobject_ref);
}
let map = crate::object_copy::copy_objects(source, dest, &union)?;
xobject_refs
.iter()
.map(|xref| {
map.get(xref).copied().ok_or_else(|| {
Error::Unsupported(
"imported Form XObject reference missing from copy map".to_string(),
)
})
})
.collect()
}
fn effective_box_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<Vec<Object>> {
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"
)))
}
fn leaf_box_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
key: &[u8],
) -> Result<Option<Vec<Object>>> {
let page_obj = pdf.resolve_borrowed(page_ref)?;
let Some(dict) = page_obj.as_dict() else {
return Ok(None);
};
let val = match dict.get(key).cloned() {
None | Some(Object::Null) => return Ok(None),
Some(v) => v,
};
resolve_rect_array(pdf, val, page_ref, key)
}
fn inherited_box_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
key: &[u8],
) -> Result<Option<Vec<Object>>> {
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_obj = pdf.resolve_borrowed(current)?;
let Some(dict) = node_obj.as_dict() else {
return Ok(None);
};
let val = match dict.get(key).cloned() {
Some(v) if !matches!(v, Object::Null) => Some(v),
_ => None,
};
let parent_val = dict.get("Parent").cloned();
if let Some(arr) = val.and_then(|v| resolve_rect_array(pdf, v, current, key).transpose()) {
return Ok(Some(arr?));
}
match parent_val {
Some(Object::Reference(r)) => {
current = r;
depth += 1;
}
_ => return Ok(None),
}
}
}
fn resolve_rect_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
val: Object,
node: ObjectRef,
key: &[u8],
) -> Result<Option<Vec<Object>>> {
let arr = match val {
Object::Array(arr) => arr,
Object::Reference(r) => match pdf.resolve(r)? {
Object::Array(arr) => arr,
Object::Null => return Ok(None),
_ => {
return Err(Error::Unsupported(format!(
"/{} reference {r} on node {node} does not resolve to an array",
String::from_utf8_lossy(key)
)));
}
},
_ => {
return Err(Error::Unsupported(format!(
"/{} entry on node {node} is not a rectangle 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))
}
fn rectangle_dimensions(arr: &[Object]) -> (f64, f64) {
let n = |o: &Object| -> f64 {
match o {
Object::Integer(i) => *i as f64,
Object::Real(r) => *r,
_ => 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())
}
pub(crate) struct PageTransform {
pub rotate_present: bool,
pub rotate: i32,
pub uu_present: bool,
pub scale: f64,
}
pub(crate) fn read_page_transform<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<PageTransform> {
let (rotate_present, rotate) = inherited_rotate_attribute(pdf, page_ref)?;
let (uu_present, scale) = leaf_user_unit(pdf, page_ref)?;
Ok(PageTransform {
rotate_present,
rotate,
uu_present,
scale,
})
}
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_obj = pdf.resolve_borrowed(current)?;
let Some(dict) = node_obj.as_dict() else {
return Ok((false, 0));
};
(dict.get("Rotate").cloned(), dict.get("Parent").cloned())
};
if let Some(val) = rotate_val {
let resolved = match val {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
match resolved {
Object::Null => {}
Object::Integer(n) => return Ok((true, n as i32)),
_ => return Ok((true, 0)),
}
}
match parent_val {
Some(Object::Reference(r)) => {
current = r;
depth += 1;
}
_ => return Ok((false, 0)),
}
}
}
fn leaf_user_unit<R: Read + Seek>(pdf: &mut Pdf<R>, page_ref: ObjectRef) -> Result<(bool, f64)> {
let uu_val = {
let page_obj = pdf.resolve_borrowed(page_ref)?;
let Some(dict) = page_obj.as_dict() else {
return Ok((false, 1.0));
};
dict.get("UserUnit").cloned()
};
let Some(val) = uu_val else {
return Ok((false, 1.0));
};
let resolved = match val {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
match resolved {
Object::Null => Ok((false, 1.0)),
Object::Integer(n) => Ok((true, n as f64)),
Object::Real(r) => Ok((true, r)),
_ => Ok((true, 1.0)),
}
}
pub(crate) fn transformation_matrix(
t: &PageTransform,
width: f64,
height: f64,
invert: bool,
) -> [f64; 6] {
const IDENTITY: [f64; 6] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
if !(t.rotate_present || t.uu_present) {
return IDENTITY;
}
let mut scale = t.scale;
let mut rotate = t.rotate;
if invert {
if scale == 0.0 {
return IDENTITY;
}
scale = 1.0 / scale;
rotate = 360 - rotate;
}
match rotate {
90 => [0.0, -scale, scale, 0.0, 0.0, width * scale],
180 => [-scale, 0.0, 0.0, -scale, width * scale, height * scale],
270 => [0.0, scale, -scale, 0.0, height * scale, 0.0],
_ => [scale, 0.0, 0.0, scale, 0.0, 0.0],
}
}
fn matrix_objects(m: &[f64; 6]) -> Vec<Object> {
m.iter().map(|&x| Object::Real(x)).collect()
}
fn page_group<R: Read + Seek>(pdf: &mut Pdf<R>, page_ref: ObjectRef) -> Result<Option<Object>> {
let group_val = {
let page_obj = pdf.resolve_borrowed(page_ref)?;
let Some(dict) = page_obj.as_dict() else {
return Ok(None);
};
dict.get("Group").cloned()
};
match group_val {
None | Some(Object::Null) => Ok(None),
Some(Object::Reference(r)) => Ok(Some(pdf.resolve(r)?)),
Some(direct) => Ok(Some(direct)),
}
}
fn xobject_object_closure<R: Read + Seek>(
pdf: &mut Pdf<R>,
xobject_ref: ObjectRef,
) -> Result<BTreeSet<ObjectRef>> {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut stack: Vec<(ObjectRef, usize)> = vec![(xobject_ref, 0)];
visited.insert(xobject_ref);
while let Some((current, depth)) = stack.pop() {
if depth >= MAX_XOBJECT_CLOSURE_DEPTH {
return Err(Error::Unsupported(format!(
"Form XObject object graph exceeds depth {MAX_XOBJECT_CLOSURE_DEPTH} at {current}"
)));
}
let obj = pdf.resolve(current)?;
let mut refs = Vec::new();
collect_object_refs(&obj, &mut refs);
for r in refs {
if visited.insert(r) {
stack.push((r, depth + 1));
}
}
}
Ok(visited)
}
fn collect_object_refs(obj: &Object, out: &mut Vec<ObjectRef>) {
match obj {
Object::Reference(r) => out.push(*r),
Object::Array(items) => {
for item in items {
collect_object_refs(item, out);
}
}
Object::Dictionary(dict) => {
for (_key, value) in dict.iter() {
collect_object_refs(value, out);
}
}
Object::Stream(stream) => {
for (_key, value) in stream.dict.iter() {
collect_object_refs(value, out);
}
}
Object::Null
| Object::Boolean(_)
| Object::Integer(_)
| Object::Real(_)
| Object::Name(_)
| Object::String(_) => {}
}
}
fn next_object_ref<R: Read + Seek>(pdf: &Pdf<R>) -> Result<ObjectRef> {
let n = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0)
.checked_add(1)
.ok_or_else(|| Error::Unsupported("object-number space exhausted".to_string()))?;
Ok(ObjectRef::new(n, 0))
}
#[cfg(test)]
mod tests {
use super::*;
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) -> Stream {
pdf.resolve(xref)
.unwrap()
.into_stream()
.expect("Form XObject must be a stream")
}
fn numbers(arr: &[Object]) -> Vec<i64> {
arr.iter()
.map(|o| {
o.as_integer()
.or_else(|| o.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 = page_to_form_xobject(&mut pdf, page_ref).unwrap();
let stream = form_stream(&mut pdf, xref);
let dict = &stream.dict;
let keys: BTreeSet<Vec<u8>> = dict.iter().map(|(k, _)| k.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".as_slice())
);
assert_eq!(
dict.get("Type").unwrap().as_name(),
Some(b"XObject".as_slice())
);
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 = page_to_form_xobject(&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!(matches!(bbox[0], Object::Integer(10)));
assert!(matches!(bbox[1], Object::Integer(10)));
assert!(matches!(bbox[2], Object::Real(v) if (v - 500.5).abs() < 1e-9));
assert!(matches!(bbox[3], Object::Integer(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 = page_to_form_xobject(&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 = page_to_form_xobject(&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_rejects_short_box_array() {
let mut pdf = open(one_page_doc("/TrimBox [0 0 5]", "x", &[]));
let err = page_to_form_xobject(&mut pdf, ObjectRef::new(3, 0));
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn page_to_form_xobject_rejects_non_array_box() {
let mut pdf = open(one_page_doc("/TrimBox /NotARect", "x", &[]));
let err = page_to_form_xobject(&mut pdf, ObjectRef::new(3, 0));
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn page_to_form_xobject_rejects_box_ref_to_non_array() {
let bad = (6u32, "<< /Type /Foo >>");
let mut pdf = open(one_page_doc("/CropBox 6 0 R", "x", &[bad]));
let err = page_to_form_xobject(&mut pdf, ObjectRef::new(3, 0));
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn page_to_form_xobject_errors_when_no_box_anywhere() {
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 err = page_to_form_xobject(&mut pdf, ObjectRef::new(3, 0));
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[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 = page_to_form_xobject(&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!(matches!(bbox[2], Object::Name(_)));
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 = [
Object::Integer(612),
Object::Integer(792),
Object::Integer(0),
Object::Integer(0),
];
assert_eq!(rectangle_dimensions(&swapped), (612.0, 792.0));
let ordered = [
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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 = page_to_form_xobject(&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".as_slice())
);
assert_eq!(
group.get("S").unwrap().as_name(),
Some(b"Transparency".as_slice())
);
assert_eq!(
group.get("CS").unwrap().as_name(),
Some(b"DeviceRGB".as_slice())
);
}
#[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 = page_to_form_xobject(&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".as_slice())
);
}
#[test]
fn page_to_form_xobject_rejects_non_page() {
let mut pdf = open(one_page_doc("", "x", &[]));
let err = page_to_form_xobject(&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".as_slice())
);
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(Object::Reference(r)) => *r,
other => panic!("F1 should be a reference, got {other:?}"), };
let font_obj = dest.resolve(font_ref).unwrap();
let font = font_obj
.as_dict()
.expect("font ref resolves to a dict in dest");
assert_eq!(
font.get("Type").unwrap().as_name(),
Some(b"Font".as_slice())
);
assert_eq!(
font.get("BaseFont").unwrap().as_name(),
Some(b"Helvetica".as_slice())
);
}
#[test]
fn xobject_object_closure_handles_cyclic_references() {
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 /MediaBox [0 0 10 10] \
/Resources << /A 4 0 R >> >>",
),
(4, "<< /Peer 5 0 R >>"),
(5, "<< /Peer 4 0 R >>"),
],
1,
));
let xref = page_to_form_xobject(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let closure = xobject_object_closure(&mut pdf, xref).unwrap();
assert!(closure.contains(&xref));
assert!(closure.contains(&ObjectRef::new(4, 0)));
assert!(closure.contains(&ObjectRef::new(5, 0)));
}
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 got = resolve_rect_array(
&mut pdf,
Object::Reference(ObjectRef::new(3, 0)),
ObjectRef::new(1, 0),
b"TrimBox",
)
.unwrap();
assert!(got.is_none());
}
#[test]
fn xobject_object_closure_errors_when_ref_chain_too_deep() {
let total = MAX_XOBJECT_CLOSURE_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()),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 10 10] \
/Resources << /A 4 0 R >> >>"
.to_string(),
),
];
for n in 4..=(total as u32) {
objs.push((n, format!("<< /Next {} 0 R >>", n + 1)));
}
objs.push(((total + 1) as u32, "<< /Leaf true >>".to_string()));
let borrowed: Vec<(u32, &str)> = objs.iter().map(|(n, b)| (*n, b.as_str())).collect();
let mut pdf = open(build_pdf(&borrowed, 1));
let xref = page_to_form_xobject(&mut pdf, ObjectRef::new(3, 0)).unwrap();
let err = xobject_object_closure(&mut pdf, xref);
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[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_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!(
transformation_matrix(&t, 612.0, 792.0, true),
[1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
);
}
}