2bc41aeb8602
lib.rs
//! VectorCraft PDF export and import.
//!
//! - [`export`] writes one PDF page per artboard with `krilla`: vector paths (fills, strokes with
//! caps/joins/miter/dashes, inside/outside alignment as clips, non-zero/even-odd; arrowheads,
//! width profiles, fitted or dotted dashes as the canvas's filled outlines and brushed strokes
//! as their brush art), opacity and blend modes (transparency groups),
//! clip groups, linear/radial gradients (shadings), pattern fills and strokes as their tiles and
//! freeform and Perceptual gradients, gradients mixed around the hue wheel and dithered gradient fills as images at the raster
//! effects resolution (clipped to what they paint), embedded images (resampled and
//! compressed as the Compression settings say) and text as outlined glyph paths, or as real
//! text in embedded subset fonts (Advanced). Colours are converted, tagged with ICC profiles and
//! given an output intent as the Output settings say. Hidden objects,
//! guides and template layers are skipped, and so are non-printing layers unless asked for.
//! Layers and sublayers can be PDF layers (optional content groups with their visibility, print
//! state and lock), and overprinting fills and strokes overprint (Advanced).
//! Each page is its artboard (the trim box) grown by the bleed (the bleed box) and by the
//! printer's marks around it (the media box), drawn in Registration. [`PdfSettings`] is the Save PDF
//! dialog's model (standard, compatibility, General, Compression, Marks and Bleeds, Output,
//! Advanced, Security); options the writer doesn't apply yet come back as warnings. With Preserve
//! Editing the native document rides along as an embedded file ([`editing()`]), and the first
//! page can carry a `.ai` file's editing copy of the art ([`PrivateData`]). Each page can
//! carry a thumbnail ([`Thumbnail`], drawn by the caller), and Fast Web View writes a linearised
//! file (still linearised when encrypted). A PDF 1.3 file ([`PdfSettings::pdf13`]) must be flat:
//! the app flattens the document first, and the writer refuses transparency that is left.
//! - [`import`] reads PDF (and PDF-compatible `.ai`) pages with `hayro-interpret` into a
//! [`Document`]: one artboard per page, and a layer per page or per optional content group
//! (with its visibility, print state and lock; art that is off comes in as a hidden layer),
//! paths with fill/stroke, clip groups, transparency groups (with isolation and knockout), soft
//! masks โ opacity masks, axial/radial shadings โ gradients (stop opacity and unextended ends
//! kept), mesh shadings โ gradient meshes, tiling patterns โ pattern swatches, images (JPEG
//! passthrough, others re-encoded as PNG) and text as point type (or glyph outlines, see
//! [`TextAs`]). Colours keep their model: CMYK, Gray, and spot
//! inks (Separation, DeviceN) as spot swatches at a tint; a file painted mostly in CMYK opens as a
//! CMYK document. [`ImportOptions`] pick the pages, the box each
//! artboard gets ([`CropTo`]) and the password; [`info`] lists the pages and their boxes.
//! The native document a PDF carries comes back too ([`ImportReport::native`], [`editing()`]),
//! and [`file_info()`] reads its File Info (the information dictionary and the XMP packet).
//! - Presets: named settings, the built-in ones generated in code ([`builtin_presets`]).
//! - [`print()`] lays a document out on paper as File โ Print does ([`PrintSettings`]) and writes
//! the job as a print-ready PDF: composite or one page per ink.
//! - Security: the open and permissions passwords encrypt the written file with the standard
//! security handler, the algorithm following the compatibility ([`Encryption`]); either password
//! opens an encrypted file.
#![forbid(unsafe_code)]
mod editing;
mod encrypt;
mod export;
mod file_info;
mod forms;
mod images;
mod import;
mod import_color;
mod import_image;
mod import_lines;
mod import_mask;
mod import_scan;
mod import_shading;
mod import_text;
mod lab_spot;
mod linearize;
mod marks;
mod output;
mod pages;
mod patch;
mod pdfx;
mod piece_info;
mod post;
mod presets;
mod print;
mod settings;
mod streams;
mod surface;
mod syntax;
pub use editing::{EDITING_FILE, Editing, LEGACY_EDITING_FILE, editing, editing_with};
pub use encrypt::Encryption;
pub use export::{check_page_sizes, export, export_with_report, page_areas};
pub use file_info::{FileInfo, MAX_TEMPLATE_BYTES, file_info, metadata_template, read_template};
#[cfg(any(test, feature = "read-count"))]
pub use import::imports_of;
pub use import::{
INVISIBLE_TEXT_NOTE, OFF_ARTBOARD_NOTE, OUTLINED_TEXT_NOTE, PAST_PAGE_NOTE, RESHAPED_TEXT_NOTE, UNMATCHED_GLYPHS_NOTE, UNNAMED_CHARACTERS_NOTE,
holds_outlines, import, import_opened, import_with_report, is_glyph_outlines, is_outlines_note,
};
#[cfg(any(test, feature = "read-count"))]
pub use pages::reads_of;
pub use pages::{
IllustratorData, Opened, PageInfo, PdfInfo, TrimPages, has_illustrator_data, illustrator_data, illustrator_data_without_pdf_part, info,
is_postscript, open_pdf, read_illustrator_data_without_pdf_part,
};
pub use piece_info::{PRIVATE_CHUNK, PrivateData};
pub use post::{THUMBNAIL_SIZE, Thumbnail};
pub use presets::*;
pub use print::*;
pub use settings::*;
use vectorcraft_doc::Document;
/// Export options: the Save PDF settings plus what one export run decides (pages, title, date).
#[derive(Clone, Debug, Default)]
pub struct PdfOptions {
pub settings: PdfSettings,
/// 0-based artboard indices to export, in page order; `None` = all artboards.
pub artboards: Option<Vec<usize>>,
/// Document title for the metadata; `None` = the document's title.
pub title: Option<String>,
/// Ask PDF viewers to display the document title instead of the file name.
pub display_doc_title: bool,
/// Creation date as Unix seconds (UTC); `None` = now (native) / omitted (wasm). PDF/A needs a date.
pub created: Option<i64>,
/// Modification date as Unix seconds (UTC); `None` = the creation date.
pub modified: Option<i64>,
/// The native document (`.vectorcraft` bytes) Preserve Editing embeds.
pub native: Option<Vec<u8>>,
/// The editing copy of the art for every page's `PieceInfo`, as a `.ai` file carries it.
pub private_data: Option<PrivateData>,
/// The pages drawn small, in page order: what Embed Page Thumbnails embeds (the writer
/// doesn't draw; [`page_areas`] says what each page shows).
pub thumbnails: Vec<Thumbnail>,
}
impl PdfOptions {
/// Default options with uncompressed content streams (readable operators, for tests and
/// debugging).
pub fn uncompressed() -> Self {
let compression = CompressionSettings { compress_text: false, ..Default::default() };
Self { settings: PdfSettings { compression, ..Default::default() }, ..Default::default() }
}
}
/// Import options.
#[derive(Clone, Debug)]
pub struct ImportOptions {
/// Import at most this many pages (of those picked); `None` = all of them.
pub max_pages: Option<usize>,
/// Horizontal gap in points between the artboards created for consecutive pages (on trim
/// boxes, plus the document's bleed on both sides).
pub artboard_gap: f64,
/// 0-based pages to import, in this order; `None` = every page.
pub pages: Option<Vec<usize>>,
/// The page box each artboard gets.
pub crop: CropTo,
/// The (user) password of an encrypted PDF.
pub password: Option<String>,
/// What text becomes.
pub text_as: TextAs,
/// Optional content groups become layers (else each page is one layer, without the art
/// that is off).
pub layers: bool,
/// The file is an editor's own document (`.ai`): RGB in its `ICCBased` spaces keeps its numbers
/// (see `Colors::uncalibrated_rgb`). Off for PDFs, whose profiles stand.
pub uncalibrated_rgb: bool,
}
impl Default for ImportOptions {
fn default() -> Self {
Self {
max_pages: None,
artboard_gap: 36.0,
pages: None,
crop: CropTo::default(),
password: None,
text_as: TextAs::default(),
layers: true,
uncalibrated_rgb: false,
}
}
}
settings::choice! {
/// What imported text becomes.
TextAs {
/// Point type, one object per line run, in the file's fonts (by name).
Text = "text", "Text";
/// Paths of the glyphs' outlines (looks the same without the fonts).
Outlines = "outlines", "Outlines";
} default Text
}
settings::choice! {
/// The page box an imported or placed page is cropped to: its artboard (or placed frame).
CropTo {
/// The bounds of the page's art.
Bounding = "bounding", "Bounding Box";
Art = "art", "Art";
/// The visible page area (what viewers show).
Crop = "crop", "Crop";
/// The finished page: an import takes the bleed box round it as the document's bleed.
Trim = "trim", "Trim";
Bleed = "bleed", "Bleed";
/// The whole sheet.
Media = "media", "Media";
} default Crop
}
/// Result of an import with non-fatal warnings (unsupported features, skipped content).
#[derive(Clone, Debug)]
pub struct ImportReport {
pub document: Document,
pub warnings: Vec<String>,
/// The native document the PDF carries (written with Preserve Editing), if any.
pub native: Option<Editing>,
/// Every page shows only text, over an editor's private data: that data, where it reads,
/// is the file's art (a file saved without its PDF part shows a notice there instead).
pub only_text: bool,
/// The size in points of a unit of the first page read's user space: the `UserUnit` the PDF
/// reader applies to that page (1 for a page without one). The page came in at its size in
/// points, its numbers times this.
pub user_unit: f64,
}
/// Result of an export with non-fatal warnings (features approximated or dropped).
#[derive(Clone, Debug)]
pub struct ExportReport {
pub bytes: Vec<u8>,
/// What the file leaves out of the document or writes differently.
pub warnings: Vec<String>,
/// Notes on the options: one the export didn't apply or applied another way.
pub setting_notes: Vec<String>,
}
#[derive(Debug, thiserror::Error, PartialEq)]
pub enum PdfError {
#[error("the document has no artboards")]
NoArtboards,
#[error("artboard {0} does not exist")]
BadArtboard(usize),
#[error("unsupported: {0}")]
Unsupported(String),
#[error("PDF writer error: {0}")]
Write(String),
/// The caller asked for the export to stop ([`vectorcraft_doc::cancel`]).
#[error("cancelled")]
Cancelled,
#[error("cannot read PDF: {0}")]
Parse(String),
#[error("the PDF has no pages")]
NoPages,
#[error("invalid PDF setting: {0}")]
BadSetting(String),
#[error("the PDF is password-protected: give its password")]
NeedsPassword,
#[error("the PDF password is wrong")]
WrongPassword,
#[error("page {0} does not exist (the PDF has {1})")]
BadPage(usize, usize),
#[error(
"this is a PostScript file (an .ai saved in an older format or without PDF compatibility, or an EPS file), not a PDF: File โบ Open and File โบ Place read it as EPS"
)]
PostScript,
#[error(
"the file holds only a placeholder page, not its art (it was saved without PDF compatibility): save it again with PDF compatibility on, or as PDF or SVG"
)]
PlaceholderOnly,
}
impl From<craft_pdf::write::WriteError> for PdfError {
fn from(error: craft_pdf::write::WriteError) -> Self {
Self::Write(error.to_string())
}
}
#[cfg(test)]
use tests::{import_fidelity as tests_import_fidelity, live_text as tests_live_text, stroke as tests_stroke};
#[cfg(test)]
mod tests;
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.