use crate::object_handle::{ObjectHandle, ObjectValue};
use crate::pages::tree_rebuild::RebuildResult;
use crate::{Error, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
const DEFAULT_MAX_OUTLINE_REMAP_DEPTH: usize = 100;
#[derive(Default)]
struct Surviving {
map: BTreeMap<ObjectRef, ObjectRef>,
new_refs: BTreeSet<ObjectRef>,
}
impl Surviving {
fn from_rebuild(result: &RebuildResult) -> Self {
let map = result
.ref_map
.iter()
.filter_map(|(&old, new_refs)| new_refs.first().map(|&new| (old, new)))
.collect();
let new_refs = result.new_kids.iter().copied().collect();
Surviving { map, new_refs }
}
fn remap(&self, old: ObjectRef) -> Option<ObjectRef> {
self.map.get(&old).copied()
}
fn is_surviving_target(&self, page_ref: ObjectRef) -> bool {
self.map.contains_key(&page_ref) || self.new_refs.contains(&page_ref)
}
}
fn child_if_present(parent: &ObjectHandle, key: &[u8]) -> Result<Option<ObjectHandle>> {
if parent.try_has_key(key)? {
Ok(Some(parent.try_get_key(key)?))
} else {
Ok(None)
}
}
fn indirect_child(parent: &ObjectHandle, key: &[u8]) -> Result<Option<ObjectHandle>> {
Ok(child_if_present(parent, key)?.filter(|child| child.object_ref().is_some()))
}
pub fn remap_outline_and_dests<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
) -> Result<()> {
remap_outline_and_dests_with_max_depth(pdf, result, DEFAULT_MAX_OUTLINE_REMAP_DEPTH)
}
pub fn remap_outline_and_dests_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
max_depth: usize,
) -> Result<()> {
null_removed_pages(pdf, result)?;
let surviving = Surviving::from_rebuild(result);
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(()), };
let catalog = pdf.get_object_handle(catalog_ref);
if !catalog.try_is_dictionary()? {
return Ok(());
}
let outlines = indirect_child(&catalog, b"/Outlines")?;
if let Some(names) = child_if_present(&catalog, b"/Names")? {
if names.try_is_dictionary()? {
if let Some(dests) = child_if_present(&names, b"/Dests")? {
let mut nt_visited = BTreeSet::new();
remap_name_tree(pdf, &dests, &surviving, 0, max_depth, &mut nt_visited)?;
}
}
}
if let Some(dests) = child_if_present(&catalog, b"/Dests")? {
if dests.try_is_dictionary()? {
remap_dests_dict(pdf, &dests, &surviving)?;
}
}
if let Some(outlines) = outlines {
if let Some(first) = indirect_child(&outlines, b"/First")? {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
remap_outline_tree(pdf, first, 0, max_depth, &surviving, &mut visited)?;
}
}
remap_annot_dests(pdf, result, &surviving)?;
remap_open_action_dest(pdf, &catalog, &surviving)?;
Ok(())
}
fn remap_annot_dests<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
surviving: &Surviving,
) -> Result<()> {
let mut visited_arrays: BTreeSet<ObjectRef> = BTreeSet::new();
let mut visited_items: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in &result.new_kids {
let page = pdf.get_object_handle(page_ref);
let Some(annots) = child_if_present(&page, b"/Annots")? else {
continue;
};
if !annots.try_is_array()? {
continue;
}
if let Some(array_ref) = annots.object_ref() {
if !visited_arrays.insert(array_ref) {
continue;
}
}
remap_annot_array(pdf, &annots, surviving, &mut visited_items)?;
}
Ok(())
}
fn remap_annot_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
arr: &ObjectHandle,
surviving: &Surviving,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
let Some(items) = arr.try_as_array()? else {
return Ok(());
};
for item in items {
if let Some(item_ref) = item.object_ref() {
if !visited.insert(item_ref) {
continue;
}
}
remap_item_dest(pdf, &item, surviving)?;
}
Ok(())
}
fn remap_open_action_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
catalog: &ObjectHandle,
surviving: &Surviving,
) -> Result<()> {
let Some(oa) = child_if_present(catalog, b"/OpenAction")? else {
return Ok(());
};
remap_action_dest(pdf, &oa, surviving)?;
Ok(())
}
fn remap_action_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
value: &ObjectHandle,
surviving: &Surviving,
) -> Result<bool> {
if !value.try_is_dictionary()? {
return remap_dest(pdf, value, surviving);
}
if let Some(action_type) = child_if_present(value, b"/S")? {
if let Some(name) = action_type.try_as_name()? {
if name != b"GoTo" {
return Ok(false);
}
}
}
let Some(dest) = child_if_present(value, b"/D")? else {
return Ok(false);
};
remap_dest(pdf, &dest, surviving)
}
fn remap_goto_action<R: Read + Seek>(
pdf: &mut Pdf<R>,
action: &ObjectHandle,
surviving: &Surviving,
) -> Result<bool> {
if !action.try_is_dictionary()? {
return Ok(false);
}
let Some(action_type) = child_if_present(action, b"/S")? else {
return Ok(false);
};
if !matches!(action_type.try_as_name()?, Some(name) if name == b"GoTo") {
return Ok(false);
}
let Some(dest) = child_if_present(action, b"/D")? else {
return Ok(false);
};
remap_dest(pdf, &dest, surviving)
}
fn null_removed_pages<R: Read + Seek>(pdf: &mut Pdf<R>, result: &RebuildResult) -> Result<()> {
if result.removed_page_objgens.is_empty() {
for &removed in &result.removed_pages {
pdf.replace_object(removed, ObjectHandle::null())?;
}
return Ok(());
}
for object_gen in &result.removed_page_objgens {
let page =
pdf.get_object_handle_by_raw_identity(object_gen.get_obj(), object_gen.get_gen());
page.set_resolved(ObjectValue::Null);
}
Ok(())
}
fn remap_name_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: &ObjectHandle,
surviving: &Surviving,
depth: usize,
max_depth: usize,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
if depth >= max_depth {
let node_ref = node
.object_ref()
.map_or_else(|| "direct".to_owned(), |object_ref| object_ref.to_string());
return Err(Error::Unsupported(format!(
"outline_dest_remap: name-tree depth limit {max_depth} exceeded at {node_ref}"
)));
}
if let Some(node_ref) = node.object_ref() {
if !visited.insert(node_ref) {
return Ok(()); }
}
if !node.try_is_dictionary()? {
return Ok(()); }
if let Some(pairs) = child_if_present(node, b"/Names")? {
remap_name_pairs(pdf, &pairs, surviving)?;
return Ok(());
}
if let Some(kids) = child_if_present(node, b"/Kids")? {
if let Some(items) = kids.try_as_array()? {
for child in items {
if child.object_ref().is_some() {
remap_name_tree(pdf, &child, surviving, depth + 1, max_depth, visited)?;
} }
}
}
Ok(())
}
fn remap_name_pairs<R: Read + Seek>(
pdf: &mut Pdf<R>,
pairs: &ObjectHandle,
surviving: &Surviving,
) -> Result<()> {
let Some(mut items) = pairs.try_as_array()? else {
return Ok(());
};
if items.len() % 2 != 0 {
items.pop();
pairs.set_array_items(items.clone())?;
}
for dest in items.iter().skip(1).step_by(2) {
remap_dest(pdf, dest, surviving)?;
}
Ok(())
}
fn remap_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest: &ObjectHandle,
surviving: &Surviving,
) -> Result<bool> {
remap_dest_depth(pdf, dest, surviving, MAX_DEST_RESOLVE_DEPTH)
}
const MAX_DEST_RESOLVE_DEPTH: usize = 64;
fn remap_dest_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
dest: &ObjectHandle,
surviving: &Surviving,
depth: usize,
) -> Result<bool> {
if depth == 0 {
return Ok(false);
}
if let Some(items) = dest.try_as_array()? {
let Some(first) = items.first() else {
return Ok(false);
};
let Some(old_ref) = first.object_ref() else {
return Ok(false);
};
let Some(new_ref) = surviving.remap(old_ref) else {
return Ok(false);
};
if new_ref == old_ref || !surviving.is_surviving_target(old_ref) {
return Ok(false);
}
dest.set_array_item(0, pdf.get_object_handle(new_ref))?;
return Ok(true);
}
if dest.try_is_dictionary()? {
let Some(value) = child_if_present(dest, b"/D")? else {
return Ok(false);
};
return remap_dest_depth(pdf, &value, surviving, depth - 1);
}
Ok(false)
}
fn remap_dests_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
dests: &ObjectHandle,
surviving: &Surviving,
) -> Result<()> {
for key in dests.try_get_keys()? {
let value = dests.try_get_key(&key)?;
remap_dest(pdf, &value, surviving)?;
}
Ok(())
}
fn remap_outline_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
first: ObjectHandle,
depth: usize,
max_depth: usize,
surviving: &Surviving,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
if depth >= max_depth {
let first_ref = first
.object_ref()
.map_or_else(|| "direct".to_owned(), |object_ref| object_ref.to_string());
return Err(Error::Unsupported(format!(
"outline_dest_remap: depth limit {max_depth} exceeded at {first_ref}"
)));
}
let mut current = Some(first);
while let Some(item) = current {
if let Some(item_ref) = item.object_ref() {
if !visited.insert(item_ref) {
break; }
}
if !item.try_is_dictionary()? {
break; }
let next = indirect_child(&item, b"/Next")?;
let first_child = indirect_child(&item, b"/First")?;
remap_item_dest(pdf, &item, surviving)?;
if let Some(child_first) = first_child {
remap_outline_tree(pdf, child_first, depth + 1, max_depth, surviving, visited)?;
}
current = next;
}
Ok(())
}
fn remap_item_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
item: &ObjectHandle,
surviving: &Surviving,
) -> Result<()> {
if !item.try_is_dictionary()? {
return Ok(());
}
if let Some(dest) = child_if_present(item, b"/Dest")? {
remap_dest(pdf, &dest, surviving)?;
}
if let Some(action) = child_if_present(item, b"/A")? {
remap_goto_action(pdf, &action, surviving)?;
}
Ok(())
}