Editar formularios

PDF Oxide proporciona soporte integral de campos de formulario: leer valores existentes, llenar campos programáticamente, agregar nuevos campos, configurar propiedades, aplanar formularios a contenido estático y exportar datos de formulario en formatos FDF/XFDF. Los formularios XFA pueden analizarse y convertirse a AcroForm.

Leer campos de formulario

Obtener todos los campos de formulario

Rust

use pdf_oxide::editor::DocumentEditor;

let mut editor = DocumentEditor::open("form.pdf")?;
let fields = editor.get_form_fields()?;

for field in &fields {
    println!("Field: {} = {:?}", field.name(), field.value());
    if let Some(ft) = field.field_type() {
        println!("  Type: {:?}", ft);
    }
    if let Some(tooltip) = field.tooltip() {
        println!("  Tooltip: {}", tooltip);
    }
}

WASM

const doc = new WasmPdfDocument(bytes);
const fields = doc.getFormFields();

for (const f of fields) {
  console.log(`${f.name} (${f.field_type}) = ${f.value}`);
}

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("form.pdf")
fields = doc.get_form_fields()

for field in fields:
    print(f"{field.name} ({field.field_type}) = {field.value}")

Obtener un valor de campo específico

Rust

let mut editor = DocumentEditor::open("form.pdf")?;

let value = editor.get_form_field_value("first_name")?;
println!("First name: {:?}", value);

WASM

const value = doc.getFormFieldValue("first_name");
console.log(`First name: ${value}`);

Python

value = doc.get_form_field_value("first_name")
print(f"First name: {value}")

Verificar si un campo existe

let mut editor = DocumentEditor::open("form.pdf")?;

if editor.has_form_field("email")? {
    println!("Email field exists");
}

Establecer valores de campos de formulario

Establecer un valor de campo

Rust

use pdf_oxide::editor::DocumentEditor;
use pdf_oxide::editor::form_fields::FormFieldValue;

let mut editor = DocumentEditor::open("form.pdf")?;

// Set a text field
editor.set_form_field_value("first_name", FormFieldValue::Text("Jane".to_string()))?;

// Set a checkbox
editor.set_form_field_value("agree_terms", FormFieldValue::Boolean(true))?;

// Set a choice field
editor.set_form_field_value("country", FormFieldValue::Choice("United States".to_string()))?;

editor.save("filled.pdf")?;

WASM

const doc = new WasmPdfDocument(bytes);

doc.setFormFieldValue("first_name", "Jane");
doc.setFormFieldValue("agree_terms", true);
doc.setFormFieldValue("country", "United States");

writeFileSync("filled.pdf", doc.save());
doc.free();

Python

doc = PdfDocument("form.pdf")

doc.set_form_field_value("first_name", "Jane")
doc.set_form_field_value("agree_terms", True)
doc.set_form_field_value("country", "United States")

doc.save("filled.pdf")

FormFieldValue Variants

Variante	Descripción	Example
Text(String)	Text field value	FormFieldValue::Text("Hello".into())
Boolean(bool)	Checkbox/radio state	FormFieldValue::Boolean(true)
Choice(String)	Single choice selection	FormFieldValue::Choice("Option A".into())
MultiChoice(Vec<String>)	Multiple selections	FormFieldValue::MultiChoice(vec!["A".into(), "B".into()])
None	No value / clear field	FormFieldValue::None

Agregar campos de formulario

Agregar un nuevo campo de formulario

use pdf_oxide::editor::DocumentEditor;
use pdf_oxide::writer::form_fields::TextFieldWidget;

let mut editor = DocumentEditor::open("document.pdf")?;

// Create a text input field on page 0
let widget = TextFieldWidget::new("user_name")
    .with_rect(100.0, 700.0, 200.0, 20.0)
    .with_default_value("Enter name");

editor.add_form_field(widget, 0)?;
editor.save("with-form.pdf")?;

Agregar campos jerárquicos

Crear relaciones padre-hijo de campos para formularios estructurados.

use pdf_oxide::editor::form_fields::ParentFieldConfig;

let mut editor = DocumentEditor::open("document.pdf")?;

// Create a parent field
let parent = ParentFieldConfig::new("address");
editor.add_parent_field(parent)?;

// Add child fields under the parent
let street = TextFieldWidget::new("street")
    .with_rect(100.0, 600.0, 300.0, 20.0);
editor.add_child_field(street, 0, "address")?;

let city = TextFieldWidget::new("city")
    .with_rect(100.0, 570.0, 150.0, 20.0);
editor.add_child_field(city, 0, "address")?;

editor.save("hierarchical-form.pdf")?;

Eliminar un campo de formulario

let mut editor = DocumentEditor::open("form.pdf")?;
editor.remove_form_field("obsolete_field")?;
editor.save("cleaned.pdf")?;

Propiedades de campos de formulario

Configurar propiedades

Configurar propiedades individuales de campos por nombre.

