폼 필드 편집

PDF Oxide는 폼 필드에 대한 포괄적인 지원을 제공합니다. 기존 값 읽기, 프로그래밍 방식의 필드 채우기, 새 필드 추가, 속성 구성, 폼을 정적 콘텐츠로 평탄화, FDF/XFDF 형식으로 폼 데이터 내보내기가 모두 가능합니다. XFA 폼은 분석하여 AcroForm으로 변환할 수 있습니다.

폼 필드 읽기

모든 폼 필드 가져오기

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.fieldType}) = ${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}")

Go

doc, _ := pdfoxide.Open("form.pdf")
defer doc.Close()

fields, _ := doc.FormFields()
for _, f := range fields {
    fmt.Printf("%s (%s) = %s\n", f.Name, f.Type, f.Value)
}

C#

using var doc = PdfDocument.Open("form.pdf");
foreach (var f in doc.GetFormFields())
    Console.WriteLine($"{f.Name} ({f.Type}) = {f.Value}");

Java

try (PdfDocument doc = PdfDocument.open(java.nio.file.Path.of("form.pdf"))) {
    for (fyi.oxide.pdf.form.FormField f : doc.formFields()) {
        System.out.println(f.name() + " (" + f.type() + ") = " + f.value().orElse(""));
    }
}

Kotlin

PdfDocument.open(java.nio.file.Path.of("form.pdf")).use { doc ->
    for (f in doc.formFields()) {
        println("${f.name()} (${f.type()}) = ${f.value().orElse("")}")
    }
}

Scala

Using.resource(PdfDocument.open("form.pdf")) { doc =>
  doc.formFieldsSeq.foreach { f =>
    println(s"${f.name} (${f.`type`}) = ${f.valueOption.getOrElse("")}")
  }
}

Clojure

(with-open [doc (pdf/open "form.pdf")]
  (doseq [f (pdf/form-fields doc)]
    (println (.name f) "(" (.type f) ") =" (.orElse (.value f) ""))))

Ruby

PdfOxide::PdfDocument.open('form.pdf') do |doc|
  doc.form_fields.each do |f|
    puts "#{f[:name]} (#{f[:type]}) = #{f[:value]}"
  end
end

C++

auto doc = pdf_oxide::Document::open("form.pdf");
for (const auto& f : doc.get_form_fields())
    std::cout << f.name << " (" << f.type << ") = " << f.value << "\n";

Swift

let doc = try Document.open("form.pdf")
for f in try doc.formFields() {
    print("\(f.name) (\(f.type)) = \(f.value)")
}

Dart

final doc = PdfDocument.open('form.pdf');
for (final f in doc.getFormFields()) {
  print('${f.name} (${f.type}) = ${f.value}');
}

R

doc <- pdf_open("form.pdf")
for (f in pdf_get_form_fields(doc)) {
  cat(sprintf("%s (%s) = %s\n", f$name, f$type, f$value))
}

Julia

doc = open_document("form.pdf")
for f in get_form_fields(doc)
    println("$(f.name) ($(f.type)) = $(f.value)")
end

Zig

var doc = try pdf_oxide.Document.open("form.pdf");
var fields = try doc.formFields();
defer fields.deinit();
const n = try fields.count();
var i: i32 = 0;
while (i < n) : (i += 1) {
    const name = try fields.getName(a, i);
    defer a.free(name);
    const ftype = try fields.getType(a, i);
    defer a.free(ftype);
    const value = try fields.getValue(a, i);
    defer a.free(value);
    std.debug.print("{s} ({s}) = {s}\n", .{ name, ftype, value });
}

Objective-C

NSError *err = nil;
POXDocument *doc = [POXDocument openPath:@"form.pdf" error:&err];
for (POXFormField *f in [doc formFieldsWithError:&err]) {
    NSLog(@"%@ (%@) = %@", f.name, f.type, f.value);
}

Elixir

{:ok, doc} = PdfOxide.open("form.pdf")
{:ok, fields} = PdfOxide.form_fields(doc)
for f <- fields do
  IO.puts("#{f.name} (#{f.type}) = #{f.value}")
