Skip to content
PDF Oxide

PDF-Bearbeitung — Überblick

PDF Oxide bietet zwei API-Ebenen für die Bearbeitung bestehender PDFs: die High-Level-Klasse Pdf (empfohlen) und den niedrigeren DocumentEditor. Beide ermöglichen es Ihnen, ein PDF zu öffnen, Inhalt und Metadaten zu ändern, Änderungen zu verfolgen und das Ergebnis zu speichern.

Ein PDF zur Bearbeitung öffnen

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("input.pdf")

Der Editor wird beim ersten Zugriff initialisiert. Sie können sofort mit dem Lesen beginnen, und der Editor wird aktiviert, wenn Sie eine ändernde Methode wie set_title() oder page() aufrufen.

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const bytes = new Uint8Array(/* file bytes */);
const doc = new WasmPdfDocument(bytes);

Rust

Verwenden Sie die einheitliche Pdf-API:

use pdf_oxide::api::Pdf;

let mut doc = Pdf::open("input.pdf")?;

Oder verwenden Sie DocumentEditor direkt für niedrigere Kontrolle:

use pdf_oxide::editor::DocumentEditor;

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

Auf Änderungen prüfen

Vor dem Speichern können Sie prüfen, ob Änderungen vorgenommen wurden:

Python

doc = PdfDocument("input.pdf")
print(doc.is_modified)  # False -- noch keine Änderungen

doc.set_title("Updated Title")
print(doc.is_modified)  # True

Rust

let mut doc = Pdf::open("input.pdf")?;
assert!(!doc.is_modified());

doc.editor().unwrap().set_title("Updated Title");
assert!(doc.is_modified());

Speichern

Python

doc = PdfDocument("input.pdf")
doc.set_title("New Title")
doc.save("output.pdf")

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const bytes = new Uint8Array(/* file bytes */);
const doc = new WasmPdfDocument(bytes);
doc.setTitle("New Title");
const output = doc.save();
doc.free();

Rust

let mut doc = Pdf::open("input.pdf")?;
doc.editor().unwrap().set_title("New Title");
doc.save("output.pdf")?;

// Oder unter einem neuen Pfad speichern
doc.save_as("copy.pdf")?;

Die Methode save() führt standardmäßig ein vollständiges Neuschreiben des PDFs durch. Für erweiterte Speicheroptionen (inkrementelle Updates, Verschlüsselung) siehe Verschlüsselung & Sicherheit.

Dokument-Metadaten

Standardmäßige PDF-Metadatenfelder lesen und schreiben: Titel, Autor, Betreff und Schlüsselwörter.

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("input.pdf")

# Metadaten setzen
doc.set_title("Quarterly Report")
doc.set_author("Jane Smith")
doc.set_subject("Q4 2025 Financial Results")
doc.set_keywords("finance, quarterly, 2025")

doc.save("output.pdf")

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const bytes = new Uint8Array(/* file bytes */);
const doc = new WasmPdfDocument(bytes);

// Metadaten setzen
doc.setTitle("Quarterly Report");
doc.setAuthor("Jane Smith");
doc.setSubject("Q4 2025 Financial Results");
doc.setKeywords("finance, quarterly, 2025");

const output = doc.save();
doc.free();

Rust

use pdf_oxide::editor::DocumentEditor;

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

// Metadaten lesen
if let Some(title) = editor.title()? {
    println!("Current title: {}", title);
}
if let Some(author) = editor.author()? {
    println!("Current author: {}", author);
}
if let Some(subject) = editor.subject()? {
    println!("Current subject: {}", subject);
}
if let Some(keywords) = editor.keywords()? {
    println!("Current keywords: {}", keywords);
}

// Metadaten setzen
editor.set_title("Quarterly Report");
editor.set_author("Jane Smith");
editor.set_subject("Q4 2025 Financial Results");
editor.set_keywords("finance, quarterly, 2025");

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

Dokumentinformationen

Quellpfad und Version

use pdf_oxide::editor::DocumentEditor;

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

// Pfad zur Originaldatei
println!("Source: {}", editor.source_path());

// PDF-Version als (Haupt, Neben)
let (major, minor) = editor.version();
println!("PDF-Version: {}.{}", major, minor);