let mut editor = DocumentEditor::open("form.pdf")?;

// Access control
editor.set_form_field_readonly("signature_date", true)?;
editor.set_form_field_required("email", true)?;

// Tooltip
editor.set_form_field_tooltip("phone", "Enter phone number with area code")?;

// Position and size
editor.set_form_field_rect("name", pdf_oxide::geometry::Rect::new(100.0, 700.0, 200.0, 20.0))?;

// Text constraints
editor.set_form_field_max_length("zip_code", 10)?;
editor.set_form_field_alignment("amount", 2)?;  // 0=left, 1=center, 2=right

// Appearance
editor.set_form_field_background_color("highlight_field", [1.0, 1.0, 0.8])?;
editor.set_form_field_border_color("name", [0.0, 0.0, 0.0])?;
editor.set_form_field_border_width("name", 1.0)?;
editor.set_form_field_default_appearance("name", "/Helv 12 Tf 0 g")?;

// Raw flags
editor.set_form_field_flags("options", 0x100000)?;

editor.save("styled-form.pdf")?;

Propiedades de FormFieldWrapper

Al trabajar con objetos FormFieldWrapper retornados por get_form_fields():

Método	Retorna	Descripción
name()	&str	Nombre completo del campo
partial_name()	&str	Nombre parcial (sin prefijo del padre)
value()	FormFieldValue	Valor actual del campo
set_value(value)	()	Establecer el valor del campo
field_type()	Option<&FieldType>	Tipo de campo
page_index()	usize	Página que contiene el campo
bounds()	Option<Rect>	Posición y tamaño del campo
tooltip()	Option<&str>	Texto de tooltip
is_modified()	bool	Si el valor ha sido cambiado
is_new()	bool	Si el campo fue agregado (no del origen)
is_readonly()	bool	Indicador de solo lectura
set_readonly(bool)	()	Establecer solo lectura flag
is_required()	bool	Indicador de requerido
set_required(bool)	()	Establecer como requerido flag
is_no_export()	bool	Indicador de no exportar
set_no_export(bool)	()	Establecer indicador de no exportar
set_tooltip(text)	()	Establecer tooltip text
set_rect(rect)	()	Establecer posición y tamaño
set_max_length(len)	()	Establecer longitud máxima de texto
get_max_length()	Option<u32>	Obtener longitud máxima de texto
set_alignment(align)	()	Establecer alineación de texto
get_alignment()	Option<u32>	Obtener alineación de texto
set_background_color(rgb)	()	Establecer color de fondo
get_background_color()	Option<[f32; 3]>	Obtener color de fondo
set_border_color(rgb)	()	Establecer color de borde
get_border_color()	Option<[f32; 3]>	Obtener color de borde
set_border_width(width)	()	Establecer ancho de borde
get_border_width()	Option<f32>	Obtener ancho de borde
set_default_appearance(da)	()	Establecer apariencia predeterminada string
get_default_appearance()	Option<&str>	Obtener cadena de apariencia predeterminada
set_default_value(value)	()	Establecer valor predeterminado
get_default_value()	Option<&FormFieldValue>	Obtener valor predeterminado
has_parent()	bool	Verificar campo padre
parent_name()	Option<&str>	Nombre del campo padre

Aplanar formularios

El aplanamiento convierte campos de formulario interactivos en contenido de página estático. Los valores de los campos se convierten en parte del dibujo de la página y ya no pueden ser editados.

Aplanar una sola página

Rust

let mut editor = DocumentEditor::open("form.pdf")?;
editor.flatten_forms_on_page(0)?;
editor.save("flat-page0.pdf")?;

WASM

const doc = new WasmPdfDocument(bytes);
doc.flattenFormsOnPage(0);
writeFileSync("flat-page0.pdf", doc.save());
doc.free();

Aplanar todos los formularios

Rust

let mut editor = DocumentEditor::open("form.pdf")?;
editor.flatten_forms()?;
editor.save("flat.pdf")?;

WASM

const doc = new WasmPdfDocument(bytes);
doc.flattenForms();
writeFileSync("flat.pdf", doc.save());
doc.free();

Verificar estado de aplanamiento

editor.flatten_forms_on_page(0)?;
assert!(editor.is_page_marked_for_form_flatten(0));
assert!(editor.will_remove_acroform());

Exportar datos de formulario

Exportar valores de campos de formulario a formato FDF o XFDF para procesamiento externo.

Exportar a FDF

Rust

let mut editor = DocumentEditor::open("filled-form.pdf")?;
editor.export_form_data_fdf("form-data.fdf")?;

WASM

const doc = new WasmPdfDocument(bytes);
const fdfData = doc.exportFormData("fdf");
writeFileSync("form-data.fdf", fdfData);
doc.free();

Python

doc = PdfDocument("filled-form.pdf")
doc.export_form_data("form-data.fdf", format="fdf")

Exportar a XFDF