end

특정 필드 값 가져오기

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}")

필드 존재 여부 확인

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

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

폼 필드 값 설정

필드 값 설정하기

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")

Go

editor, _ := pdfoxide.OpenEditor("form.pdf")
defer editor.Close()

_ = editor.SetFormFieldValue("first_name", "Jane")
_ = editor.SetFormFieldValue("agree_terms", "Yes")
_ = editor.SetFormFieldValue("country", "United States")

_ = editor.Save("filled.pdf")

C#

using var editor = DocumentEditor.Open("form.pdf");

editor.SetFormFieldValue("first_name", "Jane");
editor.SetFormFieldValue("agree_terms", "Yes");
editor.SetFormFieldValue("country", "United States");

editor.Save("filled.pdf");

Java

try (DocumentEditor editor = DocumentEditor.open("form.pdf")) {
    editor.setFormField("first_name", "Jane");
    editor.setFormField("agree_terms", true);
    editor.setFormField("country", "United States");
    editor.saveTo(java.nio.file.Path.of("filled.pdf"));
}

Kotlin

DocumentEditor.open("form.pdf").use { editor ->
    editor.setFormField("first_name", "Jane")
    editor.setFormField("agree_terms", true)
    editor.setFormField("country", "United States")
    editor.saveTo(java.nio.file.Path.of("filled.pdf"))
}

Scala

Using.resource(DocumentEditor.open("form.pdf")) { editor =>
  editor.setFormField("first_name", "Jane")
  editor.setFormField("agree_terms", true)
  editor.setFormField("country", "United States")
  editor.saveTo(java.nio.file.Path.of("filled.pdf"))
}

Clojure

(with-open [editor (pdf/editor "form.pdf")]
  (.setFormField editor "first_name" "Jane")
  (.setFormField editor "agree_terms" true)
  (.setFormField editor "country" "United States")
  (.saveTo editor (java.nio.file.Path/of "filled.pdf" (into-array String []))))

Ruby

PdfOxide::DocumentEditor.open('form.pdf') do |editor|
  editor.set_form_field('first_name', 'Jane')
  editor.set_form_field('agree_terms', true)
  editor.set_form_field('country', 'United States')
  editor.save_to('filled.pdf')
end

C++

auto editor = pdf_oxide::DocumentEditor::open("form.pdf");

editor.set_form_field_value("first_name", "Jane");
editor.set_form_field_value("agree_terms", "Yes");
editor.set_form_field_value("country", "United States");

editor.save("filled.pdf");

Swift

let editor = try DocumentEditor.open("form.pdf")

try editor.setFormFieldValue("first_name", "Jane")
try editor.setFormFieldValue("agree_terms", "Yes")
try editor.setFormFieldValue("country", "United States")

try editor.save("filled.pdf")

Dart

final editor = DocumentEditor.open('form.pdf');

editor.setFormFieldValue('first_name', 'Jane');
editor.setFormFieldValue('agree_terms', 'Yes');
editor.setFormFieldValue('country', 'United States');

editor.save('filled.pdf');

R

editor <- pdf_editor_open("form.pdf")

pdf_editor_set_form_field_value(editor, "first_name", "Jane")
pdf_editor_set_form_field_value(editor, "agree_terms", "Yes")
pdf_editor_set_form_field_value(editor, "country", "United States")

pdf_editor_save(editor, "filled.pdf")

Julia

editor = open_editor("form.pdf")

set_form_field_value(editor, "first_name", "Jane")
set_form_field_value(editor, "agree_terms", "Yes")
set_form_field_value(editor, "country", "United States")

save(editor, "filled.pdf")

Zig

var editor = try pdf_oxide.DocumentEditor.openEditor("form.pdf");
defer editor.deinit();

try editor.setFormFieldValue("first_name", "Jane");
try editor.setFormFieldValue("agree_terms", "Yes");
try editor.setFormFieldValue("country", "United States");

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

Objective-C

NSError *err = nil;
POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"form.pdf" error:&err];

[editor setFormField:@"first_name" value:@"Jane" error:&err];
[editor setFormField:@"agree_terms" value:@"Yes" error:&err];
[editor setFormField:@"country" value:@"United States" error:&err];

