use crate::object_handle::ObjectHandle;
use crate::page_object_helper::PageBox;
use crate::{Matrix, ObjectRef, Pdf, Rectangle, Result};
use std::io::{Read, Seek};
pub struct AnnotationObjectHelper<'a, R: Read + Seek + 'static> {
annot: ObjectHandle,
pdf: &'a mut Pdf<R>,
}
const QPDF_FAKE_NAME: &[u8] = b"QPDFFakeName";
impl<'a, R: Read + Seek> AnnotationObjectHelper<'a, R> {
pub fn new(annot_ref: ObjectRef, pdf: &'a mut Pdf<R>) -> Self {
let annot = pdf.get_object_handle(annot_ref);
Self { annot, pdf }
}
pub fn from_object_handle(annot: ObjectHandle, pdf: &'a mut Pdf<R>) -> Self {
Self { annot, pdf }
}
fn resolved_key(&mut self, key: &[u8]) -> Result<ObjectHandle> {
self.pdf.resolve(&self.annot)?;
let child = self.annot.get_key(key);
self.pdf.resolve(&child)?;
Ok(child)
}
pub fn get_subtype(&mut self) -> Result<Vec<u8>> {
Ok(self
.resolved_key(b"/Subtype")?
.as_name()
.unwrap_or_else(|| QPDF_FAKE_NAME.to_vec()))
}
pub fn get_rect(&mut self) -> Result<PageBox> {
let rect = self.resolved_key(b"/Rect")?;
self.array_as_rectangle(&rect)
}
fn array_as_rectangle(&mut self, handle: &ObjectHandle) -> Result<PageBox> {
let zero = PageBox::new(0.0, 0.0, 0.0, 0.0);
let Some(items) = handle.as_array() else {
return Ok(zero);
};
if items.len() != 4 {
return Ok(zero);
}
let mut nums = [0.0f64; 4];
for (i, item) in items.iter().enumerate() {
self.pdf.resolve(item)?;
let Some(n) = as_number(item) else {
return Ok(zero);
};
nums[i] = n;
}
Ok(PageBox::new(
nums[0].min(nums[2]),
nums[1].min(nums[3]),
nums[0].max(nums[2]),
nums[1].max(nums[3]),
))
}
pub fn get_appearance_dictionary(&mut self) -> Result<ObjectHandle> {
self.resolved_key(b"/AP")
}
pub fn get_appearance_state(&mut self) -> Result<Vec<u8>> {
Ok(self.resolved_key(b"/AS")?.as_name().unwrap_or_default())
}
pub fn get_flags(&mut self) -> Result<i64> {
Ok(self.resolved_key(b"/F")?.as_integer().unwrap_or(0))
}
pub fn get_appearance_stream(
&mut self,
which: &[u8],
state: Option<&[u8]>,
) -> Result<ObjectHandle> {
let ap = self.get_appearance_dictionary()?;
if ap.as_dictionary().is_some() {
let ap_sub = ap.get_key(&dict_key(which));
self.pdf.resolve(&ap_sub)?;
if ap_sub.as_stream_dict().is_some() {
return Ok(ap_sub);
}
if ap_sub.as_dictionary().is_some() {
let desired_state: Vec<u8> = match state {
Some(s) if !s.is_empty() => s.to_vec(),
_ => self.get_appearance_state()?,
};
if !desired_state.is_empty() {
let ap_sub_val = ap_sub.get_key(&dict_key(&desired_state));
self.pdf.resolve(&ap_sub_val)?;
if ap_sub_val.as_stream_dict().is_some() {
return Ok(ap_sub_val);
}
}
} } Ok(ObjectHandle::null())
}
pub fn get_page_content_for_appearance(
&mut self,
name: &str,
rotate: i32,
required_flags: i64,
forbidden_flags: i64,
) -> Result<Vec<u8>> {
let appearance = self.get_appearance_stream(b"N", None)?;
self.build_page_content_for_appearance(
name,
appearance,
rotate,
required_flags,
forbidden_flags,
)
}
fn build_page_content_for_appearance(
&mut self,
name: &str,
appearance: ObjectHandle,
rotate: i32,
required_flags: i64,
forbidden_flags: i64,
) -> Result<Vec<u8>> {
let Some(appearance_dict) = appearance.as_stream_dict() else {
return Ok(Vec::new());
};
let flags = self.get_flags()?;
if (flags & forbidden_flags) != 0 {
return Ok(Vec::new());
}
if (flags & required_flags) != required_flags {
return Ok(Vec::new());
}
let bbox_handle = appearance_dict.get_key(b"/BBox");
let Some(bbox) = self.rectangle_from_handle(&bbox_handle)? else {
return Ok(Vec::new());
};
let Some(rect) = self.rectangle_for_key(b"/Rect")? else {
return Ok(Vec::new());
};
let matrix_handle = appearance_dict.get_key(b"/Matrix");
let matrix = self.matrix_from_handle(&matrix_handle)?.unwrap_or_default();
let do_rotate = rotate != 0 && (flags & 0x10) != 0;
let (rect, matrix) = if do_rotate {
let mut rotated_matrix = Matrix::default();
rotated_matrix.rotatex90(rotate);
rotated_matrix.concat(matrix);
let rect_width = rect.urx - rect.llx;
let rect_height = rect.ury - rect.lly;
let rotated_rect = match rotate {
90 => Rectangle::new(
rect.llx,
rect.ury,
rect.llx + rect_height,
rect.ury + rect_width,
),
180 => Rectangle::new(
rect.llx - rect_width,
rect.ury,
rect.llx,
rect.ury + rect_height,
),
270 => Rectangle::new(
rect.llx - rect_height,
rect.ury - rect_width,
rect.llx,
rect.ury,
),
_ => rect,
};
(rotated_rect, rotated_matrix)
} else {
(rect, matrix)
};
let transformed_bbox = matrix.transform_rectangle(bbox);
let width = transformed_bbox.urx - transformed_bbox.llx;
let height = transformed_bbox.ury - transformed_bbox.lly;
if width == 0.0 || height == 0.0 {
return Ok(Vec::new());
}
let mut placement = Matrix::default();
placement.translate(rect.llx, rect.lly);
placement.scale(
(rect.urx - rect.llx) / width,
(rect.ury - rect.lly) / height,
);
placement.translate(-transformed_bbox.llx, -transformed_bbox.lly);
if do_rotate {
placement.rotatex90(rotate);
}
appearance_dict.replace_key(b"/Subtype", ObjectHandle::name(b"Form".to_vec()))?;
self.pdf.mark_object_handle_dirty(&appearance_dict)?;
Ok(format!("q\n{} cm\n{} Do\nQ\n", placement.unparse(), name).into_bytes())
}
fn rectangle_for_key(&mut self, key: &[u8]) -> Result<Option<Rectangle>> {
let handle = self.resolved_key(key)?;
self.rectangle_from_handle(&handle)
}
fn rectangle_from_handle(&mut self, handle: &ObjectHandle) -> Result<Option<Rectangle>> {
self.pdf.resolve(handle)?;
let Some(items) = handle.as_array() else {
return Ok(None);
};
if items.len() != 4 {
return Ok(None);
}
let mut numbers = [0.0; 4];
for (index, item) in items.iter().enumerate() {
self.pdf.resolve(item)?;
let Some(number) = as_number(item) else {
return Ok(None);
};
numbers[index] = number;
}
Ok(Some(Rectangle::new(
numbers[0].min(numbers[2]),
numbers[1].min(numbers[3]),
numbers[0].max(numbers[2]),
numbers[1].max(numbers[3]),
)))
}
fn matrix_from_handle(&mut self, handle: &ObjectHandle) -> Result<Option<Matrix>> {
self.pdf.resolve(handle)?;
let Some(items) = handle.as_array() else {
return Ok(None);
};
if items.len() != 6 {
return Ok(None);
}
let mut numbers = [0.0; 6];
for (index, item) in items.iter().enumerate() {
self.pdf.resolve(item)?;
let Some(number) = as_number(item) else {
return Ok(None);
};
numbers[index] = number;
}
Ok(Some(Matrix::from(numbers)))
}
}
fn dict_key(name: &[u8]) -> Vec<u8> {
let mut key = Vec::with_capacity(name.len() + 1);
key.push(b'/');
key.extend_from_slice(name);
key
}
fn as_number(handle: &ObjectHandle) -> Option<f64> {
handle
.as_integer()
.map(|n| n as f64)
.or_else(|| handle.as_real())
}