Referência da API Julia
O PDF Oxide oferece bindings idiomáticos de Julia (PdfOxide.jl) construídos diretamente sobre a C ABI do pdf_oxide via ccall — sem crate intermediária. Os handles nativos são envolvidos em structs mutáveis com finalizers, strings C e buffers são copiados para dentro de Julia e liberados automaticamente, e qualquer status da C ABI diferente de sucesso lança um PdfOxideError. Os índices de página começam em 0.
using Pkg
Pkg.add("PdfOxide")
A cdylib nativa libpdf_oxide é carregada em tempo de execução e resolvida na seguinte ordem: PDF_OXIDE_LIB_PATH → PDF_OXIDE_LIB_DIR → ../target/release → target/release → o carregador do sistema. Compile-a com o conjunto de features dos bindings:
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)
Para a API Rust, consulte a Referência da API Rust. Para a API Python, consulte a Referência da API Python. Para detalhes de tipos, consulte Tipos e Enums.
A maioria dos tipos de handle (PdfDocument, Pdf, DocumentEditor, DocumentBuilder, RenderedImage, Certificate, SignatureInfo, Timestamp, TsaClient, Dss, resultados de validação, Barcode, OcrEngine, Renderer, ElementList, EmbeddedFont, PageBuilder) é dona de memória nativa. Libere-os de forma antecipada com close!(x) — é idempotente e também é executado na finalização.
PdfDocument
O handle de leitura para abrir, extrair, pesquisar, renderizar, validar e inspecionar um PDF existente.
Abertura
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
| Função |
Descrição |
open_document(path; password=nothing) |
Abre um PDF a partir de um caminho no sistema de arquivos (opcionalmente protegido por senha). |
open_from_bytes(data) |
Abre um PDF a partir de um vetor de bytes em memória. |
open_with_password(path, password) |
Abre um PDF criptografado em disco com uma senha. |
| Função |
Retorna |
Descrição |
page_count(d) |
Int |
Número de páginas. |
version(d) |
PdfVersion |
Versão do PDF (major/minor). |
is_encrypted(d) |
Bool |
Se o documento está criptografado. |
has_structure_tree(d) |
Bool |
Se o documento é um PDF Tagueado com árvore de estrutura. |
has_xfa(d) |
Bool |
Se o documento contém um formulário XFA. |
authenticate(d, password) |
Bool |
Autentica a senha de um documento criptografado (uma senha incorreta retorna false, não um erro). |
Conversão do Documento Completo
| Função |
Retorna |
Descrição |
to_markdown_all(d) |
String |
Markdown do documento inteiro. |
to_html_all(d) |
String |
HTML do documento inteiro. |
to_plain_text_all(d) |
String |
Texto puro do documento inteiro. |
extract_all_text(d) |
String |
Extração automática de texto do documento inteiro. |
classify_document(d) |
String |
Classifica o documento inteiro; retorna a string JSON do classificador. |
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
| Função |
Descrição |
extract_text(d, page) |
Extrai texto puro de uma página com índice começando em 0. |
to_plain_text(d, page) |
Renderiza uma página em texto puro consciente de layout. |
to_markdown(d, page) |
Renderiza uma página em Markdown. |
to_html(d, page) |
Renderiza uma página em HTML. |
extract_structured_json(d, page) |
Extrai um modelo JSON de documento estruturado para uma página. |
extract_text_auto(d, page) |
Escolhe automaticamente a melhor extração de texto para uma página. |
extract_page_auto(d, page, options="{}") |
Extração automática de página com uma string de opções em JSON. |
classify_page(d, page) |
Classifica uma página; retorna a string JSON do classificador. |
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}
| Função |
Descrição |
extract_chars(d, page) |
Extrai glifos de uma página como um Vector{Char}. |
extract_words(d, page) |
Extrai palavras de uma página como um Vector{Word}. |
extract_text_lines(d, page) |
Extrai linhas de texto como um Vector{TextLine}. |
extract_tables(d, page) |
Extrai tabelas como um Vector{Table}. |
embedded_fonts(d, page) |
Fontes embutidas como um Vector{Font}. |
embedded_images(d, page) |
Imagens embutidas como um Vector{Image}. |
page_annotations(d, page) |
Anotações como um Vector{Annotation}. |
extract_paths(d, page) |
Caminhos vetoriais como um 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}
Cada uma restringe a extração ao retângulo (x, y, w, h) em pontos do espaço do usuário do PDF, em uma página com índice começando em 0.
Pesquisa
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
| Função |
Descrição |
search(d, page, term, caseSensitive) |
Pesquisa term em uma única página. |
search_all(d, term, caseSensitive) |
Pesquisa term no documento inteiro. |
search_results_to_json(d, term, caseSensitive) |
Serializa os resultados de pesquisa do documento inteiro em JSON. |
Geometria da Página
| Função |
Retorna |
Descrição |
page_get_width(d, page) |
Float64 |
Largura da página (em pontos PDF). |
page_get_height(d, page) |
Float64 |
Altura da página (em pontos PDF). |
page_get_rotation(d, page) |
Int |
Rotação absoluta (em graus) de uma página. |
page(d, index) |
PdfPage |
Uma visão de página com índice começando em 0 sobre o documento (veja PdfPage). |
| Função |
Retorna |
Descrição |
get_outline(d) |
String |
Marcadores / sumário (JSON). |
get_page_labels(d) |
String |
Intervalos de rótulos de página (JSON). |
get_xmp_metadata(d) |
String |
Metadados XMP (JSON). |
get_source_bytes(d) |
Vector{UInt8} |
Os bytes de origem originais do documento. |
plan_split_by_bookmarks(d, options="{}") |
String |
Planeja uma operação de divisão por marcadores (JSON). |
Inspeção de Anotações
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
| Função |
Retorna |
Descrição |
annotations_to_json(d, page) |
String |
Todas as anotações de uma página como JSON. |
annotation_get_color(d, page, index) |
UInt32 |
Cor RGBA compactada de 32 bits de uma anotação. |
annotation_creation_date(d, page, index) |
String |
Data de criação da anotação. |
annotation_modification_date(d, page, index) |
String |
Data de modificação da anotação. |
annotation_is_hidden(d, page, index) |
Bool |
Se a anotação está oculta. |
annotation_is_marked_deleted(d, page, index) |
Bool |
Se a anotação está marcada para exclusão. |
annotation_is_printable(d, page, index) |
Bool |
Se a anotação é imprimível. |
annotation_is_read_only(d, page, index) |
Bool |
Se a anotação é somente leitura. |
link_annotation_uri(d, page, index) |
String |
URI de uma anotação Link. |
text_annotation_icon_name(d, page, index) |
String |
Nome do ícone de uma anotação Text (nota adesiva). |
highlight_quad_points_count(d, page, index) |
Int |
Contagem de quadriláteros de uma anotação Highlight. |
highlight_quad_point(d, page, index, quad_index) |
NTuple{8,Float64} |
O quadrilátero de índice quad_index (8 floats). |
Auxiliares de JSON para Fontes e Elementos
| Função |
Retorna |
Descrição |
fonts_to_json(d, page) |
String |
Fontes embutidas de uma página como JSON. |
font_size(d, page, index) |
Float64 |
Tamanho da fonte de índice index entre as fontes embutidas. |
page_get_elements(d, page) |
ElementList |
Elementos de região de layout da página como uma 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
| Função |
Descrição |
get_form_fields(d) |
Todos os campos do AcroForm como um Vector{FormField}. |
form_field_count(d) |
Contagem rápida de campos. |
export_form_data_to_bytes(d, format_type) |
Exporta os dados do formulário (format_type seleciona FDF/XFDF). |
import_form_data(d, path) |
Importa dados de formulário a partir de um arquivo; retorna o código de status C. |
form_import_from_file(d, filename) |
Importa dados de formulário; retorna true em caso de sucesso. |
OCR
page_needs_ocr(d::PdfDocument, page::Integer) -> Bool
ocr_extract_text(d::PdfDocument, page::Integer, engine::Union{Nothing,OcrEngine} = nothing) -> String
| Função |
Descrição |
page_needs_ocr(d, page) |
Se uma página é escaneada/híbrida e precisa de OCR. |
ocr_extract_text(d, page, engine=nothing) |
Extrai texto via OCR (nothing recorre apenas à extração nativa). Veja OcrEngine. |
Assinaturas (nível de documento)
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}
| Função |
Descrição |
sign(d, cert; reason, location) |
Assina o documento com cert; retorna um código de status. |
get_signature_count(d) |
Número de assinaturas no documento. |
get_signature(d, index) |
A assinatura de índice index como uma SignatureInfo. |
verify_all_signatures(d) |
Verifica todas as assinaturas; retorna um código de status. |
has_timestamp(d) |
Se o documento possui um carimbo de tempo no nível de documento. |
document_get_dss(d) |
Lê o /DSS do documento em uma Dss, ou nothing se não houver. |
Validação e Conversão
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 são aliases em camelCase dos três validadores. Veja Resultados de Validação.
Conversão para Office
to_docx(d::PdfDocument) -> Vector{UInt8}
to_pptx(d::PdfDocument) -> Vector{UInt8}
to_xlsx(d::PdfDocument) -> Vector{UInt8}
Converte o PDF de volta em um buffer de bytes DOCX / PPTX / XLSX. A abertura de arquivos do Office como PDFs é feita com open_from_docx_bytes / open_from_pptx_bytes / open_from_xlsx_bytes (veja Entrada do Office).
Ciclo de Vida
| Função |
Descrição |
close!(d) |
Libera o handle nativo imediatamente (idempotente; também é executado na finalização). |
PdfPage
Uma visão de página leve, com índice começando em 0, retornada por page(doc, index). Os métodos delegam para o documento pai.
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
| Método |
Retorna |
Descrição |
text(p) |
String |
Texto puro da página. |
markdown(p) |
String |
Markdown da página. |
html(p) |
String |
HTML da página. |
plain_text(p) |
String |
Texto puro consciente de layout. |
extract_chars(p) |
Vector{Char} |
Glifos. |
extract_words(p) |
Vector{Word} |
Palavras. |
extract_text_lines(p) |
Vector{TextLine} |
Linhas de texto. |
extract_tables(p) |
Vector{Table} |
Tabelas. |
embedded_fonts(p) |
Vector{Font} |
Fontes embutidas. |
embedded_images(p) |
Vector{Image} |
Imagens embutidas. |
page_annotations(p) |
Vector{Annotation} |
Anotações. |
extract_paths(p) |
Vector{Path} |
Caminhos vetoriais. |
search(p, term, caseSensitive) |
Vector{SearchResult} |
Pesquisa na página. |
render_page(p, format=0) |
RenderedImage |
Renderiza a página (0=PNG). |
render_page_zoom(p, zoom, format=0) |
RenderedImage |
Renderiza com um fator de zoom. |
render_page_thumbnail(p, size, format=0) |
RenderedImage |
Renderiza uma miniatura que cabe em size px. |
Renderização
Renderiza páginas de PdfDocument em imagens. format: 0=PNG (padrão), 1=JPEG. As coordenadas estão em pontos do espaço do usuário do PDF.
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
| Função |
Descrição |
render_page(d, page, format=0) |
Renderiza uma página (0=PNG). |
render_page_zoom(d, page, zoom, format=0) |
Renderiza com um fator de zoom. |
render_page_thumbnail(d, page, size, format=0) |
Renderiza uma miniatura que cabe em size px. |
render_page_region(d, page, x, y, w, h, format=0) |
Renderiza um recorte retangular (em pontos do espaço do usuário). |
render_page_fit(d, page, w, h, format=0) |
Renderiza ajustando dentro de w×h px, preservando a proporção. |
render_page_raw(d, page, dpi) |
Renderiza em um buffer RGBA8888 pré-multiplicado bruto; retorna (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) |
Renderiza com a superfície completa de RenderOptions (canais de fundo 0–1; flags são 0/1). |
render_page_with_options_ex(...; excluded_layers) |
Como acima, mais filtragem de camadas OCG — suprime as camadas /Name indicadas. |
estimate_render_time(d, page) |
Estima o tempo de renderização (em ms) de uma página. |
renderPage / renderPageZoom / renderPageThumbnail são aliases em camelCase de render_page / render_page_zoom / render_page_thumbnail.
Renderer
Um handle de renderizador reutilizável.
create_renderer(dpi::Integer = 150, format::Integer = 0, quality::Integer = 90, anti_alias::Bool = true) -> Renderer
close!(r::Renderer)
RenderedImage
O resultado de uma chamada de renderização. Campos: width::Int, height::Int, data::Vector{UInt8} (bytes codificados, ou RGBA bruto no caso de render_page_raw).
save(img::RenderedImage, path::AbstractString) # write to disk (format inferred)
close!(img::RenderedImage)
DocumentEditor
O handle de edição para modificar e regravar um PDF existente.
Abertura e Origem
open_editor(path::AbstractString) -> DocumentEditor
open_editor_from_bytes(data::AbstractVector{UInt8}) -> DocumentEditor
| Função |
Retorna |
Descrição |
is_modified(e) |
Bool |
Se o editor possui modificações não salvas. |
get_source_path(e) |
String |
Caminho de origem a partir do qual o editor foi aberto. |
page_count(e) |
Int |
Número de páginas. |
version(e) |
PdfVersion |
Versão do PDF. |
| Função |
Descrição |
get_producer(e) |
Produtor a partir de /Info.Producer. |
set_producer(e, value) |
Define /Info.Producer. |
get_creation_date(e) |
Data de criação a partir de /Info.CreationDate (string de data PDF bruta). |
set_creation_date(e, date_str) |
Define /Info.CreationDate (string de data PDF bruta). |
Salvamento
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)
| Função |
Descrição |
save(e, path) |
Salva o documento editado em um caminho. |
save_to_bytes(e) |
Serializa o documento editado em bytes. |
save_to_bytes_with_options(e, compress, garbage_collect, linearize) |
Serializa com opções de compressão / coleta de lixo / linearização. |
extract_pages_to_bytes(e, pages) |
Extrai um subconjunto de páginas para um novo PDF em memória. |
save_encrypted(e, path, user_pw, owner_pw) |
Salva com criptografia AES-256 em um caminho. |
save_encrypted_to_bytes(e, user_pw, owner_pw) |
Salva com criptografia AES-256 em bytes. |
convert_to_pdf_a(e, level) |
Converte para PDF/A no próprio documento (level: 0=A1b…7=A3u). |
Mesclagem e Anexos
| Função |
Descrição |
merge_from(e, source_path) |
Mescla páginas de um PDF em disco. |
merge_from_bytes(e, data) |
Mescla páginas de um buffer de PDF em memória. |
embed_file(e, name, data) |
Embute um arquivo anexo (name, bytes em data). |
Operações em Páginas
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)
| Função |
Descrição |
rotate_all_pages(e, degrees) |
Rotaciona todas as páginas (de forma relativa). |
rotate_page_by(e, page, degrees) |
Rotaciona uma página de forma aditiva. |
get_page_rotation(e, page) |
Rotação absoluta de uma página. |
set_page_rotation(e, page, degrees) |
Define a rotação absoluta de uma página. |
delete_page(e, page) |
Exclui uma página. |
move_page(e, from, to) |
Move uma página de um índice para outro. |
Caixas de Página e Recorte
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)
| Função |
Descrição |
get_page_media_box(e, page) |
Obtém a MediaBox de uma página. |
get_page_crop_box(e, page) |
Obtém a CropBox de uma página. |
set_page_media_box(e, page, x, y, w, h) |
Define a MediaBox de uma página. |
set_page_crop_box(e, page, x, y, w, h) |
Define a CropBox de uma página. |
crop_margins(e, left, right, top, bottom) |
Corta todas as páginas pelas margens (espaço do usuário). |
Apagamento / 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)
| Função |
Descrição |
erase_region(e, page, x, y, w, h) |
Apaga uma região retangular. |
erase_regions(e, page, rects) |
Apaga várias regiões (rects é um vetor de tuplas (x, y, w, h)). |
clear_erase_regions(e, page) |
Limpa todas as entradas de apagamento de região pendentes de uma página. |
Remoção de Cabeçalho / Rodapé / Artefatos
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)
| Função |
Descrição |
erase_header(d, page) / erase_footer(d, page) / erase_artifacts(d, page) |
Apaga o cabeçalho / rodapé / artefatos detectados em uma página. |
remove_headers(d, threshold=0.5) / remove_footers(...) / remove_artifacts(...) |
Remove cabeçalhos / rodapés / artefatos repetidos no documento inteiro, acima de um limiar de frequência. |
Achatamento de Anotações
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)
Redação
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
| Função |
Descrição |
apply_page_redactions(e, page) |
Aplica (grava definitivamente) as redações de uma página. |
apply_all_redactions(e) |
Aplica todas as redações pendentes. |
is_page_marked_for_redaction(e, page) |
Se uma página está marcada para redação. |
unmark_page_for_redaction(e, page) |
Remove a marca de redação de uma página. |
redaction_add(e, page, x1, y1, x2, y2, r, g, b) |
Enfileira uma caixa de redação com cor de sobreposição (DeviceRGB, 0–1). |
redaction_count(e, page) |
Número de regiões de redação enfileiradas em uma página. |
redaction_apply(e, scrub_metadata, r, g, b) |
Aplica destrutivamente todas as redações enfileiradas; retorna os glifos eliminados. |
redaction_scrub_metadata(e) |
Remove Info/XMP/JavaScript/EmbeddedFiles; retorna a contagem removida. |
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})
| Função |
Descrição |
set_form_field_value(e, name, value) |
Define o valor de um campo de formulário (UTF-8). |
flatten_forms(e) |
Achata todos os formulários (grava os valores no conteúdo da página). |
flatten_forms_on_page(e, page) |
Achata os formulários de uma única página. |
flatten_warnings_count(e) |
Número de avisos do último salvamento com achatamento de formulário. |
flatten_warning(e, index) |
A string de aviso de achatamento de índice index. |
import_fdf_bytes(e, data) |
Importa dados de formulário FDF a partir de bytes. |
import_xfdf_bytes(e, data) |
Importa dados de formulário XFDF a partir de bytes. |
Estampagem de Código de Barras
add_barcode_to_page(e::DocumentEditor, page::Integer, b::Barcode, x, y, width, height)
Estampa um Barcode em uma página no retângulo (x, y, width, height). Veja Códigos de Barras.
Ciclo de Vida
close!(e::DocumentEditor) libera o handle.
Pdf
O handle leve de criação retornado pelas fábricas from_*.
Fábricas
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
| Função |
Descrição |
from_markdown(input) |
Constrói um Pdf a partir de Markdown. |
from_html(input) |
Constrói um Pdf a partir de HTML. |
from_text(input) |
Constrói um Pdf a partir de texto puro. |
from_image(path) |
Constrói um Pdf a partir de um arquivo de imagem. |
from_image_bytes(data) |
Constrói um Pdf a partir de bytes de imagem em memória. |
from_html_css(html, css, font_bytes=nothing) |
Constrói a partir de HTML + CSS com uma fonte embutida opcional. |
from_html_css_with_fonts(html, css, families, fonts) |
Constrói a partir de HTML + CSS com uma cascata de múltiplas fontes (families[i] nomeia fonts[i]). |
Métodos
| Função |
Retorna |
Descrição |
save(p, path) |
— |
Grava o PDF construído em um caminho. |
to_bytes(p) |
Vector{UInt8} |
Serializa o PDF construído em bytes. |
get_page_count(p) |
Int |
Contagem de páginas de um Pdf em construção. |
close!(p) |
— |
Libera o handle. |
merge_pdfs
merge_pdfs(paths::AbstractVector{<:AbstractString}) -> Vector{UInt8}
Mescla os PDFs em paths (na ordem informada) em um único buffer de bytes de PDF.
Entrada do Office
open_from_docx_bytes(data::AbstractVector{UInt8}) -> Pdf
open_from_pptx_bytes(data::AbstractVector{UInt8}) -> Pdf
open_from_xlsx_bytes(data::AbstractVector{UInt8}) -> Pdf
Converte bytes de DOCX / PPTX / XLSX em um Pdf.
DocumentBuilder
Um construtor de PDF fluente e consciente de estrutura. Crie páginas com a4_page / letter_page / page, faça o layout do conteúdo no PageBuilder retornado, chame done para confirmar cada página e, depois, build / save / as variantes criptografadas.
DocumentBuilder() -> DocumentBuilder
Configuração no Nível do Documento
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)
| Função |
Descrição |
set_title / set_author / set_subject / set_keywords / set_creator |
Define o campo de metadados /Info correspondente. |
on_open(b, value) |
Define uma ação JavaScript de abertura do documento. |
language(b, value) |
Define o idioma do documento (ex.: "en-US"). |
tagged_pdf_ua1(b) |
Ativa o modo de PDF tagueado PDF/UA-1. |
role_map(b, custom, standard) |
Mapeia um tipo de estrutura personalizado para um tipo padrão. |
register_embedded_font(b, name, f) |
Registra uma EmbeddedFont carregada sob o nome name (consome a fonte). |
Páginas
a4_page(b::DocumentBuilder) -> PageBuilder
letter_page(b::DocumentBuilder) -> PageBuilder
page(b::DocumentBuilder, width::Real, height::Real) -> PageBuilder
Saída
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}
| Função |
Descrição |
build(b) |
Constrói e retorna os bytes do PDF (o builder ainda precisa ser fechado). |
save(b, path) |
Constrói e salva em um caminho. |
save_encrypted_builder(b, path, user_pw, owner_pw) |
Constrói e salva com criptografia AES-256. |
to_bytes_encrypted(b, user_pw, owner_pw) |
Constrói bytes criptografados (AES-256). |
EmbeddedFont
embedded_font_from_file(path::AbstractString) -> EmbeddedFont
embedded_font_from_bytes(data::AbstractVector{UInt8}; name::Union{Nothing,AbstractString} = nothing) -> EmbeddedFont
| Função |
Descrição |
embedded_font_from_file(path) |
Carrega uma fonte TTF/OTF a partir de um caminho. |
embedded_font_from_bytes(data; name) |
Carrega uma fonte a partir de bytes (name pode ficar vazio para usar o nome PostScript). |
PageBuilder
Retornado por a4_page / letter_page / page. Todos os métodos modificam a página no local; chame done(p) para confirmá-la no builder pai (isso consome o handle da página).
Texto e Layout
font(p::PageBuilder, name::AbstractString, size::Real)
at(p::PageBuilder, x::Real, y::Real)
heading(p::PageBuilder, level::Integer, text::AbstractString)
| Método |
Descrição |
font(p, name, size) |
Define a fonte + o tamanho para o texto seguinte. |
at(p, x, y) |
Move o cursor para a posição absoluta (x, y) (pontos, a partir do canto inferior esquerdo). |
heading(p, level, text) |
Emite um título no nível level (1–6). |
Os seguintes métodos com valor de string compartilham a assinatura f(p::PageBuilder, value::AbstractString):
| Método |
Descrição |
text(p, value) |
Emite um trecho de texto do corpo. |
paragraph(p, value) |
Emite um parágrafo com quebra automática de linha. |
link_url(p, value) |
Transforma o texto anterior em um link de URL. |
link_named(p, value) |
Vincula o texto anterior a um destino nomeado. |
link_javascript(p, value) |
Anexa uma ação JavaScript ao texto anterior. |
on_open(p, value) |
Define uma ação JavaScript de abertura de página. |
on_close(p, value) |
Define uma ação JavaScript de fechamento de página. |
field_keystroke(p, value) / field_format(p, value) / field_validate(p, value) / field_calculate(p, value) |
Anexa ações JavaScript de campo do AcroForm. |
sticky_note(p, value) |
Anexa uma nota adesiva ao conteúdo anterior. |
watermark(p, value) |
Adiciona uma marca d’água de texto. |
stamp(p, value) |
Adiciona uma anotação de carimbo. |
inline(p, value) |
Anexa um trecho de texto em linha. |
inline_bold(p, value) |
Anexa um trecho em linha em negrito. |
inline_italic(p, value) |
Anexa um trecho em linha em itálico. |
Métodos de layout sem argumentos, todos f(p::PageBuilder):
| Método |
Descrição |
horizontal_rule(p) |
Desenha uma linha horizontal. |
space(p) |
Insere espaço vertical. |
newline(p) |
Quebra para uma nova linha. |
new_page_same_size(p) |
Inicia uma nova página com as mesmas dimensões. |
watermark_confidential(p) |
Adiciona uma marca d’água “CONFIDENTIAL”. |
watermark_draft(p) |
Adiciona uma marca d’água “DRAFT”. |
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)
| Método |
Descrição |
link_page(p, page_index) |
Vincula o texto anterior a um índice de página interno. |
sticky_note_at(p, x, y, text) |
Posiciona uma nota adesiva avulsa. |
freetext(p, x, y, w, h, text) |
Posiciona uma anotação de texto livre dentro de um retângulo. |
footnote(p, ref_mark, note_text) |
Adiciona uma nota de rodapé (sobrescrito em linha + corpo no fim da página). |
columns(p, column_count, gap_pt, text) |
Distribui o texto em colunas balanceadas. |
inline_color(p, r, g, b_, text) |
Anexa um trecho em linha colorido em RGB (canais 0–1). |
Anotações de Marcação
As quatro a seguir compartilham f(p::PageBuilder, r::Real, g::Real, b_::Real) e se aplicam ao texto anterior com uma cor RGB:
| Método |
Descrição |
highlight(p, r, g, b) |
Destaca o texto anterior. |
underline(p, r, g, b) |
Sublinha o texto anterior. |
strikeout(p, r, g, b) |
Risca o texto anterior. |
squiggly(p, r, g, b) |
Sublinha o texto anterior com linha ondulada. |
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)
| Método |
Descrição |
text_field(p, name, x, y, w, h; default_value) |
Adiciona um campo de texto de linha única. |
checkbox(p, name, x, y, w, h, checked) |
Adiciona uma caixa de seleção com um estado inicial marcado. |
combo_box(p, name, x, y, w, h, options; selected) |
Adiciona uma caixa de combinação suspensa. |
radio_group(p, name, values, xs, ys, ws, hs; selected) |
Adiciona um grupo de botões de opção (arrays paralelos descrevem cada botão). |
push_button(p, name, x, y, w, h, caption) |
Adiciona um botão clicável. |
signature_field(p, name, x, y, w, h) |
Adiciona um espaço reservado para assinatura ainda não assinada. |
Imagens e Códigos de Barras
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)
| Método |
Descrição |
image(p, bytes, x, y, w, h) |
Embute uma imagem (JPEG/PNG/WebP bruto). |
image_with_alt(p, bytes, x, y, w, h, alt_text) |
Embute uma imagem com texto alternativo de acessibilidade. |
image_artifact(p, bytes, x, y, w, h) |
Embute uma imagem decorativa como um /Artifact. |
barcode_1d(p, barcode_type, data, x, y, w, h) |
Posiciona um código de barras 1D (barcode_type: 0=Code128…7=Codabar). |
barcode_qr(p, data, x, y, size) |
Posiciona um código QR quadrado. |
Gráficos Vetoriais
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)
| Método |
Descrição |
rect(p, x, y, w, h) |
Contorno de retângulo traçado em 1pt preto. |
filled_rect(p, x, y, w, h, r, g, b) |
Retângulo preenchido em RGB (0–1). |
line(p, x1, y1, x2, y2) |
Linha de 1pt preta. |
stroke_rect(p, x, y, w, h, width, r, g, b) |
Retângulo traçado, widthpt em RGB. |
stroke_line(p, x1, y1, x2, y2, width, r, g, b) |
Linha traçada, widthpt em RGB. |
stroke_rect_dashed(...) |
Retângulo traçado tracejado (dash_array define os comprimentos ligado/desligado, phase o deslocamento). |
stroke_line_dashed(...) |
Linha traçada tracejada. |
text_in_rect(p, x, y, w, h, text, align) |
Desenha texto dentro de um retângulo (align: 0=Esquerda, 1=Centro, 2=Direita). |
Tabelas
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)
| Método |
Descrição |
table(p, n_columns, widths, aligns, n_rows, cell_strings, has_header) |
Emite uma tabela em buffer (aligns: 0=Esquerda/1=Centro/2=Direita; cell_strings é row-major n_rows × n_columns). |
streaming_table_begin(p, headers, widths, aligns, repeat_header) |
Abre uma tabela em streaming (arrays paralelos de comprimento n_columns). |
streaming_table_begin_v2(...) |
Abre uma tabela em streaming com mode de largura (0=Fixed, 1=Sample, 2=AutoAll) e max_rowspan. |
streaming_table_set_batch_size(p, batch_size) |
Define o tamanho do lote (0 → 256). |
streaming_table_pending_row_count(p) |
Linhas inseridas desde o último limite de lote. |
streaming_table_batch_count(p) |
Número de lotes completos até agora. |
streaming_table_push_row(p, cells) |
Insere uma linha (rowspan=1). |
streaming_table_push_row_v2(p, cells, rowspans) |
Insere uma linha com rowspans por célula (≥2 abrangências). |
streaming_table_flush(p) |
Descarrega o lote atual. |
streaming_table_finish(p) |
Finaliza a tabela em streaming. |
Confirmação
done(p::PageBuilder) # commit this page's buffered operations to its parent builder (consumes the handle)
Tipos de Valor
Structs imutáveis retornadas pela extração. Bbox tem os campos x, y, width, height (unidades do espaço do usuário do PDF).
| Tipo |
Campos |
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 (use cell(t, row, col) para uma célula com índice começando em 0) |
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)
Assinaturas Digitais
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
| Função |
Descrição |
certificate_load_from_bytes(data, password="") |
Carrega as credenciais de assinatura a partir de bytes PKCS#12 / PFX. |
certificate_load_from_pem(cert_pem, key_pem) |
Carrega a partir de um certificado + chave privada codificados em PEM. |
certificate_get_subject(c) / certificate_get_issuer(c) / certificate_get_serial(c) |
Strings de titular / emissor / número de série. |
certificate_get_validity(c) |
Janela de validade como (not_before, not_after) em segundos desde a época Unix. |
certificate_is_valid(c) |
Se o certificado está atualmente válido. |
Assinatura
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}
| Função |
Descrição |
sign_bytes(pdf, cert, reason, location) |
Assina bytes brutos de PDF; retorna o PDF assinado. |
sign_bytes_pades(pdf, cert, level, tsa_url, reason, location; certs, crls, ocsps) |
Assinatura PAdES baseline (level: 0=B-B, 1=B-T, 2=B-LT; tsa_url obrigatório para level ≥ 1). |
sign_bytes_pades_opts(...) |
Variante por struct de opções de sign_bytes_pades (comportamento idêntico, constrói um PadesSignOptionsC). |
add_timestamp(pdf_data, sig_index, tsa_url) |
Adiciona um carimbo de tempo RFC 3161 a uma assinatura; retorna o PDF com carimbo de tempo. |
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
| Função |
Descrição |
signature_get_signer_name(s) / _reason(s) / _location(s) |
Nome / motivo / local do signatário. |
signature_get_signing_time(s) |
Hora da assinatura (segundos desde a época Unix). |
signature_get_certificate(s) |
O Certificate do signatário (de posse própria). |
signature_get_pades_level(s) |
Código do nível PAdES. |
signature_has_timestamp(s) |
Se há um carimbo de tempo RFC 3161 embutido. |
signature_get_timestamp(s) |
O Timestamp embutido (de posse própria). |
signature_add_timestamp(s, ts) |
Anexa um Timestamp; retorna true em caso de sucesso. |
signature_verify(s) |
Verificação criptográfica dos atributos do signatário (1=válida, 0=inválida, -1=desconhecida). |
signature_verify_detached(s, pdf) |
Verificação completa ponta a ponta contra os bytes integrais do PDF (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
| Função |
Descrição |
timestamp_parse(data) |
Analisa um TimeStampToken RFC 3161 em DER (ou um TSTInfo isolado). |
timestamp_get_token(t) |
Os bytes brutos do token. |
timestamp_get_message_imprint(t) |
Os bytes do digest message-imprint. |
timestamp_get_time(t) |
Hora do carimbo de tempo (segundos desde a época Unix). |
timestamp_get_serial(t) |
String do número de série. |
timestamp_get_tsa_name(t) |
Nome da TSA. |
timestamp_get_policy_oid(t) |
OID da política. |
timestamp_get_hash_algorithm(t) |
Código do algoritmo de digest. |
timestamp_verify(t) |
Se o token é verificável. |
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
| Função |
Descrição |
tsa_client_create(url; …) |
Cria um cliente de TSA RFC 3161 (autenticação básica, timeout, algoritmo de hash, nonce e cert-req opcionais). |
tsa_request_timestamp(t, data) |
Solicita um carimbo de tempo sobre data (E/S de rede). |
tsa_request_timestamp_hash(t, hash, hash_algo) |
Solicita um carimbo de tempo sobre um digest pré-calculado. |
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}
| Função |
Descrição |
dss_cert_count(d) / dss_crl_count(d) / dss_ocsp_count(d) / dss_vri_count(d) |
Contagens de certificados / CRLs / respostas OCSP / entradas VRI. |
dss_get_cert(d, index) / dss_get_crl(d, index) / dss_get_ocsp(d, index) |
Os bytes do certificado / CRL / resposta OCSP de índice index. |
Resultados de Validação
validate_pdf_a / validate_pdf_ua / validate_pdf_x retornam PdfAResults / UaResults / PdfXResults.
| Função |
Retorna |
Descrição |
is_compliant(r::PdfAResults) |
Bool |
Se o documento é compatível com PDF/A. |
is_compliant(r::PdfXResults) |
Bool |
Se o documento é compatível com PDF/X. |
is_accessible(r::UaResults) |
Bool |
Se o documento é acessível segundo PDF/UA. |
errors(r) |
Vector{String} |
Mensagens de erro (PdfAResults / UaResults / PdfXResults). |
warnings(r) |
Vector{String} |
Mensagens de aviso. |
ua_stats(r::UaResults) |
NamedTuple |
Contagens de elementos de acessibilidade (structure, images, tables, forms, annotations, pages). |
pdf_a_error_count(r) / pdf_a_warning_count(r) |
Int |
Contagens de erros / avisos de PDF/A. |
pdf_ua_error_count(r) / pdf_ua_warning_count(r) |
Int |
Contagens de erros / avisos de PDF/UA. |
pdf_x_error_count(r) |
Int |
Contagem de erros de PDF/X. |
Códigos de Barras
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
| Função |
Descrição |
generate_qr_code(data, error_correction=0, size_px=256) |
Gera um código QR. |
generate_barcode(data, format=0, size_px=256) |
Gera um código de barras 1D/2D. |
barcode_get_data(b) |
A string de payload decodificada/codificada. |
barcode_get_format(b) |
O código do formato. |
barcode_get_confidence(b) |
Confiança da decodificação (0.0–1.0). |
barcode_get_image_png(b, size_px=256) |
Renderiza em bytes PNG. |
barcode_get_svg(b, size_px=256) |
Renderiza em uma string SVG. |
Estampe um código de barras em uma página do editor com 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
Cria um motor de OCR a partir dos caminhos do modelo de detecção, do modelo de reconhecimento e do arquivo de dicionário. Use-o com ocr_extract_text(doc, page, engine) e page_needs_ocr(doc, page) (veja PdfDocument › OCR). close!(o::OcrEngine) o libera.
Pré-busca de Modelos
prefetch_models(languages_csv::AbstractString) -> String
prefetch_available() -> Int
model_manifest() -> String
| Função |
Descrição |
prefetch_models(languages_csv) |
Pré-busca modelos de OCR/layout para idiomas separados por vírgula. |
prefetch_available() |
Se a pré-busca de modelos está disponível. |
model_manifest() |
O manifesto dos modelos empacotados (JSON/string). |
Configuração Global e Criptografia
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
| Função |
Descrição |
set_log_level(level) |
Define o nível de log global (0–5). |
get_log_level() |
Obtém o nível de log global atual. |
set_max_ops_per_stream(limit) |
Define o limite de operações de conteúdo por stream; retorna o limite anterior. |
set_preserve_unmapped_glyphs(preserve) |
Alterna a preservação de glifos não mapeados; retorna a configuração anterior. |
Política e Inventário de Criptografia
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
| Função |
Descrição |
crypto_active_provider() |
O nome do provedor de criptografia ativo. |
crypto_cbom() |
Lista de Materiais Criptográficos (CBOM, em JSON). |
crypto_inventory() |
Inventário de algoritmos criptográficos (JSON). |
crypto_policy() |
A política de criptografia ativa. |
crypto_set_policy(spec) |
Define a política de criptografia ativa a partir de spec; retorna um código de status. |
crypto_fips_available() |
Se um provedor FIPS está disponível. |
crypto_use_fips() |
Se o modo FIPS está ativo. |
Tratamento de Erros
Todo status da C ABI diferente de sucesso lança um 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 carrega o code numérico da C ABI e o nome da operação que falhou.
Exemplo Completo
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
O PDF Oxide oferece bindings nativos para todos os principais ecossistemas: Rust, Python, Node.js, WASM, C#, Golang, Java, PHP, Ruby, C++, Swift, Kotlin, Dart, R, Zig, Scala, Clojure, Objective-C e Elixir.
Próximos Passos