[editor saveToPath:@"filled.pdf" error:&err];

Elixir

{:ok, editor} = PdfOxide.open_editor("form.pdf")

PdfOxide.set_form_field_value(editor, "first_name", "Jane")
PdfOxide.set_form_field_value(editor, "agree_terms", "Yes")
PdfOxide.set_form_field_value(editor, "country", "United States")

PdfOxide.editor_save(editor, "filled.pdf")

FormFieldValue 변형 목록

변형	설명	예시
Text(String)	텍스트 필드 값	FormFieldValue::Text("Hello".into())
Boolean(bool)	체크박스/라디오 상태	FormFieldValue::Boolean(true)
Choice(String)	단일 선택	FormFieldValue::Choice("Option A".into())
MultiChoice(Vec<String>)	다중 선택	FormFieldValue::MultiChoice(vec!["A".into(), "B".into()])
None	값 없음 / 필드 지우기	FormFieldValue::None

폼 필드 추가

새 폼 필드 추가하기

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")?;

계층형 필드 추가하기

구조화된 폼을 위한 부모-자식 필드 관계를 만듭니다.

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")?;

폼 필드 삭제하기

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

폼 필드 속성

속성 설정하기

이름으로 개별 필드 속성을 구성합니다.

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")?;

FormFieldWrapper 속성

get_form_fields()가 반환하는 FormFieldWrapper 객체를 다룰 때:

메서드	반환값	설명
name()	&str	필드 전체 이름
partial_name()	&str	부분 이름 (부모 접두사 제외)
value()	FormFieldValue	현재 필드 값
set_value(value)	()	필드 값 설정
field_type()	Option<&FieldType>	필드 유형
page_index()	usize	필드가 위치한 페이지
bounds()	Option<Rect>	필드 위치 및 크기
tooltip()	Option<&str>	툴팁 텍스트
is_modified()	bool	값이 변경되었는지 여부
is_new()	bool	새로 추가된 필드인지 여부
is_readonly()	bool	읽기 전용 플래그
set_readonly(bool)	()	읽기 전용 플래그 설정
is_required()	bool	필수 플래그
set_required(bool)	()	필수 플래그 설정
is_no_export()	bool	내보내기 금지 플래그
set_no_export(bool)	()	내보내기 금지 플래그 설정
set_tooltip(text)	()	툴팁 텍스트 설정
set_rect(rect)	()	위치 및 크기 설정
set_max_length(len)	()	최대 텍스트 길이 설정
get_max_length()	Option<u32>	최대 텍스트 길이 가져오기
set_alignment(align)	()	텍스트 정렬 설정
get_alignment()	Option<u32>	텍스트 정렬 가져오기
set_background_color(rgb)	()	배경색 설정
get_background_color()	Option<[f32; 3]>	배경색 가져오기
set_border_color(rgb)	()	테두리 색상 설정
get_border_color()	Option<[f32; 3]>	테두리 색상 가져오기
set_border_width(width)	()	테두리 두께 설정
get_border_width()	Option<f32>	테두리 두께 가져오기
set_default_appearance(da)	()	기본 외관 문자열 설정
get_default_appearance()	Option<&str>	기본 외관 문자열 가져오기
set_default_value(value)	()	기본값 설정
get_default_value()	Option<&FormFieldValue>	기본값 가져오기
has_parent()	bool	부모 필드 존재 여부 확인
parent_name()	Option<&str>	부모 필드 이름

폼 평탄화

평탄화는 대화형 폼 필드를 정적 페이지 콘텐츠로 변환합니다. 필드 값이 페이지 렌더링의 일부가 되며 더 이상 편집할 수 없습니다.

단일 페이지 평탄화

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();

C++

auto editor = pdf_oxide::DocumentEditor::open("form.pdf");
editor.flatten_forms_on_page(0);
editor.save("flat-page0.pdf");

Swift

let editor = try DocumentEditor.open("form.pdf")
try editor.flattenFormsOnPage(0)
try editor.save("flat-page0.pdf")

Dart

