use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use crate::acroform_document_helper::{collect_reachable_refs, collect_refs_in_object};
use crate::overlay_appearance_stream::adjust_appearance_stream;
use crate::parser::{is_delimiter, is_ws, Parser};
use crate::{Error, Object, ObjectRef, Pdf, Result};
const MAX_PARENT_WALK_DEPTH: usize = 100;
struct InheritedOverrides {
override_da: bool,
from_default_da: Vec<u8>,
override_q: bool,
from_default_q: i64,
}
#[derive(Debug, Default)]
pub(crate) struct AnnotationSurvey {
pub annots: Vec<(ObjectRef, Option<ObjectRef>)>,
pub source_dr: Option<ObjectRef>,
pub source_default_da: Option<Vec<u8>>,
pub source_default_q: Option<i64>,
}
#[derive(Debug, Default, Clone)]
pub(crate) struct AnnotationCopyTemplate {
pub annots: Vec<(ObjectRef, Option<ObjectRef>)>,
pub source_dr: Option<ObjectRef>,
pub source_default_da: Option<Vec<u8>>,
pub source_default_q: Option<i64>,
}
pub(crate) fn survey_source_annotations<R: Read + Seek>(
source: &mut Pdf<R>,
source_page_ref: ObjectRef,
) -> Result<Option<(AnnotationSurvey, BTreeSet<ObjectRef>)>> {
let annots_val = {
let obj = source.resolve_borrowed(source_page_ref)?;
let Some(dict) = obj.as_dict() else {
return Ok(None);
};
dict.get("Annots").cloned()
};
let annots_array = match annots_val {
None | Some(Object::Null) => return Ok(None),
Some(Object::Array(arr)) => arr,
Some(Object::Reference(r)) => match source.resolve(r)? {
Object::Array(arr) => arr,
_ => return Ok(None),
},
_ => return Ok(None),
};
if annots_array.is_empty() {
return Ok(None);
}
let mut annots: Vec<(ObjectRef, Option<ObjectRef>)> = Vec::new();
for item in annots_array {
let annot_ref = match item {
Object::Reference(r) => r,
direct @ (Object::Dictionary(_) | Object::Stream(_)) => {
let new_ref = allocate_next_ref(source)?;
source.set_object(new_ref, direct);
new_ref
}
_ => continue, };
let top_field = top_level_field_for_annot(source, annot_ref)?;
annots.push((annot_ref, top_field));
}
if annots.is_empty() {
return Ok(None); }
let (source_dr, source_default_da, source_default_q) = read_source_acroform_defaults(source)?;
let mut closure: BTreeSet<ObjectRef> = BTreeSet::new();
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
for (annot_ref, top_field) in &annots {
collect_reachable_refs(source, *annot_ref, &mut closure, &mut seen, 0, true)?;
if let Some(tf) = top_field {
collect_reachable_refs(source, *tf, &mut closure, &mut seen, 0, true)?;
}
}
if let Some(dr_ref) = source_dr {
collect_refs_in_object(
source,
&Object::Reference(dr_ref),
&mut closure,
&mut seen,
0,
0,
false,
)?;
}
Ok(Some((
AnnotationSurvey {
annots,
source_dr,
source_default_da,
source_default_q,
},
closure,
)))
}
fn top_level_field_for_annot<R: Read + Seek>(
source: &mut Pdf<R>,
annot_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let (is_widget, is_field, parent_ref) = {
let obj = source.resolve_borrowed(annot_ref)?;
let Some(dict) = obj.as_dict() else {
return Ok(None); };
let is_widget = matches!(
dict.get("Subtype"),
Some(Object::Name(name)) if name == b"Widget"
);
let is_field =
dict.get("T").is_some() || dict.get("FT").is_some() || dict.get("Kids").is_some();
let parent_ref = dict.get_ref("Parent");
(is_widget, is_field, parent_ref)
};
if !is_widget {
return Ok(None);
}
let mut current = if let Some(p) = parent_ref {
p
} else if is_field {
return Ok(Some(annot_ref));
} else {
return Ok(None); };
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
visited.insert(annot_ref);
for _ in 0..MAX_PARENT_WALK_DEPTH {
if !visited.insert(current) {
return Ok(None); }
let parent_of_current = {
let obj = source.resolve_borrowed(current)?;
let Some(dict) = obj.as_dict() else {
return Ok(None);
};
dict.get_ref("Parent")
};
match parent_of_current {
Some(p) => current = p,
None => return Ok(Some(current)),
}
}
Err(Error::Unsupported(format!(
"AcroForm /Parent chain from {annot_ref} exceeds maximum depth of {MAX_PARENT_WALK_DEPTH}"
)))
}
#[allow(clippy::type_complexity)]
fn read_source_acroform_defaults<R: Read + Seek>(
source: &mut Pdf<R>,
) -> Result<(Option<ObjectRef>, Option<Vec<u8>>, Option<i64>)> {
let Some(root_ref) = source.root_ref() else {
return Ok((None, None, None));
};
let acroform_val = {
let obj = source.resolve_borrowed(root_ref)?;
let Some(dict) = obj.as_dict() else {
return Ok((None, None, None));
};
dict.get("AcroForm").cloned()
};
let acroform_dict = match acroform_val {
None | Some(Object::Null) => return Ok((None, None, None)),
Some(Object::Dictionary(d)) => d,
Some(Object::Reference(r)) => match source.resolve(r)? {
Object::Dictionary(d) => d,
_ => return Ok((None, None, None)),
},
_ => return Ok((None, None, None)),
};
let dr = match acroform_dict.get("DR").cloned() {
Some(Object::Reference(r)) => Some(r),
Some(dr_val @ (Object::Dictionary(_) | Object::Stream(_))) => {
let new_ref = allocate_next_ref(source)?;
source.set_object(new_ref, dr_val);
Some(new_ref)
}
_ => None, };
let da = match acroform_dict.get("DA") {
Some(Object::String(s)) => Some(s.clone()),
_ => None,
};
let q = match acroform_dict.get("Q") {
Some(Object::Integer(n)) => Some(*n),
_ => None,
};
Ok((dr, da, q))
}
pub(crate) fn template_from_survey(
survey: &AnnotationSurvey,
copy_map: &BTreeMap<ObjectRef, ObjectRef>,
) -> AnnotationCopyTemplate {
let annots = survey
.annots
.iter()
.filter_map(|(annot_ref, top_field)| {
let dest_annot = *copy_map.get(annot_ref)?;
let dest_top_field = top_field.and_then(|tf| copy_map.get(&tf).copied());
Some((dest_annot, dest_top_field))
})
.collect();
AnnotationCopyTemplate {
annots,
source_dr: survey.source_dr.and_then(|r| copy_map.get(&r).copied()),
source_default_da: survey.source_default_da.clone(),
source_default_q: survey.source_default_q,
}
}
#[derive(Debug, Default, Clone)]
pub(crate) struct DrMap {
by_name: BTreeMap<Vec<u8>, BTreeMap<Vec<u8>, Vec<u8>>>,
by_source_ref: BTreeMap<(Vec<u8>, ObjectRef), Vec<u8>>,
}
impl DrMap {
pub(crate) fn new() -> Self {
Self::default()
}
pub(crate) fn is_empty(&self) -> bool {
self.by_name.is_empty()
}
pub(crate) fn category(&self, category: &[u8]) -> Option<&BTreeMap<Vec<u8>, Vec<u8>>> {
self.by_name.get(category)
}
pub(crate) fn categories(&self) -> impl Iterator<Item = &Vec<u8>> {
self.by_name.keys()
}
pub(crate) fn insert_rename(&mut self, category: &[u8], old: Vec<u8>, new: Vec<u8>) {
self.by_name
.entry(category.to_vec())
.or_default()
.insert(old, new);
}
}
#[cfg(test)]
impl DrMap {
pub(crate) fn for_test(category: &[u8], old: &[u8], new: &[u8]) -> Self {
let mut map = Self::new();
map.by_name
.entry(category.to_vec())
.or_default()
.insert(old.to_vec(), new.to_vec());
map
}
}
pub(crate) fn apply_placement<R: Read + Seek>(
dest: &mut Pdf<R>,
dest_page_ref: ObjectRef,
template: &AnnotationCopyTemplate,
cm: [f64; 6],
dest_acroform_dr: &mut Option<ObjectRef>,
dr_map: &mut DrMap,
) -> Result<Vec<ObjectRef>> {
if template.annots.is_empty() {
return Ok(Vec::new()); }
let mut per_placement_dup: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
dr_map.by_name.clear();
let mut dr_map_ready = false;
let overrides = compute_inherited_overrides(dest, template)?;
let mut new_top_fields: Vec<ObjectRef> = Vec::new();
let mut added_top_field_set: BTreeSet<ObjectRef> = BTreeSet::new();
let mut new_annot_refs: Vec<ObjectRef> = Vec::new();
for (dest_annot_ref, dest_top_field) in &template.annots {
if dest_top_field.is_some() && !dr_map_ready {
dr_map_ready = true;
if let Some(source_dr) = template.source_dr {
let dr_ref = ensure_dest_acroform_dr(dest, source_dr, dr_map)?;
if dest_acroform_dr.is_none() {
*dest_acroform_dr = Some(dr_ref);
}
} }
let new_top_field_ref = if let Some(top_ref) = dest_top_field {
let new_top = duplicate_field_tree(
dest,
*top_ref,
&mut per_placement_dup,
*dest_acroform_dr,
overrides.as_ref(),
dr_map,
)?; if added_top_field_set.insert(new_top) {
new_top_fields.push(new_top);
}
Some(new_top)
} else {
None
};
let _ = new_top_field_ref;
let new_annot_ref = match per_placement_dup.get(dest_annot_ref) {
Some(&existing) => existing,
None => {
let new = shallow_dup_indirect(dest, *dest_annot_ref)?;
per_placement_dup.insert(*dest_annot_ref, new);
new
}
};
transform_annot_ap_streams(dest, new_annot_ref, cm, dr_map)?;
transform_annot_rect(dest, new_annot_ref, cm)?;
set_annot_page_ref_if_null(dest, new_annot_ref)?;
new_annot_refs.push(new_annot_ref);
}
append_page_annots(dest, dest_page_ref, &new_annot_refs)?;
Ok(new_top_fields)
}
fn shallow_dup_indirect<R: Read + Seek>(
dest: &mut Pdf<R>,
src_ref: ObjectRef,
) -> Result<ObjectRef> {
let obj = dest.resolve(src_ref)?;
let new_ref = allocate_next_ref(dest)?;
dest.set_object(new_ref, obj);
Ok(new_ref)
}
fn allocate_next_ref<R: Read + Seek>(dest: &Pdf<R>) -> Result<ObjectRef> {
let n = dest
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0)
.checked_add(1)
.ok_or_else(|| Error::Unsupported("object-number space exhausted".to_string()))?;
Ok(ObjectRef::new(n, 0))
}
fn duplicate_field_tree<R: Read + Seek>(
dest: &mut Pdf<R>,
top_ref: ObjectRef,
per_placement_dup: &mut BTreeMap<ObjectRef, ObjectRef>,
dest_dr: Option<ObjectRef>,
overrides: Option<&InheritedOverrides>,
dr_map: &DrMap,
) -> Result<ObjectRef> {
let new_top = match per_placement_dup.get(&top_ref) {
Some(&existing) => return Ok(existing),
None => {
let new = shallow_dup_indirect(dest, top_ref)?;
per_placement_dup.insert(top_ref, new);
new
}
};
let per_category_resources: BTreeMap<Vec<u8>, crate::Dictionary> = if dr_map.is_empty() {
BTreeMap::new()
} else {
let dr_dict = match dest_dr {
Some(dr_ref) => dest.resolve(dr_ref)?.into_dict(),
None => None,
};
let mut resolved: BTreeMap<Vec<u8>, crate::Dictionary> = BTreeMap::new();
if let Some(dr_dict) = dr_dict.as_ref() {
for category in dr_map.by_name.keys() {
let sub = match dr_dict.get(category).cloned() {
Some(Object::Dictionary(d)) => Some(d),
Some(Object::Reference(r)) => dest.resolve(r)?.into_dict(), _ => None,
};
if let Some(d) = sub {
resolved.insert(category.clone(), d);
}
}
} resolved
};
let mut queue: std::collections::VecDeque<(ObjectRef, ObjectRef)> =
std::collections::VecDeque::new();
queue.push_back((top_ref, new_top));
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
seen.insert(top_ref);
while let Some((_src_ref, dup_ref)) = queue.pop_front() {
let Some(mut dict) = dest.resolve(dup_ref)?.into_dict() else {
continue; };
if let Some(parent_ref) = dict.get_ref("Parent") {
if let Some(&parent_dup) = per_placement_dup.get(&parent_ref) {
dict.insert("Parent", Object::Reference(parent_dup));
}
}
if let Some(kids_val) = dict.get("Kids").cloned() {
let kids_array = match kids_val {
Object::Array(arr) => Some(arr),
Object::Reference(kr) => match dest.resolve(kr)? {
Object::Array(arr) => Some(arr),
_ => None,
},
_ => None,
};
if let Some(mut kids) = kids_array {
for entry in kids.iter_mut() {
if let Object::Reference(kid_ref) = *entry {
let kid_dup = match per_placement_dup.get(&kid_ref) {
Some(&existing) => existing, None => {
let new = shallow_dup_indirect(dest, kid_ref)?;
per_placement_dup.insert(kid_ref, new);
new
}
};
*entry = Object::Reference(kid_dup);
if seen.insert(kid_ref) {
queue.push_back((kid_ref, kid_dup));
}
} }
dict.insert("Kids", Object::Array(kids));
} }
if let Some(dr) = dest_dr {
if dict.get("DR").is_some() {
dict.insert("DR", Object::Reference(dr));
}
}
if let Some(ov) = overrides {
adjust_inherited_field(dest, dup_ref, &mut dict, ov, per_placement_dup)?;
}
if !per_category_resources.is_empty() {
match dict.remove("DA") {
Some(Object::String(da)) => {
let new_da = adjust_default_appearance(&da, dr_map, &per_category_resources);
dict.insert("DA", Object::String(new_da));
}
Some(Object::Reference(da_ref)) => {
match dest.resolve(da_ref)? {
Object::String(da) => {
let new_da =
adjust_default_appearance(&da, dr_map, &per_category_resources);
dict.insert("DA", Object::String(new_da));
}
_ => {
dict.insert("DA", Object::Reference(da_ref));
}
}
}
Some(other) => {
dict.insert("DA", other);
}
None => {}
}
}
dest.set_object(dup_ref, Object::Dictionary(dict));
}
Ok(new_top)
}
fn adjust_default_appearance(
da: &[u8],
dr_map: &DrMap,
per_category_resources: &BTreeMap<Vec<u8>, crate::Dictionary>,
) -> Vec<u8> {
if dr_map.is_empty() {
return da.to_vec();
}
let mut out: Vec<u8> = Vec::with_capacity(da.len());
let mut last_name: Option<(usize, usize, Vec<u8>)> = None;
let mut pos = 0usize;
while pos < da.len() {
let byte = da[pos];
if is_ws(byte) {
let start = pos;
while pos < da.len() && is_ws(da[pos]) {
pos += 1;
}
out.extend_from_slice(&da[start..pos]);
continue;
}
if byte == b'%' {
let start = pos;
while pos < da.len() && !matches!(da[pos], b'\n' | b'\r') {
pos += 1;
}
out.extend_from_slice(&da[start..pos]);
continue;
}
if byte == b'/'
|| byte == b'('
|| byte == b'<'
|| byte == b'['
|| matches!(byte, b'+' | b'-' | b'.' | b'0'..=b'9')
{
let mut parser = Parser::new_no_reference(&da[pos..]);
match parser.parse_one_object() {
Ok(obj) => {
let end = pos + parser.position();
let out_start = out.len();
out.extend_from_slice(&da[pos..end]);
if let Object::Name(name) = obj {
last_name = Some((out_start, out.len(), name));
}
pos = end;
}
Err(_) => {
out.push(byte);
pos += 1;
}
}
continue;
}
let start = pos;
while pos < da.len() && !is_ws(da[pos]) && !is_delimiter(da[pos]) {
pos += 1;
}
if pos == start {
out.push(da[pos]);
pos += 1;
continue;
}
out.extend_from_slice(&da[start..pos]);
if let Some(category) = da_operator_category(&da[start..pos]) {
if let Some((out_start, out_end, name)) = last_name.take() {
let renamed = dr_map
.category(category)
.and_then(|m| m.get(name.as_slice()));
if let Some(new_name) = renamed {
let present = per_category_resources
.get(category)
.is_some_and(|d| d.get(name.as_slice()).is_some());
if present {
let mut replacement = Vec::with_capacity(new_name.len() + 1);
replacement.push(b'/');
crate::object::write_name_escaped(&mut replacement, new_name);
out.splice(out_start..out_end, replacement);
}
}
}
}
}
out
}
fn da_operator_category(op: &[u8]) -> Option<&'static [u8]> {
match op {
b"Tf" => Some(b"Font"),
b"Do" => Some(b"XObject"),
b"gs" => Some(b"ExtGState"),
b"sh" => Some(b"Shading"),
b"cs" | b"CS" => Some(b"ColorSpace"),
b"SCN" | b"scn" => Some(b"Pattern"),
b"BDC" | b"DP" => Some(b"Properties"),
_ => None,
}
}
fn transform_annot_ap_streams<R: Read + Seek>(
dest: &mut Pdf<R>,
annot_ref: ObjectRef,
cm: [f64; 6],
dr_map: &DrMap,
) -> Result<()> {
let Some(mut annot_dict) = dest.resolve(annot_ref)?.into_dict() else {
return Ok(()); };
let Some(ap_val) = annot_dict.get("AP").cloned() else {
return Ok(());
};
let Some(mut apdict) = (match ap_val {
Object::Dictionary(d) => Some(d),
Object::Reference(r) => dest.resolve(r)?.into_dict(), _ => None, }) else {
return Ok(()); };
let ap_keys: Vec<Vec<u8>> = apdict.iter().map(|(k, _)| k.to_vec()).collect();
for key in ap_keys {
let val = apdict.get(&key).cloned();
let Some(val) = val else { continue };
match val {
Object::Reference(stream_ref) => {
if let Some(new_ref) = dup_and_transform_ap_stream(dest, stream_ref, cm)? {
if !dr_map.is_empty() {
adjust_appearance_stream(dest, new_ref, dr_map)?;
}
apdict.insert(&key, Object::Reference(new_ref));
}
}
Object::Dictionary(sub) => {
let mut sub = sub;
let sub_keys: Vec<Vec<u8>> = sub.iter().map(|(k, _)| k.to_vec()).collect();
for sub_key in sub_keys {
let Some(sub_val) = sub.get(&sub_key).cloned() else {
continue; };
if let Object::Reference(stream_ref) = sub_val {
if let Some(new_ref) = dup_and_transform_ap_stream(dest, stream_ref, cm)? {
if !dr_map.is_empty() {
adjust_appearance_stream(dest, new_ref, dr_map)?;
}
sub.insert(&sub_key, Object::Reference(new_ref));
}
} }
apdict.insert(&key, Object::Dictionary(sub));
}
_ => {} }
}
annot_dict.insert("AP", Object::Dictionary(apdict));
dest.set_object(annot_ref, Object::Dictionary(annot_dict));
Ok(())
}
fn dup_and_transform_ap_stream<R: Read + Seek>(
dest: &mut Pdf<R>,
stream_ref: ObjectRef,
cm: [f64; 6],
) -> Result<Option<ObjectRef>> {
let obj = dest.resolve(stream_ref)?;
let Object::Stream(mut stream) = obj else {
return Ok(None); };
let old_matrix = read_matrix_array(&stream.dict, b"Matrix");
let had_matrix = old_matrix.is_some();
let apcm = old_matrix.unwrap_or(IDENTITY);
let new_matrix = concat_matrices(apcm, cm);
if had_matrix || new_matrix != IDENTITY {
stream.dict.insert("Matrix", matrix_to_object(new_matrix));
}
let new_ref = allocate_next_ref(dest)?;
dest.set_object(new_ref, Object::Stream(stream));
Ok(Some(new_ref))
}
fn read_matrix_array(dict: &crate::Dictionary, key: &[u8]) -> Option<[f64; 6]> {
let arr = match dict.get(key)? {
Object::Array(a) if a.len() == 6 => a,
_ => return None, };
let mut out = [0.0f64; 6];
for (i, item) in arr.iter().enumerate() {
out[i] = match item {
Object::Integer(n) => *n as f64,
Object::Real(x) | Object::RealLiteral { value: x, .. } => *x, _ => return None, };
}
Some(out)
}
fn matrix_to_object(m: [f64; 6]) -> Object {
Object::Array(m.iter().map(|&x| qpdf_real(x)).collect())
}
fn qpdf_real(v: f64) -> Object {
let s = format!("{v:.6}");
let trimmed = s.trim_end_matches('0').trim_end_matches('.');
let rounded: f64 = trimmed.parse().unwrap_or(0.0);
Object::Real(rounded)
}
fn concat_matrices(this: [f64; 6], other: [f64; 6]) -> [f64; 6] {
let [a, b, c, d, e, f] = this;
let [oa, ob, oc, od, oe, of] = other;
[
a * oa + c * ob,
b * oa + d * ob,
a * oc + c * od,
b * oc + d * od,
a * oe + c * of + e,
b * oe + d * of + f,
]
}
const IDENTITY: [f64; 6] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
fn transform_annot_rect<R: Read + Seek>(
dest: &mut Pdf<R>,
annot_ref: ObjectRef,
cm: [f64; 6],
) -> Result<()> {
let Some(mut dict) = dest.resolve(annot_ref)?.into_dict() else {
return Ok(()); };
let rect_val = dict.get("Rect").cloned();
let rect = match rect_val {
Some(Object::Array(arr)) => arr,
_ => return Ok(()), };
if rect.len() != 4 {
return Ok(()); }
let mut nums = [0.0f64; 4];
for (i, item) in rect.iter().enumerate() {
nums[i] = match item {
Object::Integer(n) => *n as f64,
Object::Real(x) | Object::RealLiteral { value: x, .. } => *x,
_ => return Ok(()), };
}
let new_rect = transform_rect_by_cm(nums, cm);
dict.insert(
"Rect",
Object::Array(new_rect.iter().map(|&x| qpdf_real(x)).collect()),
);
dest.set_object(annot_ref, Object::Dictionary(dict));
Ok(())
}
fn transform_rect_by_cm(rect: [f64; 4], cm: [f64; 6]) -> [f64; 4] {
let [llx, lly, urx, ury] = rect;
let corners = [(llx, lly), (llx, ury), (urx, lly), (urx, ury)];
let mut min_x = f64::INFINITY;
let mut min_y = f64::INFINITY;
let mut max_x = f64::NEG_INFINITY;
let mut max_y = f64::NEG_INFINITY;
for (x, y) in corners {
let (tx, ty) = apply_matrix_to_point(cm, x, y);
if tx < min_x {
min_x = tx;
}
if tx > max_x {
max_x = tx;
}
if ty < min_y {
min_y = ty;
}
if ty > max_y {
max_y = ty;
}
}
[min_x, min_y, max_x, max_y]
}
fn apply_matrix_to_point(m: [f64; 6], x: f64, y: f64) -> (f64, f64) {
let [a, b, c, d, e, f] = m;
(a * x + c * y + e, b * x + d * y + f)
}
fn compute_inherited_overrides<R: Read + Seek>(
dest: &mut Pdf<R>,
template: &AnnotationCopyTemplate,
) -> Result<Option<InheritedOverrides>> {
let (dest_da, dest_q) = read_dest_acroform_defaults(dest)?;
let from_da = template
.source_default_da
.as_deref()
.unwrap_or(b"")
.to_vec();
let from_q = template.source_default_q.unwrap_or(0);
let override_da = from_da != dest_da;
let override_q = from_q != dest_q;
if !override_da && !override_q {
return Ok(None);
}
Ok(Some(InheritedOverrides {
override_da,
from_default_da: from_da,
override_q,
from_default_q: from_q,
}))
}
fn read_dest_acroform_defaults<R: Read + Seek>(dest: &mut Pdf<R>) -> Result<(Vec<u8>, i64)> {
let Some(root_ref) = dest.root_ref() else {
return Ok((Vec::new(), 0)); };
let acroform_val = {
let obj = dest.resolve_borrowed(root_ref)?;
let Some(dict) = obj.as_dict() else {
return Ok((Vec::new(), 0)); };
dict.get("AcroForm").cloned()
};
let acroform_dict = match acroform_val {
None | Some(Object::Null) => return Ok((Vec::new(), 0)),
Some(Object::Dictionary(d)) => d, Some(Object::Reference(r)) => match dest.resolve(r)? {
Object::Dictionary(d) => d,
_ => return Ok((Vec::new(), 0)), },
_ => return Ok((Vec::new(), 0)), };
let da = match acroform_dict.get("DA") {
Some(Object::String(s)) => s.clone(), _ => Vec::new(),
};
let q = match acroform_dict.get("Q") {
Some(Object::Integer(n)) => *n, _ => 0,
};
Ok((da, q))
}
fn adjust_inherited_field<R: Read + Seek>(
dest: &mut Pdf<R>,
field_ref: ObjectRef,
field_dict: &mut crate::Dictionary,
overrides: &InheritedOverrides,
per_placement_dup: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
if overrides.override_da
&& field_dict.get("DA").is_none()
&& !ancestor_has_key(dest, field_ref, b"DA", per_placement_dup)?
{
field_dict.insert("DA", Object::String(overrides.from_default_da.clone()));
}
if overrides.override_q
&& field_dict.get("Q").is_none()
&& !ancestor_has_key(dest, field_ref, b"Q", per_placement_dup)?
{
field_dict.insert("Q", Object::Integer(overrides.from_default_q));
}
Ok(())
}
fn ancestor_has_key<R: Read + Seek>(
dest: &mut Pdf<R>,
field_ref: ObjectRef,
key: &[u8],
per_placement_dup: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<bool> {
let mut current = field_ref;
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
for _ in 0..MAX_PARENT_WALK_DEPTH {
if !visited.insert(current) {
return Ok(false); }
let parent = {
let obj = dest.resolve_borrowed(current)?;
let Some(dict) = obj.as_dict() else {
return Ok(false); };
dict.get_ref("Parent")
};
let Some(parent_ref) = parent else {
return Ok(false);
};
let ancestor_ref = per_placement_dup
.get(&parent_ref)
.copied()
.unwrap_or(parent_ref);
let has = {
let obj = dest.resolve_borrowed(ancestor_ref)?;
match obj.as_dict() {
Some(dict) => dict.get(key).is_some(),
None => false, }
};
if has {
return Ok(true);
} current = ancestor_ref; }
Ok(false) }
fn set_annot_page_ref_if_null<R: Read + Seek>(
dest: &mut Pdf<R>,
annot_ref: ObjectRef,
) -> Result<()> {
let Some(mut dict) = dest.resolve(annot_ref)?.into_dict() else {
return Ok(()); };
match dict.get("P") {
Some(Object::Null) => {}
_ => return Ok(()),
}
dict.remove("P");
dest.set_object(annot_ref, Object::Dictionary(dict));
Ok(())
}
fn append_page_annots<R: Read + Seek>(
dest: &mut Pdf<R>,
dest_page_ref: ObjectRef,
new_annot_refs: &[ObjectRef],
) -> Result<()> {
if new_annot_refs.is_empty() {
return Ok(()); }
let Some(mut page_dict) = dest.resolve(dest_page_ref)?.into_dict() else {
return Ok(()); };
let mut annots = match page_dict.get("Annots").cloned() {
None | Some(Object::Null) => Vec::new(),
Some(Object::Array(arr)) => arr,
Some(Object::Reference(r)) => match dest.resolve(r)? {
Object::Array(arr) => arr,
_ => Vec::new(),
},
_ => Vec::new(),
};
for &r in new_annot_refs {
annots.push(Object::Reference(r));
}
page_dict.insert("Annots", Object::Array(annots));
dest.set_object(dest_page_ref, Object::Dictionary(page_dict));
Ok(())
}
fn ensure_dest_acroform_dr<R: Read + Seek>(
dest: &mut Pdf<R>,
source_dr: ObjectRef,
dr_map: &mut DrMap,
) -> Result<ObjectRef> {
let Some(root_ref) = dest.root_ref() else {
return Err(Error::Unsupported(
"destination has no /Root; cannot install /AcroForm for copied form fields".into(),
));
};
let Some(mut catalog) = dest.resolve(root_ref)?.into_dict() else {
return Err(Error::Unsupported(
"destination /Root does not resolve to a dictionary".into(),
));
};
let acroform_val = catalog.get("AcroForm").cloned();
let acroform_ref = match acroform_val {
Some(Object::Reference(r)) => r,
Some(Object::Dictionary(existing)) => {
let af_ref = allocate_next_ref(dest)?;
dest.set_object(af_ref, Object::Dictionary(existing));
catalog.insert("AcroForm", Object::Reference(af_ref));
dest.set_object(root_ref, Object::Dictionary(catalog));
af_ref
}
_ => {
let mut af = crate::Dictionary::new();
af.insert("Fields", Object::Array(Vec::new()));
let af_ref = allocate_next_ref(dest)?;
dest.set_object(af_ref, Object::Dictionary(af));
catalog.insert("AcroForm", Object::Reference(af_ref));
dest.set_object(root_ref, Object::Dictionary(catalog));
af_ref
}
};
let mut acroform_dict = match dest.resolve(acroform_ref)?.into_dict() {
Some(d) => d,
None => {
return Err(Error::Unsupported(
"destination /AcroForm does not resolve to a dictionary".into(),
));
}
};
match acroform_dict.get("DR").cloned() {
Some(Object::Reference(existing)) => {
merge_resources_shallow(dest, existing, source_dr, dr_map)?;
return Ok(existing);
}
Some(Object::Dictionary(existing)) => {
let dr_ref = allocate_next_ref(dest)?;
dest.set_object(dr_ref, Object::Dictionary(existing));
acroform_dict.insert("DR", Object::Reference(dr_ref));
dest.set_object(acroform_ref, Object::Dictionary(acroform_dict));
merge_resources_shallow(dest, dr_ref, source_dr, dr_map)?;
return Ok(dr_ref);
}
_ => {}
}
let dr_ref = allocate_next_ref(dest)?;
dest.set_object(dr_ref, Object::Dictionary(crate::Dictionary::new()));
merge_resources_shallow(dest, dr_ref, source_dr, dr_map)?;
acroform_dict.insert("DR", Object::Reference(dr_ref));
dest.set_object(acroform_ref, Object::Dictionary(acroform_dict));
Ok(dr_ref)
}
fn merge_resources_shallow<R: Read + Seek>(
dest: &mut Pdf<R>,
dest_dr: ObjectRef,
source_dr: ObjectRef,
dr_map: &mut DrMap,
) -> Result<()> {
let Some(src_dict) = dest.resolve(source_dr)?.into_dict() else {
return Ok(()); };
let Some(mut dest_dict) = dest.resolve(dest_dr)?.into_dict() else {
return Ok(()); };
dr_map.by_name.clear();
for (type_key, src_type_val) in src_dict.iter() {
let src_type_dict = match src_type_val {
Object::Reference(r) => dest.resolve(*r)?.into_dict(),
_ => src_type_val.as_dict().cloned(),
};
let Some(src_type_dict) = src_type_dict else {
if dest_dict.get(type_key).is_none() {
dest_dict.insert(type_key, src_type_val.clone());
}
continue;
};
let (mut new_type_dict, new_indirect_target) = match dest_dict.get(type_key).cloned() {
Some(Object::Dictionary(existing)) => (existing, None),
Some(Object::Reference(r)) => match dest.resolve(r)?.into_dict() {
Some(d) => (d, Some(allocate_next_ref(dest)?)),
None => (crate::Dictionary::new(), None),
},
_ => (crate::Dictionary::new(), None),
};
for (existing_name, existing_val) in new_type_dict.iter() {
if let Object::Reference(existing_ref) = existing_val {
dr_map
.by_source_ref
.entry((type_key.to_vec(), *existing_ref))
.or_insert_with(|| existing_name.to_vec());
} }
for (name, val) in src_type_dict.iter() {
match new_type_dict.get(name) {
None => {
new_type_dict.insert(name, val.clone());
if let Some(source_ref) = val.as_ref_id() {
dr_map
.by_source_ref
.entry((type_key.to_vec(), source_ref))
.or_insert_with(|| name.to_vec());
} }
Some(existing_val) => {
let same_object = matches!(
(existing_val, val),
(Object::Reference(d), Object::Reference(s)) if d == s
);
if same_object {
continue;
}
let reuse_key = val.as_ref_id().map(|r| (type_key.to_vec(), r));
let reuse = reuse_key
.as_ref()
.and_then(|k| dr_map.by_source_ref.get(k))
.cloned();
if let Some(existing_new_name) = reuse {
dr_map
.by_name
.entry(type_key.to_vec())
.or_default()
.insert(name.to_vec(), existing_new_name);
continue;
}
let new_name = unique_dr_name(name, &new_type_dict)?;
new_type_dict.insert(&new_name, val.clone());
dr_map
.by_name
.entry(type_key.to_vec())
.or_default()
.insert(name.to_vec(), new_name.clone());
if let Some(key) = reuse_key {
dr_map.by_source_ref.insert(key, new_name);
}
}
}
}
if let Some(new_ref) = new_indirect_target {
dest.set_object(new_ref, Object::Dictionary(new_type_dict));
dest_dict.insert(type_key, Object::Reference(new_ref));
} else {
dest_dict.insert(type_key, Object::Dictionary(new_type_dict));
}
}
dest.set_object(dest_dr, Object::Dictionary(dest_dict));
Ok(())
}
pub(crate) fn unique_dr_name(base: &[u8], dict: &crate::Dictionary) -> Result<Vec<u8>> {
let mut n: u32 = 1;
loop {
let candidate = [base, b"_", n.to_string().as_bytes()].concat();
if dict.get(&candidate).is_none() {
return Ok(candidate);
}
n = n
.checked_add(1)
.ok_or_else(|| Error::Unsupported("DR resource-name suffix space exhausted".into()))?;
}
}
pub(crate) fn add_and_rename_form_fields<R: Read + Seek>(
dest: &mut Pdf<R>,
new_top_fields: Vec<ObjectRef>,
) -> Result<()> {
if new_top_fields.is_empty() {
return Ok(());
}
let Some(root_ref) = dest.root_ref() else {
return Ok(()); };
let mut catalog = match dest.resolve(root_ref)?.into_dict() {
Some(d) => d,
None => return Ok(()), };
let acroform_ref = match catalog.get("AcroForm").cloned() {
Some(Object::Reference(r)) => r,
Some(Object::Dictionary(existing)) => {
let r = allocate_next_ref(dest)?;
dest.set_object(r, Object::Dictionary(existing));
catalog.insert("AcroForm", Object::Reference(r));
dest.set_object(root_ref, Object::Dictionary(catalog));
r
}
_ => {
let mut dict = crate::Dictionary::new();
dict.insert("Fields", Object::Array(Vec::new()));
let r = allocate_next_ref(dest)?;
dest.set_object(r, Object::Dictionary(dict));
catalog.insert("AcroForm", Object::Reference(r));
dest.set_object(root_ref, Object::Dictionary(catalog));
r
} };
let mut existing_fqns: BTreeSet<Vec<u8>> = BTreeSet::new();
let existing_top_field_refs = read_existing_top_field_refs(dest, acroform_ref)?;
for &top in &existing_top_field_refs {
collect_fully_qualified_names(dest, top, Vec::new(), 0, &mut existing_fqns)?;
}
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut queue: std::collections::VecDeque<ObjectRef> = new_top_fields.iter().copied().collect();
while let Some(field_ref) = queue.pop_front() {
if !seen.insert(field_ref) {
continue; }
let has_t = {
let obj = dest.resolve_borrowed(field_ref)?;
let Some(dict) = obj.as_dict() else { continue };
dict.get("T").is_some()
};
if has_t {
let old_fqn = fully_qualified_name_of(dest, field_ref)?;
let append = {
let mut candidate_fqn = old_fqn.clone();
let mut suffix = 0u32;
let mut append = Vec::new();
while existing_fqns.contains(&candidate_fqn) {
suffix = suffix.checked_add(1).ok_or_else(|| {
Error::Unsupported("field name suffix space exhausted".into())
})?;
append = format!("+{suffix}").into_bytes();
candidate_fqn = old_fqn.clone();
candidate_fqn.extend_from_slice(&append);
}
append
};
if !append.is_empty() {
let Some(mut dict) = dest.resolve(field_ref)?.into_dict() else {
continue; };
let old_t = match dict.get("T").cloned() {
Some(Object::String(s)) => s,
Some(_) => Vec::new(), None => Vec::new(), };
let mut new_t = old_t;
new_t.extend_from_slice(&append);
dict.insert("T", Object::String(new_t));
dest.set_object(field_ref, Object::Dictionary(dict));
}
let mut final_fqn = old_fqn;
final_fqn.extend_from_slice(&append);
existing_fqns.insert(final_fqn);
}
let kids_refs = {
let obj = dest.resolve_borrowed(field_ref)?;
let Some(dict) = obj.as_dict() else { continue };
match dict.get("Kids") {
Some(Object::Array(arr)) => arr
.iter()
.filter_map(|item| match item {
Object::Reference(r) => Some(*r),
_ => None, })
.collect::<Vec<_>>(),
_ => Vec::new(),
}
};
for k in kids_refs {
queue.push_back(k);
}
}
let Some(mut acroform_dict) = dest.resolve(acroform_ref)?.into_dict() else {
return Ok(()); };
match acroform_dict.get("Fields").cloned() {
Some(Object::Reference(fields_ref)) => {
let mut fields = match dest.resolve(fields_ref)? {
Object::Array(arr) => arr,
_ => Vec::new(), };
for r in new_top_fields {
fields.push(Object::Reference(r));
}
dest.set_object(fields_ref, Object::Array(fields));
}
other => {
let mut fields = match other {
Some(Object::Array(arr)) => arr,
_ => Vec::new(), };
for r in new_top_fields {
fields.push(Object::Reference(r));
}
acroform_dict.insert("Fields", Object::Array(fields));
dest.set_object(acroform_ref, Object::Dictionary(acroform_dict));
}
}
Ok(())
}
fn read_existing_top_field_refs<R: Read + Seek>(
dest: &mut Pdf<R>,
acroform_ref: ObjectRef,
) -> Result<Vec<ObjectRef>> {
let Some(dict) = dest.resolve(acroform_ref)?.into_dict() else {
return Ok(Vec::new()); };
let fields = match dict.get("Fields").cloned() {
Some(Object::Array(arr)) => arr,
Some(Object::Reference(r)) => match dest.resolve(r)? {
Object::Array(arr) => arr,
_ => return Ok(Vec::new()), },
_ => return Ok(Vec::new()), };
Ok(fields
.into_iter()
.filter_map(|item| match item {
Object::Reference(r) => Some(r),
_ => None, })
.collect())
}
fn collect_fully_qualified_names<R: Read + Seek>(
dest: &mut Pdf<R>,
field_ref: ObjectRef,
parent_fqn: Vec<u8>,
depth: usize,
out: &mut BTreeSet<Vec<u8>>,
) -> Result<()> {
if depth > MAX_PARENT_WALK_DEPTH {
return Err(Error::Unsupported(format!(
"AcroForm field tree exceeds maximum depth of {MAX_PARENT_WALK_DEPTH}"
)));
}
let (own_fqn, kids_val) = {
let obj = dest.resolve_borrowed(field_ref)?;
let Some(dict) = obj.as_dict() else {
return Ok(()); };
let own_fqn = match dict.get("T") {
Some(Object::String(t)) => {
let mut fqn = parent_fqn.clone();
if !fqn.is_empty() {
fqn.push(b'.'); }
fqn.extend_from_slice(t);
Some(fqn)
}
_ => None,
};
(own_fqn, dict.get("Kids").cloned())
};
let kids_refs: Vec<ObjectRef> = match kids_val {
Some(Object::Array(arr)) => arr
.iter()
.filter_map(|item| match item {
Object::Reference(r) => Some(*r),
_ => None, })
.collect(),
Some(Object::Reference(r)) => match dest.resolve(r)? {
Object::Array(arr) => arr
.into_iter()
.filter_map(|item| match item {
Object::Reference(r) => Some(r),
_ => None,
})
.collect(),
_ => Vec::new(),
},
_ => Vec::new(),
};
let recursion_fqn = own_fqn.clone().unwrap_or(parent_fqn);
if let Some(fqn) = own_fqn {
out.insert(fqn);
}
for kid in kids_refs {
collect_fully_qualified_names(dest, kid, recursion_fqn.clone(), depth + 1, out)?;
}
Ok(())
}
fn fully_qualified_name_of<R: Read + Seek>(
dest: &mut Pdf<R>,
field_ref: ObjectRef,
) -> Result<Vec<u8>> {
let mut names_reverse: Vec<Vec<u8>> = Vec::new();
let mut current = field_ref;
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
for _ in 0..MAX_PARENT_WALK_DEPTH {
if !visited.insert(current) {
break;
}
let (t_opt, parent) = {
let obj = dest.resolve_borrowed(current)?;
let Some(dict) = obj.as_dict() else {
break;
};
let t_opt = match dict.get("T") {
Some(Object::String(s)) => Some(s.clone()),
_ => None,
};
let parent = dict.get_ref("Parent");
(t_opt, parent)
};
if let Some(t) = t_opt {
names_reverse.push(t);
}
match parent {
Some(p) => current = p,
None => break,
}
}
names_reverse.reverse();
let mut out = Vec::new();
for (i, n) in names_reverse.iter().enumerate() {
if i > 0 {
out.push(b'.'); }
out.extend_from_slice(n);
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
fn minimal_pdf_bytes() -> 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 >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(
format!("xref\n0 2\n0000000000 65535 f \n{off1:010} 00000 n \n").as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 2 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn open_minimal() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(minimal_pdf_bytes())).expect("minimal pdf should parse")
}
fn set_dict<R: Read + Seek>(pdf: &mut Pdf<R>, n: u32, entries: &[(&str, Object)]) -> ObjectRef {
let mut d = crate::Dictionary::new();
for (k, v) in entries {
d.insert(*k, v.clone());
}
let r = ObjectRef::new(n, 0);
pdf.set_object(r, Object::Dictionary(d));
r
}
fn set_font_dr<R: Read + Seek>(
pdf: &mut Pdf<R>,
n: u32,
entries: &[(&str, ObjectRef)],
) -> ObjectRef {
let mut font = crate::Dictionary::new();
for (name, r) in entries {
font.insert(*name, Object::Reference(*r));
}
set_dict(pdf, n, &[("Font", Object::Dictionary(font))])
}
fn font_dict<R: Read + Seek>(pdf: &mut Pdf<R>, dr_ref: ObjectRef) -> crate::Dictionary {
let dr = pdf.resolve(dr_ref).unwrap().into_dict().unwrap();
dr.get("Font").and_then(Object::as_dict).unwrap().clone()
}
#[test]
fn merge_resources_shallow_dest_empty_is_verbatim_insert() {
let mut pdf = open_minimal();
let font_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let dest_dr = set_dict(&mut pdf, 2, &[]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", font_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert!(dr_map.is_empty());
let font = font_dict(&mut pdf, dest_dr);
assert_eq!(font.get_ref("F1"), Some(font_ref));
}
#[test]
fn merge_resources_shallow_renames_on_collision_with_different_ref() {
let mut pdf = open_minimal();
let helv_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let courier_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", helv_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", courier_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_1".to_vec())
);
let font = font_dict(&mut pdf, dest_dr);
assert_eq!(font.get_ref("F1"), Some(helv_ref));
assert_eq!(font.get_ref("F1_1"), Some(courier_ref));
}
#[test]
fn merge_resources_shallow_same_ref_collision_is_noop() {
let mut pdf = open_minimal();
let font_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", font_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", font_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert!(dr_map.is_empty());
let font = font_dict(&mut pdf, dest_dr);
assert_eq!(font.get_ref("F1"), Some(font_ref));
assert!(font.get("F1_1").is_none());
}
#[test]
fn merge_resources_shallow_scans_past_taken_suffix_to_next_n() {
let mut pdf = open_minimal();
let helv_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let other_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"TimesRoman".to_vec()))],
);
let courier_ref = set_dict(
&mut pdf,
12,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", helv_ref), ("F1_1", other_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", courier_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_2".to_vec())
);
let font = font_dict(&mut pdf, dest_dr);
assert_eq!(font.get_ref("F1"), Some(helv_ref));
assert_eq!(font.get_ref("F1_1"), Some(other_ref));
assert_eq!(font.get_ref("F1_2"), Some(courier_ref));
}
#[test]
fn merge_resources_shallow_resolves_indirect_source_resource_type_dict() {
let mut pdf = open_minimal();
let font_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let font_subdict_ref = ObjectRef::new(4, 0);
let mut font_sub = crate::Dictionary::new();
font_sub.insert("F1", Object::Reference(font_ref));
pdf.set_object(font_subdict_ref, Object::Dictionary(font_sub));
let source_dr = set_dict(
&mut pdf,
3,
&[("Font", Object::Reference(font_subdict_ref))],
);
let dest_dr = set_dict(&mut pdf, 2, &[]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert!(dr_map.is_empty());
let font = font_dict(&mut pdf, dest_dr);
assert_eq!(font.get_ref("F1"), Some(font_ref));
}
#[test]
fn merge_resources_shallow_copies_indirect_dest_sub_dict_into_fresh_ref() {
let mut pdf = open_minimal();
let helv_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let courier_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_font_subdict_ref = ObjectRef::new(4, 0);
let mut dest_font_sub = crate::Dictionary::new();
dest_font_sub.insert("F0", Object::Reference(helv_ref));
pdf.set_object(dest_font_subdict_ref, Object::Dictionary(dest_font_sub));
let dest_dr = set_dict(
&mut pdf,
2,
&[("Font", Object::Reference(dest_font_subdict_ref))],
);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", courier_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert!(dr_map.is_empty(), "no name collision, no rename");
let dest_dict = pdf.resolve(dest_dr).unwrap().into_dict().unwrap();
let new_font_ref = dest_dict.get_ref("Font").expect("Font must be indirect");
assert_ne!(
new_font_ref, dest_font_subdict_ref,
"qpdf shallow-copies indirect sub-dicts into a fresh ref",
);
let original = pdf
.resolve(dest_font_subdict_ref)
.unwrap()
.into_dict()
.unwrap();
assert_eq!(original.get_ref("F0"), Some(helv_ref));
assert!(
original.get("F1").is_none(),
"original indirect object must not be mutated (other holders would see F1 leak)",
);
let merged = pdf.resolve(new_font_ref).unwrap().into_dict().unwrap();
assert_eq!(merged.get_ref("F0"), Some(helv_ref));
assert_eq!(merged.get_ref("F1"), Some(courier_ref));
}
#[test]
fn merge_resources_shallow_clears_stale_by_name_between_source_merges() {
let mut pdf = open_minimal();
let times_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Times-Roman".to_vec()))],
);
let helv_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", times_ref)]);
let source_a = set_font_dr(&mut pdf, 3, &[("F1", helv_ref)]);
let source_b = set_font_dr(&mut pdf, 4, &[("F1", times_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_a, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_1".to_vec()),
);
merge_resources_shallow(&mut pdf, dest_dr, source_b, &mut dr_map).unwrap();
assert!(
dr_map.is_empty(),
"by_name must clear at merge start so B's fields don't inherit A's F1→F1_1 mapping"
);
assert_eq!(
dr_map.by_source_ref.get(&(b"Font".to_vec(), helv_ref)),
Some(&b"F1_1".to_vec()),
"by_source_ref must persist across merges (dest-scoped reuse map)",
);
}
#[test]
fn merge_resources_shallow_reuse_is_keyed_by_source_ref_not_by_name() {
let mut pdf = open_minimal();
let times_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Times-Roman".to_vec()))],
);
let helv_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let courier_ref = set_dict(
&mut pdf,
12,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", times_ref)]);
let source_a = set_font_dr(&mut pdf, 3, &[("F1", helv_ref)]);
let source_b = set_font_dr(&mut pdf, 4, &[("F1", courier_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_a, &mut dr_map).unwrap();
merge_resources_shallow(&mut pdf, dest_dr, source_b, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_2".to_vec()),
);
let font_after_ab = font_dict(&mut pdf, dest_dr);
assert_eq!(font_after_ab.get_ref("F1"), Some(times_ref));
assert_eq!(font_after_ab.get_ref("F1_1"), Some(helv_ref));
assert_eq!(font_after_ab.get_ref("F1_2"), Some(courier_ref));
merge_resources_shallow(&mut pdf, dest_dr, source_a, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_1".to_vec()),
"re-merging source A must refresh by_name back to F1_1 (the ref-keyed reuse)",
);
let font_after_aba = font_dict(&mut pdf, dest_dr);
assert!(
font_after_aba.get("F1_3").is_none(),
"must NOT mint F1_3; must reuse F1_1 keyed by helv_ref",
);
assert_eq!(font_after_aba.get_ref("F1_1"), Some(helv_ref));
assert_eq!(font_after_aba.get_ref("F1_2"), Some(courier_ref));
}
#[test]
fn merge_resources_shallow_reuses_prior_rename_across_repeated_calls() {
let mut pdf = open_minimal();
let helv_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let courier_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", helv_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", courier_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_1".to_vec())
);
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_1".to_vec())
);
let font = font_dict(&mut pdf, dest_dr);
assert_eq!(font.get_ref("F1"), Some(helv_ref));
assert_eq!(font.get_ref("F1_1"), Some(courier_ref));
assert!(
font.get("F1_2").is_none(),
"second call must reuse F1_1 rather than minting F1_2"
);
}
#[test]
fn merge_resources_shallow_reuses_verbatim_insert_from_same_source_ref() {
let mut pdf = open_minimal();
let helv_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let courier_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F2", courier_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", helv_ref), ("F2", helv_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F2".as_slice())),
Some(&b"F1".to_vec()),
"second collision must reuse the verbatim-inserted /F1 name",
);
let font = font_dict(&mut pdf, dest_dr);
assert_eq!(font.get_ref("F1"), Some(helv_ref));
assert_eq!(font.get_ref("F2"), Some(courier_ref));
assert!(
font.get("F2_1").is_none(),
"must not mint /F2_1 when the source ref is already at /F1",
);
}
#[test]
fn merge_resources_shallow_reuses_preexisting_dest_ref_at_different_name() {
let mut pdf = open_minimal();
let helv_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let courier_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", helv_ref), ("F2", courier_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F2", helv_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F2".as_slice())),
Some(&b"F1".to_vec()),
);
let font = font_dict(&mut pdf, dest_dr);
assert!(
font.get("F2_1").is_none(),
"must reuse the pre-existing /F1 rather than mint /F2_1",
);
}
#[test]
fn ensure_dest_acroform_dr_creates_fresh_dr_when_dest_has_no_acroform() {
let mut pdf = open_minimal();
let font_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", font_ref)]);
let mut dr_map = DrMap::new();
let dr_ref = ensure_dest_acroform_dr(&mut pdf, source_dr, &mut dr_map).unwrap();
assert!(dr_map.is_empty());
let font = font_dict(&mut pdf, dr_ref);
assert_eq!(font.get_ref("F1"), Some(font_ref));
}
#[test]
fn ensure_dest_acroform_dr_reuses_existing_dr_across_repeated_calls_without_rename() {
let mut pdf = open_minimal();
let font_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", font_ref)]);
let mut dr_map1 = DrMap::new();
let dr_ref1 = ensure_dest_acroform_dr(&mut pdf, source_dr, &mut dr_map1).unwrap();
assert!(dr_map1.is_empty());
let mut dr_map2 = DrMap::new();
let dr_ref2 = ensure_dest_acroform_dr(&mut pdf, source_dr, &mut dr_map2).unwrap();
assert_eq!(dr_ref1, dr_ref2, "the same /DR object must be reused");
assert!(dr_map2.is_empty(), "same source ref must not be re-renamed");
let font = font_dict(&mut pdf, dr_ref2);
assert_eq!(font.get_ref("F1"), Some(font_ref));
assert!(font.get("F1_1").is_none());
}
#[test]
fn apply_placement_clears_stale_by_name_for_annotation_only_placement() {
let mut pdf = open_minimal();
let times_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Times-Roman".to_vec()))],
);
let helv_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", times_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", helv_ref)]);
let mut dr_map = DrMap::new();
merge_resources_shallow(&mut pdf, dest_dr, source_dr, &mut dr_map).unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_1".to_vec()),
"sanity: the setup step actually populated a stale rename"
);
let page_ref = set_dict(&mut pdf, 20, &[]);
let annot_ref = set_dict(&mut pdf, 21, &[]);
let template = AnnotationCopyTemplate {
annots: vec![(annot_ref, None)], source_dr: None,
..Default::default()
};
let mut dest_acroform_dr: Option<ObjectRef> = None;
apply_placement(
&mut pdf,
page_ref,
&template,
IDENTITY,
&mut dest_acroform_dr,
&mut dr_map,
)
.unwrap();
assert!(
dr_map.category(b"Font").is_none(),
"an annotation-only placement (no top-level field) must clear a stale \
by_name rename left over from a prior placement, not silently carry it \
forward into whatever reads dr_map for THIS placement's own AP streams"
);
}
#[test]
fn apply_placement_leading_non_field_annot_sees_empty_dr_map() {
let mut pdf = open_minimal();
let dest_font_ref = set_dict(
&mut pdf,
10,
&[("BaseFont", Object::Name(b"Times-Roman".to_vec()))],
);
let source_font_ref = set_dict(
&mut pdf,
11,
&[("BaseFont", Object::Name(b"Helvetica".to_vec()))],
);
let local_font_ref = set_dict(
&mut pdf,
12,
&[("BaseFont", Object::Name(b"Courier".to_vec()))],
);
let dest_dr = set_font_dr(&mut pdf, 2, &[("F1", dest_font_ref)]);
let source_dr = set_font_dr(&mut pdf, 3, &[("F1", source_font_ref)]);
let mut acroform = crate::Dictionary::new();
acroform.insert("Fields", Object::Array(Vec::new()));
acroform.insert("DR", Object::Reference(dest_dr));
let acroform_ref = ObjectRef::new(30, 0);
pdf.set_object(acroform_ref, Object::Dictionary(acroform));
let mut catalog = crate::Dictionary::new();
catalog.insert("Type", Object::Name(b"Catalog".to_vec()));
catalog.insert("AcroForm", Object::Reference(acroform_ref));
pdf.set_object(ObjectRef::new(1, 0), Object::Dictionary(catalog));
let page_ref = set_dict(&mut pdf, 20, &[]);
let mut ap_font = crate::Dictionary::new();
ap_font.insert("F1", Object::Reference(local_font_ref));
let mut ap_resources = crate::Dictionary::new();
ap_resources.insert("Font", Object::Dictionary(ap_font));
let ap_stream_ref = ObjectRef::new(22, 0);
let mut ap_stream_dict = crate::Dictionary::new();
ap_stream_dict.insert("Resources", Object::Dictionary(ap_resources));
pdf.set_object(
ap_stream_ref,
Object::Stream(crate::Stream::new(ap_stream_dict, b"/F1 10 Tf".to_vec())),
);
let mut ap_dict = crate::Dictionary::new();
ap_dict.insert("N", Object::Reference(ap_stream_ref));
let non_field_annot_ref = set_dict(&mut pdf, 21, &[("AP", Object::Dictionary(ap_dict))]);
let field_annot_ref = set_dict(&mut pdf, 23, &[]);
let template = AnnotationCopyTemplate {
annots: vec![
(non_field_annot_ref, None),
(field_annot_ref, Some(field_annot_ref)),
],
source_dr: Some(source_dr),
..Default::default()
};
let mut dr_map = DrMap::new();
let mut dest_acroform_dr: Option<ObjectRef> = None;
apply_placement(
&mut pdf,
page_ref,
&template,
IDENTITY,
&mut dest_acroform_dr,
&mut dr_map,
)
.unwrap();
assert_eq!(
dr_map
.category(b"Font")
.and_then(|m| m.get(b"F1".as_slice())),
Some(&b"F1_1".to_vec()),
"sanity: the widget's field-tree walk must have triggered a real \
F1 -> F1_1 collision rename"
);
let page = pdf.resolve(page_ref).unwrap().into_dict().unwrap();
let annots_arr = page.get("Annots").and_then(Object::as_array).unwrap();
assert_eq!(annots_arr.len(), 2);
let new_non_field_annot_ref = annots_arr[0].as_ref_id().unwrap();
let new_annot = pdf
.resolve(new_non_field_annot_ref)
.unwrap()
.into_dict()
.unwrap();
let new_ap_stream_ref = new_annot
.get("AP")
.and_then(Object::as_dict)
.and_then(|ap| ap.get_ref("N"))
.expect("dup'd AP /N stream ref");
let new_ap_stream = pdf
.resolve(new_ap_stream_ref)
.unwrap()
.into_stream()
.unwrap();
assert_eq!(
new_ap_stream.data, b"/F1 10 Tf",
"the leading non-field annot's AP content must be untouched — \
dr_map was still empty when it was processed"
);
let new_ap_font = new_ap_stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.and_then(|r| r.get("Font"))
.and_then(Object::as_dict)
.expect("AP stream /Resources/Font");
assert_eq!(
new_ap_font.get_ref("F1"),
Some(local_font_ref),
"the leading non-field annot's own /Resources/Font/F1 must be \
untouched — no rename applied while dr_map was still empty"
);
assert!(
new_ap_font.get("F1_1").is_none(),
"no F1_1 entry should have been minted on the non-field annot's \
AP stream — adjustAppearanceStream must not have run at all"
);
}
fn font_resources_map(names: &[&str]) -> BTreeMap<Vec<u8>, crate::Dictionary> {
let mut font = crate::Dictionary::new();
for (i, name) in names.iter().enumerate() {
font.insert(*name, Object::Reference(ObjectRef::new(100 + i as u32, 0)));
}
let mut resources = BTreeMap::new();
resources.insert(b"Font".to_vec(), font);
resources
}
fn category_resources_map(
category: &[u8],
names: &[&str],
) -> BTreeMap<Vec<u8>, crate::Dictionary> {
let mut sub = crate::Dictionary::new();
for (i, name) in names.iter().enumerate() {
sub.insert(*name, Object::Reference(ObjectRef::new(100 + i as u32, 0)));
}
let mut resources = BTreeMap::new();
resources.insert(category.to_vec(), sub);
resources
}
fn category_dr_map(category: &[u8], entries: &[(&str, &str)]) -> DrMap {
let mut inner = BTreeMap::new();
for (old, new) in entries {
inner.insert(old.as_bytes().to_vec(), new.as_bytes().to_vec());
}
let mut dr_map = DrMap::new();
dr_map.by_name.insert(category.to_vec(), inner);
dr_map
}
#[test]
fn adjust_default_appearance_empty_dr_map_is_identity() {
let dr_map = DrMap::new();
let resources: BTreeMap<Vec<u8>, crate::Dictionary> = BTreeMap::new();
let da: &[u8] = b"0 0.4 0 rg /F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_matched_font_name() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["F1", "F1_1"]);
let da: &[u8] = b"0 0.4 0 rg /F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"0 0.4 0 rg /F1_1 18 Tf".to_vec()
);
}
#[test]
fn adjust_default_appearance_name_not_in_dr_map_is_verbatim() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["ZaDi"]);
let da: &[u8] = b"0.18039 0.20392 0.21176 rg /ZaDi 0 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn adjust_default_appearance_name_absent_from_resources_is_verbatim() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["SomeOtherName"]);
let da: &[u8] = b"0 0.4 0 rg /F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn adjust_default_appearance_escapes_name_bytes_needing_hex_escape() {
let mut font = BTreeMap::new();
font.insert(b"F1".to_vec(), b"F A_1".to_vec());
let mut dr_map = DrMap::new();
dr_map.by_name.insert(b"Font".to_vec(), font);
let resources = font_resources_map(&["F1"]);
let da: &[u8] = b"/F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/F#20A_1 18 Tf".to_vec()
);
}
#[test]
fn adjust_default_appearance_name_inside_string_literal_is_verbatim() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["F1"]);
let da: &[u8] = b"(F1) 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn adjust_default_appearance_skips_comment_verbatim() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["F1", "F1_1"]);
let da: &[u8] = b"% a comment\n/F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"% a comment\n/F1_1 18 Tf".to_vec()
);
}
#[test]
fn adjust_default_appearance_recovers_from_stray_delimiter() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["F1", "F1_1"]);
let da: &[u8] = b") /F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b") /F1_1 18 Tf".to_vec()
);
}
#[test]
fn adjust_default_appearance_recovers_from_operand_parse_error() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["F1", "F1_1"]);
let da: &[u8] = b"(bad /F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"(bad /F1_1 18 Tf".to_vec()
);
}
#[test]
fn adjust_default_appearance_no_font_category_in_dr_map_is_verbatim() {
let mut dr_map = DrMap::new();
dr_map.by_name.insert(b"XObject".to_vec(), BTreeMap::new());
let resources = font_resources_map(&["F1"]);
let da: &[u8] = b"/F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn adjust_default_appearance_no_font_category_in_resources_is_verbatim() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources: BTreeMap<Vec<u8>, crate::Dictionary> = BTreeMap::new();
let da: &[u8] = b"/F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_colorspace_via_cs_operator() {
let dr_map = category_dr_map(b"ColorSpace", &[("CS1", "CS1_1")]);
let resources = category_resources_map(b"ColorSpace", &["CS1", "CS1_1"]);
let da: &[u8] = b"/CS1 cs 0.5 0.4 0.3 sc /F1 12 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/CS1_1 cs 0.5 0.4 0.3 sc /F1 12 Tf".to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_colorspace_via_uppercase_cs_operator() {
let dr_map = category_dr_map(b"ColorSpace", &[("CS1", "CS1_1")]);
let resources = category_resources_map(b"ColorSpace", &["CS1"]);
let da: &[u8] = b"/CS1 CS";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/CS1_1 CS".to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_extgstate_via_gs_operator() {
let dr_map = category_dr_map(b"ExtGState", &[("GS1", "GS1_1")]);
let resources = category_resources_map(b"ExtGState", &["GS1"]);
let da: &[u8] = b"/GS1 gs 0 0 0 rg";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/GS1_1 gs 0 0 0 rg".to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_xobject_via_do_operator() {
let dr_map = category_dr_map(b"XObject", &[("Im1", "Im1_1")]);
let resources = category_resources_map(b"XObject", &["Im1"]);
let da: &[u8] = b"/Im1 Do";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/Im1_1 Do".to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_shading_via_sh_operator() {
let dr_map = category_dr_map(b"Shading", &[("Sh1", "Sh1_1")]);
let resources = category_resources_map(b"Shading", &["Sh1"]);
let da: &[u8] = b"/Sh1 sh";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/Sh1_1 sh".to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_properties_via_bdc_operator() {
let dr_map = category_dr_map(b"Properties", &[("MC1", "MC1_1")]);
let resources = category_resources_map(b"Properties", &["MC1"]);
let da: &[u8] = b"/Span /MC1 BDC /F1 12 Tf EMC";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/Span /MC1_1 BDC /F1 12 Tf EMC".to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_properties_via_dp_operator() {
let dr_map = category_dr_map(b"Properties", &[("MC1", "MC1_1")]);
let resources = category_resources_map(b"Properties", &["MC1"]);
let da: &[u8] = b"/Span /MC1 DP";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/Span /MC1_1 DP".to_vec()
);
}
#[test]
fn adjust_default_appearance_bdc_with_absent_properties_key_is_verbatim() {
let dr_map = category_dr_map(b"Properties", &[("Span", "Span_1")]);
let resources = category_resources_map(b"Properties", &["OtherKey"]);
let da: &[u8] = b"/Span << /K 3 >> BDC";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn adjust_default_appearance_bdc_with_dict_properties_rewrites_tag_matching_qpdf() {
let dr_map = category_dr_map(b"Properties", &[("Span", "Span_1")]);
let resources = category_resources_map(b"Properties", &["Span", "Span_1"]);
let da: &[u8] = b"/Span << /K 3 >> BDC";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/Span_1 << /K 3 >> BDC".to_vec()
);
}
#[test]
fn adjust_default_appearance_rewrites_pattern_via_scn_operator() {
let dr_map = category_dr_map(b"Pattern", &[("Pat1", "Pat1_1")]);
let resources = category_resources_map(b"Pattern", &["Pat1"]);
let da: &[u8] = b"/Pat1 scn";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/Pat1_1 scn".to_vec()
);
}
#[test]
fn adjust_default_appearance_ignores_non_resource_operators() {
let dr_map = category_dr_map(b"Font", &[("F1", "F1_1")]);
let resources = font_resources_map(&["F1"]);
let da: &[u8] = b"/F1 rg";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
b"/F1 rg".to_vec()
);
}
#[test]
fn adjust_default_appearance_unmatched_category_in_dr_map_is_verbatim() {
let dr_map = category_dr_map(b"XObject", &[("Im1", "Im1_1")]);
let resources = category_resources_map(b"XObject", &["Im1"]);
let da: &[u8] = b"/F1 18 Tf";
assert_eq!(
adjust_default_appearance(da, &dr_map, &resources),
da.to_vec()
);
}
#[test]
fn overlay_pipeline_renames_colliding_dr_font_end_to_end() {
use crate::overlay::{apply_overlay_specs, OverlayKind, OverlaySpec};
use crate::page_range::PageRange;
use std::path::Path;
fn fixture(name: &str) -> Pdf<std::io::BufReader<std::fs::File>> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(name);
let file = std::fs::File::open(&path).unwrap_or_else(|e| panic!("open {path:?}: {e}"));
Pdf::open(std::io::BufReader::new(file)).unwrap()
}
fn pr(input: &str) -> PageRange {
PageRange::parse(input).unwrap_or_else(|e| panic!("parse {input:?}: {e}"))
}
let mut dest = fixture("fxo-red-with-existing-acroform-dr.pdf");
let src = fixture("form-fields-and-annotations.pdf");
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr("1"),
repeat: None,
}];
apply_overlay_specs(&mut dest, &mut specs).unwrap();
let root_ref = dest.root_ref().unwrap();
let catalog = dest.resolve(root_ref).unwrap().into_dict().unwrap();
let acroform_ref = catalog.get_ref("AcroForm").unwrap();
let acroform = dest.resolve(acroform_ref).unwrap().into_dict().unwrap();
let dr_ref = acroform.get_ref("DR").unwrap();
let font = font_dict(&mut dest, dr_ref);
let f1_ref = font.get_ref("F1").expect("original /F1 preserved");
let f1_1_ref = font.get_ref("F1_1").expect("collision renamed to /F1_1");
assert_ne!(f1_ref, f1_1_ref);
let f1_font = dest.resolve(f1_ref).unwrap().into_dict().unwrap();
assert_eq!(
f1_font.get("BaseFont"),
Some(&Object::Name(b"Helvetica".to_vec()))
);
let f1_1_font = dest.resolve(f1_1_ref).unwrap().into_dict().unwrap();
assert_eq!(
f1_1_font.get("BaseFont"),
Some(&Object::Name(b"Courier".to_vec()))
);
let fields = acroform.get("Fields").and_then(Object::as_array).unwrap();
let mut saw_rewritten_da = false;
for field in fields {
let field_ref = field.as_ref_id().unwrap();
let field_dict = dest.resolve(field_ref).unwrap().into_dict().unwrap();
if let Some(Object::String(da)) = field_dict.get("DA") {
if da.as_slice() == b"0 0.4 0 rg /F1_1 18 Tf" {
saw_rewritten_da = true;
}
}
}
assert!(
saw_rewritten_da,
"expected at least one copied field's /DA rewritten to /F1_1"
);
}
#[test]
fn overlay_pipeline_repeated_placements_reuse_dr_rename_end_to_end() {
use crate::overlay::{apply_overlay_specs, OverlayKind, OverlaySpec};
use crate::page_range::PageRange;
use std::path::Path;
fn fixture(name: &str) -> Pdf<std::io::BufReader<std::fs::File>> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(name);
let file = std::fs::File::open(&path).unwrap_or_else(|e| panic!("open {path:?}: {e}"));
Pdf::open(std::io::BufReader::new(file)).unwrap()
}
fn pr(input: &str) -> PageRange {
PageRange::parse(input).unwrap_or_else(|e| panic!("parse {input:?}: {e}"))
}
let mut dest = fixture("fxo-red-with-existing-acroform-dr.pdf");
let src = fixture("form-fields-and-annotations.pdf");
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr("1-3"),
repeat: Some(pr("1")),
}];
apply_overlay_specs(&mut dest, &mut specs).unwrap();
let root_ref = dest.root_ref().unwrap();
let catalog = dest.resolve(root_ref).unwrap().into_dict().unwrap();
let acroform_ref = catalog.get_ref("AcroForm").unwrap();
let acroform = dest.resolve(acroform_ref).unwrap().into_dict().unwrap();
let dr_ref = acroform.get_ref("DR").unwrap();
let font = font_dict(&mut dest, dr_ref);
assert!(font.get("F1").is_some(), "original /F1 preserved");
assert!(font.get("F1_1").is_some(), "collision renamed to /F1_1");
assert!(
font.get("F1_2").is_none(),
"second page must reuse /F1_1, not mint /F1_2"
);
assert!(
font.get("F1_3").is_none(),
"third page must reuse /F1_1, not mint /F1_3"
);
}
}