Rust

let mut editor = DocumentEditor::open("filled-form.pdf")?;
editor.export_form_data_xfdf("form-data.xfdf")?;

WASM

const doc = new WasmPdfDocument(bytes);
const xfdfData = doc.exportFormData("xfdf");
writeFileSync("form-data.xfdf", xfdfData);
doc.free();

Soporte de formularios XFA

PDF Oxide puede detectar, analizar y convertir formularios XFA a AcroForm estándar.

Verificar XFA

Rust

let mut editor = DocumentEditor::open("xfa-form.pdf")?;

if editor.has_xfa()? {
    println!("Document contains XFA form data");
}

WASM

const doc = new WasmPdfDocument(bytes);
if (doc.hasXfa()) {
  console.log("Document contains XFA form data");
}

Python

doc = PdfDocument("xfa-form.pdf")
if doc.has_xfa():
    print("Document contains XFA form data")

Analizar estructura XFA

let mut editor = DocumentEditor::open("xfa-form.pdf")?;

let analysis = editor.analyze_xfa()?;
println!("XFA analysis: {:?}", analysis);

Convertir XFA a AcroForm

Convertir formularios XFA a campos AcroForm estándar para mayor compatibilidad.

let mut editor = DocumentEditor::open("xfa-form.pdf")?;
editor.convert_xfa_to_acroform(&Default::default())?;
editor.save("acroform.pdf")?;

Referencia completa de la API

Operaciones de campos

Método	Retorna	Descripción
get_form_fields()	Result<Vec<FormFieldWrapper>>	Listar todos los campos de formulario
get_form_field_value(name)	Result<FormFieldValue>	Obtener el valor de un campo
has_form_field(name)	Result<bool>	Verificar si el campo existe
set_form_field_value(name, value)	Result<()>	Establecer el valor de un campo
add_form_field(widget, page)	Result<()>	Agregar un nuevo campo
add_parent_field(config)	Result<()>	Agregar un campo padre
add_child_field(widget, page, parent)	Result<()>	Agregar un campo hijo
remove_form_field(name)	Result<()>	Eliminar un campo

Propiedades de campos (por nombre)

Método	Retorna	Descripción
set_form_field_readonly(name, bool)	Result<()>	Establecer solo lectura
set_form_field_required(name, bool)	Result<()>	Establecer como requerido
set_form_field_tooltip(name, text)	Result<()>	Establecer tooltip
set_form_field_rect(name, rect)	Result<()>	Establecer posición/tamaño
set_form_field_max_length(name, len)	Result<()>	Establecer longitud máxima de texto
set_form_field_alignment(name, align)	Result<()>	Establecer alineación de texto
set_form_field_background_color(name, rgb)	Result<()>	Establecer color de fondo
set_form_field_border_color(name, rgb)	Result<()>	Establecer color de borde
set_form_field_border_width(name, width)	Result<()>	Establecer ancho de borde
set_form_field_default_appearance(name, da)	Result<()>	Establecer apariencia predeterminada
set_form_field_flags(name, flags)	Result<()>	Establecer indicadores de campo sin procesar

Aplanamiento

Método	Retorna	Descripción
flatten_forms_on_page(page)	Result<()>	Aplanar formularios en una página
flatten_forms()	Result<()>	Aplanar todos los formularios
is_page_marked_for_form_flatten(page)	bool	Verificar estado de aplanamiento
will_remove_acroform()	bool	Verificar si AcroForm será eliminado

Exportar

Método	Retorna	Descripción
export_form_data_fdf(path)	Result<()>	Exportar a archivo FDF
export_form_data_xfdf(path)	Result<()>	Exportar a archivo XFDF

XFA

Método	Retorna	Descripción
has_xfa()	Result<bool>	Verificar datos de formulario XFA
analyze_xfa()	Result<XfaAnalysis>	Analizar estructura XFA
convert_xfa_to_acroform(options)	Result<()>	Convertir XFA a AcroForm

Ejemplo avanzado: llenado y aplanamiento por lotes

use pdf_oxide::editor::DocumentEditor;
use pdf_oxide::editor::form_fields::FormFieldValue;

let mut editor = DocumentEditor::open("template.pdf")?;

// Fill form fields
editor.set_form_field_value("name", FormFieldValue::Text("John Doe".to_string()))?;
editor.set_form_field_value("date", FormFieldValue::Text("2025-12-01".to_string()))?;
editor.set_form_field_value("approved", FormFieldValue::Boolean(true))?;

// Make the completed form non-editable
editor.flatten_forms()?;

// Export data before saving
editor.export_form_data_xfdf("submission.xfdf")?;

editor.save("completed.pdf")?;

Páginas relacionadas

• Editing Overview – apertura, metadatos y flujo de trabajo de guardado
• Text Editing – modificar contenido de texto directamente
• Annotation Editing – add and manage annotations
• Encryption & Security – restringir edición de formularios con permisos