use crate::content_stream::{ContentStreamParser, ContentToken};
use crate::page_rotate::resolve_inherited_rotate;
use crate::pages::{resolve_inherited_resources, DEFAULT_MAX_PAGE_TREE_DEPTH};
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result};
use std::collections::BTreeSet;
use std::io::{Read, Seek};
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PageBox {
pub llx: f64,
pub lly: f64,
pub urx: f64,
pub ury: f64,
}
impl PageBox {
pub fn new(llx: f64, lly: f64, urx: f64, ury: f64) -> Self {
Self { llx, lly, urx, ury }
}
}
pub struct PageObjectHelper<'a, R: Read + Seek> {
page_ref: ObjectRef,
pdf: &'a mut Pdf<R>,
}
impl<'a, R: Read + Seek> PageObjectHelper<'a, R> {
pub fn new(page_ref: ObjectRef, pdf: &'a mut Pdf<R>) -> Self {
Self { page_ref, pdf }
}
fn ensure_leaf_page(&mut self) -> Result<()> {
let obj = self.pdf.resolve_borrowed(self.page_ref)?;
match obj {
Object::Dictionary(ref d) if matches!(d.get("Type"), Some(Object::Name(n)) if n == b"Page") => {
Ok(())
}
_ => Err(Error::Unsupported(format!(
"object {} is not a /Type /Page dictionary",
self.page_ref
))),
}
}
pub fn content_streams(&mut self) -> Result<Vec<ContentToken>> {
self.ensure_leaf_page()?;
let raw = crate::pages::page_content_bytes(self.pdf, self.page_ref)?;
if raw.is_empty() {
return Ok(Vec::new());
}
let tokens = ContentStreamParser::new(&raw).collect::<Result<Vec<_>>>()?;
Ok(tokens)
}
pub fn resources(&mut self) -> Result<Option<Dictionary>> {
self.ensure_leaf_page()?;
resolve_inherited_resources(self.pdf, self.page_ref)
}
pub fn rotate(&mut self) -> Result<i32> {
self.ensure_leaf_page()?;
resolve_inherited_rotate(self.pdf, self.page_ref)
}
pub fn get_annotations(&mut self) -> Result<Vec<ObjectRef>> {
self.ensure_leaf_page()?;
let page_obj = self.pdf.resolve_borrowed(self.page_ref)?;
let Object::Dictionary(page_dict) = page_obj else {
return Err(Error::Unsupported(format!(
"object {} is not a dictionary, cannot read /Annots",
self.page_ref
)));
};
let annots_val = match page_dict.get("Annots").cloned() {
None => return Ok(Vec::new()),
Some(Object::Null) => return Ok(Vec::new()),
Some(v) => v,
};
let annots_array = match annots_val {
Object::Array(arr) => arr,
Object::Reference(r) => {
let resolved = self.pdf.resolve_borrowed(r)?;
match resolved {
Object::Array(arr) => arr.clone(),
_ => {
return Err(Error::Unsupported(format!(
"/Annots reference {r} on page {} does not resolve to an array",
self.page_ref
)));
}
}
}
other => {
return Err(Error::Unsupported(format!(
"/Annots on page {} has unexpected type {}",
self.page_ref,
object_type_name(&other)
)));
}
};
let mut refs = Vec::with_capacity(annots_array.len());
for (i, elem) in annots_array.iter().enumerate() {
match elem {
Object::Reference(r) => refs.push(*r),
other => {
return Err(Error::Unsupported(format!(
"/Annots element {i} on page {} has type {} (expected reference)",
self.page_ref,
object_type_name(other)
)));
}
}
}
Ok(refs)
}
pub fn media_box(&mut self) -> Result<Option<PageBox>> {
self.ensure_leaf_page()?;
self.inherited_box(b"MediaBox")
}
pub fn crop_box(&mut self) -> Result<Option<PageBox>> {
self.ensure_leaf_page()?;
match self.inherited_box(b"CropBox")? {
Some(b) => Ok(Some(b)),
None => self.media_box(),
}
}
pub fn bleed_box(&mut self) -> Result<Option<PageBox>> {
self.ensure_leaf_page()?;
match self.leaf_box(b"BleedBox")? {
Some(b) => Ok(Some(b)),
None => self.crop_box(),
}
}
pub fn trim_box(&mut self) -> Result<Option<PageBox>> {
self.ensure_leaf_page()?;
match self.leaf_box(b"TrimBox")? {
Some(b) => Ok(Some(b)),
None => self.crop_box(),
}
}
pub fn art_box(&mut self) -> Result<Option<PageBox>> {
self.ensure_leaf_page()?;
match self.leaf_box(b"ArtBox")? {
Some(b) => Ok(Some(b)),
None => self.crop_box(),
}
}
fn inherited_box(&mut self, key: &[u8]) -> Result<Option<PageBox>> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = self.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 = self.pdf.resolve_borrowed(current)?;
let Object::Dictionary(dict) = node_obj else {
return Ok(None);
};
let val = dict.get(key).cloned();
let parent_val = dict.get("Parent").cloned();
if let Some(val) = val {
match val {
Object::Null => {}
Object::Array(arr) => {
return parse_rect_array(&arr, key).map(Some);
}
Object::Reference(r) => {
let resolved = self.pdf.resolve_borrowed(r)?;
match resolved {
Object::Null => {}
Object::Array(arr) => {
return parse_rect_array(arr, key).map(Some);
}
_ => {
return Err(Error::Unsupported(format!(
"/{} reference {r} on node {current} does not resolve to an array",
String::from_utf8_lossy(key)
)));
}
}
}
_ => {
return Err(Error::Unsupported(format!(
"/{} entry on node {current} has unexpected type",
String::from_utf8_lossy(key)
)));
}
}
}
let parent_val = match parent_val {
Some(Object::Null) | None => return Ok(None),
Some(v) => v,
};
match parent_val {
Object::Reference(r) => {
current = r;
depth += 1;
}
_ => return Ok(None),
}
}
}
fn leaf_box(&mut self, key: &[u8]) -> Result<Option<PageBox>> {
let page_obj = self.pdf.resolve_borrowed(self.page_ref)?;
let Object::Dictionary(dict) = page_obj else {
return Ok(None);
};
let val = match dict.get(key).cloned() {
None => return Ok(None),
Some(Object::Null) => return Ok(None),
Some(v) => v,
};
match val {
Object::Array(arr) => parse_rect_array(&arr, key).map(Some),
Object::Reference(r) => {
let resolved = self.pdf.resolve_borrowed(r)?;
match resolved {
Object::Null => Ok(None),
Object::Array(arr) => parse_rect_array(arr, key).map(Some),
_ => Err(Error::Unsupported(format!(
"/{} reference {r} on page {} does not resolve to an array",
String::from_utf8_lossy(key),
self.page_ref
))),
}
}
_ => Err(Error::Unsupported(format!(
"/{} entry on page {} has unexpected type",
String::from_utf8_lossy(key),
self.page_ref
))),
}
}
}
fn parse_rect_array(arr: &[Object], key: &[u8]) -> Result<PageBox> {
if arr.len() < 4 {
return Err(Error::Unsupported(format!(
"/{} rectangle array has {} elements, expected 4",
String::from_utf8_lossy(key),
arr.len()
)));
}
let mut coords = [0f64; 4];
for (i, elem) in arr.iter().take(4).enumerate() {
coords[i] = match elem {
Object::Integer(n) => *n as f64,
Object::Real(r) => *r,
other => {
return Err(Error::Unsupported(format!(
"/{} rectangle element {i} has type {} (expected number)",
String::from_utf8_lossy(key),
object_type_name(other)
)));
}
};
}
Ok(PageBox::new(coords[0], coords[1], coords[2], coords[3]))
}
fn object_type_name(obj: &Object) -> &'static str {
match obj {
Object::Null => "null",
Object::Boolean(_) => "boolean",
Object::Integer(_) => "integer",
Object::Real(_) => "real",
Object::Name(_) => "name",
Object::String(_) => "string",
Object::Array(_) => "array",
Object::Dictionary(_) => "dictionary",
Object::Stream(_) => "stream",
Object::Reference(_) => "reference",
}
}