final editor = DocumentEditor.open('form.pdf');
editor.flattenFormsOnPage(0);
editor.save('flat-page0.pdf');

R

editor <- pdf_editor_open("form.pdf")
pdf_editor_flatten_forms_on_page(editor, 0)
pdf_editor_save(editor, "flat-page0.pdf")

Julia

editor = open_editor("form.pdf")
flatten_forms_on_page(editor, 0)
save(editor, "flat-page0.pdf")

Zig

var editor = try pdf_oxide.DocumentEditor.openEditor("form.pdf");
defer editor.deinit();
try editor.flattenFormsOnPage(0);
try editor.save("flat-page0.pdf");

Objective-C

NSError *err = nil;
POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"form.pdf" error:&err];
[editor flattenFormsOnPage:0 error:&err];
[editor saveToPath:@"flat-page0.pdf" error:&err];

Elixir

{:ok, editor} = PdfOxide.open_editor("form.pdf")
PdfOxide.flatten_forms_on_page(editor, 0)
PdfOxide.editor_save(editor, "flat-page0.pdf")

모든 폼 평탄화

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();

Go

editor, _ := pdfoxide.OpenEditor("form.pdf")
defer editor.Close()

_ = editor.FlattenForms()
_ = editor.Save("flat.pdf")

C#

using var editor = DocumentEditor.Open("form.pdf");
editor.FlattenForms();
editor.Save("flat.pdf");

C++

auto editor = pdf_oxide::DocumentEditor::open("form.pdf");
editor.flatten_forms();
editor.save("flat.pdf");

Swift

let editor = try DocumentEditor.open("form.pdf")
try editor.flattenForms()
try editor.save("flat.pdf")

Dart

final editor = DocumentEditor.open('form.pdf');
editor.flattenForms();
editor.save('flat.pdf');

R

editor <- pdf_editor_open("form.pdf")
pdf_editor_flatten_forms(editor)
pdf_editor_save(editor, "flat.pdf")

Julia

editor = open_editor("form.pdf")
flatten_forms(editor)
save(editor, "flat.pdf")

Zig

var editor = try pdf_oxide.DocumentEditor.openEditor("form.pdf");
defer editor.deinit();
try editor.flattenForms();
try editor.save("flat.pdf");

Objective-C

NSError *err = nil;
POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"form.pdf" error:&err];
[editor flattenForms:&err];
[editor saveToPath:@"flat.pdf" error:&err];

Elixir

{:ok, editor} = PdfOxide.open_editor("form.pdf")
PdfOxide.flatten_forms(editor)
PdfOxide.editor_save(editor, "flat.pdf")

평탄화 상태 확인

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

폼 데이터 내보내기

외부 처리를 위해 폼 필드 값을 FDF 또는 XFDF 형식으로 내보냅니다.

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")

C++

