use crate::outline_document_helper::OutlineDocumentHelper;
use crate::{ObjectHandle, ObjectRef, Result};
use std::collections::{BTreeMap, VecDeque};
use std::io::{Read, Seek};
use std::ops::Index;
use std::sync::OnceLock;
fn outline_dict_key(object: &ObjectHandle, key: &[u8]) -> Result<Option<ObjectHandle>> {
if !object.try_has_key(key)? {
return Ok(None);
}
Ok(Some(object.try_get_key(key)?))
}
fn title_from_handle(value: &ObjectHandle) -> Result<String> {
if let Some(bytes) = value.as_string() {
Ok(String::from_utf8_lossy(&crate::pdf_string::utf8_value(&bytes)).into_owned())
} else {
value.type_warning("string", "returning empty string")?;
Ok(String::new())
}
}
fn count_from_handle(value: &ObjectHandle) -> Result<i32> {
value.try_get_int_value_as_int()
}
fn goto_action_dest<R: Read + Seek>(
helper: &mut OutlineDocumentHelper<'_, R>,
action: ObjectHandle,
) -> Result<Option<ObjectHandle>> {
let action = helper.resolve_value_handle(action)?;
if !action.try_is_dictionary()? {
return Ok(None);
}
let subtype = helper.resolve_value_handle(action.try_get_key(b"/S")?)?;
if !subtype.try_is_name_and_equals(b"GoTo")? {
return Ok(None);
}
if !action.try_has_key(b"/D")? {
return Ok(None);
}
Ok(Some(action.try_get_key(b"/D")?))
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct OutlineId(pub(crate) usize);
#[derive(Debug, Clone)]
pub struct OutlineItem {
pub source_ref: Option<ObjectRef>,
pub parent: Option<OutlineId>,
pub kids: Vec<OutlineId>,
pub object: ObjectHandle,
}
impl OutlineItem {
pub fn get_title<R: Read + Seek>(
&self,
helper: &mut OutlineDocumentHelper<'_, R>,
) -> Result<String> {
helper.ensure_handle_belongs_to_pdf(&self.object)?;
let Some(value) = outline_dict_key(&self.object, b"/Title")? else {
return Ok(String::new());
};
value.try_dereference()?;
title_from_handle(&value)
}
pub fn get_count<R: Read + Seek>(
&self,
helper: &mut OutlineDocumentHelper<'_, R>,
) -> Result<i32> {
helper.ensure_handle_belongs_to_pdf(&self.object)?;
let Some(value) = outline_dict_key(&self.object, b"/Count")? else {
return Ok(0);
};
value.try_dereference()?;
count_from_handle(&value)
}
pub fn get_dest<R: Read + Seek>(
&self,
helper: &mut OutlineDocumentHelper<'_, R>,
) -> Result<ObjectHandle> {
helper.ensure_handle_belongs_to_pdf(&self.object)?;
let dest_src = outline_dict_key(&self.object, b"/Dest")?;
let candidate = match dest_src {
Some(dest) => Some(dest),
None => goto_action_dest(helper, self.object.try_get_key(b"/A")?)?,
};
let Some(candidate) = candidate else {
return Ok(ObjectHandle::null());
};
let candidate = helper.resolve_value_handle(candidate)?;
let is_named = candidate.try_as_name()?.is_some() || candidate.as_string().is_some();
let dest = if is_named {
helper.resolve_named_dest(candidate)?
} else {
candidate
};
dest.try_dereference()?;
Ok(dest)
}
pub fn get_dest_page<R: Read + Seek>(
&self,
helper: &mut OutlineDocumentHelper<'_, R>,
) -> Result<ObjectHandle> {
let dest = self.get_dest(helper)?;
Ok(dest
.as_array()
.and_then(|items| items.into_iter().next())
.unwrap_or_else(ObjectHandle::null))
}
}
#[derive(Debug)]
pub struct OutlineTree {
pub(crate) items: Vec<OutlineItem>,
pub(crate) roots: Vec<OutlineId>,
by_page: OnceLock<BTreeMap<Option<ObjectRef>, Vec<OutlineId>>>,
}
impl OutlineTree {
pub(crate) fn new() -> Self {
Self {
items: Vec::new(),
roots: Vec::new(),
by_page: OnceLock::new(),
}
}
fn normalize_page_key(page: Option<ObjectRef>) -> Option<ObjectRef> {
page.filter(|reference| *reference != ObjectRef::new(0, 0))
}
fn page_key<R: Read + Seek>(
item: &OutlineItem,
helper: &mut OutlineDocumentHelper<'_, R>,
) -> Result<Option<ObjectRef>> {
Ok(Self::normalize_page_key(
item.get_dest_page(helper)?.object_ref(),
))
}
fn initialize_by_page<R: Read + Seek>(
&self,
helper: &mut OutlineDocumentHelper<'_, R>,
) -> Result<BTreeMap<Option<ObjectRef>, Vec<OutlineId>>> {
let mut index = BTreeMap::<Option<ObjectRef>, Vec<OutlineId>>::new();
let mut queue: VecDeque<OutlineId> = self.roots.iter().copied().collect();
while let Some(id) = queue.pop_front() {
let key = Self::page_key(&self[id], helper)?;
index.entry(key).or_default().push(id);
queue.extend(self[id].kids.iter().copied());
}
Ok(index)
}
fn by_page<R: Read + Seek>(
&self,
helper: &mut OutlineDocumentHelper<'_, R>,
) -> Result<&BTreeMap<Option<ObjectRef>, Vec<OutlineId>>> {
if self.by_page.get().is_none() {
let built = self.initialize_by_page(helper)?;
let _ = self.by_page.set(built);
}
Ok(self
.by_page
.get()
.expect("populated by the check-then-set above"))
}
pub fn get_outlines_for_page<R: Read + Seek>(
&self,
helper: &mut OutlineDocumentHelper<'_, R>,
page: Option<ObjectRef>,
) -> Result<impl Iterator<Item = (OutlineId, &OutlineItem)>> {
Ok(self
.by_page(helper)?
.get(&Self::normalize_page_key(page))
.into_iter()
.flatten()
.copied()
.map(|id| (id, &self[id])))
}
pub fn roots(&self) -> &[OutlineId] {
&self.roots
}
pub fn get(&self, id: OutlineId) -> Option<&OutlineItem> {
self.items.get(id.0)
}
pub fn preorder(&self) -> OutlineTreeIter<'_> {
OutlineTreeIter {
tree: self,
stack: self.roots.iter().rev().map(|&id| (1, id)).collect(),
}
}
}
impl Index<OutlineId> for OutlineTree {
type Output = OutlineItem;
fn index(&self, id: OutlineId) -> &Self::Output {
&self.items[id.0]
}
}
pub struct OutlineTreeIter<'a> {
tree: &'a OutlineTree,
stack: Vec<(usize, OutlineId)>,
}
impl<'a> Iterator for OutlineTreeIter<'a> {
type Item = (usize, OutlineId, &'a OutlineItem);
fn next(&mut self) -> Option<Self::Item> {
let (depth, id) = self.stack.pop()?;
let item = &self.tree[id];
self.stack
.extend(item.kids.iter().rev().map(|&kid| (depth + 1, kid)));
Some((depth, id, item))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn non_dictionary_action_is_ignored_by_goto_destination() {
let mut pdf = crate::Pdf::empty().unwrap();
let catalog = pdf.root_handle().unwrap();
catalog
.replace_key(b"/A", ObjectHandle::integer(1))
.unwrap();
let item = OutlineItem {
source_ref: None,
parent: None,
kids: Vec::new(),
object: catalog,
};
let mut helper = pdf.outline();
let destination = item.get_dest(&mut helper).unwrap();
assert!(destination.try_is_null().unwrap());
}
}