use crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH;
use crate::{Error, Object, ObjectRef, Pdf, Result};
use std::collections::BTreeSet;
use std::io::{Read, Seek};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RotateMode {
Assign,
Add,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RotateOp {
pub mode: RotateMode,
pub degrees: i32,
}
pub fn normalize_rotate(deg: i32) -> i32 {
normalize_rotate_i64(deg as i64)
}
fn normalize_rotate_i64(deg: i64) -> i32 {
let snapped = (deg as i128 + 45).div_euclid(90) * 90;
snapped.rem_euclid(360) as i32
}
pub fn compose_rotate(existing: i32, op: &RotateOp) -> i32 {
let raw: i64 = match op.mode {
RotateMode::Assign => op.degrees as i64,
RotateMode::Add => existing as i64 + op.degrees as i64,
};
normalize_rotate_i64(raw)
}
pub fn resolve_inherited_rotate<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<i32> {
resolve_inherited_rotate_with_max_depth(pdf, page_ref, DEFAULT_MAX_PAGE_TREE_DEPTH)
}
pub fn resolve_inherited_rotate_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
max_depth: usize,
) -> Result<i32> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = page_ref;
let mut depth: usize = 0;
loop {
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {max_depth} at {current}"
)));
}
if !seen.insert(current) {
return Ok(0);
}
let node_obj = pdf.resolve(current)?;
let Object::Dictionary(dict) = node_obj else {
return Ok(0);
};
if let Some(rotate_val) = dict.get("Rotate").cloned() {
match rotate_val {
Object::Null => {}
Object::Integer(n) => return Ok(normalize_rotate_i64(n)),
Object::Reference(r) => {
let resolved = pdf.resolve(r)?;
match resolved {
Object::Null => {}
Object::Integer(n) => return Ok(normalize_rotate_i64(n)),
_ => {
return Err(Error::Unsupported(format!(
"/Rotate reference {r} on node {current} does not resolve to an integer"
)));
}
}
}
_ => {
return Err(Error::Unsupported(format!(
"/Rotate entry on node {current} has unexpected type"
)));
}
}
}
let parent_val = match dict.get("Parent").cloned() {
Some(Object::Null) | None => return Ok(0), Some(v) => v,
};
match parent_val {
Object::Reference(r) => {
current = r;
depth += 1;
}
_ => return Ok(0),
}
}
}
pub fn apply_rotate_to_pages<R: Read + Seek>(
pdf: &mut Pdf<R>,
pages: &[ObjectRef],
op: &RotateOp,
) -> Result<()> {
for &page_ref in pages {
let existing = resolve_inherited_rotate(pdf, page_ref)?;
let new_rotate = compose_rotate(existing, op);
let page_obj = pdf.resolve(page_ref)?;
let Object::Dictionary(mut page_dict) = page_obj else {
return Err(Error::Unsupported(format!(
"object {page_ref} is not a dictionary, cannot set /Rotate"
)));
};
let is_leaf_page = matches!(
page_dict.get("Type"),
Some(Object::Name(t)) if t.as_slice() == b"Page"
);
if !is_leaf_page {
return Err(Error::Unsupported(format!(
"object {page_ref} is not a leaf /Page (missing or non-/Page /Type), cannot set /Rotate"
)));
}
page_dict.insert("Rotate", Object::Integer(new_rotate as i64));
pdf.set_object(page_ref, Object::Dictionary(page_dict));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::writer::write_pdf;
use crate::{pages, Pdf};
use std::io::Cursor;
#[test]
fn normalize_standard_values() {
assert_eq!(normalize_rotate(0), 0);
assert_eq!(normalize_rotate(90), 90);
assert_eq!(normalize_rotate(180), 180);
assert_eq!(normalize_rotate(270), 270);
}
#[test]
fn normalize_wraparound() {
assert_eq!(normalize_rotate(360), 0);
assert_eq!(normalize_rotate(450), 90);
assert_eq!(normalize_rotate(540), 180);
assert_eq!(normalize_rotate(720), 0);
}
#[test]
fn normalize_negative() {
assert_eq!(normalize_rotate(-90), 270);
assert_eq!(normalize_rotate(-180), 180);
assert_eq!(normalize_rotate(-270), 90);
assert_eq!(normalize_rotate(-360), 0);
assert_eq!(normalize_rotate(-450), 270);
}
#[test]
fn normalize_non_multiple_of_90_rounds_to_nearest() {
assert_eq!(normalize_rotate(44), 0);
assert_eq!(normalize_rotate(45), 90);
assert_eq!(normalize_rotate(89), 90);
assert_eq!(normalize_rotate(91), 90);
assert_eq!(normalize_rotate(134), 90);
assert_eq!(normalize_rotate(135), 180);
}
#[test]
fn normalize_extreme_i32_inputs_do_not_overflow() {
let max = normalize_rotate(i32::MAX);
let min = normalize_rotate(i32::MIN);
assert!(matches!(max, 0 | 90 | 180 | 270));
assert!(matches!(min, 0 | 90 | 180 | 270));
}
#[test]
fn compose_assign_overwrites_existing() {
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 90,
};
assert_eq!(compose_rotate(270, &op), 90);
assert_eq!(compose_rotate(0, &op), 90);
assert_eq!(compose_rotate(90, &op), 90);
}
#[test]
fn compose_add_accumulates() {
let op = RotateOp {
mode: RotateMode::Add,
degrees: 90,
};
assert_eq!(compose_rotate(0, &op), 90);
assert_eq!(compose_rotate(90, &op), 180);
assert_eq!(compose_rotate(270, &op), 0); }
#[test]
fn compose_add_negative() {
let op = RotateOp {
mode: RotateMode::Add,
degrees: -90,
};
assert_eq!(compose_rotate(0, &op), 270);
assert_eq!(compose_rotate(90, &op), 0);
}
#[test]
fn compose_add_large() {
let op = RotateOp {
mode: RotateMode::Add,
degrees: 450,
};
assert_eq!(compose_rotate(90, &op), 180);
}
#[test]
fn compose_assign_normalizes() {
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 450,
};
assert_eq!(compose_rotate(0, &op), 90);
}
#[test]
fn compose_add_extreme_degrees_do_not_overflow() {
let op = RotateOp {
mode: RotateMode::Add,
degrees: i32::MAX,
};
assert!(matches!(compose_rotate(270, &op), 0 | 90 | 180 | 270));
let op = RotateOp {
mode: RotateMode::Add,
degrees: i32::MIN,
};
assert!(matches!(compose_rotate(90, &op), 0 | 90 | 180 | 270));
}
fn build_single_page_pdf(page_rotate: Option<i32>, parent_rotate: Option<i32>) -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
let pages_str = if let Some(r) = parent_rotate {
format!("2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 /Rotate {r} >>\nendobj\n")
} else {
"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n".to_string()
};
pdf.extend_from_slice(pages_str.as_bytes());
let off3 = pdf.len() as u64;
let page_str = if let Some(r) = page_rotate {
format!(
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Rotate {r} >>\nendobj\n"
)
} else {
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n".to_string()
};
pdf.extend_from_slice(page_str.as_bytes());
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_page_has_direct_rotate() {
let bytes = build_single_page_pdf(Some(90), None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
assert_eq!(resolve_inherited_rotate(&mut pdf, page_ref).unwrap(), 90);
}
#[test]
fn resolve_inherits_from_parent() {
let bytes = build_single_page_pdf(None, Some(180));
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
assert_eq!(resolve_inherited_rotate(&mut pdf, page_ref).unwrap(), 180);
}
#[test]
fn resolve_defaults_to_zero_when_absent() {
let bytes = build_single_page_pdf(None, None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
assert_eq!(resolve_inherited_rotate(&mut pdf, page_ref).unwrap(), 0);
}
#[test]
fn resolve_normalizes_non_standard_value() {
let bytes = build_single_page_pdf(Some(45), None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
assert_eq!(resolve_inherited_rotate(&mut pdf, page_ref).unwrap(), 90);
}
#[test]
fn assign_replaces_existing_rotate() {
let bytes = build_single_page_pdf(Some(90), None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 180,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let obj = pdf.resolve(page_ref).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(dict.get("Rotate"), Some(&Object::Integer(180)));
}
#[test]
fn add_accumulates_onto_direct_rotate() {
let bytes = build_single_page_pdf(Some(90), None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
let op = RotateOp {
mode: RotateMode::Add,
degrees: 90,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let obj = pdf.resolve(page_ref).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(dict.get("Rotate"), Some(&Object::Integer(180)));
}
#[test]
fn add_wraps_at_360() {
let bytes = build_single_page_pdf(Some(270), None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
let op = RotateOp {
mode: RotateMode::Add,
degrees: 90,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let obj = pdf.resolve(page_ref).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(dict.get("Rotate"), Some(&Object::Integer(0)));
}
#[test]
fn inherited_rotate_is_materialized_on_leaf() {
let bytes = build_single_page_pdf(None, Some(90));
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 180,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let obj = pdf.resolve(page_ref).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(dict.get("Rotate"), Some(&Object::Integer(180)));
}
#[test]
fn add_with_inherited_rotate_materializes_combined() {
let bytes = build_single_page_pdf(None, Some(90));
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
let op = RotateOp {
mode: RotateMode::Add,
degrees: 90,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let obj = pdf.resolve(page_ref).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(dict.get("Rotate"), Some(&Object::Integer(180)));
}
#[test]
fn assign_zero_materializes_zero_explicitly() {
let bytes = build_single_page_pdf(None, None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 0,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let obj = pdf.resolve(page_ref).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(dict.get("Rotate"), Some(&Object::Integer(0)));
}
#[test]
fn apply_to_empty_slice_is_noop() {
let bytes = build_single_page_pdf(Some(90), None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 270,
};
apply_rotate_to_pages(&mut pdf, &[], &op).unwrap();
let obj = pdf.resolve(ObjectRef::new(3, 0)).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(dict.get("Rotate"), Some(&Object::Integer(90)));
}
#[test]
fn rejects_pages_tree_node_target() {
let bytes = build_single_page_pdf(None, None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let pages_ref = ObjectRef::new(2, 0);
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 90,
};
let err = apply_rotate_to_pages(&mut pdf, &[pages_ref], &op).unwrap_err();
assert!(
matches!(err, Error::Unsupported(_)),
"expected Unsupported for /Pages node, got {err:?}"
);
let obj = pdf.resolve(pages_ref).unwrap();
let Object::Dictionary(dict) = obj else {
panic!("not a dict")
};
assert_eq!(
dict.get("Rotate"),
None,
"/Pages node must not gain /Rotate"
);
}
#[test]
fn round_trip_rotate_preserved_after_write_reopen() {
let bytes = build_single_page_pdf(Some(90), None);
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_ref = ObjectRef::new(3, 0);
let op = RotateOp {
mode: RotateMode::Assign,
degrees: 270,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let mut pdf2 = Pdf::open(Cursor::new(out)).unwrap();
let page_refs = pages::page_refs(&mut pdf2).unwrap();
assert_eq!(page_refs.len(), 1);
let obj2 = pdf2.resolve(page_refs[0]).unwrap();
let Object::Dictionary(dict2) = obj2 else {
panic!("not a dict after round-trip")
};
assert_eq!(
dict2.get("Rotate"),
Some(&Object::Integer(270)),
"expected /Rotate 270 explicitly on leaf after round-trip"
);
}
#[test]
fn round_trip_inherited_rotate_materialized_on_leaf() {
let bytes = build_single_page_pdf(None, Some(180));
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page_refs_before = pages::page_refs(&mut pdf).unwrap();
let page_ref = page_refs_before[0];
let op = RotateOp {
mode: RotateMode::Add,
degrees: 90,
};
apply_rotate_to_pages(&mut pdf, &[page_ref], &op).unwrap();
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let mut pdf2 = Pdf::open(Cursor::new(out)).unwrap();
let page_refs2 = pages::page_refs(&mut pdf2).unwrap();
let obj2 = pdf2.resolve(page_refs2[0]).unwrap();
let Object::Dictionary(dict2) = obj2 else {
panic!("not a dict")
};
assert_eq!(
dict2.get("Rotate"),
Some(&Object::Integer(270)),
"expected inherited+add materialized on leaf"
);
}
fn build_two_page_pdf(page1_rotate: Option<i32>, page2_rotate: Option<i32>) -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(
b"2 0 obj\n<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
let page1_str = if let Some(r) = page1_rotate {
format!(
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Rotate {r} >>\nendobj\n"
)
} else {
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n".to_string()
};
pdf.extend_from_slice(page1_str.as_bytes());
let off4 = pdf.len() as u64;
let page2_str = if let Some(r) = page2_rotate {
format!(
"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Rotate {r} >>\nendobj\n"
)
} else {
"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n".to_string()
};
pdf.extend_from_slice(page2_str.as_bytes());
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3, off4,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn apply_to_multiple_pages_each_updated_independently() {
let bytes = build_two_page_pdf(Some(90), Some(0));
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let page1 = ObjectRef::new(3, 0);
let page2 = ObjectRef::new(4, 0);
let op = RotateOp {
mode: RotateMode::Add,
degrees: 90,
};
apply_rotate_to_pages(&mut pdf, &[page1, page2], &op).unwrap();
let obj1 = pdf.resolve(page1).unwrap();
let Object::Dictionary(dict1) = obj1 else {
panic!("not a dict")
};
assert_eq!(dict1.get("Rotate"), Some(&Object::Integer(180)), "page 1");
let obj2 = pdf.resolve(page2).unwrap();
let Object::Dictionary(dict2) = obj2 else {
panic!("not a dict")
};
assert_eq!(dict2.get("Rotate"), Some(&Object::Integer(90)), "page 2");
}
}