use crate::object_handle::ObjectHandle;
use crate::qpdf_obj_gen::QpdfObjGen;
use crate::{Error, ObjectRef, Pdf, Result};
use std::collections::BTreeSet;
use std::io::{Read, Seek};
const NON_NAME_CHECKBOX_WARNING: &str =
"ignoring attempt to set a checkbox field to a value whose type is not name";
const NON_NAME_RADIO_WARNING: &str =
"ignoring attempt to set a radio button field to an object that is not a name";
const RADIO_BUTTON_SHAPE_WARNING: &str =
"don't know how to set the value of this field as a radio button";
const BROKEN_RADIO_BUTTON_WARNING: &str = "unable to set the value of this radio button";
const BROKEN_CHECKBOX_WARNING: &str = "unable to set the value of this checkbox";
#[path = "form_field_object_helper/rendering.rs"]
mod rendering;
fn mark_field_node_seen(seen: &mut BTreeSet<QpdfObjGen>, current: &ObjectHandle) -> bool {
current
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.map(|object_gen| seen.insert(object_gen))
.unwrap_or(true)
}
#[deprecated(
note = "no qpdf counterpart; QPDFObjGen::set ignores direct identities and qpdf has no direct-parent cycle guard"
)]
fn mark_direct_node_seen(direct_seen: &mut Vec<ObjectHandle>, current: &ObjectHandle) -> bool {
if !current.is_direct() {
return true;
}
if direct_seen
.iter()
.any(|handle: &ObjectHandle| handle.is_same_object_as(current))
{
return false;
}
direct_seen.push(current.clone());
true
}
#[deprecated(note = "no qpdf counterpart; qpdf does not report direct-parent cycle errors")]
fn direct_parent_cycle_error(field_ref: ObjectRef) -> Error {
Error::Unsupported(format!(
"field tree contains a /Parent cycle of direct dictionaries at {field_ref}"
))
}
pub struct FormFieldObjectHelper<'a, R: Read + Seek + 'static> {
field_ref: Option<ObjectRef>,
field: ObjectHandle,
pdf: &'a mut Pdf<R>,
}
impl<'a, R: Read + Seek> FormFieldObjectHelper<'a, R> {
pub fn new(field_ref: ObjectRef, pdf: &'a mut Pdf<R>) -> Self {
let field = pdf.get_object_handle(field_ref);
Self {
field_ref: Some(field_ref),
field,
pdf,
}
}
pub fn from_object_handle(field: ObjectHandle, pdf: &'a mut Pdf<R>) -> Self {
Self {
field_ref: field.object_ref(),
field,
pdf,
}
}
pub fn is_null(&mut self) -> Result<bool> {
let field = self.dereferenced(self.field.clone())?;
field.try_is_null()
}
pub fn parent(&mut self) -> Result<Option<ObjectRef>> {
self.direct_parent(self.field.clone())
}
pub fn get_parent(&mut self) -> Result<ObjectHandle> {
self.field.try_get_key(b"/Parent")
}
#[allow(deprecated)]
pub fn get_top_level_field(&mut self) -> Result<(ObjectHandle, bool)> {
let mut current = self.field.clone();
let mut seen = BTreeSet::new();
let mut direct_seen = Vec::new();
let mut is_different = false;
loop {
if !mark_field_node_seen(&mut seen, ¤t) {
break;
}
if !mark_direct_node_seen(&mut direct_seen, ¤t) {
return Err(direct_parent_cycle_error(
self.field_ref.unwrap_or(ObjectRef::new(0, 0)),
));
}
let node = self.dereferenced(current.clone())?;
let parent = if node.try_is_null()? {
ObjectHandle::null()
} else {
match node.try_get_key(b"/Parent") {
Err(Error::QpdfExc(warning)) if !node.try_is_dictionary()? => {
self.pdf.push_qpdf_warning(warning)?;
ObjectHandle::null()
}
result => result?,
}
};
let parent = self.dereferenced(parent)?;
if parent.try_is_null()? {
break;
}
current = parent;
is_different = true;
}
Ok((current, is_different))
}
pub fn get_inheritable_field_value(&mut self, key: &[u8]) -> Result<Option<ObjectHandle>> {
self.resolve_inherited_handle(key)
}
pub fn get_inheritable_field_value_as_string(&mut self, key: &[u8]) -> Result<String> {
let value = self.resolve_inherited_handle(key)?;
Ok(self.resolve_string_handle(value)?.unwrap_or_default())
}
pub fn get_inheritable_field_value_as_name(&mut self, key: &[u8]) -> Result<Vec<u8>> {
Ok(self
.resolve_inherited_name(self.field.clone(), key)?
.map(|name| {
let mut result = Vec::with_capacity(name.len() + 1);
result.push(b'/');
result.extend(name);
result
})
.unwrap_or_default())
}
pub fn get_field_type(&mut self) -> Result<Option<Vec<u8>>> {
Ok(self
.resolve_inherited_name(self.field.clone(), b"FT")?
.map(|name| {
let mut result = Vec::with_capacity(name.len() + 1);
result.push(b'/');
result.extend(name);
result
}))
}
pub fn field_value(&mut self) -> Result<Option<ObjectHandle>> {
self.resolve_inherited_handle(b"V")
}
pub fn field_value_handle(&mut self) -> Result<Option<ObjectHandle>> {
self.field_value()
}
pub fn field_value_reference(&mut self) -> Result<Option<ObjectRef>> {
Ok(self.field_value()?.and_then(|value| value.object_ref()))
}
pub fn field_default_value(&mut self) -> Result<Option<ObjectHandle>> {
self.resolve_inherited_handle(b"DV")
}
pub fn field_default_value_handle(&mut self) -> Result<Option<ObjectHandle>> {
self.field_default_value()
}
pub fn get_value(&mut self) -> Result<Option<ObjectHandle>> {
self.field_value()
}
pub fn get_value_as_string(&mut self) -> Result<String> {
self.get_inheritable_field_value_as_string(b"V")
}
pub fn get_default_value(&mut self) -> Result<Option<ObjectHandle>> {
self.field_default_value()
}
pub fn get_default_value_as_string(&mut self) -> Result<String> {
self.get_inheritable_field_value_as_string(b"DV")
}
pub fn field_flags(&mut self) -> Result<Option<i64>> {
self.resolve_inherited_integer(self.field.clone(), b"Ff")
}
pub fn get_flags(&mut self) -> Result<i64> {
Ok(self.field_flags()?.unwrap_or(0))
}
pub fn get_partial_name(&mut self) -> Result<String> {
self.string_key(self.field.clone(), b"T")
.map(|value| value.unwrap_or_default())
}
#[allow(deprecated)]
pub fn get_fully_qualified_name(&mut self) -> Result<String> {
let mut current = self.field.clone();
let mut seen = BTreeSet::new();
let mut direct_seen = Vec::new();
let mut parts = Vec::new();
while mark_field_node_seen(&mut seen, ¤t) {
if !mark_direct_node_seen(&mut direct_seen, ¤t) {
return Err(direct_parent_cycle_error(
self.field_ref.unwrap_or(ObjectRef::new(0, 0)),
));
}
let node = self.dereferenced(current.clone())?;
if !node.try_is_dictionary()? {
break;
}
if let Some(name) = self.resolve_string_handle(Some(node.try_get_key(b"/T")?))? {
parts.push(name);
}
let parent = self.dereferenced(node.try_get_key(b"/Parent")?)?;
if parent.try_is_null()? {
break;
}
current = parent;
}
parts.reverse();
Ok(parts.join("."))
}
pub fn get_alternative_name(&mut self) -> Result<String> {
match self.string_key(self.field.clone(), b"TU")? {
Some(name) => Ok(name),
None => self.get_fully_qualified_name(),
}
}
pub fn get_mapping_name(&mut self) -> Result<String> {
match self.string_key(self.field.clone(), b"TM")? {
Some(name) => Ok(name),
None => self.get_alternative_name(),
}
}
pub fn get_default_appearance(&mut self) -> Result<String> {
if let Some(value) = self.resolve_inherited_handle(b"DA")? {
if let Some(value) = self.resolve_string_handle(Some(value))? {
return Ok(value);
}
}
let value = self.acroform_value(b"DA")?;
Ok(self.resolve_string_handle(value)?.unwrap_or_default())
}
pub fn get_default_resources(&mut self) -> Result<Option<ObjectHandle>> {
self.acroform_value(b"DR")
}
pub fn get_quadding(&mut self) -> Result<i64> {
if let Some(value) = self.resolve_inherited_handle(b"Q")? {
if let Some(value) = self.dereferenced(value)?.try_as_integer()? {
return Ok(value);
}
}
Ok(self
.acroform_value(b"Q")?
.map(|value| self.dereferenced(value))
.transpose()?
.map(|value| value.try_as_integer())
.transpose()?
.flatten()
.unwrap_or(0))
}
pub fn is_text(&mut self) -> Result<bool> {
Ok(self.get_field_type()?.as_deref() == Some(b"/Tx"))
}
pub fn is_checkbox(&mut self) -> Result<bool> {
Ok(self.get_field_type()?.as_deref() == Some(b"/Btn")
&& self.field_flags()?.unwrap_or(0) & ((1 << 15) | (1 << 16)) == 0)
}
pub fn is_checked(&mut self) -> Result<bool> {
if !self.is_checkbox()? {
return Ok(false);
}
let Some(value) = self.field_value()? else {
return Ok(false);
};
let value = self.dereferenced(value)?;
Ok(value.try_as_name()?.is_some_and(|value| value != b"Off"))
}
pub fn is_radio_button(&mut self) -> Result<bool> {
Ok(self.get_field_type()?.as_deref() == Some(b"/Btn")
&& self.field_flags()?.unwrap_or(0) & (1 << 15) == 1 << 15)
}
pub fn is_pushbutton(&mut self) -> Result<bool> {
Ok(self.get_field_type()?.as_deref() == Some(b"/Btn")
&& self.field_flags()?.unwrap_or(0) & (1 << 16) == 1 << 16)
}
pub fn is_choice(&mut self) -> Result<bool> {
Ok(self.get_field_type()?.as_deref() == Some(b"/Ch"))
}
pub fn get_choices(&mut self) -> Result<Vec<String>> {
if !self.is_choice()? {
return Ok(Vec::new());
}
let Some(options) = self.resolve_inherited_handle(b"Opt")? else {
return Ok(Vec::new());
};
let options = self.dereferenced(options)?;
let Some(items) = options.try_as_array()? else {
return Ok(Vec::new());
};
let mut choices = Vec::new();
for item in items {
if let Some(value) = self.resolve_string_handle(Some(item))? {
choices.push(value);
}
}
Ok(choices)
}
pub fn set_field_attribute(&mut self, key: &[u8], value: ObjectHandle) -> Result<()> {
self.set_direct_attribute(&self.field.clone(), key, value)
}
pub fn set_field_attribute_string(&mut self, key: &[u8], value: &str) -> Result<()> {
self.set_field_attribute(
key,
ObjectHandle::string(crate::pdf_string::new_unicode_string(value.as_bytes())),
)
}
pub fn set_value(&mut self, value: ObjectHandle, need_appearances: bool) -> Result<()> {
let value = self.dereferenced(value)?;
if self.get_field_type()?.as_deref() == Some(b"/Btn") {
if self.is_checkbox()? {
if let Some(name) = value.try_as_name()? {
self.set_checkbox_value(name != b"Off")?;
} else {
self.field.warn_if_possible(NON_NAME_CHECKBOX_WARNING)?;
}
} else if self.is_radio_button()? {
if let Some(name) = value.try_as_name()? {
self.set_radio_button_value(self.field.clone(), &name)?;
} else {
self.field.warn_if_possible(NON_NAME_RADIO_WARNING)?;
}
} else if self.is_pushbutton()? {
self.field
.warn_if_possible("ignoring attempt set the value of a pushbutton field")?;
}
return Ok(());
}
let value = if let Some(string) = value.as_string() {
ObjectHandle::string(crate::pdf_string::new_unicode_string(
&crate::pdf_string::utf8_value(&string),
))
} else {
value
};
self.set_field_attribute(b"V", value)?;
if need_appearances {
self.set_need_appearances()?;
}
Ok(())
}
pub fn set_value_string(&mut self, value: &str, need_appearances: bool) -> Result<()> {
self.set_value(
ObjectHandle::string(crate::pdf_string::new_unicode_string(value.as_bytes())),
need_appearances,
)
}
pub fn generate_appearance_for(&mut self, widget_ref: ObjectRef) -> Result<Option<ObjectRef>> {
let widget = self.pdf.get_object_handle(widget_ref);
self.generate_appearance_for_handle(widget)
}
pub(crate) fn generate_appearance_for_handle(
&mut self,
widget: ObjectHandle,
) -> Result<Option<ObjectRef>> {
match self.get_field_type()?.as_deref() {
Some(b"/Tx") => {
rendering::render_text_field_canonical_handles(self.pdf, self.field.clone(), widget)
}
Some(b"/Ch") => rendering::render_choice_field_canonical_handles(
self.pdf,
self.field.clone(),
widget,
),
_ => Ok(None),
}
}
pub fn clear_need_appearances_after_generation(pdf: &mut Pdf<R>) -> Result<()> {
let root = pdf.trailer_key_handle(b"Root");
if root.try_is_null()? {
return Ok(());
}
let acroform = root.try_get_key(b"/AcroForm")?;
if !acroform.try_is_dictionary()? {
return Ok(());
}
let need_appearances = acroform.try_get_key(b"/NeedAppearances")?;
need_appearances.try_dereference()?;
if need_appearances.as_boolean() != Some(true) {
return Ok(());
}
acroform.remove_key(b"/NeedAppearances");
Ok(())
}
fn set_need_appearances(&mut self) -> Result<()> {
crate::AcroFormDocumentHelper::new(self.pdf)?.set_need_appearances(true)
}
fn set_checkbox_value(&mut self, checked: bool) -> Result<()> {
let annotation = self.appearance_annotation(self.field.clone())?;
let on_value = self.checkbox_state(annotation.as_ref(), checked)?;
let value = ObjectHandle::name(on_value);
self.set_field_attribute(b"/V", value.clone())?;
if let Some(annotation) = annotation {
self.set_direct_attribute(&annotation, b"/AS", value)?;
} else {
self.field.warn_if_possible(BROKEN_CHECKBOX_WARNING)?;
}
Ok(())
}
fn checkbox_state(
&mut self,
annotation: Option<&ObjectHandle>,
checked: bool,
) -> Result<Vec<u8>> {
if !checked {
return Ok(b"Off".to_vec());
}
Ok(annotation
.map(|dictionary| self.normal_appearance_names(dictionary))
.transpose()?
.and_then(|names| names.into_iter().find(|name| name != b"Off"))
.unwrap_or_else(|| b"Yes".to_vec()))
}
fn set_radio_button_value(&mut self, field: ObjectHandle, value: &[u8]) -> Result<()> {
let field = self.dereferenced(field)?;
let parent = self.dereferenced(field.try_get_key(b"/Parent")?)?;
if !parent.try_is_null()? {
if let Some(parent_dict) = self.dictionary_handle_for(parent.clone())? {
let parent_parent = self.dereferenced(parent_dict.try_get_key(b"/Parent")?)?;
if parent_parent.try_is_null()? && self.is_radio_for(parent_dict.clone())? {
return self.set_radio_button_value(parent_dict, value);
}
}
}
let parent_is_null = parent.try_is_null()?;
let kids = self.dereferenced(field.try_get_key(b"/Kids")?)?;
if !parent_is_null {
field.warn_if_possible(RADIO_BUTTON_SHAPE_WARNING)?;
return Ok(());
}
let Some(items) = kids.try_as_array()? else {
field.warn_if_possible(RADIO_BUTTON_SHAPE_WARNING)?;
return Ok(());
};
self.set_direct_attribute(&field, b"/V", ObjectHandle::name(value.to_vec()))?;
self.update_radio_kids(items, value, &field)
}
fn update_radio_kids(
&mut self,
kids: Vec<ObjectHandle>,
value: &[u8],
warning_handle: &ObjectHandle,
) -> Result<()> {
for kid in kids {
self.update_radio_kid(kid, value, warning_handle)?;
}
Ok(())
}
fn update_radio_kid(
&mut self,
kid: ObjectHandle,
value: &[u8],
warning_handle: &ObjectHandle,
) -> Result<()> {
let kid = self.dereferenced(kid)?;
if !kid.try_is_dictionary()? {
warning_handle.warn_if_possible(BROKEN_RADIO_BUTTON_WARNING)?;
return Ok(());
}
if self.has_non_null_appearance(&kid)? {
let state = self.radio_state(&kid, value)?;
self.set_direct_attribute(&kid, b"/AS", ObjectHandle::name(state))?;
return Ok(());
}
let grandkids = self.dereferenced(kid.try_get_key(b"/Kids")?)?;
if let Some(items) = grandkids.try_as_array()? {
if !self.update_first_radio_widget(items, value)? {
warning_handle.warn_if_possible(BROKEN_RADIO_BUTTON_WARNING)?;
}
} else {
warning_handle.warn_if_possible(BROKEN_RADIO_BUTTON_WARNING)?;
}
Ok(())
}
fn update_first_radio_widget(&mut self, kids: Vec<ObjectHandle>, value: &[u8]) -> Result<bool> {
for widget in kids {
if self.update_radio_widget(widget, value)? {
return Ok(true);
}
}
Ok(false)
}
fn update_radio_widget(&mut self, widget: ObjectHandle, value: &[u8]) -> Result<bool> {
let widget = self.dereferenced(widget)?;
if !widget.try_is_dictionary()? || !self.has_non_null_appearance(&widget)? {
return Ok(false);
}
let state = self.radio_state(&widget, value)?;
self.set_direct_attribute(&widget, b"/AS", ObjectHandle::name(state))?;
Ok(true)
}
fn radio_state(&mut self, widget: &ObjectHandle, value: &[u8]) -> Result<Vec<u8>> {
let names = self.normal_appearance_names(widget)?;
Ok(if names.iter().any(|name| name == value) {
value.to_vec()
} else {
b"Off".to_vec()
})
}
fn appearance_annotation(&mut self, start: ObjectHandle) -> Result<Option<ObjectHandle>> {
let field = self.dereferenced(start)?;
if self.has_non_null_appearance(&field)? {
return Ok(Some(field));
}
let kids = self.dereferenced(field.try_get_key(b"/Kids")?)?;
let Some(items) = kids.try_as_array()? else {
return Ok(None);
};
for kid in items {
let kid = self.dereferenced(kid)?;
if !kid.try_is_dictionary()? {
continue;
}
if self.has_non_null_appearance(&kid)? {
return Ok(Some(kid));
}
}
Ok(None)
}
fn has_non_null_appearance(&mut self, dictionary: &ObjectHandle) -> Result<bool> {
let appearance = self.dereferenced(dictionary.try_get_key(b"/AP")?)?;
Ok(!appearance.try_is_null()?)
}
fn normal_appearance_names(&mut self, dictionary: &ObjectHandle) -> Result<Vec<Vec<u8>>> {
let appearance = self.dereferenced(dictionary.try_get_key(b"/AP")?)?;
let normal = self.dereferenced(appearance.try_get_key(b"/N")?)?;
let Some(entries) = normal.try_as_dictionary()? else {
return Ok(Vec::new());
};
Ok(entries
.keys()
.filter_map(|key| key.strip_prefix(b"/").map(ToOwned::to_owned))
.collect())
}
fn set_direct_attribute(
&mut self,
target: &ObjectHandle,
key: &[u8],
value: ObjectHandle,
) -> Result<()> {
let Some(dictionary) = self.dictionary_handle_for(target.clone())? else {
return Ok(());
};
let key = crate::object_handle::canonical_dictionary_key(key);
dictionary.replace_key(&key, value)?;
Ok(())
}
fn dictionary_handle_for(&mut self, handle: ObjectHandle) -> Result<Option<ObjectHandle>> {
let handle = self.dereferenced(handle)?;
if handle.try_is_dictionary()? {
Ok(Some(handle))
} else {
Ok(None)
}
}
fn is_radio_for(&mut self, field: ObjectHandle) -> Result<bool> {
Ok(
self.field_type_for(field.clone())?.as_deref() == Some(b"/Btn")
&& self.resolve_inherited_integer(field, b"Ff")?.unwrap_or(0) & (1 << 15)
== 1 << 15,
)
}
fn field_type_for(&mut self, field: ObjectHandle) -> Result<Option<Vec<u8>>> {
Ok(self.resolve_inherited_name(field, b"FT")?.map(|name| {
let mut result = Vec::with_capacity(name.len() + 1);
result.push(b'/');
result.extend(name);
result
}))
}
fn acroform_value(&mut self, key: &[u8]) -> Result<Option<ObjectHandle>> {
let root = self.pdf.trailer_key_handle(b"Root");
let root = self.dereferenced(root)?;
if root.try_is_null()? || !root.try_is_dictionary()? {
return Ok(None);
}
let acroform = self.dereferenced(root.try_get_key(b"/AcroForm")?)?;
if !acroform.try_is_dictionary()? {
return Ok(None);
}
let key = crate::object_handle::canonical_dictionary_key(key);
let value = self.dereferenced(acroform.try_get_key(&key)?)?;
Ok((!value.try_is_null()?).then_some(value))
}
fn utf8_string(value: &[u8]) -> String {
String::from_utf8_lossy(&crate::pdf_string::utf8_value(value)).into_owned()
}
fn direct_parent(&mut self, field: ObjectHandle) -> Result<Option<ObjectRef>> {
let field = self.dereferenced(field)?;
if !field.try_is_dictionary()? {
return Ok(None);
}
let parent = self.dereferenced(field.try_get_key(b"/Parent")?)?;
if parent.try_is_null()? {
return Ok(None);
}
Ok(parent.object_ref())
}
fn resolve_inherited_name(
&mut self,
field: ObjectHandle,
key: &[u8],
) -> Result<Option<Vec<u8>>> {
let Some(value) = self.resolve_inherited_handle_from(field, key)? else {
return Ok(None);
};
self.dereferenced(value)?.try_as_name()
}
fn resolve_inherited_handle(&mut self, key: &[u8]) -> Result<Option<ObjectHandle>> {
self.resolve_inherited_handle_from(self.field.clone(), key)
}
#[allow(deprecated)]
fn resolve_inherited_handle_from(
&mut self,
field: ObjectHandle,
key: &[u8],
) -> Result<Option<ObjectHandle>> {
let key = crate::object_handle::canonical_dictionary_key(key);
let mut current = field;
let mut seen = BTreeSet::new();
let mut direct_seen = Vec::new();
loop {
if !mark_field_node_seen(&mut seen, ¤t) {
return Ok(None);
}
if !mark_direct_node_seen(&mut direct_seen, ¤t) {
return Err(direct_parent_cycle_error(
self.field_ref.unwrap_or(ObjectRef::new(0, 0)),
));
}
let node = self.dereferenced(current)?;
if !node.try_is_dictionary()? {
return Ok(None);
}
let value = self.dereferenced(node.try_get_key(&key)?)?;
if !value.try_is_null()? {
return Ok(Some(value));
}
let parent = self.dereferenced(node.try_get_key(b"/Parent")?)?;
if parent.try_is_null()? {
return Ok(None);
}
current = parent;
}
}
fn resolve_inherited_integer(
&mut self,
field: ObjectHandle,
key: &[u8],
) -> Result<Option<i64>> {
let Some(value) = self.resolve_inherited_handle_from(field, key)? else {
return Ok(None);
};
Ok(Some(
self.dereferenced(value)?.try_as_integer()?.unwrap_or(0),
))
}
fn string_key(&mut self, field: ObjectHandle, key: &[u8]) -> Result<Option<String>> {
let field = self.dereferenced(field)?;
if !field.try_is_dictionary()? {
return Ok(None);
}
self.resolve_string_handle(Some(
field.try_get_key(&crate::object_handle::canonical_dictionary_key(key))?,
))
}
fn resolve_string_handle(&mut self, value: Option<ObjectHandle>) -> Result<Option<String>> {
let Some(value) = value else {
return Ok(None);
};
let value = self.dereferenced(value)?;
Ok(value.as_string().map(|value| Self::utf8_string(&value)))
}
fn dereferenced(&mut self, handle: ObjectHandle) -> Result<ObjectHandle> {
handle.try_dereference()?;
Ok(handle)
}
}
#[cfg(test)]
mod tests {
use super::{mark_field_node_seen, FormFieldObjectHelper};
use crate::object_handle::{ObjectHandle, ObjectValue};
use crate::{ObjectRef, Pdf};
use std::collections::BTreeSet;
#[test]
fn qpdf_seen_set_ignores_direct_handles_and_tracks_indirect_identity() {
let mut seen = BTreeSet::new();
assert!(mark_field_node_seen(&mut seen, &ObjectHandle::integer(1)));
assert!(mark_field_node_seen(&mut seen, &ObjectHandle::integer(1)));
let first = ObjectHandle::new_indirect_unresolved(ObjectRef::new(10, 0), -1);
let same_object = ObjectHandle::new_indirect_unresolved(ObjectRef::new(10, 0), -1);
assert!(mark_field_node_seen(&mut seen, &first));
assert!(!mark_field_node_seen(&mut seen, &same_object));
}
#[test]
fn qpdf_seen_set_tracks_a_raw_generation_identity() {
let mut seen = BTreeSet::new();
let raw = ObjectHandle::new_indirect_unresolved(ObjectRef::new(10, 65_535), -1);
assert!(mark_field_node_seen(&mut seen, &raw));
assert!(!mark_field_node_seen(&mut seen, &raw));
}
#[test]
fn top_level_field_scalar_parent_warns_and_returns_the_scalar_like_qpdf() {
let mut pdf = Pdf::empty().expect("empty PDF should open");
let field = pdf.get_object_handle(ObjectRef::new(17, 0));
field.set_resolved(ObjectValue::Dictionary(
[
(b"/T".to_vec(), ObjectHandle::string(b"field".to_vec())),
(b"/Parent".to_vec(), ObjectHandle::integer(42)),
]
.into_iter()
.collect(),
));
let mut helper = FormFieldObjectHelper::from_object_handle(field, &mut pdf);
let (top_level, is_different) = helper
.get_top_level_field()
.expect("a scalar parent warns and terminates the top-level walk");
drop(helper);
assert_eq!(top_level.as_integer(), Some(42));
assert!(is_different);
let warnings = pdf.get_warnings();
assert_eq!(warnings.len(), 1);
assert_eq!(
warnings.entries()[0].get_message_detail(),
b"operation for dictionary attempted on object of type integer: returning null for attempted key retrieval"
);
}
#[test]
fn top_level_null_field_returns_null_without_a_type_warning() {
let mut pdf = Pdf::empty().expect("empty PDF should open");
let mut helper = FormFieldObjectHelper::from_object_handle(ObjectHandle::null(), &mut pdf);
let (top_level, is_different) = helper
.get_top_level_field()
.expect("qpdf getKeyIfDict short-circuits a null receiver");
drop(helper);
assert!(top_level.is_null());
assert!(!is_different);
assert!(pdf.get_warnings().is_empty());
}
#[test]
#[allow(deprecated)]
fn direct_seen_set_ignores_indirect_handles_and_tracks_direct_identity() {
let mut direct_seen = Vec::new();
let indirect = ObjectHandle::new_indirect_unresolved(ObjectRef::new(10, 0), -1);
assert!(super::mark_direct_node_seen(&mut direct_seen, &indirect));
assert!(super::mark_direct_node_seen(&mut direct_seen, &indirect));
assert!(direct_seen.is_empty());
let direct = ObjectHandle::dictionary(Vec::new());
assert!(super::mark_direct_node_seen(&mut direct_seen, &direct));
assert!(!super::mark_direct_node_seen(&mut direct_seen, &direct));
let other_direct = ObjectHandle::dictionary(Vec::new());
assert!(super::mark_direct_node_seen(
&mut direct_seen,
&other_direct
));
}
#[test]
fn direct_field_is_returned_as_the_top_level_handle() {
let mut pdf = Pdf::empty().expect("empty PDF");
let mut helper = super::FormFieldObjectHelper::from_object_handle(
ObjectHandle::dictionary(Vec::new()),
&mut pdf,
);
let (top_level, is_different) = helper
.get_top_level_field()
.expect("qpdf returns the direct top-level helper");
assert!(top_level.object_ref().is_none());
assert!(!is_different);
}
#[test]
fn set_checkbox_value_syncs_as_for_a_direct_merged_field_widget() {
let mut pdf = Pdf::empty().expect("empty PDF");
let field = ObjectHandle::dictionary(vec![
(b"/FT".to_vec(), ObjectHandle::name(b"Btn".to_vec())),
(
b"/AP".to_vec(),
ObjectHandle::dictionary(vec![(
b"/N".to_vec(),
ObjectHandle::dictionary(vec![
(b"/Off".to_vec(), ObjectHandle::null()),
(b"/Chosen".to_vec(), ObjectHandle::null()),
]),
)]),
),
]);
let mut helper = super::FormFieldObjectHelper::from_object_handle(field.clone(), &mut pdf);
helper
.set_value(ObjectHandle::name(b"On".to_vec()), true)
.expect("set direct merged checkbox value");
assert_eq!(
field.try_get_key(b"/V").unwrap().as_name(),
Some(b"Chosen".to_vec())
);
assert_eq!(
field.try_get_key(b"/AS").unwrap().as_name(),
Some(b"Chosen".to_vec()),
"a direct merged field/widget checkbox must have /AS synced, not just /V"
);
}
#[test]
fn broken_radio_button_set_value_records_qpdf_warning() {
let mut pdf = Pdf::empty().expect("empty PDF");
let field = pdf
.make_indirect_object_handle(ObjectHandle::dictionary(vec![
(b"/FT".to_vec(), ObjectHandle::name(b"Btn".to_vec())),
(b"/Ff".to_vec(), ObjectHandle::integer(1 << 15)),
(
b"/Kids".to_vec(),
ObjectHandle::array(vec![ObjectHandle::dictionary(Vec::new())]),
),
]))
.expect("allocate broken radio field");
let field_ref = field.object_ref().expect("radio field reference");
{
let mut helper = super::FormFieldObjectHelper::new(field_ref, &mut pdf);
helper
.set_value(ObjectHandle::name(b"2".to_vec()), true)
.expect("set broken radio value");
}
let diagnostics = pdf.repair_diagnostics();
let messages: Vec<_> = diagnostics
.entries()
.iter()
.map(|diagnostic| String::from_utf8_lossy(diagnostic.what_bytes()).into_owned())
.collect();
assert_eq!(
messages,
["object 3 0: unable to set the value of this radio button"]
);
}
#[test]
fn broken_checkbox_set_value_records_qpdf_warning() {
let mut pdf = Pdf::empty().expect("empty PDF");
let field = pdf
.make_indirect_object_handle(ObjectHandle::dictionary(vec![(
b"/FT".to_vec(),
ObjectHandle::name(b"Btn".to_vec()),
)]))
.expect("allocate broken checkbox field");
let field_ref = field.object_ref().expect("checkbox field reference");
{
let mut helper = super::FormFieldObjectHelper::new(field_ref, &mut pdf);
helper
.set_value(ObjectHandle::name(b"Sure".to_vec()), true)
.expect("set broken checkbox value");
}
let diagnostics = pdf.repair_diagnostics();
let messages: Vec<_> = diagnostics
.entries()
.iter()
.map(|diagnostic| String::from_utf8_lossy(diagnostic.what_bytes()).into_owned())
.collect();
assert_eq!(
messages,
["object 3 0: unable to set the value of this checkbox"]
);
}
#[test]
fn button_set_value_type_and_pushbutton_warnings_follow_qpdf() {
let mut pdf = Pdf::open_mem_owned_with_options(
include_bytes!("../../../tests/fixtures/minimal.pdf").to_vec(),
crate::PdfOpenOptions {
suppress_warnings: true,
..crate::PdfOpenOptions::default()
},
)
.expect("open minimal PDF");
let checkbox = pdf
.make_indirect_object_handle(ObjectHandle::dictionary(vec![(
b"/FT".to_vec(),
ObjectHandle::name(b"Btn".to_vec()),
)]))
.expect("allocate checkbox");
let radio = pdf
.make_indirect_object_handle(ObjectHandle::dictionary(vec![
(b"/FT".to_vec(), ObjectHandle::name(b"Btn".to_vec())),
(b"/Ff".to_vec(), ObjectHandle::integer(1 << 15)),
]))
.expect("allocate radio");
let pushbutton = pdf
.make_indirect_object_handle(ObjectHandle::dictionary(vec![
(b"/FT".to_vec(), ObjectHandle::name(b"Btn".to_vec())),
(b"/Ff".to_vec(), ObjectHandle::integer(1 << 16)),
]))
.expect("allocate pushbutton");
{
let mut helper = super::FormFieldObjectHelper::new(
checkbox.object_ref().expect("checkbox reference"),
&mut pdf,
);
helper
.set_value(ObjectHandle::integer(1), true)
.expect("set checkbox with invalid value type");
}
{
let mut helper = super::FormFieldObjectHelper::new(
radio.object_ref().expect("radio reference"),
&mut pdf,
);
helper
.set_value(ObjectHandle::integer(1), true)
.expect("set radio with invalid value type");
}
{
let mut helper = super::FormFieldObjectHelper::new(
pushbutton.object_ref().expect("pushbutton reference"),
&mut pdf,
);
helper
.set_value(ObjectHandle::name(b"On".to_vec()), true)
.expect("set pushbutton value");
}
let diagnostics = pdf.repair_diagnostics();
let messages: Vec<_> = diagnostics
.entries()
.iter()
.map(|diagnostic| diagnostic.message_string())
.collect();
assert!(messages.iter().any(|message| message.contains(
"ignoring attempt to set a checkbox field to a value whose type is not name"
)));
assert!(messages.iter().any(|message| message.contains(
"ignoring attempt to set a radio button field to an object that is not a name"
)));
assert!(messages.iter().any(
|message| message.contains("ignoring attempt set the value of a pushbutton field")
));
}
#[test]
fn radio_button_shape_failures_warn_once_per_missing_widget() {
let mut pdf = Pdf::open_mem_owned_with_options(
include_bytes!("../../../tests/fixtures/minimal.pdf").to_vec(),
crate::PdfOpenOptions {
suppress_warnings: true,
..crate::PdfOpenOptions::default()
},
)
.expect("open minimal PDF");
let field = pdf
.make_indirect_object_handle(ObjectHandle::dictionary(vec![
(b"/FT".to_vec(), ObjectHandle::name(b"Btn".to_vec())),
(b"/Ff".to_vec(), ObjectHandle::integer(1 << 15)),
(
b"/Kids".to_vec(),
ObjectHandle::array(vec![
ObjectHandle::integer(1),
ObjectHandle::dictionary(vec![(
b"/Kids".to_vec(),
ObjectHandle::array(Vec::new()),
)]),
]),
),
]))
.expect("allocate malformed radio field");
{
let mut helper = super::FormFieldObjectHelper::new(
field.object_ref().expect("radio reference"),
&mut pdf,
);
helper
.set_value(ObjectHandle::name(b"On".to_vec()), true)
.expect("set malformed radio value");
}
let diagnostics = pdf.repair_diagnostics();
let messages: Vec<_> = diagnostics
.entries()
.iter()
.map(|diagnostic| diagnostic.message_string())
.filter(|message| message.contains("unable to set the value of this radio button"))
.collect();
assert_eq!(messages.len(), 2);
}
}