use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use crate::acroform_document_helper::{collect_reachable_refs, collect_refs_in_object};
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,
}
}
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>,
) -> Result<Vec<ObjectRef>> {
if template.annots.is_empty() {
return Ok(Vec::new()); }
let mut per_placement_dup: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
let has_any_top_field = template.annots.iter().any(|(_, tf)| tf.is_some());
if has_any_top_field && dest_acroform_dr.is_none() {
if let Some(source_dr) = template.source_dr {
*dest_acroform_dr = Some(ensure_dest_acroform_dr(dest, source_dr)?);
} }
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 {
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(),
)?; 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)?;
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>,
) -> 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 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)?;
}
dest.set_object(dup_ref, Object::Dictionary(dict));
}
Ok(new_top)
}
fn transform_annot_ap_streams<R: Read + Seek>(
dest: &mut Pdf<R>,
annot_ref: ObjectRef,
cm: [f64; 6],
) -> 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)? {
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)? {
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,
) -> 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)) => 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));
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)?;
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,
) -> 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(()); };
for (type_key, src_type_val) in src_dict.iter() {
let Some(src_type_dict) = src_type_val.as_dict() else {
dest_dict.insert(type_key, src_type_val.clone()); continue; };
let mut new_type_dict = crate::Dictionary::new();
for (name, val) in src_type_dict.iter() {
new_type_dict.insert(name, val.clone());
}
dest_dict.insert(type_key, Object::Dictionary(new_type_dict));
}
dest.set_object(dest_dr, Object::Dictionary(dest_dict));
Ok(())
}
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)
}