// Seitenanzahl
println!("Pages: {}", editor.current_page_count());

Vollständige API-Referenz

DocumentEditor

Methode Rückgabe Beschreibung
open(path) Result<DocumentEditor> Ein PDF zur Bearbeitung öffnen
is_modified() bool Prüfen, ob Änderungen vorgenommen wurden
source_path() &str Pfad zum Quell-PDF
source() &PdfDocument Schreibgeschützter Zugriff auf das Quelldokument
version() (u8, u8) PDF-Version (Haupt, Neben)
current_page_count() usize Seitenanzahl im Dokument
title() Result<Option<String>> Dokumenttitel abrufen
set_title(title) () Dokumenttitel setzen
author() Result<Option<String>> Dokumentautor abrufen
set_author(author) () Dokumentautor setzen
subject() Result<Option<String>> Dokumentbetreff abrufen
set_subject(subject) () Dokumentbetreff setzen
keywords() Result<Option<String>> Dokumentschlüsselwörter abrufen
set_keywords(keywords) () Dokumentschlüsselwörter setzen
save(path) Result<()> Mit vollständigem Neuschreiben speichern
save_with_options(path, options) Result<()> Mit benutzerdefinierten Optionen speichern

Pdf (Einheitliche API)

Methode Rückgabe Beschreibung
Pdf::open(path) Result<Pdf> Ein PDF zur Bearbeitung öffnen
Pdf::open_editor(path) Result<DocumentEditor> Direkt als DocumentEditor öffnen
is_modified() bool Prüfen, ob Änderungen existieren
save(path) Result<()> Das Dokument speichern
save_as(path) Result<()> Unter neuem Pfad speichern
page(index) Result<PdfPage> Eine Seite zur DOM-Bearbeitung abrufen
save_page(page) Result<()> Eine geänderte Seite zurückspeichern
editor() Option<&mut DocumentEditor> Auf den zugrundeliegenden Editor zugreifen

EditableDocument Trait

Das EditableDocument-Trait definiert den Kernvertrag für die Bearbeitung:

pub trait EditableDocument {
    fn get_info(&mut self) -> Result<DocumentInfo>;
    fn set_info(&mut self, info: DocumentInfo) -> Result<()>;
    fn page_count(&mut self) -> Result<usize>;
    fn get_page_info(&mut self, index: usize) -> Result<PageInfo>;
    fn remove_page(&mut self, index: usize) -> Result<()>;
    fn move_page(&mut self, from: usize, to: usize) -> Result<()>;
    fn duplicate_page(&mut self, index: usize) -> Result<usize>;
    fn save(&mut self, path: impl AsRef<Path>) -> Result<()>;
    fn save_with_options(&mut self, path: impl AsRef<Path>, options: SaveOptions) -> Result<()>;
}

Vollständiger Bearbeitungs-Workflow

Dieses Beispiel zeigt eine vollständige Bearbeitungssitzung: Öffnen, Inspizieren, Metadaten ändern, Inhalt bearbeiten und Speichern.

Python

from pdf_oxide import PdfDocument

# Dokument öffnen
doc = PdfDocument("report.pdf")
print(f"Pages: {doc.page_count()}")

# Metadaten aktualisieren
doc.set_title("Annual Report 2025")
doc.set_author("Finance Team")

# Text auf Seite 0 bearbeiten
page = doc.page(0)
for text in page.find_text_containing("DRAFT"):
    page.set_text(text.id, "FINAL")
doc.save_page(page)

# Speichern
doc.save("report-final.pdf")

Rust

use pdf_oxide::api::Pdf;

let mut doc = Pdf::open("report.pdf")?;
println!("Pages: {}", doc.page_count()?);

// Metadaten aktualisieren
{
    let editor = doc.editor().unwrap();
    editor.set_title("Annual Report 2025");
    editor.set_author("Finance Team");
}

// Text auf Seite 0 bearbeiten
let mut page = doc.page(0)?;
let drafts = page.find_text_containing("DRAFT");
for t in &drafts {
    page.set_text(t.id(), "FINAL")?;
}
doc.save_page(page)?;

// Speichern
doc.save("report-final.pdf")?;

Verwandte Seiten