Julia-API-Referenz
PDF Oxide bietet idiomatische Julia-Bindings (PdfOxide.jl), die direkt über ccall auf dem pdf_oxide C-ABI aufsetzen — ohne Shim-Crate. Native Handles werden in mutable Structs mit Finalizern verpackt, C-Strings und Buffer werden nach Julia kopiert und automatisch freigegeben, und jeder nicht erfolgreiche C-ABI-Status wirft einen PdfOxideError. Seitenindizes sind 0-basiert.
using Pkg
Pkg.add("PdfOxide")
Die native libpdf_oxide-cdylib wird zur Laufzeit geladen und über PDF_OXIDE_LIB_PATH → PDF_OXIDE_LIB_DIR → ../target/release → target/release → den System-Loader aufgelöst. Baue sie mit dem Binding-Feature-Set:
cargo build --release --lib --features ocr,rendering,signatures,barcodes,tsa-client,system-fonts
using PdfOxide
pdf = from_markdown("# Hello\n\nbody\n")
doc = open_from_bytes(to_bytes(pdf))
page_count(doc)
extract_text(doc, 0) # 0-based page index
to_markdown_all(doc)
close!(doc)
Für die Rust-API siehe die Rust-API-Referenz. Für die Python-API siehe die Python-API-Referenz. Für Typdetails siehe Typen & Enums.
Die meisten Handle-Typen (PdfDocument, Pdf, DocumentEditor, DocumentBuilder, RenderedImage, Certificate, SignatureInfo, Timestamp, TsaClient, Dss, Validierungsergebnisse, Barcode, OcrEngine, Renderer, ElementList, EmbeddedFont, PageBuilder) besitzen nativen Speicher. Gib sie mit close!(x) frühzeitig frei — der Aufruf ist idempotent und läuft auch bei der Finalisierung.
PdfDocument
Das Lese-Handle zum Öffnen, Extrahieren, Durchsuchen, Rendern, Validieren und Inspizieren eines bestehenden PDFs.
Öffnen
open_document(path::AbstractString; password::Union{Nothing,AbstractString} = nothing) -> PdfDocument
open_from_bytes(data::AbstractVector{UInt8}) -> PdfDocument
open_with_password(path::AbstractString, password::AbstractString) -> PdfDocument
| Funktion |
Beschreibung |
open_document(path; password=nothing) |
Öffnet ein PDF von einem Dateisystempfad (optional passwortgeschützt). |
open_from_bytes(data) |
Öffnet ein PDF aus einem In-Memory-Bytevektor. |
open_with_password(path, password) |
Öffnet ein verschlüsseltes PDF auf der Festplatte mit einem Passwort. |
| Funktion |
Rückgabe |
Beschreibung |
page_count(d) |
Int |
Anzahl der Seiten. |
version(d) |
PdfVersion |
PDF-Version (major/minor). |
is_encrypted(d) |
Bool |
Ob das Dokument verschlüsselt ist. |
has_structure_tree(d) |
Bool |
Ob das Dokument ein Tagged PDF mit Strukturbaum ist. |
has_xfa(d) |
Bool |
Ob das Dokument ein XFA-Formular enthält. |
authenticate(d, password) |
Bool |
Authentifizierung gegen das Passwort eines verschlüsselten Dokuments (ein falsches Passwort liefert false, keinen Fehler). |
Konvertierung des Gesamtdokuments
| Funktion |
Rückgabe |
Beschreibung |
to_markdown_all(d) |
String |
Markdown für das gesamte Dokument. |
to_html_all(d) |
String |
HTML für das gesamte Dokument. |
to_plain_text_all(d) |
String |
Reiner Text für das gesamte Dokument. |
extract_all_text(d) |
String |
Automatische Textextraktion für das gesamte Dokument. |
classify_document(d) |
String |
Klassifiziert das gesamte Dokument; liefert den JSON-String des Klassifikators. |
extract_text(d::PdfDocument, page::Integer) -> String
to_plain_text(d::PdfDocument, page::Integer) -> String
to_markdown(d::PdfDocument, page::Integer) -> String
to_html(d::PdfDocument, page::Integer) -> String
extract_structured_json(d::PdfDocument, page::Integer) -> String
| Funktion |
Beschreibung |
extract_text(d, page) |
Extrahiert reinen Text von einer 0-basierten Seite. |
to_plain_text(d, page) |
Rendert eine Seite zu layoutbewusstem reinem Text. |
to_markdown(d, page) |
Rendert eine Seite zu Markdown. |
to_html(d, page) |
Rendert eine Seite zu HTML. |
extract_structured_json(d, page) |
Extrahiert ein strukturiertes Dokument-JSON-Modell für eine Seite. |
extract_text_auto(d, page) |
Wählt automatisch die beste Textextraktion für eine Seite aus. |
extract_page_auto(d, page, options="{}") |
Automatische Seitenextraktion mit einem JSON-Optionsstring. |
classify_page(d, page) |
Klassifiziert eine Seite; liefert den JSON-String des Klassifikators. |
extract_chars(d::PdfDocument, page::Integer) -> Vector{Char}
extract_words(d::PdfDocument, page::Integer) -> Vector{Word}
extract_text_lines(d::PdfDocument, page::Integer) -> Vector{TextLine}
extract_tables(d::PdfDocument, page::Integer) -> Vector{Table}
embedded_fonts(d::PdfDocument, page::Integer) -> Vector{Font}
embedded_images(d::PdfDocument, page::Integer) -> Vector{Image}
page_annotations(d::PdfDocument, page::Integer) -> Vector{Annotation}
extract_paths(d::PdfDocument, page::Integer) -> Vector{Path}
| Funktion |
Beschreibung |
extract_chars(d, page) |
Extrahiert Glyphen von einer Seite als Vector{Char}. |
extract_words(d, page) |
Extrahiert Wörter von einer Seite als Vector{Word}. |
extract_text_lines(d, page) |
Extrahiert Textzeilen als Vector{TextLine}. |
extract_tables(d, page) |
Extrahiert Tabellen als Vector{Table}. |
embedded_fonts(d, page) |
Eingebettete Schriftarten als Vector{Font}. |
embedded_images(d, page) |
Eingebettete Bilder als Vector{Image}. |
page_annotations(d, page) |
Annotationen als Vector{Annotation}. |
extract_paths(d, page) |
Vektorpfade als Vector{Path}. |
extract_text_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> String
extract_words_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{Word}
extract_lines_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{TextLine}
extract_tables_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{Table}
extract_images_in_rect(d::PdfDocument, page::Integer, x, y, w, h) -> Vector{Image}
Jede dieser Funktionen beschränkt die Extraktion auf das Rechteck (x, y, w, h) in PDF-User-Space-Punkten auf einer 0-basierten Seite.
Suche
search(d::PdfDocument, page::Integer, term::AbstractString, caseSensitive::Bool) -> Vector{SearchResult}
search_all(d::PdfDocument, term::AbstractString, caseSensitive::Bool) -> Vector{SearchResult}
search_results_to_json(d::PdfDocument, term::AbstractString, caseSensitive::Bool) -> String
| Funktion |
Beschreibung |
search(d, page, term, caseSensitive) |
Durchsucht eine einzelne Seite nach term. |
search_all(d, term, caseSensitive) |
Durchsucht das gesamte Dokument nach term. |
search_results_to_json(d, term, caseSensitive) |
Serialisiert die Suchergebnisse des gesamten Dokuments als JSON. |
Seitengeometrie
| Funktion |
Rückgabe |
Beschreibung |
page_get_width(d, page) |
Float64 |
Seitenbreite (PDF-Punkte). |
page_get_height(d, page) |
Float64 |
Seitenhöhe (PDF-Punkte). |
page_get_rotation(d, page) |
Int |
Absolute Rotation (Grad) einer Seite. |
page(d, index) |
PdfPage |
Eine 0-basierte Seitenansicht über das Dokument (siehe PdfPage). |
| Funktion |
Rückgabe |
Beschreibung |
get_outline(d) |
String |
Lesezeichen / Inhaltsverzeichnis (JSON). |
get_page_labels(d) |
String |
Seitenbeschriftungsbereiche (JSON). |
get_xmp_metadata(d) |
String |
XMP-Metadaten (JSON). |
get_source_bytes(d) |
Vector{UInt8} |
Die ursprünglichen Quellbytes des Dokuments. |
plan_split_by_bookmarks(d, options="{}") |
String |
Plant eine Split-nach-Lesezeichen-Operation (JSON). |
Annotationsinspektion
annotations_to_json(d::PdfDocument, page::Integer) -> String
annotation_get_color(d::PdfDocument, page::Integer, index::Integer) -> UInt32
annotation_creation_date(d::PdfDocument, page::Integer, index::Integer) -> String
annotation_modification_date(d::PdfDocument, page::Integer, index::Integer) -> String
| Funktion |
Rückgabe |
Beschreibung |
annotations_to_json(d, page) |
String |
Alle Annotationen einer Seite als JSON. |
annotation_get_color(d, page, index) |
UInt32 |
32-Bit-gepackte RGBA-Farbe einer Annotation. |
annotation_creation_date(d, page, index) |
String |
Erstellungsdatum der Annotation. |
annotation_modification_date(d, page, index) |
String |
Änderungsdatum der Annotation. |
annotation_is_hidden(d, page, index) |
Bool |
Ob die Annotation ausgeblendet ist. |
annotation_is_marked_deleted(d, page, index) |
Bool |
Ob die Annotation als gelöscht markiert ist. |
annotation_is_printable(d, page, index) |
Bool |
Ob die Annotation druckbar ist. |
annotation_is_read_only(d, page, index) |
Bool |
Ob die Annotation schreibgeschützt ist. |
link_annotation_uri(d, page, index) |
String |
URI einer Link-Annotation. |
text_annotation_icon_name(d, page, index) |
String |
Symbolname einer Text-(Sticky-Note-)Annotation. |
highlight_quad_points_count(d, page, index) |
Int |
Anzahl der Quad-Punkte einer Highlight-Annotation. |
highlight_quad_point(d, page, index, quad_index) |
NTuple{8,Float64} |
Das quad_index-te Quad (8 Float-Werte). |
Font- & Element-JSON-Hilfsfunktionen
| Funktion |
Rückgabe |
Beschreibung |
fonts_to_json(d, page) |
String |
Eingebettete Schriftarten einer Seite als JSON. |
font_size(d, page, index) |
Float64 |
Schriftgröße der index-ten eingebetteten Schriftart. |
page_get_elements(d, page) |
ElementList |
Layout-Regionselemente der Seite als ElementList. |
get_form_fields(d::PdfDocument) -> Vector{FormField}
form_field_count(d::PdfDocument) -> Int
export_form_data_to_bytes(d::PdfDocument, format_type::Integer) -> Vector{UInt8}
import_form_data(d::PdfDocument, path::AbstractString) -> Int
form_import_from_file(d::PdfDocument, filename::AbstractString) -> Bool
| Funktion |
Beschreibung |
get_form_fields(d) |
Alle AcroForm-Felder als Vector{FormField}. |
form_field_count(d) |
Bequeme Feldanzahl. |
export_form_data_to_bytes(d, format_type) |
Exportiert Formulardaten (format_type wählt FDF/XFDF). |
import_form_data(d, path) |
Importiert Formulardaten aus einer Datei; liefert den C-Statuscode. |
form_import_from_file(d, filename) |
Importiert Formulardaten; liefert true bei Erfolg. |
OCR
page_needs_ocr(d::PdfDocument, page::Integer) -> Bool
ocr_extract_text(d::PdfDocument, page::Integer, engine::Union{Nothing,OcrEngine} = nothing) -> String
| Funktion |
Beschreibung |
page_needs_ocr(d, page) |
Ob eine Seite gescannt/hybrid ist und OCR benötigt. |
ocr_extract_text(d, page, engine=nothing) |
Extrahiert Text via OCR (nothing fällt auf reine native Extraktion zurück). Siehe OcrEngine. |
Signaturen (auf Dokumentebene)
sign(d::PdfDocument, cert::Certificate; reason::AbstractString = "", location::AbstractString = "") -> Int
get_signature_count(d::PdfDocument) -> Int
get_signature(d::PdfDocument, index::Integer) -> SignatureInfo
verify_all_signatures(d::PdfDocument) -> Int
has_timestamp(d::PdfDocument) -> Int
document_get_dss(d::PdfDocument) -> Union{Dss,Nothing}
| Funktion |
Beschreibung |
sign(d, cert; reason, location) |
Signiert das Dokument mit cert; liefert einen Statuscode. |
get_signature_count(d) |
Anzahl der Signaturen im Dokument. |
get_signature(d, index) |
Die index-te Signatur als SignatureInfo. |
verify_all_signatures(d) |
Verifiziert alle Signaturen; liefert einen Statuscode. |
has_timestamp(d) |
Ob das Dokument einen Zeitstempel auf Dokumentebene trägt. |
document_get_dss(d) |
Liest das /DSS des Dokuments in ein Dss, oder nothing, falls keines vorhanden ist. |
Validierung & Konvertierung
validate_pdf_a(d::PdfDocument, level::Integer) -> PdfAResults
validate_pdf_ua(d::PdfDocument, level::Integer) -> UaResults
validate_pdf_x(d::PdfDocument, level::Integer) -> PdfXResults
document_convert_to_pdf_a(d::PdfDocument, level::Integer) -> Bool
validatePdfA / validatePdfUa / validatePdfX sind camelCase-Aliase der drei Validatoren. Siehe Validierungsergebnisse.
Office-Konvertierung
to_docx(d::PdfDocument) -> Vector{UInt8}
to_pptx(d::PdfDocument) -> Vector{UInt8}
to_xlsx(d::PdfDocument) -> Vector{UInt8}
Konvertiert das PDF zurück in einen DOCX-/PPTX-/XLSX-Byte-Buffer. Das Öffnen von Office-Dateien als PDFs erfolgt mit open_from_docx_bytes / open_from_pptx_bytes / open_from_xlsx_bytes (siehe Office-Eingabe).
Lebenszyklus
| Funktion |
Beschreibung |
close!(d) |
Gibt das native Handle sofort frei (idempotent; läuft auch bei der Finalisierung). |
PdfPage
Eine leichtgewichtige 0-basierte Seitenansicht, zurückgegeben von page(doc, index). Methoden delegieren an das übergeordnete Dokument.
p = page(doc, 0)
text(p) # -> String
markdown(p) # -> String
extract_words(p) # -> Vector{Word}
search(p, "term", false) # -> Vector{SearchResult}
render_page(p) # -> RenderedImage
| Methode |
Rückgabe |
Beschreibung |
text(p) |
String |
Reiner Text der Seite. |
markdown(p) |
String |
Markdown der Seite. |
html(p) |
String |
HTML der Seite. |
plain_text(p) |
String |
Layoutbewusster reiner Text. |
extract_chars(p) |
Vector{Char} |
Glyphen. |
extract_words(p) |
Vector{Word} |
Wörter. |
extract_text_lines(p) |
Vector{TextLine} |
Textzeilen. |
extract_tables(p) |
Vector{Table} |
Tabellen. |
embedded_fonts(p) |
Vector{Font} |
Eingebettete Schriftarten. |
embedded_images(p) |
Vector{Image} |
Eingebettete Bilder. |
page_annotations(p) |
Vector{Annotation} |
Annotationen. |
extract_paths(p) |
Vector{Path} |
Vektorpfade. |
search(p, term, caseSensitive) |
Vector{SearchResult} |
Durchsucht die Seite. |
render_page(p, format=0) |
RenderedImage |
Rendert die Seite (0=PNG). |
render_page_zoom(p, zoom, format=0) |
RenderedImage |
Rendert mit einem Zoomfaktor. |
render_page_thumbnail(p, size, format=0) |
RenderedImage |
Rendert eine Miniaturansicht, die in size px passt. |
Rendering
Rendert PdfDocument-Seiten zu Bildern. format: 0=PNG (Standard), 1=JPEG. Koordinaten sind PDF-User-Space-Punkte.
render_page(d::PdfDocument, pageIndex::Integer, format::Integer = 0) -> RenderedImage
render_page_zoom(d::PdfDocument, pageIndex::Integer, zoom::Real, format::Integer = 0) -> RenderedImage
render_page_thumbnail(d::PdfDocument, pageIndex::Integer, size::Integer, format::Integer = 0) -> RenderedImage
render_page_region(d::PdfDocument, page::Integer, crop_x, crop_y, crop_width, crop_height, format::Integer = 0) -> RenderedImage
render_page_fit(d::PdfDocument, page::Integer, w::Integer, h::Integer, format::Integer = 0) -> RenderedImage
render_page_raw(d::PdfDocument, page::Integer, dpi::Integer) -> Tuple{RenderedImage,Int,Int}
render_page_with_options(d::PdfDocument, page::Integer, dpi, format, bg_r, bg_g, bg_b, bg_a, transparent_background, render_annotations, jpeg_quality) -> RenderedImage
render_page_with_options_ex(d::PdfDocument, page::Integer, dpi, format, bg_r, bg_g, bg_b, bg_a, transparent_background, render_annotations, jpeg_quality, excluded_layers::AbstractVector{<:AbstractString} = String[]) -> RenderedImage
| Funktion |
Beschreibung |
render_page(d, page, format=0) |
Rendert eine Seite (0=PNG). |
render_page_zoom(d, page, zoom, format=0) |
Rendert mit einem Zoomfaktor. |
render_page_thumbnail(d, page, size, format=0) |
Rendert eine Miniaturansicht, die in size px passt. |
render_page_region(d, page, x, y, w, h, format=0) |
Rendert einen rechteckigen Ausschnitt (User-Space-Punkte). |
render_page_fit(d, page, w, h, format=0) |
Rendert passend in w×h px unter Beibehaltung des Seitenverhältnisses. |
render_page_raw(d, page, dpi) |
Rendert in einen rohen, vormultiplizierten RGBA8888-Buffer; liefert (image, width, height). |
render_page_with_options(d, page, dpi, format, bg_r, bg_g, bg_b, bg_a, transparent_background, render_annotations, jpeg_quality) |
Rendert mit der vollständigen RenderOptions-Oberfläche (Hintergrundkanäle 0–1; Flags sind 0/1). |
render_page_with_options_ex(...; excluded_layers) |
Wie oben, plus OCG-Layer-Filterung — unterdrückt die benannten /Name-Layer. |
estimate_render_time(d, page) |
Schätzt die Renderzeit (ms) für eine Seite. |
renderPage / renderPageZoom / renderPageThumbnail sind camelCase-Aliase von render_page / render_page_zoom / render_page_thumbnail.
Renderer
Ein wiederverwendbares Renderer-Handle.
create_renderer(dpi::Integer = 150, format::Integer = 0, quality::Integer = 90, anti_alias::Bool = true) -> Renderer
close!(r::Renderer)
RenderedImage
Das Ergebnis eines Render-Aufrufs. Felder: width::Int, height::Int, data::Vector{UInt8} (kodierte Bytes, oder rohes RGBA bei render_page_raw).
save(img::RenderedImage, path::AbstractString) # write to disk (format inferred)
close!(img::RenderedImage)
DocumentEditor
Das Bearbeitungs-Handle zum Verändern und erneuten Speichern eines bestehenden PDFs.
Öffnen & Quelle
open_editor(path::AbstractString) -> DocumentEditor
open_editor_from_bytes(data::AbstractVector{UInt8}) -> DocumentEditor
| Funktion |
Rückgabe |
Beschreibung |
is_modified(e) |
Bool |
Ob der Editor ungespeicherte Änderungen hat. |
get_source_path(e) |
String |
Quellpfad, von dem der Editor geöffnet wurde. |
page_count(e) |
Int |
Anzahl der Seiten. |
version(e) |
PdfVersion |
PDF-Version. |
| Funktion |
Beschreibung |
get_producer(e) |
Producer aus /Info.Producer. |
set_producer(e, value) |
Setzt /Info.Producer. |
get_creation_date(e) |
Erstellungsdatum aus /Info.CreationDate (roher PDF-Datumsstring). |
set_creation_date(e, date_str) |
Setzt /Info.CreationDate (roher PDF-Datumsstring). |
Speichern
save(e::DocumentEditor, path::AbstractString)
save_to_bytes(e::DocumentEditor) -> Vector{UInt8}
save_to_bytes_with_options(e::DocumentEditor, compress::Bool, garbage_collect::Bool, linearize::Bool) -> Vector{UInt8}
extract_pages_to_bytes(e::DocumentEditor, pages::AbstractVector{<:Integer}) -> Vector{UInt8}
save_encrypted(e::DocumentEditor, path::AbstractString, user_password::AbstractString, owner_password::AbstractString)
save_encrypted_to_bytes(e::DocumentEditor, user_password::AbstractString, owner_password::AbstractString) -> Vector{UInt8}
convert_to_pdf_a(e::DocumentEditor, level::Integer)
| Funktion |
Beschreibung |
save(e, path) |
Speichert das bearbeitete Dokument unter einem Pfad. |
save_to_bytes(e) |
Serialisiert das bearbeitete Dokument zu Bytes. |
save_to_bytes_with_options(e, compress, garbage_collect, linearize) |
Serialisiert mit Optionen für Komprimierung / GC / Linearisierung. |
extract_pages_to_bytes(e, pages) |
Extrahiert eine Teilmenge von Seiten in ein neues In-Memory-PDF. |
save_encrypted(e, path, user_pw, owner_pw) |
Speichert mit AES-256-Verschlüsselung unter einem Pfad. |
save_encrypted_to_bytes(e, user_pw, owner_pw) |
Speichert mit AES-256-Verschlüsselung zu Bytes. |
convert_to_pdf_a(e, level) |
Konvertiert in-place nach PDF/A (level: 0=A1b…7=A3u). |
Zusammenführen & Anhänge
| Funktion |
Beschreibung |
merge_from(e, source_path) |
Führt Seiten aus einem PDF auf der Festplatte zusammen. |
merge_from_bytes(e, data) |
Führt Seiten aus einem In-Memory-PDF-Buffer zusammen. |
embed_file(e, name, data) |
Bettet einen Dateianhang ein (name, data-Bytes). |
Seitenoperationen
rotate_all_pages(e::DocumentEditor, degrees::Integer)
rotate_page_by(e::DocumentEditor, page::Integer, degrees::Integer)
get_page_rotation(e::DocumentEditor, page::Integer) -> Int
set_page_rotation(e::DocumentEditor, page::Integer, degrees::Integer)
delete_page(e::DocumentEditor, page::Integer)
move_page(e::DocumentEditor, from::Integer, to::Integer)
| Funktion |
Beschreibung |
rotate_all_pages(e, degrees) |
Rotiert alle Seiten (relativ). |
rotate_page_by(e, page, degrees) |
Rotiert eine Seite additiv. |
get_page_rotation(e, page) |
Absolute Rotation einer Seite. |
set_page_rotation(e, page, degrees) |
Setzt die absolute Rotation einer Seite. |
delete_page(e, page) |
Löscht eine Seite. |
move_page(e, from, to) |
Verschiebt eine Seite von einem Index zu einem anderen. |
Seitenboxen & Zuschneiden
get_page_media_box(e::DocumentEditor, page::Integer) -> NTuple{4,Float64}
get_page_crop_box(e::DocumentEditor, page::Integer) -> NTuple{4,Float64}
set_page_media_box(e::DocumentEditor, page::Integer, x, y, w, h)
set_page_crop_box(e::DocumentEditor, page::Integer, x, y, w, h)
crop_margins(e::DocumentEditor, left::Real, right::Real, top::Real, bottom::Real)
| Funktion |
Beschreibung |
get_page_media_box(e, page) |
Liest die MediaBox einer Seite. |
get_page_crop_box(e, page) |
Liest die CropBox einer Seite. |
set_page_media_box(e, page, x, y, w, h) |
Setzt die MediaBox einer Seite. |
set_page_crop_box(e, page, x, y, w, h) |
Setzt die CropBox einer Seite. |
crop_margins(e, left, right, top, bottom) |
Schneidet alle Seiten anhand von Rändern zu (User-Space). |
Löschen / Whiteout
erase_region(e::DocumentEditor, page::Integer, x, y, w, h)
erase_regions(e::DocumentEditor, page::Integer, rects::AbstractVector{<:NTuple{4,<:Real}})
clear_erase_regions(e::DocumentEditor, page::Integer)
| Funktion |
Beschreibung |
erase_region(e, page, x, y, w, h) |
Löscht einen rechteckigen Bereich. |
erase_regions(e, page, rects) |
Löscht mehrere Bereiche (rects ist ein Vektor von (x, y, w, h)-Tupeln). |
clear_erase_regions(e, page) |
Löscht alle ausstehenden Erase-Bereichseinträge einer Seite. |
Entfernen von Kopf-/Fußzeilen / Artefakten
erase_header(d::PdfDocument, page::Integer)
erase_footer(d::PdfDocument, page::Integer)
erase_artifacts(d::PdfDocument, page::Integer)
remove_headers(d::PdfDocument, threshold::Real = 0.5)
remove_footers(d::PdfDocument, threshold::Real = 0.5)
remove_artifacts(d::PdfDocument, threshold::Real = 0.5)
| Funktion |
Beschreibung |
erase_header(d, page) / erase_footer(d, page) / erase_artifacts(d, page) |
Löscht die erkannte Kopfzeile / Fußzeile / Artefakte einer Seite. |
remove_headers(d, threshold=0.5) / remove_footers(...) / remove_artifacts(...) |
Entfernt sich wiederholende Kopfzeilen / Fußzeilen / Artefakte im gesamten Dokument oberhalb eines Häufigkeitsschwellwerts. |
Annotationen reduzieren (Flatten)
flatten_annotations(e::DocumentEditor, page::Integer)
flatten_all_annotations(e::DocumentEditor)
is_page_marked_for_flatten(e::DocumentEditor, page::Integer) -> Bool
unmark_page_for_flatten(e::DocumentEditor, page::Integer)
Schwärzung (Redaction)
apply_page_redactions(e::DocumentEditor, page::Integer)
apply_all_redactions(e::DocumentEditor)
is_page_marked_for_redaction(e::DocumentEditor, page::Integer) -> Bool
unmark_page_for_redaction(e::DocumentEditor, page::Integer)
redaction_add(e::DocumentEditor, page::Integer, x1, y1, x2, y2, r, g, b)
redaction_count(e::DocumentEditor, page::Integer) -> Int
redaction_apply(e::DocumentEditor, scrub_metadata::Bool, r::Real, g::Real, b::Real) -> Int
redaction_scrub_metadata(e::DocumentEditor) -> Int
| Funktion |
Beschreibung |
apply_page_redactions(e, page) |
Wendet (brennt) Schwärzungen auf einer Seite an. |
apply_all_redactions(e) |
Wendet alle ausstehenden Schwärzungen an. |
is_page_marked_for_redaction(e, page) |
Ob eine Seite für die Schwärzung markiert ist. |
unmark_page_for_redaction(e, page) |
Entfernt die Schwärzungsmarkierung einer Seite. |
redaction_add(e, page, x1, y1, x2, y2, r, g, b) |
Stellt eine Schwärzungsbox mit Overlay-Farbe ein (DeviceRGB, 0–1). |
redaction_count(e, page) |
Anzahl der vorgemerkten Schwärzungsbereiche einer Seite. |
redaction_apply(e, scrub_metadata, r, g, b) |
Wendet alle vorgemerkten Schwärzungen destruktiv an; liefert die Anzahl der entfernten Glyphen. |
redaction_scrub_metadata(e) |
Entfernt Info/XMP/JavaScript/EmbeddedFiles; liefert die Anzahl der entfernten Einträge. |
set_form_field_value(e::DocumentEditor, name::AbstractString, value::AbstractString)
flatten_forms(e::DocumentEditor)
flatten_forms_on_page(e::DocumentEditor, page::Integer)
flatten_warnings_count(e::DocumentEditor) -> Int
flatten_warning(e::DocumentEditor, index::Integer) -> String
import_fdf_bytes(e::DocumentEditor, data::AbstractVector{UInt8})
import_xfdf_bytes(e::DocumentEditor, data::AbstractVector{UInt8})
| Funktion |
Beschreibung |
set_form_field_value(e, name, value) |
Setzt einen Formularfeldwert (UTF-8). |
flatten_forms(e) |
Reduziert alle Formulare (backt Werte in den Seiteninhalt ein). |
flatten_forms_on_page(e, page) |
Reduziert Formulare auf einer einzelnen Seite. |
flatten_warnings_count(e) |
Anzahl der Warnungen aus dem letzten Formular-Flatten-Speichervorgang. |
flatten_warning(e, index) |
Der index-te Flatten-Warnungsstring. |
import_fdf_bytes(e, data) |
Importiert FDF-Formulardaten aus Bytes. |
import_xfdf_bytes(e, data) |
Importiert XFDF-Formulardaten aus Bytes. |
Barcode-Stempelung
add_barcode_to_page(e::DocumentEditor, page::Integer, b::Barcode, x, y, width, height)
Stempelt einen Barcode auf eine Seite an das Rechteck (x, y, width, height). Siehe Barcodes.
Lebenszyklus
close!(e::DocumentEditor) gibt das Handle frei.
Pdf
Das leichtgewichtige Erstellungs-Handle, das von den from_*-Factories zurückgegeben wird.
Factories
from_markdown(input::AbstractString) -> Pdf
from_html(input::AbstractString) -> Pdf
from_text(input::AbstractString) -> Pdf
from_image(path::AbstractString) -> Pdf
from_image_bytes(data::AbstractVector{UInt8}) -> Pdf
from_html_css(html::AbstractString, css::AbstractString, font_bytes::Union{Nothing,AbstractVector{UInt8}} = nothing) -> Pdf
from_html_css_with_fonts(html::AbstractString, css::AbstractString, families::AbstractVector{<:AbstractString}, fonts::AbstractVector{<:AbstractVector{UInt8}}) -> Pdf
| Funktion |
Beschreibung |
from_markdown(input) |
Baut ein Pdf aus Markdown. |
from_html(input) |
Baut ein Pdf aus HTML. |
from_text(input) |
Baut ein Pdf aus reinem Text. |
from_image(path) |
Baut ein Pdf aus einer Bilddatei. |
from_image_bytes(data) |
Baut ein Pdf aus In-Memory-Bildbytes. |
from_html_css(html, css, font_bytes=nothing) |
Baut aus HTML + CSS mit einer optional eingebetteten Schriftart. |
from_html_css_with_fonts(html, css, families, fonts) |
Baut aus HTML + CSS mit einer Multi-Font-Kaskade (families[i] benennt fonts[i]). |
Methoden
| Funktion |
Rückgabe |
Beschreibung |
save(p, path) |
— |
Schreibt das erstellte PDF unter einen Pfad. |
to_bytes(p) |
Vector{UInt8} |
Serialisiert das erstellte PDF zu Bytes. |
get_page_count(p) |
Int |
Seitenanzahl eines Builder-Pdf. |
close!(p) |
— |
Gibt das Handle frei. |
merge_pdfs
merge_pdfs(paths::AbstractVector{<:AbstractString}) -> Vector{UInt8}
Führt die PDFs unter paths (in dieser Reihenfolge) zu einem einzigen PDF-Byte-Buffer zusammen.
Office-Eingabe
open_from_docx_bytes(data::AbstractVector{UInt8}) -> Pdf
open_from_pptx_bytes(data::AbstractVector{UInt8}) -> Pdf
open_from_xlsx_bytes(data::AbstractVector{UInt8}) -> Pdf
Konvertiert DOCX-/PPTX-/XLSX-Bytes in ein Pdf.
DocumentBuilder
Ein fließender, strukturbewusster PDF-Builder. Erstelle Seiten mit a4_page / letter_page / page, gestalte den Inhalt auf dem zurückgegebenen PageBuilder, rufe done auf, um jede Seite zu übernehmen, und anschließend build / save / verschlüsselte Varianten.
DocumentBuilder() -> DocumentBuilder
Konfiguration auf Dokumentebene
set_title(b::DocumentBuilder, value::AbstractString)
set_author(b::DocumentBuilder, value::AbstractString)
set_subject(b::DocumentBuilder, value::AbstractString)
set_keywords(b::DocumentBuilder, value::AbstractString)
set_creator(b::DocumentBuilder, value::AbstractString)
on_open(b::DocumentBuilder, value::AbstractString)
language(b::DocumentBuilder, value::AbstractString)
tagged_pdf_ua1(b::DocumentBuilder)
role_map(b::DocumentBuilder, custom::AbstractString, standard::AbstractString)
register_embedded_font(b::DocumentBuilder, name::AbstractString, f::EmbeddedFont)
| Funktion |
Beschreibung |
set_title / set_author / set_subject / set_keywords / set_creator |
Setzt das entsprechende /Info-Metadatenfeld. |
on_open(b, value) |
Setzt eine Dokument-öffnen-JavaScript-Aktion. |
language(b, value) |
Setzt die Dokumentsprache (z. B. "en-US"). |
tagged_pdf_ua1(b) |
Aktiviert den PDF/UA-1-Tagged-PDF-Modus. |
role_map(b, custom, standard) |
Bildet einen benutzerdefinierten Strukturtyp auf einen Standardtyp ab. |
register_embedded_font(b, name, f) |
Registriert eine geladene EmbeddedFont unter name (verbraucht die Schriftart). |
Seiten
a4_page(b::DocumentBuilder) -> PageBuilder
letter_page(b::DocumentBuilder) -> PageBuilder
page(b::DocumentBuilder, width::Real, height::Real) -> PageBuilder
Ausgabe
build(b::DocumentBuilder) -> Vector{UInt8}
save(b::DocumentBuilder, path::AbstractString)
save_encrypted_builder(b::DocumentBuilder, path::AbstractString, user_password::AbstractString, owner_password::AbstractString)
to_bytes_encrypted(b::DocumentBuilder, user_password::AbstractString, owner_password::AbstractString) -> Vector{UInt8}
| Funktion |
Beschreibung |
build(b) |
Baut das PDF und liefert die Bytes zurück (der Builder muss weiterhin geschlossen werden). |
save(b, path) |
Baut und speichert unter einem Pfad. |
save_encrypted_builder(b, path, user_pw, owner_pw) |
Baut und speichert mit AES-256-Verschlüsselung. |
to_bytes_encrypted(b, user_pw, owner_pw) |
Baut verschlüsselte Bytes (AES-256). |
EmbeddedFont
embedded_font_from_file(path::AbstractString) -> EmbeddedFont
embedded_font_from_bytes(data::AbstractVector{UInt8}; name::Union{Nothing,AbstractString} = nothing) -> EmbeddedFont
| Funktion |
Beschreibung |
embedded_font_from_file(path) |
Lädt eine TTF/OTF-Schriftart von einem Pfad. |
embedded_font_from_bytes(data; name) |
Lädt eine Schriftart aus Bytes (name kann leer sein, um den PostScript-Namen zu verwenden). |
PageBuilder
Zurückgegeben von a4_page / letter_page / page. Alle Methoden verändern die Seite in-place; rufe done(p) auf, um sie beim übergeordneten Builder zu übernehmen (dies verbraucht das Seiten-Handle).
Text & Layout
font(p::PageBuilder, name::AbstractString, size::Real)
at(p::PageBuilder, x::Real, y::Real)
heading(p::PageBuilder, level::Integer, text::AbstractString)
| Methode |
Beschreibung |
font(p, name, size) |
Setzt die Schriftart + Größe für nachfolgenden Text. |
at(p, x, y) |
Bewegt den Cursor zur absoluten Position (x, y) (Punkte, von unten links). |
heading(p, level, text) |
Gibt eine Überschrift auf level (1–6) aus. |
Die folgenden stringwertigen Methoden teilen sich alle die Signatur f(p::PageBuilder, value::AbstractString):
| Methode |
Beschreibung |
text(p, value) |
Gibt einen Fließtext-Lauf aus. |
paragraph(p, value) |
Gibt einen umbrochenen Absatz aus. |
link_url(p, value) |
Macht den vorherigen Text zu einem URL-Link. |
link_named(p, value) |
Verlinkt den vorherigen Text auf ein benanntes Ziel. |
link_javascript(p, value) |
Hängt eine JavaScript-Aktion an den vorherigen Text. |
on_open(p, value) |
Setzt eine Seite-öffnen-JavaScript-Aktion. |
on_close(p, value) |
Setzt eine Seite-schließen-JavaScript-Aktion. |
field_keystroke(p, value) / field_format(p, value) / field_validate(p, value) / field_calculate(p, value) |
Hängt AcroForm-Feld-JavaScript-Aktionen an. |
sticky_note(p, value) |
Hängt eine Sticky-Note an den vorherigen Inhalt an. |
watermark(p, value) |
Fügt ein Text-Wasserzeichen hinzu. |
stamp(p, value) |
Fügt eine Stempel-Annotation hinzu. |
inline(p, value) |
Hängt einen Inline-Textlauf an. |
inline_bold(p, value) |
Hängt einen fettgedruckten Inline-Lauf an. |
inline_italic(p, value) |
Hängt einen kursiven Inline-Lauf an. |
Null-Argument-Layout-Methoden, alle f(p::PageBuilder):
| Methode |
Beschreibung |
horizontal_rule(p) |
Zeichnet eine horizontale Trennlinie. |
space(p) |
Fügt vertikalen Abstand ein. |
newline(p) |
Bricht zu einer neuen Zeile um. |
new_page_same_size(p) |
Beginnt eine neue Seite mit denselben Abmessungen. |
watermark_confidential(p) |
Fügt ein „CONFIDENTIAL“-Wasserzeichen hinzu. |
watermark_draft(p) |
Fügt ein „DRAFT“-Wasserzeichen hinzu. |
link_page(p::PageBuilder, page_index::Integer)
sticky_note_at(p::PageBuilder, x::Real, y::Real, text::AbstractString)
freetext(p::PageBuilder, x::Real, y::Real, w::Real, h::Real, text::AbstractString)
footnote(p::PageBuilder, ref_mark::AbstractString, note_text::AbstractString)
columns(p::PageBuilder, column_count::Integer, gap_pt::Real, text::AbstractString)
inline_color(p::PageBuilder, r::Real, g::Real, b_::Real, text::AbstractString)
| Methode |
Beschreibung |
link_page(p, page_index) |
Verlinkt den vorherigen Text auf einen internen Seitenindex. |
sticky_note_at(p, x, y, text) |
Platziert eine freistehende Sticky-Note. |
freetext(p, x, y, w, h, text) |
Platziert eine frei fließende Text-Annotation in einem Rechteck. |
footnote(p, ref_mark, note_text) |
Fügt eine Fußnote hinzu (Inline-Hochstellung + Text am Seitenende). |
columns(p, column_count, gap_pt, text) |
Gestaltet Text über ausgewogene Spalten. |
inline_color(p, r, g, b_, text) |
Hängt einen RGB-farbigen Inline-Lauf an (Kanäle 0–1). |
Markup-Annotationen
Alle vier teilen sich f(p::PageBuilder, r::Real, g::Real, b_::Real) und wirken auf den vorherigen Text mit einer RGB-Farbe:
| Methode |
Beschreibung |
highlight(p, r, g, b) |
Hebt den vorherigen Text hervor. |
underline(p, r, g, b) |
Unterstreicht den vorherigen Text. |
strikeout(p, r, g, b) |
Streicht den vorherigen Text durch. |
squiggly(p, r, g, b) |
Wellenunterstreicht den vorherigen Text. |
text_field(p::PageBuilder, name, x, y, w, h; default_value::Union{Nothing,AbstractString} = nothing)
checkbox(p::PageBuilder, name, x, y, w, h, checked::Bool)
combo_box(p::PageBuilder, name, x, y, w, h, options::AbstractVector{<:AbstractString}; selected::Union{Nothing,AbstractString} = nothing)
radio_group(p::PageBuilder, name, values, xs, ys, ws, hs; selected::Union{Nothing,AbstractString} = nothing)
push_button(p::PageBuilder, name, x, y, w, h, caption::AbstractString)
signature_field(p::PageBuilder, name, x, y, w, h)
| Methode |
Beschreibung |
text_field(p, name, x, y, w, h; default_value) |
Fügt ein einzeiliges Textfeld hinzu. |
checkbox(p, name, x, y, w, h, checked) |
Fügt eine Checkbox mit einem anfänglich angehakten Zustand hinzu. |
combo_box(p, name, x, y, w, h, options; selected) |
Fügt eine Dropdown-Combobox hinzu. |
radio_group(p, name, values, xs, ys, ws, hs; selected) |
Fügt eine Radiogruppe hinzu (parallele Arrays beschreiben jeden Button). |
push_button(p, name, x, y, w, h, caption) |
Fügt einen klickbaren Push-Button hinzu. |
signature_field(p, name, x, y, w, h) |
Fügt einen unsignierten Signatur-Platzhalter hinzu. |
Bilder & Barcodes
image(p::PageBuilder, bytes::AbstractVector{UInt8}, x, y, w, h)
image_with_alt(p::PageBuilder, bytes::AbstractVector{UInt8}, x, y, w, h, alt_text::AbstractString)
image_artifact(p::PageBuilder, bytes::AbstractVector{UInt8}, x, y, w, h)
barcode_1d(p::PageBuilder, barcode_type::Integer, data::AbstractString, x, y, w, h)
barcode_qr(p::PageBuilder, data::AbstractString, x, y, size::Real)
| Methode |
Beschreibung |
image(p, bytes, x, y, w, h) |
Bettet ein Bild ein (rohes JPEG/PNG/WebP). |
image_with_alt(p, bytes, x, y, w, h, alt_text) |
Bettet ein Bild mit Alt-Text für Barrierefreiheit ein. |
image_artifact(p, bytes, x, y, w, h) |
Bettet ein dekoratives Bild als /Artifact ein. |
barcode_1d(p, barcode_type, data, x, y, w, h) |
Platziert einen 1D-Barcode (barcode_type: 0=Code128…7=Codabar). |
barcode_qr(p, data, x, y, size) |
Platziert einen quadratischen QR-Code. |
Vektorgrafik
rect(p::PageBuilder, x, y, w, h)
filled_rect(p::PageBuilder, x, y, w, h, r, g, b_)
line(p::PageBuilder, x1, y1, x2, y2)
stroke_rect(p::PageBuilder, x, y, w, h, width, r, g, b_)
stroke_line(p::PageBuilder, x1, y1, x2, y2, width, r, g, b_)
stroke_rect_dashed(p::PageBuilder, x, y, w, h, width, r, g, b_, dash_array::AbstractVector{<:Real}, phase::Real)
stroke_line_dashed(p::PageBuilder, x1, y1, x2, y2, width, r, g, b_, dash_array::AbstractVector{<:Real}, phase::Real)
text_in_rect(p::PageBuilder, x, y, w, h, text::AbstractString, align::Integer)
| Methode |
Beschreibung |
rect(p, x, y, w, h) |
Konturiertes 1-Pt-schwarzes Rechteck. |
filled_rect(p, x, y, w, h, r, g, b) |
Gefülltes Rechteck in RGB (0–1). |
line(p, x1, y1, x2, y2) |
1-Pt-schwarze Linie. |
stroke_rect(p, x, y, w, h, width, r, g, b) |
Konturiertes Rechteck, widthpt RGB. |
stroke_line(p, x1, y1, x2, y2, width, r, g, b) |
Konturierte Linie, widthpt RGB. |
stroke_rect_dashed(...) |
Gestricheltes konturiertes Rechteck (dash_array Ein/Aus-Längen, phase-Versatz). |
stroke_line_dashed(...) |
Gestrichelte konturierte Linie. |
text_in_rect(p, x, y, w, h, text, align) |
Zeichnet Text innerhalb eines Rechtecks (align: 0=Links, 1=Zentriert, 2=Rechts). |
Tabellen
table(p::PageBuilder, n_columns::Integer, widths::AbstractVector{<:Real}, aligns::AbstractVector{<:Integer}, n_rows::Integer, cell_strings::AbstractMatrix{<:AbstractString}, has_header::Bool)
streaming_table_begin(p::PageBuilder, headers::AbstractVector{<:AbstractString}, widths::AbstractVector{<:Real}, aligns::AbstractVector{<:Integer}, repeat_header::Bool)
streaming_table_begin_v2(p::PageBuilder, headers, widths, aligns, repeat_header::Bool, mode::Integer, sample_rows::Integer, min_col_width_pt::Real, max_col_width_pt::Real, max_rowspan::Integer)
streaming_table_set_batch_size(p::PageBuilder, batch_size::Integer)
streaming_table_pending_row_count(p::PageBuilder) -> Int
streaming_table_batch_count(p::PageBuilder) -> Int
streaming_table_push_row(p::PageBuilder, cells::AbstractVector{<:AbstractString})
streaming_table_push_row_v2(p::PageBuilder, cells::AbstractVector{<:AbstractString}, rowspans::AbstractVector{<:Integer})
streaming_table_flush(p::PageBuilder)
streaming_table_finish(p::PageBuilder)
| Methode |
Beschreibung |
table(p, n_columns, widths, aligns, n_rows, cell_strings, has_header) |
Gibt eine gepufferte Tabelle aus (aligns: 0=Links/1=Zentriert/2=Rechts; cell_strings ist zeilenweise n_rows × n_columns). |
streaming_table_begin(p, headers, widths, aligns, repeat_header) |
Öffnet eine Streaming-Tabelle (parallele Arrays der Länge n_columns). |
streaming_table_begin_v2(...) |
Öffnet eine Streaming-Tabelle mit Breiten-mode (0=Fixed, 1=Sample, 2=AutoAll) und max_rowspan. |
streaming_table_set_batch_size(p, batch_size) |
Setzt die Batch-Größe (0 → 256). |
streaming_table_pending_row_count(p) |
Seit der letzten Batch-Grenze hinzugefügte Zeilen. |
streaming_table_batch_count(p) |
Anzahl der bisher vollständigen Batches. |
streaming_table_push_row(p, cells) |
Fügt eine Zeile hinzu (rowspan=1). |
streaming_table_push_row_v2(p, cells, rowspans) |
Fügt eine Zeile mit Rowspans pro Zelle hinzu (≥2 Spans). |
streaming_table_flush(p) |
Leert den aktuellen Batch. |
streaming_table_finish(p) |
Beendet die Streaming-Tabelle. |
Übernahme
done(p::PageBuilder) # commit this page's buffered operations to its parent builder (consumes the handle)
Wert-Typen
Immutable Structs, die von der Extraktion zurückgegeben werden. Bbox hat die Felder x, y, width, height (PDF-User-Space-Einheiten).
| Typ |
Felder |
Bbox |
x, y, width, height (Float64) |
Char |
character::UInt32, bbox::Bbox, font_name::String, font_size::Float64 |
Word |
text, bbox, font_name, font_size, bold |
TextLine |
text, bbox, word_count |
Table |
row_count, col_count, has_header, cells (verwende cell(t, row, col) für eine 0-basierte Zelle) |
Font |
name, type, encoding, embedded, subset |
Image |
width, height, bitsPerComponent, format, colorspace, data |
Annotation |
type, subtype, content, author, rect::Bbox, borderWidth |
Path |
bbox::Bbox, strokeWidth, hasStroke, hasFill, operationCount |
SearchResult |
text, page, bbox::Bbox |
FormField |
name, value, type, readonly, required |
PdfVersion |
major::Int, minor::Int |
cell(t::Table, row::Integer, col::Integer) -> String
form_field_name(f::FormField) -> String
form_field_value(f::FormField) -> String
form_field_type(f::FormField) -> String
form_field_is_readonly(f::FormField) -> Bool
form_field_is_required(f::FormField) -> Bool
ElementList
element_count(l::ElementList) -> Int
element_type(l::ElementList, index::Integer) -> String
element_text(l::ElementList, index::Integer) -> String
element_rect(l::ElementList, index::Integer) -> Bbox
elements_to_json(l::ElementList) -> String
close!(l::ElementList)
Digitale Signaturen
Certificate
certificate_load_from_bytes(data::AbstractVector{UInt8}, password::AbstractString = "") -> Certificate
certificate_load_from_pem(cert_pem::AbstractString, key_pem::AbstractString) -> Certificate
certificate_get_subject(c::Certificate) -> String
certificate_get_issuer(c::Certificate) -> String
certificate_get_serial(c::Certificate) -> String
certificate_get_validity(c::Certificate) -> Tuple{Int,Int}
certificate_is_valid(c::Certificate) -> Bool
| Funktion |
Beschreibung |
certificate_load_from_bytes(data, password="") |
Lädt Signaturberechtigungen aus PKCS#12-/PFX-Bytes. |
certificate_load_from_pem(cert_pem, key_pem) |
Lädt aus PEM-kodiertem Zertifikat + privatem Schlüssel. |
certificate_get_subject(c) / certificate_get_issuer(c) / certificate_get_serial(c) |
Subjekt-/Aussteller-/Seriennummer-Strings. |
certificate_get_validity(c) |
Gültigkeitsfenster als (not_before, not_after) in Unix-Epoch-Sekunden. |
certificate_is_valid(c) |
Ob das Zertifikat derzeit gültig ist. |
Signieren
sign_bytes(pdf::AbstractVector{UInt8}, cert::Certificate, reason::AbstractString, location::AbstractString) -> Vector{UInt8}
sign_bytes_pades(pdf::AbstractVector{UInt8}, cert::Certificate, level::Integer, tsa_url::Union{Nothing,AbstractString}, reason::AbstractString, location::AbstractString; certs = Vector{UInt8}[], crls = Vector{UInt8}[], ocsps = Vector{UInt8}[]) -> Vector{UInt8}
sign_bytes_pades_opts(pdf::AbstractVector{UInt8}, cert::Certificate, level::Integer, tsa_url, reason, location; certs = Vector{UInt8}[], crls = Vector{UInt8}[], ocsps = Vector{UInt8}[]) -> Vector{UInt8}
add_timestamp(pdf_data::AbstractVector{UInt8}, sig_index::Integer, tsa_url::AbstractString) -> Vector{UInt8}
| Funktion |
Beschreibung |
sign_bytes(pdf, cert, reason, location) |
Signiert rohe PDF-Bytes; liefert das signierte PDF. |
sign_bytes_pades(pdf, cert, level, tsa_url, reason, location; certs, crls, ocsps) |
PAdES-Baseline-Signierung (level: 0=B-B, 1=B-T, 2=B-LT; tsa_url erforderlich ab Level ≥ 1). |
sign_bytes_pades_opts(...) |
Struct-Options-Variante von sign_bytes_pades (identisches Verhalten, baut PadesSignOptionsC). |
add_timestamp(pdf_data, sig_index, tsa_url) |
Fügt einer Signatur einen RFC-3161-Zeitstempel hinzu; liefert das zeitgestempelte PDF. |
SignatureInfo
signature_get_signer_name(s::SignatureInfo) -> String
signature_get_signing_reason(s::SignatureInfo) -> String
signature_get_signing_location(s::SignatureInfo) -> String
signature_get_signing_time(s::SignatureInfo) -> Int
signature_get_certificate(s::SignatureInfo) -> Certificate
signature_get_pades_level(s::SignatureInfo) -> Int
signature_has_timestamp(s::SignatureInfo) -> Bool
signature_get_timestamp(s::SignatureInfo) -> Timestamp
signature_add_timestamp(s::SignatureInfo, ts) -> Bool
signature_verify(s::SignatureInfo) -> Int
signature_verify_detached(s::SignatureInfo, pdf::AbstractVector{UInt8}) -> Int
| Funktion |
Beschreibung |
signature_get_signer_name(s) / _reason(s) / _location(s) |
Signiername / Grund / Ort. |
signature_get_signing_time(s) |
Signierzeitpunkt (Unix-Epoch-Sekunden). |
signature_get_certificate(s) |
Das Certificate des Unterzeichners (im Besitz). |
signature_get_pades_level(s) |
PAdES-Level-Code. |
signature_has_timestamp(s) |
Ob ein eingebetteter RFC-3161-Zeitstempel vorhanden ist. |
signature_get_timestamp(s) |
Der eingebettete Timestamp (im Besitz). |
signature_add_timestamp(s, ts) |
Hängt einen Timestamp an; liefert true bei Erfolg. |
signature_verify(s) |
Krypto-Prüfung der Signaturattribute (1=gültig, 0=ungültig, -1=unbekannt). |
signature_verify_detached(s, pdf) |
End-to-End-Verifikation gegen die vollständigen PDF-Bytes (1/0/-1). |
Timestamp
timestamp_parse(data::AbstractVector{UInt8}) -> Timestamp
timestamp_get_token(t::Timestamp) -> Vector{UInt8}
timestamp_get_message_imprint(t::Timestamp) -> Vector{UInt8}
timestamp_get_time(t::Timestamp) -> Int
timestamp_get_serial(t::Timestamp) -> String
timestamp_get_tsa_name(t::Timestamp) -> String
timestamp_get_policy_oid(t::Timestamp) -> String
timestamp_get_hash_algorithm(t::Timestamp) -> Int
timestamp_verify(t::Timestamp) -> Bool
| Funktion |
Beschreibung |
timestamp_parse(data) |
Parst ein DER-RFC-3161-TimeStampToken (oder rohes TSTInfo). |
timestamp_get_token(t) |
Die rohen Token-Bytes. |
timestamp_get_message_imprint(t) |
Die Message-Imprint-Digest-Bytes. |
timestamp_get_time(t) |
Zeitstempelzeitpunkt (Unix-Epoch-Sekunden). |
timestamp_get_serial(t) |
Seriennummer-String. |
timestamp_get_tsa_name(t) |
TSA-Name. |
timestamp_get_policy_oid(t) |
Policy-OID. |
timestamp_get_hash_algorithm(t) |
Digest-Algorithmus-Code. |
timestamp_verify(t) |
Ob das Token verifiziert. |
TsaClient
tsa_client_create(url::AbstractString; username = nothing, password = nothing, timeout::Integer = 30, hash_algo::Integer = 0, use_nonce::Bool = true, cert_req::Bool = true) -> TsaClient
tsa_request_timestamp(t::TsaClient, data::AbstractVector{UInt8}) -> Timestamp
tsa_request_timestamp_hash(t::TsaClient, hash::AbstractVector{UInt8}, hash_algo::Integer) -> Timestamp
| Funktion |
Beschreibung |
tsa_client_create(url; …) |
Erstellt einen RFC-3161-TSA-Client (optional Basic-Auth, Timeout, Hash-Algo, Nonce, Cert-Req). |
tsa_request_timestamp(t, data) |
Fordert einen Zeitstempel für data an (Netzwerk-I/O). |
tsa_request_timestamp_hash(t, hash, hash_algo) |
Fordert einen Zeitstempel für einen vorab berechneten Digest an. |
Dss (Document Security Store)
dss_cert_count(d::Dss) -> Int
dss_crl_count(d::Dss) -> Int
dss_ocsp_count(d::Dss) -> Int
dss_vri_count(d::Dss) -> Int
dss_get_cert(d::Dss, index::Integer) -> Vector{UInt8}
dss_get_crl(d::Dss, index::Integer) -> Vector{UInt8}
dss_get_ocsp(d::Dss, index::Integer) -> Vector{UInt8}
| Funktion |
Beschreibung |
dss_cert_count(d) / dss_crl_count(d) / dss_ocsp_count(d) / dss_vri_count(d) |
Anzahl der Zertifikate / CRLs / OCSP-Antworten / VRI-Einträge. |
dss_get_cert(d, index) / dss_get_crl(d, index) / dss_get_ocsp(d, index) |
Die index-ten Zertifikat-/CRL-/OCSP-Antwortbytes. |
Validierungsergebnisse
validate_pdf_a / validate_pdf_ua / validate_pdf_x liefern PdfAResults / UaResults / PdfXResults.
| Funktion |
Rückgabe |
Beschreibung |
is_compliant(r::PdfAResults) |
Bool |
Ob das Dokument PDF/A-konform ist. |
is_compliant(r::PdfXResults) |
Bool |
Ob das Dokument PDF/X-konform ist. |
is_accessible(r::UaResults) |
Bool |
Ob das Dokument PDF/UA-barrierefrei ist. |
errors(r) |
Vector{String} |
Fehlermeldungen (PdfAResults / UaResults / PdfXResults). |
warnings(r) |
Vector{String} |
Warnmeldungen. |
ua_stats(r::UaResults) |
NamedTuple |
Anzahl barrierefreier Elemente (structure, images, tables, forms, annotations, pages). |
pdf_a_error_count(r) / pdf_a_warning_count(r) |
Int |
PDF/A-Fehler-/Warnungsanzahl. |
pdf_ua_error_count(r) / pdf_ua_warning_count(r) |
Int |
PDF/UA-Fehler-/Warnungsanzahl. |
pdf_x_error_count(r) |
Int |
PDF/X-Fehleranzahl. |
Barcodes
generate_qr_code(data::AbstractString, error_correction::Integer = 0, size_px::Integer = 256) -> Barcode
generate_barcode(data::AbstractString, format::Integer = 0, size_px::Integer = 256) -> Barcode
barcode_get_data(b::Barcode) -> String
barcode_get_format(b::Barcode) -> Int
barcode_get_confidence(b::Barcode) -> Float64
barcode_get_image_png(b::Barcode, size_px::Integer = 256) -> Vector{UInt8}
barcode_get_svg(b::Barcode, size_px::Integer = 256) -> String
| Funktion |
Beschreibung |
generate_qr_code(data, error_correction=0, size_px=256) |
Generiert einen QR-Code. |
generate_barcode(data, format=0, size_px=256) |
Generiert einen 1D-/2D-Barcode. |
barcode_get_data(b) |
Die dekodierte/kodierte Payload als String. |
barcode_get_format(b) |
Der Format-Code. |
barcode_get_confidence(b) |
Dekodierungs-Konfidenz (0,0–1,0). |
barcode_get_image_png(b, size_px=256) |
Rendert zu PNG-Bytes. |
barcode_get_svg(b, size_px=256) |
Rendert zu einem SVG-String. |
Stempelt einen Barcode auf eine Editorseite mit add_barcode_to_page(e, page, b, x, y, width, height).
OCR
OcrEngine
ocr_engine_create(det_model_path::AbstractString, rec_model_path::AbstractString, dict_path::AbstractString) -> OcrEngine
Erstellt eine OCR-Engine aus den Pfaden zu Erkennungsmodell, Recognition-Modell und Wörterbuchdatei. Verwende sie mit ocr_extract_text(doc, page, engine) und page_needs_ocr(doc, page) (siehe PdfDocument › OCR). close!(o::OcrEngine) gibt sie frei.
Modell-Prefetch
prefetch_models(languages_csv::AbstractString) -> String
prefetch_available() -> Int
model_manifest() -> String
| Funktion |
Beschreibung |
prefetch_models(languages_csv) |
Lädt OCR-/Layout-Modelle für kommagetrennte Sprachen vorab. |
prefetch_available() |
Ob das Modell-Prefetching verfügbar ist. |
model_manifest() |
Das gebündelte Modell-Manifest (JSON/String). |
Globale Konfiguration & Kryptografie
set_log_level(level::Integer) # 0=Off 1=Error 2=Warn 3=Info 4=Debug 5=Trace
get_log_level() -> Int
set_max_ops_per_stream(limit::Integer) -> Int
set_preserve_unmapped_glyphs(preserve::Integer) -> Int
| Funktion |
Beschreibung |
set_log_level(level) |
Setzt den globalen Log-Level (0–5). |
get_log_level() |
Liest den aktuellen globalen Log-Level. |
set_max_ops_per_stream(limit) |
Setzt das Operationslimit pro Stream-Inhalt; liefert das vorherige Limit. |
set_preserve_unmapped_glyphs(preserve) |
Schaltet die Erhaltung nicht zugeordneter Glyphen um; liefert die vorherige Einstellung. |
Krypto-Policy & Inventar
crypto_active_provider() -> String
crypto_cbom() -> String
crypto_inventory() -> String
crypto_policy() -> String
crypto_set_policy(spec::AbstractString) -> Int
crypto_fips_available() -> Int
crypto_use_fips() -> Int
| Funktion |
Beschreibung |
crypto_active_provider() |
Der Name des aktiven Krypto-Providers. |
crypto_cbom() |
Cryptographic Bill of Materials (JSON). |
crypto_inventory() |
Krypto-Algorithmus-Inventar (JSON). |
crypto_policy() |
Die aktive Krypto-Policy. |
crypto_set_policy(spec) |
Setzt die aktive Krypto-Policy aus spec; liefert einen Statuscode. |
crypto_fips_available() |
Ob ein FIPS-Provider verfügbar ist. |
crypto_use_fips() |
Ob der FIPS-Modus aktiv ist. |
Fehlerbehandlung
Jeder nicht erfolgreiche C-ABI-Status wirft einen PdfOxideError:
using PdfOxide
try
doc = open_document("file.pdf")
text = extract_text(doc, 0)
close!(doc)
catch e
if e isa PdfOxideError
@warn "PDF error" code=e.code op=e.op
else
rethrow()
end
end
PdfOxideError <: Exception trägt den numerischen C-ABI-code und den Namen der fehlgeschlagenen Operation.
Vollständiges Beispiel
using PdfOxide
# --- Creation ---
doc_bytes = let b = DocumentBuilder()
set_title(b, "Report")
p = letter_page(b)
font(p, "Helvetica", 18)
at(p, 72, 720)
heading(p, 1, "Quarterly Report")
paragraph(p, "Generated by PDF Oxide.")
done(p)
out = build(b)
close!(b)
out
end
# --- Extraction ---
doc = open_from_bytes(doc_bytes)
println("Pages: ", page_count(doc))
for i in 0:page_count(doc)-1
println("Page ", i + 1, ": ", length(extract_text(doc, i)), " chars")
end
# Words + tables
words = extract_words(doc, 0)
tables = extract_tables(doc, 0)
# Search
for hit in search_all(doc, "report", false)
println("Found on page ", hit.page, " at ", hit.bbox)
end
close!(doc)
# --- Editing ---
e = open_editor("input.pdf")
rotate_all_pages(e, 90)
set_form_field_value(e, "name", "Jane Doe")
flatten_forms(e)
save(e, "output.pdf")
close!(e)
# --- Rendering ---
doc = open_document("input.pdf")
img = render_page(doc, 0) # PNG
save(img, "page0.png")
close!(img)
close!(doc)
Other Language Bindings
PDF Oxide bietet native Bindings für jedes wichtige Ökosystem: Rust, Python, Node.js, WASM, C#, Golang, Java, PHP, Ruby, C++, Swift, Kotlin, Dart, R, Zig, Scala, Clojure, Objective-C und Elixir.
Nächste Schritte