auto doc = pdf_oxide::Document::open("filled-form.pdf");
auto fdf = doc.export_form_data_to_bytes(0);  // 0 = FDF
std::ofstream("form-data.fdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(fdf.data()), fdf.size());

Swift

let doc = try Document.open("filled-form.pdf")
let fdf = try doc.exportFormData(formatType: 0)  // 0 = FDF
try Data(fdf).write(to: URL(fileURLWithPath: "form-data.fdf"))

Dart

final doc = PdfDocument.open('filled-form.pdf');
final fdf = doc.exportFormDataToBytes(0);  // 0 = FDF
File('form-data.fdf').writeAsBytesSync(fdf);

R

doc <- pdf_open("filled-form.pdf")
fdf <- pdf_export_form_data_to_bytes(doc, 0)  # 0 = FDF
writeBin(fdf, "form-data.fdf")

Julia

doc = open_document("filled-form.pdf")
fdf = export_form_data_to_bytes(doc, 0)  # 0 = FDF
write("form-data.fdf", fdf)

Zig

var doc = try pdf_oxide.Document.open("filled-form.pdf");
const fdf = try doc.exportFormDataToBytes(a, 0);  // 0 = FDF
defer a.free(fdf);
try std.fs.cwd().writeFile(.{ .sub_path = "form-data.fdf", .data = fdf });

Objective-C

NSError *err = nil;
POXDocument *doc = [POXDocument openPath:@"filled-form.pdf" error:&err];
NSData *fdf = [doc exportFormDataToBytes:0 error:&err];  // 0 = FDF
[fdf writeToFile:@"form-data.fdf" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("filled-form.pdf")
{:ok, fdf} = PdfOxide.export_form_data_to_bytes(doc, 0)  # 0 = FDF
File.write!("form-data.fdf", fdf)

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();

C++

auto doc = pdf_oxide::Document::open("filled-form.pdf");
auto xfdf = doc.export_form_data_to_bytes(1);  // 1 = XFDF
std::ofstream("form-data.xfdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(xfdf.data()), xfdf.size());

Swift

let doc = try Document.open("filled-form.pdf")
let xfdf = try doc.exportFormData(formatType: 1)  // 1 = XFDF
try Data(xfdf).write(to: URL(fileURLWithPath: "form-data.xfdf"))

Dart

final doc = PdfDocument.open('filled-form.pdf');
final xfdf = doc.exportFormDataToBytes(1);  // 1 = XFDF
File('form-data.xfdf').writeAsBytesSync(xfdf);

R

doc <- pdf_open("filled-form.pdf")
xfdf <- pdf_export_form_data_to_bytes(doc, 1)  # 1 = XFDF
writeBin(xfdf, "form-data.xfdf")

Julia

doc = open_document("filled-form.pdf")
xfdf = export_form_data_to_bytes(doc, 1)  # 1 = XFDF
write("form-data.xfdf", xfdf)

Zig

var doc = try pdf_oxide.Document.open("filled-form.pdf");
const xfdf = try doc.exportFormDataToBytes(a, 1);  // 1 = XFDF
defer a.free(xfdf);
try std.fs.cwd().writeFile(.{ .sub_path = "form-data.xfdf", .data = xfdf });

Objective-C

NSError *err = nil;
POXDocument *doc = [POXDocument openPath:@"filled-form.pdf" error:&err];
NSData *xfdf = [doc exportFormDataToBytes:1 error:&err];  // 1 = XFDF
[xfdf writeToFile:@"form-data.xfdf" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("filled-form.pdf")
{:ok, xfdf} = PdfOxide.export_form_data_to_bytes(doc, 1)  # 1 = XFDF
File.write!("form-data.xfdf", xfdf)

폼 데이터 가져오기

내보내기의 역방향 작업입니다. FDF 또는 XFDF 파일(또는 원시 FDF/XFDF 바이트)에서 필드 값을 문서로 다시 불러옵니다. 데스크톱 PDF 리더, 다른 라이브러리, 서버 파이프라인 등에서 작성된 데이터를 AcroForm 필드에 적용할 수 있습니다.

FDF 또는 XFDF 폼 데이터를 PDF로 가져오려면?

C ABI에는 전용 가져오기 함수군이 선언되어 있으며, Swift 바인딩은 4개의 진입점을 모두 감쌉니다.

C ABI 심볼	Swift 메서드	데이터 소스
pdf_form_import_from_file	importFormFromFile(_:)	FDF/XFDF 파일 경로
pdf_document_import_form_data	importFormData(_:)	FDF/XFDF 파일 경로
pdf_editor_import_fdf_bytes	importFdfBytes(_:)	메모리 내 FDF 바이트
pdf_editor_import_xfdf_bytes	importXfdfBytes(_:)	메모리 내 XFDF 바이트

정확한 C ABI 시그니처 (include/pdf_oxide_c/pdf_oxide.h 참조):

bool    pdf_form_import_from_file(const void *document, const char *filename, int32_t *error_code);
int32_t pdf_document_import_form_data(const void *document, const char *data_path, int32_t *error_code);
int32_t pdf_editor_import_fdf_bytes(const void *document, const uint8_t *data, uintptr_t data_len, int32_t *error_code);
int32_t pdf_editor_import_xfdf_bytes(const void *document, const uint8_t *data, uintptr_t data_len, int32_t *error_code);

v0.3.69 지원 현황. 이 4개의 가져오기 진입점은 C ABI에 선언되고 Swift 래퍼에서 노출되어 있지만, 내부 구현은 아직 연결되지 않았습니다. v0.3.69에서는 런타임에 각각 Unsupported 상태(오류 코드 8)를 반환합니다. Python, Node.js, Go, WASM 바인딩에서는 전혀 노출되지 않으며, Rust 수준의 FDF/XFDF 읽기 기능도 없습니다(pdf_oxide::fdf 모듈에는 FdfWriter/XfdfWriter 내보내기 측만 포함됩니다). 네이티브 가져오기 경로가 제공될 때까지는 아래의 “파싱 후 채우기” 우회 방법을 사용하세요. 이 방법은 현재 모든 바인딩에서 작동합니다.

Swift (인터페이스는 존재하지만 백엔드 구현 전까지 Unsupported를 던집니다)

import PdfOxide

let editor = try DocumentEditor.open(path: "form.pdf")

// From a file on disk (FDF or XFDF):
try editor.importFormFromFile("submission.fdf")   // -> Bool
try editor.importFormData("submission.xfdf")      // -> Int32 status

// From in-memory bytes:
let fdf = Array("%FDF-1.2\n...".utf8)
try editor.importFdfBytes(fdf)                     // -> Int32 status

let xfdf = Array("<?xml version=\"1.0\"?><xfdf>...</xfdf>".utf8)
try editor.importXfdfBytes(xfdf)                   // -> Int32 status

try editor.save(to: "filled.pdf")

각 메서드는 FFI 상태 코드(또는 importFormFromFile의 경우 Bool)를 반환하며, 오류 코드가 0이 아닐 경우 PdfOxideError를 던집니다. 현재는 필드가 수정되는 대신 Unsupported 오류가 발생합니다.

FDF/XFDF 데이터를 지금 바로 적용하려면 (언어 공통 우회 방법)?

모든 바인딩이 set_form_field_value를 제공하므로, v0.3.69에서 폼 데이터를 가져오는 범용 방법은 FDF/XFDF를 직접 파싱한 후 각 name -> value 쌍을 문서에 쓰는 것입니다. 두 형식 모두 작고 명세가 명확한 텍스트 형식입니다. FDF는 PDF 딕셔너리 구문으로 값을 감싸고, XFDF는 일반 XML입니다.

Python – XFDF 파일 가져오기

# `defusedxml` guards against XXE and billion-laughs attacks when parsing
# untrusted XFDF (the stdlib xml parsers are unsafe by default):
#   pip install defusedxml
import defusedxml.ElementTree as ET
from pdf_oxide import PdfDocument

# XFDF: <xfdf><fields><field name="..."><value>...</value></field></fields></xfdf>
tree = ET.parse("submission.xfdf")
ns = {"x": "http://ns.adobe.com/xfdf/"}

doc = PdfDocument("form.pdf")
for field in tree.findall(".//x:field", ns) or tree.findall(".//field"):
    name = field.get("name")
    value_el = field.find("x:value", ns)
    if value_el is None:
        value_el = field.find("value")
    if name and value_el is not None:
        doc.set_form_field_value(name, value_el.text or "")

doc.save("filled.pdf")

Rust – DocumentEditor를 통해 XFDF 파일 가져오기

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

fn import_xfdf(pdf: &str, xfdf: &str, out: &str) -> Result<(), Box<dyn std::error::Error>> {
    let mut editor = DocumentEditor::open(pdf)?;
    let xml = std::fs::read_to_string(xfdf)?;

    // Minimal extraction of <field name="..."><value>...</value></field> pairs.
    for chunk in xml.split("<field ").skip(1) {
        let name = chunk
            .split("name=\"").nth(1)
            .and_then(|s| s.split('"').next());
        let value = chunk
            .split("<value>").nth(1)
            .and_then(|s| s.split("</value>").next());
        if let (Some(name), Some(value)) = (name, value) {
            editor.set_form_field_value(name, FormFieldValue::Text(value.to_string()))?;
        }
    }

    editor.save(out)?;
    Ok(())
}

Node.js – XFDF 파일 가져오기

const fs = require("fs");
const { PdfDocument } = require("pdf-oxide");

const xfdf = fs.readFileSync("submission.xfdf", "utf8");
const doc = new PdfDocument("form.pdf");

const re = /<field\s+name="([^"]+)"[^>]*>\s*<value>([\s\S]*?)<\/value>/g;
let m;
while ((m = re.exec(xfdf)) !== null) {
  doc.setFormFieldValue(m[1], m[2]);
}

fs.writeFileSync("filled.pdf", doc.save());
doc.close();

FDF도 동일한 방식으로 처리할 수 있습니다. /Fields 배열에서 각 /T (name) /V (value) 항목을 파싱하고 set_form_field_value를 호출하면 됩니다. 네이티브 가져오기 경로가 구현되면 수동 파싱 없이 importFdfBytes / importXfdfBytes / importFormFromFile을 직접 호출할 수 있습니다.

XFA 폼 지원

PDF Oxide는 XFA 폼을 감지하고 분석하며 표준 AcroForm으로 변환할 수 있습니다.

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")

C++

auto doc = pdf_oxide::Document::open("xfa-form.pdf");
if (doc.has_xfa())
    std::cout << "Document contains XFA form data\n";

Swift

let doc = try Document.open("xfa-form.pdf")
if try doc.hasXfa() {
    print("Document contains XFA form data")
}

Dart

final doc = PdfDocument.open('xfa-form.pdf');
if (doc.hasXfa()) {
  print('Document contains XFA form data');
}

R

doc <- pdf_open("xfa-form.pdf")
if (pdf_has_xfa(doc)) {
  cat("Document contains XFA form data\n")
}

Julia

doc = open_document("xfa-form.pdf")
if has_xfa(doc)
    println("Document contains XFA form data")
end

Zig

var doc = try pdf_oxide.Document.open("xfa-form.pdf");
if (doc.hasXfa()) {
    std.debug.print("Document contains XFA form data\n", .{});
}

Objective-C

NSError *err = nil;
POXDocument *doc = [POXDocument openPath:@"xfa-form.pdf" error:&err];
if ([doc hasXfa]) {
    NSLog(@"Document contains XFA form data");
}

Elixir

{:ok, doc} = PdfOxide.open("xfa-form.pdf")
if PdfOxide.has_xfa?(doc) do
  IO.puts("Document contains XFA form data")
end

XFA 구조 분석

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

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

XFA를 AcroForm으로 변환

더 넓은 호환성을 위해 XFA 폼을 표준 AcroForm 필드로 변환합니다.

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

전체 API 참조

필드 작업

메서드	반환값	설명
get_form_fields()	Result<Vec<FormFieldWrapper>>	모든 폼 필드 나열
get_form_field_value(name)	Result<FormFieldValue>	필드 값 가져오기
has_form_field(name)	Result<bool>	필드 존재 여부 확인
set_form_field_value(name, value)	Result<()>	필드 값 설정
add_form_field(widget, page)	Result<()>	새 필드 추가
add_parent_field(config)	Result<()>	부모 필드 추가
add_child_field(widget, page, parent)	Result<()>	자식 필드 추가
remove_form_field(name)	Result<()>	필드 삭제

필드 속성 (이름 기준)

메서드	반환값	설명
set_form_field_readonly(name, bool)	Result<()>	읽기 전용 설정
set_form_field_required(name, bool)	Result<()>	필수 여부 설정
set_form_field_tooltip(name, text)	Result<()>	툴팁 설정
set_form_field_rect(name, rect)	Result<()>	위치 및 크기 설정
set_form_field_max_length(name, len)	Result<()>	최대 텍스트 길이 설정
set_form_field_alignment(name, align)	Result<()>	텍스트 정렬 설정
set_form_field_background_color(name, rgb)	Result<()>	배경색 설정
set_form_field_border_color(name, rgb)	Result<()>	테두리 색상 설정
set_form_field_border_width(name, width)	Result<()>	테두리 두께 설정
set_form_field_default_appearance(name, da)	Result<()>	기본 외관 설정
set_form_field_flags(name, flags)	Result<()>	원시 필드 플래그 설정

평탄화

메서드	반환값	설명
flatten_forms_on_page(page)	Result<()>	한 페이지의 폼 평탄화
flatten_forms()	Result<()>	모든 폼 평탄화
is_page_marked_for_form_flatten(page)	bool	평탄화 상태 확인
will_remove_acroform()	bool	AcroForm 제거 여부 확인

내보내기

메서드	반환값	설명
export_form_data_fdf(path)	Result<()>	FDF 파일로 내보내기
export_form_data_xfdf(path)	Result<()>	XFDF 파일로 내보내기

가져오기 (C ABI + Swift; v0.3.69 런타임에서 Unsupported)

C ABI 심볼	Swift 메서드	반환값	설명
pdf_form_import_from_file	importFormFromFile(_:)	bool / Bool	파일 경로에서 FDF/XFDF 가져오기
pdf_document_import_form_data	importFormData(_:)	int32_t / Int32	파일 경로에서 폼 데이터 가져오기
pdf_editor_import_fdf_bytes	importFdfBytes(_:)	int32_t / Int32	메모리 바이트에서 FDF 가져오기
pdf_editor_import_xfdf_bytes	importXfdfBytes(_:)	int32_t / Int32	메모리 바이트에서 XFDF 가져오기

네이티브 가져오기 백엔드가 구현될 때까지 오류 코드 8(Unsupported)을 반환합니다. 현재는 파싱된 FDF/XFDF 데이터를 적용하려면 set_form_field_value를 사용하세요.

XFA

메서드	반환값	설명
has_xfa()	Result<bool>	XFA 폼 데이터 여부 확인
analyze_xfa()	Result<XfaAnalysis>	XFA 구조 분석
convert_xfa_to_acroform(options)	Result<()>	XFA를 AcroForm으로 변환

심화 예제: 일괄 채우기 및 평탄화

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")?;

자주 묻는 질문

PDF Oxide는 v0.3.69에서 FDF/XFDF 데이터를 PDF로 가져올 수 있나요? 아직 네이티브 단일 호출 가져오기는 지원되지 않습니다. C ABI에 pdf_form_import_from_file, pdf_document_import_form_data, pdf_editor_import_fdf_bytes, pdf_editor_import_xfdf_bytes가 선언되고 Swift 래퍼에서도 노출되어 있지만, 런타임에서 Unsupported 상태(오류 코드 8)를 반환합니다. FDF/XFDF를 파싱하고 각 필드에 set_form_field_value를 호출하세요. 이 방법은 현재 모든 바인딩에서 동작합니다.

어떤 바인딩이 가져오기 메서드를 제공하나요? C ABI와 Swift 래퍼만 가져오기 인터페이스를 노출합니다. Python, Node.js, Go, WASM 바인딩에서는 제공되지 않습니다. 내보내기(export_form_data_fdf / export_form_data_xfdf 및 export_form_data)는 모든 바인딩에서 완전히 구현되어 있습니다.

FDF와 XFDF의 차이는 무엇인가요? FDF는 PDF에서 파생된 이진/텍스트 컨테이너입니다(%FDF-1.2 헤더, /Fields 배열). XFDF는 그 XML 동등물(<xfdf><fields>...)로, 표준 도구로 생성하고 파싱하기가 더 쉽습니다. 두 형식 모두 동일한 필드 이름 -> 값 데이터를 담습니다. PDF Oxide는 두 형식 모두 내보낼 수 있습니다.

일괄 작업에 충분히 빠른가요? 네. PDF Oxide의 추출 코어는 벤치마크 코퍼스에서 평균 0.8ms, 통과율 100%를 기록하므로, 일반적인 폼의 경우 필드 읽기, 값 설정, 재저장이 문서당 1밀리초 미만으로 처리됩니다.

관련 페이지

• 편집 개요 – 문서 열기, 메타데이터 및 저장 흐름
• 텍스트 편집 – 텍스트 콘텐츠 직접 수정
• 주석 편집 – 주석 추가 및 관리
• 암호화 및 보안 – 권한으로 폼 편집 제한