Skip to content

PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust

Merge remote-tracking branch 'upstream/main' into main

Combiler011d1d509331bc
diff --cc crates/engine/src/edit.rs
index 000000000,faf471207..b8a300937
mode 000000,100644..100644
--- a/crates/engine/src/edit.rs
+++ b/crates/engine/src/edit.rs
@@@ -1,0 -1,1577 +1,1737 @@@
+ //! The edits a document takes: what each is called, whether its permissions allow it, and running it.
+
+ use std::sync::Arc;
+
+ use crate::{
- AddedContent, AddedText, Background, BoxSpec, EditError, FieldProps, FieldValue, FillMark, HeaderFooter, Hidden, ImageEdit, InitialView, Label,
- LineEnding, LinkAction, LinkStyle, MarkFile, MarkKind, Markup, NewAnnotation, NewField, NoteIcon, ObjectTarget, PageBox, Protection, ReviewState,
- Rgb, Shape, Standard, Style, TabOrder, TransitionSpec, Watermark, a11y, copy_image, decode_data_file, embed_image, field_table, fit_picture,
- image_content_type, is_xfa_data_file, js, mark_source, measure, open_source, strip_xfa, unrestricted, xfa, xfa_after_data_change,
++ Added, AddedContent, AddedText, Background, BoxSpec, EditError, FieldProps, FieldValue, FillMark, HeaderFooter, Hidden, ImageEdit, InitialView,
++ Label, LineEnding, LinkAction, LinkStyle, MarkFile, MarkKind, Markup, NewAnnotation, NewField, NoteIcon, ObjectTarget, PageBox, Protection,
++ ReviewState, Rgb, Shape, Standard, Style, TabOrder, TransitionSpec, Watermark, a11y, copy_image, decode_data_file, embed_image, field_table,
++ fit_picture, image_content_type, is_xfa_data_file, js, mark_source, measure, open_source, strip_xfa, unrestricted, xfa, xfa_after_data_change,
+ };
+
+ /// Edits that can be applied to a document. Page indices are 0-based.
+ #[derive(Clone, Debug, PartialEq)]
+ pub enum Edit {
+ RotatePages {
+ pages: Vec<usize>,
+ degrees: i64,
+ },
+ DeletePages {
+ pages: Vec<usize>,
+ },
+ MovePages {
+ pages: Vec<usize>,
+ to: usize,
+ },
+ /// `pages` reversed among the positions they occupy.
+ ReversePages {
+ pages: Vec<usize>,
+ },
+ InsertBlankPage {
+ at: usize,
+ width: f64,
+ height: f64,
+ },
+ /// Copies of `pages` inserted at `at` (an index in the page order as it is now), or after
+ /// the last of them when `at` is `None`.
+ DuplicatePages {
+ pages: Vec<usize>,
+ at: Option<usize>,
+ },
+ /// Replace Pages: the content of `pages` is replaced by `src_pages` of another PDF; the
+ /// pages' links, comments and bookmarks stay.
+ ReplacePages {
+ pages: Vec<usize>,
+ name: String,
+ bytes: Arc<Vec<u8>>,
+ src_pages: Vec<usize>,
+ },
+ /// Set Page Boxes / Crop: set (or reset) one box on `pages`.
+ SetPageBox {
+ pages: Vec<usize>,
+ which: PageBox,
+ spec: BoxSpec,
+ },
+ /// Set or remove the page transition and display time of pages (ISO 32000-2 §12.4.4),
+ /// Organize ▸ Page Transitions.
+ SetTransition {
+ pages: Vec<usize>,
+ spec: TransitionSpec,
+ },
+ SetInfo {
+ key: String,
+ value: String,
+ },
+ /// Insert pages from another PDF (all pages when `pages` is `None`) at position `at`.
+ InsertPagesFrom {
+ name: String,
+ bytes: Arc<Vec<u8>>,
+ pages: Option<Vec<usize>>,
+ at: usize,
+ /// How a form field whose name the document already uses is kept separate.
+ field_conflicts: pdfcraft_organize::FieldConflicts,
+ },
+ /// Add a bookmark to `page` as child `index` of the bookmark at `parent` (`[]` = top level).
+ /// It goes to the user-space point (`left`, `top`) of the page at the reader's zoom, and
+ /// either may be `None` to keep the reader's position that way (both `None` is the page top).
+ /// A coordinate that is not finite fails the edit.
+ AddBookmark {
+ parent: Vec<usize>,
+ index: usize,
+ title: String,
+ page: usize,
+ left: Option<f64>,
+ top: Option<f64>,
+ },
+ RenameBookmark {
+ path: Vec<usize>,
+ title: String,
+ },
+ /// Delete a bookmark and the bookmarks under it.
+ DeleteBookmark {
+ path: Vec<usize>,
+ },
+ /// Move a bookmark to child `index` of `to_parent` (indices after removing it).
+ MoveBookmark {
+ from: Vec<usize>,
+ to_parent: Vec<usize>,
+ index: usize,
+ },
+ /// Point a bookmark at another page.
+ SetBookmarkPage {
+ path: Vec<usize>,
+ page: usize,
+ },
+ /// Colour a bookmark's title (`/C`); `None` or black is the default black.
+ SetBookmarkColor {
+ path: Vec<usize>,
+ color: Option<[f64; 3]>,
+ },
+ /// Make a bookmark's title bold or italic or not (`/F`); `None` keeps that one.
+ SetBookmarkStyle {
+ path: Vec<usize>,
+ bold: Option<bool>,
+ italic: Option<bool>,
+ },
+ /// Bookmarks for the tagged headings (H, H1–H6), nested by level under a new first
+ /// "Untitled" bookmark (New Bookmarks from Structure).
+ BookmarksFromStructure,
+ /// Label pages `from..=to` (0-based) as Acrobat's "Number pages" does; later pages keep their labels.
+ NumberPages {
+ from: usize,
+ to: usize,
+ style: pdfcraft_organize::LabelStyle,
+ prefix: String,
+ first: u32,
+ },
+ /// Add a calibrated distance, perimeter or area annotation.
+ AddMeasurement(measure::NewMeasurement),
+ /// Store a drawing scale for a rectangular viewport (PDF user space).
+ SetMeasurementScale {
+ page: usize,
+ bbox: [f64; 4],
+ name: String,
+ scale: measure::Scale,
+ },
+ /// Add a comment (sticky note, highlight, shape, drawing, text box…).
+ AddAnnotation(NewAnnotation),
+ /// A custom stamp from a picture file (a PDF page or an image) on `page`. A zero-size
+ /// `rect` is a point: the stamp is centred there at its natural size (at most 200 pt).
+ /// Any other `rect` is a box: the picture is scaled to fit inside it, keeping its shape,
+ /// and centred in it (#4077).
+ AddCustomStamp {
+ page: usize,
+ rect: [f64; 4],
+ name: String,
+ file: MarkFile,
+ author: String,
+ },
+ /// Delete the comment at `index` in the page's `/Annots`, with its pop-up and replies.
+ DeleteAnnotation {
+ page: usize,
+ index: usize,
+ },
+ SetAnnotationContents {
+ page: usize,
+ index: usize,
+ text: String,
+ },
+ ReplyToAnnotation {
+ page: usize,
+ index: usize,
+ text: String,
+ author: String,
+ },
+ /// Acrobat's "Set status" (a state reply by `author`).
+ SetAnnotationStatus {
+ page: usize,
+ index: usize,
+ state: ReviewState,
+ author: String,
+ },
+ /// The Eraser: rub out the parts of drawing `(page, index)` near `path` (user space).
+ EraseInk {
+ page: usize,
+ index: usize,
+ path: Vec<[f64; 2]>,
+ radius: f64,
+ },
+ /// Replace Text: strike out `quads` and add a grouped caret holding `text`.
+ ReplaceText {
+ page: usize,
+ quads: Vec<[f64; 8]>,
+ text: String,
+ author: String,
+ strike: Style,
+ caret: Style,
+ },
+ /// Acrobat's "Mark with checkmark" (a hidden `/StateModel /Marked` reply by `author`).
+ MarkAnnotation {
+ page: usize,
+ index: usize,
+ marked: bool,
+ author: String,
+ },
+ /// Properties ▸ Locked.
+ LockAnnotation {
+ page: usize,
+ index: usize,
+ locked: bool,
+ },
+ MoveAnnotation {
+ page: usize,
+ index: usize,
+ dx: f64,
+ dy: f64,
+ },
+ /// Reshape a line, connected lines, a polygon or a cloud: its points in user space (a line's
+ /// two ends, the others' corners).
+ ReshapeAnnotation {
+ page: usize,
+ index: usize,
+ points: Vec<[f64; 2]>,
+ },
+ /// Resize a rectangle, oval or text box.
+ ResizeAnnotation {
+ page: usize,
+ index: usize,
+ rect: [f64; 4],
+ },
+ StyleAnnotation {
+ page: usize,
+ index: usize,
+ color: Option<Rgb>,
+ opacity: Option<f64>,
+ width: Option<f64>,
+ /// Line or polyline: two endings. Callout: one. `None` leaves `/LE` unchanged.
+ endings: Option<Vec<pdfcraft_annot::LineEnding>>,
+ },
+ /// Fill a rectangle, oval or polygon comment, or remove its fill (`None`).
+ FillAnnotation {
+ page: usize,
+ index: usize,
+ fill: Option<Rgb>,
+ },
+ /// Change the font size (pt) of a text box, typewriter text or callout.
+ FontSizeAnnotation {
+ page: usize,
+ index: usize,
+ size: f64,
+ },
+ /// Comment properties ▸ General / note icon.
+ SetAnnotationInfo {
+ page: usize,
+ index: usize,
+ author: Option<String>,
+ subject: Option<String>,
+ icon: Option<NoteIcon>,
+ },
+ /// Fill in a form field.
+ SetFieldValue {
+ name: String,
+ value: FieldValue,
+ },
+ /// Clear form: the named fields (all when `None`) back to their defaults.
+ ResetForm {
+ names: Option<Vec<String>>,
+ },
+ /// Prepare a form: add a field on a page (`rect` in PDF user space); `name` defaults to
+ /// Acrobat's next free name ("Text1", "Check Box2", …).
+ AddField {
+ page: usize,
+ rect: [f64; 4],
+ kind: NewField,
+ name: Option<String>,
+ },
+ /// Field Properties ▸ General / Options.
+ SetFieldProps {
+ name: String,
+ props: Box<FieldProps>,
+ },
+ /// An image field (or any button): show this image file (PNG, JPEG, TIFF, GIF, BMP).
+ SetFieldImage {
+ name: String,
+ image: Arc<Vec<u8>>,
+ },
+ /// Duplicate a field onto other pages (same field, shared value).
+ DuplicateField {
+ name: String,
+ pages: Vec<usize>,
+ },
+ DeleteField {
+ name: String,
+ },
+ /// Page properties ▸ Tab order, for pages (0-based).
+ SetTabOrder {
+ pages: Vec<usize>,
+ order: TabOrder,
+ },
+ /// Document Properties ▸ Initial View (and the language and binding).
+ SetInitialView(Box<InitialView>),
+ /// Edit ▸ Attach a file: a document-level attachment (`/Names /EmbeddedFiles`) under
+ /// `name`, made unique; `mime` is the embedded file's `/Subtype` when known.
+ AddAttachment {
+ name: String,
+ bytes: Vec<u8>,
+ description: Option<String>,
+ mime: Option<String>,
+ },
+ /// Remove the document-level attachment whose name-tree key is `key`.
+ DeleteAttachment {
+ key: String,
+ },
+ /// Build a tagged structure tree for an untagged, text-only document.
+ AutoTagText,
+ /// Add alternate text: set (or clear, with `None`) a figure's alternate text. `figure` is
+ /// the figure element's object number (from `Document::figures`).
+ SetAltText {
+ figure: u32,
+ alt: Option<String>,
+ },
+ /// Add `/Form` tags and object references for all widgets in an untagged AcroForm.
+ AutoTagFormFields,
+ /// Change one property on a reachable indirect structure tag.
+ SetTagProperty {
+ object: pdfcraft_cos::ObjRef,
+ property: a11y::TagProperty,
+ value: Option<String>,
+ },
+ /// Move a structure tag before or after a direct sibling in reading order.
+ MoveTag {
+ object: pdfcraft_cos::ObjRef,
+ anchor: pdfcraft_cos::ObjRef,
+ placement: a11y::TagPlacement,
+ },
+ /// Add alternate text ▸ Decorative figure: the figure's content becomes an artifact.
+ MarkDecorative {
+ figure: u32,
+ },
+ /// Tags panel ▸ Mark as artifact: retire a leaf tag and mark its content as an artifact.
+ MarkTagArtifact {
+ object: pdfcraft_cos::ObjRef,
+ },
+ /// Document JavaScripts: add, replace (`script`) or remove (`None`) the document-level
+ /// script `name`.
+ SetDocumentScript {
+ name: String,
+ script: Option<String>,
+ },
+ /// Field Properties ▸ a custom script: set or remove field `name`'s JavaScript for `event`
+ /// (keystroke, format, validate, calculate or mouse_up).
+ SetFieldScript {
+ name: String,
+ event: String,
+ script: Option<String>,
+ },
+ /// Standards ▸ Save as PDF/A: fix what can be fixed for `level` (metadata, output intent,
+ /// forbidden actions, annotation flags, …).
+ ConvertPdfA {
+ level: pdfcraft_preflight::Level,
+ },
+ /// Remove what identifies the document as meeting `standard` (PDF/A or PDF/X).
+ RemoveStandardId {
+ standard: Standard,
+ },
+ /// What a script (button or console) changed in form fields: values, read-only, required
+ /// and visibility.
+ ApplyScriptChanges {
+ changes: Vec<pdfcraft_forms::FieldChange>,
+ },
+ /// An XFA form's scripted event (a button's `click`, say) on the object at `som`: what the
+ /// script changes (values, rows, visibility) is applied and the form laid out again.
+ XfaEvent {
+ som: String,
+ activity: String,
+ },
+ /// Scan & OCR ▸ Recognize text: put recognised words on `page` as invisible text over the
+ /// image (from [`ocr::OcrJob::run`](crate::ocr::OcrJob::run)).
+ AddOcrText {
+ page: usize,
+ words: Vec<pdfcraft_ocr::PlacedWord>,
+ },
+ /// Edit a PDF ▸ Edit text: replace the text of line `line` (from `Document::text_lines`) on
+ /// `page`, in its own font when it can show it, else in Helvetica.
+ EditTextLine {
+ page: usize,
+ line: usize,
+ text: String,
+ },
+ /// Edit a PDF ▸ an existing image on `page` (index from `Document::page_images`).
+ EditPageImage {
+ page: usize,
+ index: usize,
+ change: ImageEdit,
+ },
+ /// Move mixed existing and added objects together. References resolve before any change;
+ /// offset is a user-space vector. No retyping, reflow or font substitution is involved.
+ MoveObjects {
+ page: usize,
+ objects: Vec<ObjectTarget>,
+ offset: [f64; 2],
+ },
+ /// Edit text in a paragraph box: replace paragraph `block` (from `Document::text_blocks`),
+ /// rewrapped to the box's width.
+ EditTextBlock {
+ page: usize,
+ block: usize,
+ text: String,
+ /// Formatting changes (font, size, colour, alignment); default keeps the paragraph's.
+ style: pdfcraft_edit::BlockStyle,
+ },
+ /// An explicit open-licensed full font program, completing subsets or selected by a user.
+ RegisterTextFont {
+ page: usize,
+ bytes: Arc<Vec<u8>>,
+ },
+ /// Order tabs manually: move a field one place earlier or later on its page.
+ MoveInTabOrder {
+ name: String,
+ earlier: bool,
+ },
+ /// Set the calculation order: these calculated fields first, in this order, then the others
+ /// in their current order (see [`Document::calculation_order`](crate::Document::calculation_order)). The form recalculates.
+ SetCalculationOrder {
+ names: Vec<String>,
+ },
+ /// Add a header and footer (with `replace`, existing ones on those pages go first).
+ AddHeaderFooter {
+ pages: Vec<usize>,
+ settings: HeaderFooter,
+ replace: bool,
+ },
+ /// `file`: a picture from a file (an image, or a page of a PDF) instead of text.
+ AddWatermark {
+ pages: Vec<usize>,
+ settings: Watermark,
+ replace: bool,
+ file: Option<MarkFile>,
+ },
+ /// `file`: a picture from a file instead of a colour.
+ AddBackground {
+ pages: Vec<usize>,
+ settings: Background,
+ replace: bool,
+ file: Option<MarkFile>,
+ },
+ /// Remove every mark of a kind from every page.
+ RemoveMarks {
+ kind: MarkKind,
+ },
+ /// Edit a PDF ▸ Add content ▸ Text (`text.rect` in display space).
+ AddText {
+ page: usize,
+ text: AddedText,
+ },
+ /// Edit a PDF ▸ Add content ▸ Image: an image file placed at `rect` (display space), or at
+ /// its natural size centred on the page (shrunk to fit).
+ AddImage {
+ page: usize,
+ rect: Option<[f64; 4]>,
+ name: String,
+ bytes: Arc<Vec<u8>>,
+ },
+ /// Move, resize, retype or reformat an added item (`index` among the page's added items).
+ UpdateContent {
+ page: usize,
+ index: usize,
+ content: AddedContent,
+ },
+ DeleteContent {
+ page: usize,
+ index: usize,
+ },
+ /// Replace an added image with another file (keeping its box and transforms).
+ ReplaceImage {
+ page: usize,
+ index: usize,
+ name: String,
+ bytes: Arc<Vec<u8>>,
+ },
+ /// Edit ▸ Paste: an added item copied in this document or another, as it was: text with its
+ /// style, an image in its box (display space) with its turns, flips and crop. An image's
+ /// picture is `file` (from [`Document::added_image_file`](crate::Document::added_image_file)): the copied image object is reused
+ /// while it is still that picture in this document, else one an added image here already draws
+ /// it from, else the file is embedded.
+ PasteContent {
+ page: usize,
+ content: AddedContent,
+ file: Option<(String, Arc<Vec<u8>>)>,
+ },
+ /// Apply redaction marks (all, or those on `pages`): remove what they cover for good.
+ ApplyRedactions {
+ pages: Option<Vec<usize>>,
+ },
+ /// Remove redaction marks without applying them.
+ ClearRedactions,
+ /// Edit a PDF ▸ Link: a new link over `rect` (user space).
+ AddLink {
+ page: usize,
+ rect: [f64; 4],
+ action: LinkAction,
+ style: LinkStyle,
+ },
+ /// Link Properties (`index` in the page's `/Annots`).
+ SetLink {
+ page: usize,
+ index: usize,
+ rect: Option<[f64; 4]>,
+ action: Option<LinkAction>,
+ style: Option<LinkStyle>,
+ },
+ DeleteLink {
+ page: usize,
+ index: usize,
+ },
+ /// Remove all links (on `pages`, or everywhere).
+ RemoveLinks {
+ pages: Option<Vec<usize>>,
+ },
+ /// Create links from URLs in the text: (page, line rects in user space, URI).
+ AddLinks {
+ links: Vec<(usize, Vec<[f64; 4]>, String)>,
+ style: LinkStyle,
+ },
+ /// Import comments and/or form data (XFDF, FDF, XML, CSV, tab-delimited text).
+ ImportData {
+ name: String,
+ bytes: Arc<Vec<u8>>,
+ },
+ /// Remove Hidden Information: the chosen categories.
+ RemoveHidden {
+ which: Vec<Hidden>,
+ },
+ /// Sanitize Document: every category, then a full rewrite on save.
+ Sanitize,
+ /// An XFA form made an ordinary (static) PDF form: the XFA packets, `/NeedsRendering` and
+ /// PdfCraft's private keys go, the pages as laid out and the fields with their values
+ /// stay, so every viewer shows the same form and none lays it out again. Its scripts no
+ /// longer run.
+ XfaToStatic,
+ /// Flatten comments and/or form fields on every page into page content.
+ Flatten {
+ comments: bool,
+ fields: bool,
+ },
+ /// Bake Fill & Sign text, marks and signatures into the page. Other comments and fields stay.
+ /// A no-op (no undo step) when the document has none.
+ FlattenFillSign,
+ /// Protect with passwords and permissions (written by the next save, which is a full rewrite).
+ Protect(Protection),
+ /// Remove password security (needs the owner password).
+ RemoveProtection,
+ /// Several edits applied as one undoable step (all or nothing).
+ Batch {
+ label: String,
+ edits: Vec<Edit>,
+ },
+ }
+
+ /// Every wording [`Edit::label`] can produce, for an interface to translate. `Edit::Batch` is not
+ /// here: its wording is only the hole, because a batch carries its name as text (see
+ /// [`BATCH_LABELS`]).
+ pub const EDIT_LABELS: &[&str] = &[
+ "Rotate page",
+ "Change tag properties",
+ "Rotate pages",
+ "Delete page",
+ "Delete pages",
+ "Move page",
+ "Move pages",
+ "Reverse pages",
+ "Insert blank page",
+ "Duplicate page",
+ "Duplicate pages",
+ "Replace page",
+ "Replace pages",
+ "Crop page",
+ "Crop pages",
+ "Set page boxes",
+ "Set page transitions",
+ "Change Title",
+ "Change Author",
+ "Change Subject",
+ "Change Keywords",
+ "Change {key}",
+ "Insert pages from {name}",
+ "Insert pages from {name} — 1 field renamed",
+ "Insert pages from {name} — fields renamed",
+ "Attach {name}",
+ "Delete attachment {key}",
+ "Add bookmark",
+ "Rename bookmark",
+ "Delete bookmark",
+ "Move bookmark",
+ "Set bookmark destination",
+ "Colour",
+ "Style",
+ "New bookmarks from structure",
+ "Number pages",
+ "Measure distance",
+ "Measure perimeter",
+ "Measure area",
+ "Set measurement scale",
+ "Add sticky note",
+ "Add highlight",
+ "Add underline",
+ "Add strikethrough",
+ "Add squiggly underline",
+ "Add rectangle",
+ "Add oval",
+ "Add arrow",
+ "Add line",
+ "Add drawing",
+ "Add text box",
+ "Add checkmark",
+ "Add cross",
+ "Add dot",
+ "Add signature",
+ "Add redaction mark",
+ "Add cloud",
+ "Add polygon",
+ "Add connected lines",
+ "Add callout",
+ "Add inserted text",
+ "Add file attachment",
+ "Add stamp",
+ "Delete comment",
+ "Edit comment",
+ "Reply",
+ "Set status None",
+ "Set status Accepted",
+ "Set status Rejected",
+ "Set status Cancelled",
+ "Set status Completed",
+ "Replace text",
+ "Erase",
+ "Mark with checkmark",
+ "Remove checkmark",
+ "Lock comment",
+ "Unlock comment",
+ "Move comment",
+ "Reshape comment",
+ "Resize comment",
+ "Change comment properties",
+ "Fill in {name}",
+ "Set the image of {name}",
+ "Clear form",
+ "Add field",
+ "Change field properties",
+ "Delete field",
+ "Duplicate field",
+ "Set tab order",
+ "Set calculation order",
+ "Change initial view",
+ "Set alternate text",
+ "Mark figure as decorative",
+ "Recognize text",
+ "Run JavaScript",
+ "Run form script",
+ "Save as {level}",
+ "Remove {standard} identification",
+ "Edit script of {name}",
+ "Delete document JavaScript",
+ "Edit document JavaScript",
+ "Edit text",
+ "Load document font",
+ "Move object",
+ "Move objects",
+ "Move image",
++ "Transform image",
+ "Rotate image",
+ "Flip image",
+ "Replace image",
+ "Delete image",
++ "Bring to front",
++ "Send to back",
++ "Bring forward",
++ "Send backward",
++ "Remove crop",
++ "Crop image",
+ "Add header & footer",
+ "Update header & footer",
+ "Add watermark",
+ "Update watermark",
+ "Add background",
+ "Update background",
+ "Remove header & footer",
+ "Remove watermark",
+ "Remove background",
+ "Add text",
+ "Add image",
+ "Edit content",
+ "Delete content",
+ "Paste",
+ "Apply redactions",
+ "Remove redaction marks",
+ "Remove hidden information",
+ "Import {name}",
+ "Add link",
+ "Change link properties",
+ "Delete link",
+ "Remove all links",
+ "Create link",
+ "Create links",
+ "Sanitize document",
+ "Flatten comments",
+ "Flatten form fields",
+ "Flatten",
+ "Flatten Fill & Sign",
+ "Protect with password",
+ "Remove security",
+ ];
+
+ /// The names of the batches built below L7, which an interface shows in the same places as
+ /// [`EDIT_LABELS`] and so translates the same way. A batch built in the interface itself arrives
+ /// already worded in the interface's language.
+ pub const BATCH_LABELS: &[&str] =
+ &["Set document title", "Mark differences", "Detect form fields", "Run JavaScript", "Recognize text", field_table::LABEL, "Style"];
+
+ impl Edit {
+ /// Label for the Edit menu and history ("Undo Rotate pages").
+ pub fn label(&self) -> Label {
+ match self {
+ Edit::RotatePages { pages, .. } => plural("Rotate page", "Rotate pages", pages.len()),
+ Edit::DeletePages { pages } => plural("Delete page", "Delete pages", pages.len()),
+ Edit::MovePages { pages, .. } => plural("Move page", "Move pages", pages.len()),
+ Edit::ReversePages { .. } => Label::of("Reverse pages"),
+ Edit::InsertBlankPage { .. } => Label::of("Insert blank page"),
+ Edit::DuplicatePages { pages, .. } => plural("Duplicate page", "Duplicate pages", pages.len()),
+ Edit::ReplacePages { pages, .. } => plural("Replace page", "Replace pages", pages.len()),
+ Edit::SetPageBox { pages, which: PageBox::Crop, .. } => plural("Crop page", "Crop pages", pages.len()),
+ Edit::SetPageBox { .. } => Label::of("Set page boxes"),
+ Edit::SetTransition { .. } => Label::of("Set page transitions"),
+ // The four `/Info` keys PdfCraft itself offers get a wording of their own, so each can
+ // be said in another language; any other key is the document's and goes in as it stands.
+ Edit::SetInfo { key, .. } => match key.as_str() {
+ "Title" => Label::of("Change Title"),
+ "Author" => Label::of("Change Author"),
+ "Subject" => Label::of("Change Subject"),
+ "Keywords" => Label::of("Change Keywords"),
+ _ => Label::with("Change {key}", key.as_str()),
+ },
+ Edit::InsertPagesFrom { name, .. } => Label::with("Insert pages from {name}", name.as_str()),
+ Edit::AddBookmark { .. } => Label::of("Add bookmark"),
+ Edit::RenameBookmark { .. } => Label::of("Rename bookmark"),
+ Edit::DeleteBookmark { .. } => Label::of("Delete bookmark"),
+ Edit::MoveBookmark { .. } => Label::of("Move bookmark"),
+ Edit::SetBookmarkPage { .. } => Label::of("Set bookmark destination"),
+ // The bookmark Style and Colour menus' own names, already said in every language.
+ Edit::SetBookmarkColor { .. } => Label::of("Colour"),
+ Edit::SetBookmarkStyle { .. } => Label::of("Style"),
+ Edit::BookmarksFromStructure => Label::of("New bookmarks from structure"),
+ Edit::NumberPages { .. } => Label::of("Number pages"),
+ // What was measured is part of the wording too, for the same reason.
+ Edit::AddMeasurement(m) => Label::of(match m.kind {
+ pdfcraft_measure::Kind::Distance => "Measure distance",
+ pdfcraft_measure::Kind::Perimeter => "Measure perimeter",
+ pdfcraft_measure::Kind::Area => "Measure area",
+ }),
+ Edit::SetMeasurementScale { .. } => Label::of("Set measurement scale"),
+ Edit::AddAnnotation(a) => Label::of(add_annotation(&a.shape)),
+ Edit::AddCustomStamp { .. } => Label::of("Add stamp"),
+ Edit::DeleteAnnotation { .. } => Label::of("Delete comment"),
+ Edit::SetAnnotationContents { .. } => Label::of("Edit comment"),
+ Edit::ReplyToAnnotation { .. } => Label::of("Reply"),
+ // The state's name is part of the wording: a language may need to agree it with the rest.
+ Edit::SetAnnotationStatus { state, .. } => Label::of(match state {
+ ReviewState::None => "Set status None",
+ ReviewState::Accepted => "Set status Accepted",
+ ReviewState::Rejected => "Set status Rejected",
+ ReviewState::Cancelled => "Set status Cancelled",
+ ReviewState::Completed => "Set status Completed",
+ }),
+ Edit::ReplaceText { .. } => Label::of("Replace text"),
+ Edit::EraseInk { .. } => Label::of("Erase"),
+ Edit::MarkAnnotation { marked: true, .. } => Label::of("Mark with checkmark"),
+ Edit::MarkAnnotation { .. } => Label::of("Remove checkmark"),
+ Edit::LockAnnotation { locked: true, .. } => Label::of("Lock comment"),
+ Edit::LockAnnotation { .. } => Label::of("Unlock comment"),
+ Edit::MoveAnnotation { .. } => Label::of("Move comment"),
+ Edit::ReshapeAnnotation { .. } => Label::of("Reshape comment"),
+ Edit::ResizeAnnotation { .. } => Label::of("Resize comment"),
+ Edit::StyleAnnotation { .. } | Edit::FillAnnotation { .. } | Edit::FontSizeAnnotation { .. } | Edit::SetAnnotationInfo { .. } => {
+ Label::of("Change comment properties")
+ }
+ Edit::SetFieldValue { name, .. } => Label::with("Fill in {name}", name.as_str()),
+ Edit::SetFieldImage { name, .. } => Label::with("Set the image of {name}", name.as_str()),
+ Edit::ResetForm { .. } => Label::of("Clear form"),
+ Edit::AddField { .. } => Label::of("Add field"),
+ Edit::SetFieldProps { .. } => Label::of("Change field properties"),
+ Edit::DeleteField { .. } => Label::of("Delete field"),
+ Edit::DuplicateField { .. } => Label::of("Duplicate field"),
+ Edit::SetTabOrder { .. } | Edit::MoveInTabOrder { .. } => Label::of("Set tab order"),
+ Edit::SetCalculationOrder { .. } => Label::of("Set calculation order"),
+ Edit::SetInitialView(_) => Label::of("Change initial view"),
+ Edit::AddAttachment { name, .. } => Label::with("Attach {name}", name.as_str()),
+ Edit::DeleteAttachment { key } => Label::with("Delete attachment {key}", key.as_str()),
+ Edit::AutoTagText => Label::of("Automatically tag text"),
+ Edit::SetAltText { .. } => Label::of("Set alternate text"),
+ Edit::AutoTagFormFields => Label::of("Tag form fields"),
+ Edit::SetTagProperty { .. } => Label::of("Change tag properties"),
+ Edit::MoveTag { .. } => Label::of("Move object"),
+ Edit::MarkDecorative { .. } => Label::of("Mark figure as decorative"),
+ Edit::MarkTagArtifact { .. } => Label::of("Mark content as artifact"),
+ Edit::AddOcrText { .. } => Label::of("Recognize text"),
+ Edit::ApplyScriptChanges { .. } => Label::of("Run JavaScript"),
+ Edit::XfaEvent { .. } => Label::of("Run form script"),
+ // The level is the standard's own name ("PDF/A-2b"), so it goes in as it stands.
+ Edit::ConvertPdfA { level } => Label::with("Save as {level}", level.label()),
+ Edit::RemoveStandardId { standard } => Label::with("Remove {standard} identification", standard.label()),
+ Edit::SetFieldScript { name, .. } => Label::with("Edit script of {name}", name.as_str()),
+ Edit::SetDocumentScript { script: None, .. } => Label::of("Delete document JavaScript"),
+ Edit::SetDocumentScript { .. } => Label::of("Edit document JavaScript"),
+ Edit::EditTextLine { .. } | Edit::EditTextBlock { .. } => Label::of("Edit text"),
+ Edit::RegisterTextFont { .. } => Label::of("Load document font"),
+ Edit::MoveObjects { objects, .. } => plural("Move object", "Move objects", objects.len()),
+ Edit::EditPageImage { change, .. } => Label::of(match change {
+ ImageEdit::Move(_) => "Move image",
++ ImageEdit::Transform(_) => "Transform image",
+ ImageEdit::Rotate(_) | ImageEdit::RotateBy(_) => "Rotate image",
+ ImageEdit::Crop(_) => "Crop image",
+ ImageEdit::Flip { .. } => "Flip image",
+ ImageEdit::Replace { .. } => "Replace image",
+ ImageEdit::Delete => "Delete image",
++ ImageEdit::Arrange(ord) => match ord {
++ pdfcraft_edit::ArrangeOrder::BringToFront => "Bring to front",
++ pdfcraft_edit::ArrangeOrder::SendToBack => "Send to back",
++ pdfcraft_edit::ArrangeOrder::BringForward => "Bring forward",
++ pdfcraft_edit::ArrangeOrder::SendBackward => "Send backward",
++ },
++ ImageEdit::RemoveCrop => "Remove crop",
+ }),
+ Edit::AddHeaderFooter { replace: false, .. } => Label::of("Add header & footer"),
+ Edit::AddHeaderFooter { .. } => Label::of("Update header & footer"),
+ Edit::AddWatermark { replace: false, .. } => Label::of("Add watermark"),
+ Edit::AddWatermark { .. } => Label::of("Update watermark"),
+ Edit::AddBackground { replace: false, .. } => Label::of("Add background"),
+ Edit::AddBackground { .. } => Label::of("Update background"),
+ Edit::RemoveMarks { kind: MarkKind::HeaderFooter } => Label::of("Remove header & footer"),
+ Edit::RemoveMarks { kind: MarkKind::Watermark } => Label::of("Remove watermark"),
+ Edit::RemoveMarks { kind: MarkKind::Background } => Label::of("Remove background"),
+ Edit::AddText { .. } => Label::of("Add text"),
+ Edit::AddImage { .. } => Label::of("Add image"),
+ Edit::UpdateContent { .. } => Label::of("Edit content"),
+ Edit::DeleteContent { .. } => Label::of("Delete content"),
+ Edit::ReplaceImage { .. } => Label::of("Replace image"),
+ Edit::PasteContent { .. } => Label::of("Paste"),
+ Edit::ApplyRedactions { .. } => Label::of("Apply redactions"),
+ Edit::ClearRedactions => Label::of("Remove redaction marks"),
+ Edit::RemoveHidden { .. } => Label::of("Remove hidden information"),
+ Edit::ImportData { name, .. } => Label::with("Import {name}", name.as_str()),
+ Edit::AddLink { .. } => Label::of("Add link"),
+ Edit::SetLink { .. } => Label::of("Change link properties"),
+ Edit::DeleteLink { .. } => Label::of("Delete link"),
+ Edit::RemoveLinks { .. } => Label::of("Remove all links"),
+ Edit::AddLinks { links, .. } => plural("Create link", "Create links", links.len()),
+ Edit::Sanitize => Label::of("Sanitize document"),
+ Edit::XfaToStatic => Label::of("Convert to a static form"),
+ Edit::Flatten { comments: true, fields: false } => Label::of("Flatten comments"),
+ Edit::Flatten { comments: false, fields: true } => Label::of("Flatten form fields"),
+ Edit::Flatten { .. } => Label::of("Flatten"),
+ Edit::FlattenFillSign => Label::of("Flatten Fill & Sign"),
+ Edit::Protect(_) => Label::of("Protect with password"),
+ Edit::RemoveProtection => Label::of("Remove security"),
+ // A batch carries its own name, already worded by whoever built it.
+ // A batch carries its name as text, so the wording is only the hole (see `BATCH_LABELS`).
+ Edit::Batch { label, .. } => Label::with("{batch}", label.as_str()),
+ }
+ }
+ }
+
+ /// What the Edit menu calls a new comment ("Undo Add highlight"). A whole wording for each kind,
+ /// so a language can give the noun the article and the gender its own grammar asks for.
+ fn add_annotation(s: &Shape) -> &'static str {
+ match s {
+ Shape::Note { .. } => "Add sticky note",
+ Shape::TextMarkup { kind: Markup::Highlight, .. } => "Add highlight",
+ Shape::TextMarkup { kind: Markup::Underline, .. } => "Add underline",
+ Shape::TextMarkup { kind: Markup::StrikeOut, .. } => "Add strikethrough",
+ Shape::TextMarkup { kind: Markup::Squiggly, .. } => "Add squiggly underline",
+ Shape::Rectangle { .. } => "Add rectangle",
+ Shape::Oval { .. } => "Add oval",
+ Shape::Line { start: LineEnding::None, end: LineEnding::OpenArrow, .. } => "Add arrow",
+ Shape::Line { .. } => "Add line",
+ Shape::Ink { .. } => "Add drawing",
+ Shape::TextBox { .. } => "Add text box",
+ Shape::Typewriter { .. } => "Add text",
+ Shape::Mark { mark: FillMark::Check, .. } => "Add checkmark",
+ Shape::Mark { mark: FillMark::Cross, .. } => "Add cross",
+ Shape::Mark { mark: FillMark::Dot, .. } => "Add dot",
+ Shape::Mark { mark: FillMark::Line, .. } => "Add line",
+ Shape::Signature { .. } | Shape::TypedSignature { .. } => "Add signature",
+ Shape::Redact { .. } => "Add redaction mark",
+ Shape::Stamp { .. } | Shape::CustomStamp { .. } => "Add stamp",
+ Shape::Polygon { cloud: true, .. } => "Add cloud",
+ Shape::Polygon { .. } => "Add polygon",
+ Shape::PolyLine { .. } => "Add connected lines",
+ Shape::Callout { .. } => "Add callout",
+ Shape::Caret { .. } => "Add inserted text",
+ Shape::Attachment { .. } => "Add file attachment",
+ }
+ }
+
+ /// Whether the opening password allows an edit (§7.6.4.2, Table 22).
+ pub(crate) fn check_permission(edit: &Edit, p: &pdfcraft_cos::Permissions) -> Result<(), EditError> {
+ match edit {
+ Edit::RotatePages { .. }
+ | Edit::DeletePages { .. }
+ | Edit::MovePages { .. }
+ | Edit::ReversePages { .. }
+ | Edit::InsertBlankPage { .. }
+ | Edit::DuplicatePages { .. }
+ | Edit::ReplacePages { .. }
+ | Edit::SetPageBox { .. }
+ | Edit::SetTransition { .. }
+ | Edit::InsertPagesFrom { .. }
+ // "Assemble the document: insert, rotate or delete pages and create bookmarks" (Table 22).
+ | Edit::AddBookmark { .. }
+ | Edit::RenameBookmark { .. }
+ | Edit::DeleteBookmark { .. }
+ | Edit::MoveBookmark { .. }
+ | Edit::SetBookmarkPage { .. }
+ | Edit::SetBookmarkColor { .. }
+ | Edit::SetBookmarkStyle { .. }
+ | Edit::BookmarksFromStructure
+ | Edit::NumberPages { .. } => {
+ if p.assemble() {
+ Ok(())
+ } else {
+ Err(EditError::NotPermitted("page changes"))
+ }
+ }
+ Edit::AddMeasurement(_)
+ | Edit::AddAnnotation(_)
+ | Edit::AddCustomStamp { .. }
+ | Edit::DeleteAnnotation { .. }
+ | Edit::SetAnnotationContents { .. }
+ | Edit::ReplyToAnnotation { .. }
+ | Edit::SetAnnotationStatus { .. }
+ | Edit::MarkAnnotation { .. }
+ | Edit::ReplaceText { .. }
+ | Edit::EraseInk { .. }
+ | Edit::LockAnnotation { .. }
+ | Edit::MoveAnnotation { .. }
+ | Edit::ReshapeAnnotation { .. }
+ | Edit::ResizeAnnotation { .. }
+ | Edit::StyleAnnotation { .. }
+ | Edit::FillAnnotation { .. }
+ | Edit::FontSizeAnnotation { .. }
+ | Edit::SetAnnotationInfo { .. }
+ | Edit::SetMeasurementScale { .. } => {
+ if p.annotate() {
+ Ok(())
+ } else {
+ Err(EditError::NotPermitted("comments"))
+ }
+ }
+ Edit::SetFieldValue { .. } | Edit::ResetForm { .. } | Edit::SetFieldImage { .. } | Edit::ApplyScriptChanges { .. } | Edit::XfaEvent { .. } => {
+ if p.fill_forms() {
+ Ok(())
+ } else {
+ Err(EditError::NotPermitted("filling in form fields"))
+ }
+ }
+ Edit::Protect(_) | Edit::RemoveProtection => {
+ if unrestricted(p) {
+ Ok(())
+ } else {
+ Err(EditError::NotPermitted("changing security"))
+ }
+ }
+ // Converting to PDF/A takes the encryption off (PDF/A forbids it), so on an encrypted
+ // document it is a change of security (#3921).
+ Edit::ConvertPdfA { .. } => {
+ if unrestricted(p) {
+ Ok(())
+ } else {
+ Err(EditError::NotPermitted("removing the encryption, which PDF/A forbids"))
+ }
+ }
+ Edit::SetInfo { .. }
+ | Edit::AddHeaderFooter { .. }
+ | Edit::AddWatermark { .. }
+ | Edit::AddBackground { .. }
+ | Edit::RemoveMarks { .. }
+ | Edit::AddField { .. }
+ | Edit::ApplyRedactions { .. }
+ | Edit::AddText { .. }
+ | Edit::AddImage { .. }
+ | Edit::UpdateContent { .. }
+ | Edit::MoveObjects { .. }
+ | Edit::DeleteContent { .. }
+ | Edit::ReplaceImage { .. }
+ | Edit::PasteContent { .. }
+ | Edit::ClearRedactions
+ | Edit::RemoveHidden { .. }
+ | Edit::ImportData { .. }
+ | Edit::AddLink { .. }
+ | Edit::SetLink { .. }
+ | Edit::DeleteLink { .. }
+ | Edit::RemoveLinks { .. }
+ | Edit::AddLinks { .. }
+ | Edit::Sanitize
+ | Edit::XfaToStatic
+ | Edit::SetFieldProps { .. }
+ | Edit::DeleteField { .. }
+ | Edit::DuplicateField { .. }
+ | Edit::SetTabOrder { .. }
+ | Edit::MoveInTabOrder { .. }
+ | Edit::SetCalculationOrder { .. }
+ | Edit::SetInitialView(_)
+ | Edit::AddAttachment { .. }
+ | Edit::DeleteAttachment { .. }
+ | Edit::AutoTagText
+ | Edit::SetAltText { .. }
+ | Edit::AutoTagFormFields
+ | Edit::SetTagProperty { .. }
+ | Edit::MoveTag { .. }
+ | Edit::MarkDecorative { .. }
+ | Edit::MarkTagArtifact { .. }
+ | Edit::AddOcrText { .. }
+ | Edit::SetDocumentScript { .. }
+ | Edit::SetFieldScript { .. }
+ | Edit::RemoveStandardId { .. }
+ | Edit::EditTextLine { .. }
+ | Edit::EditTextBlock { .. }
+ | Edit::RegisterTextFont { .. }
+ | Edit::EditPageImage { .. }
+ | Edit::Flatten { .. }
+ | Edit::FlattenFillSign => {
+ if p.modify() {
+ Ok(())
+ } else {
+ Err(EditError::NotPermitted("changes to the document"))
+ }
+ }
+ Edit::Batch { edits, .. } => edits.iter().try_for_each(|e| check_permission(e, p)),
+ }
+ }
+
+ /// Dates and unique ids stamped onto what an edit creates.
+ pub(crate) struct EditCtx {
+ /// Field scripts run (`None`: JavaScript is off) and what they produced.
+ pub(crate) js: Option<js::JsRunner>,
+ /// A laid-out XFA form's template (`None`: not an XFA form, or JavaScript is off) and what
+ /// its scripts produced.
+ pub(crate) xfa: Option<Arc<pdfcraft_xfa::model::Template>>,
+ pub(crate) xfa_out: js::JsOutput,
+ /// The datasets stream this edit wrote (later writes in the edit replace it in place).
+ pub(crate) xfa_datasets: Option<pdfcraft_cos::ObjRef>,
+ /// A form script ran too long and was abandoned: the document's scripts go off.
+ pub(crate) xfa_ran_away: bool,
+ /// What the XFA scripts' time limits are multiplied by ([`Session::with_xfa_time_scale`]).
+ pub(crate) xfa_time_scale: u32,
+ /// The edit took the XFA out of the form: what went with it, for the document's warnings.
+ pub(crate) xfa_removed: Vec<String>,
+ /// Pages in the document, for `xfa.layout.pageCount()`.
+ pub(crate) pages: usize,
+ pub(crate) date: Option<String>,
+ /// Today in local time, for date tokens.
+ pub(crate) today: (i64, u32, u32),
+ pub(crate) seed: u64,
+ pub(crate) count: u64,
+ /// Fields the edit renamed to keep imported names separate (old → new), for the repair
+ /// log and the undo label.
+ pub(crate) renamed_fields: Vec<(String, String)>,
+ /// The overlay streams the edit's applied redactions added, which alone the renderer's check
+ /// leaves out.
+ pub(crate) redaction_overlays: Vec<pdfcraft_cos::ObjRef>,
+ }
+
+ impl EditCtx {
+ pub(crate) fn new(now: Option<i64>, salt: u64) -> Self {
+ let mut seed = 0x9E37_79B9_7F4A_7C15u64 ^ salt;
+ if let Some(t) = now {
+ seed ^= (t as u64).rotate_left(17);
+ }
+ #[cfg(not(target_arch = "wasm32"))]
+ if now.is_some() {
+ // Real clock: mix in sub-second time so ids from two sessions don't collide.
+ seed ^= std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.subsec_nanos() as u64).unwrap_or(0) << 32;
+ }
+ Self {
+ js: None,
+ xfa: None,
+ xfa_out: Default::default(),
+ xfa_datasets: None,
+ xfa_ran_away: false,
+ xfa_time_scale: 1,
+ xfa_removed: Vec::new(),
+ pages: 0,
+ date: now.map(pdfcraft_cos::pdf_date),
+ today: (1970, 1, 1),
+ seed,
+ count: 0,
+ renamed_fields: Vec::new(),
+ redaction_overlays: Vec::new(),
+ }
+ }
+
+ /// 32 bytes of entropy for new encryption keys and salts. `RandomState` is seeded by the
+ /// operating system, so no extra dependency is needed.
+ fn entropy(&mut self) -> [u8; 32] {
+ use std::hash::{BuildHasher, Hasher};
+ let mut out = [0u8; 32];
+ for (i, chunk) in out.chunks_mut(8).enumerate() {
+ let mut h = std::collections::hash_map::RandomState::new().build_hasher();
+ h.write_u64(self.seed ^ i as u64);
+ h.write_u64(self.count);
+ self.count += 1;
+ chunk.copy_from_slice(&h.finish().to_le_bytes());
+ }
+ out
+ }
+
+ /// A fresh `/NM`: a random-looking UUID (version 4 layout) from a splitmix64 stream.
+ fn meta(&mut self) -> pdfcraft_annot::Meta {
+ let mut next = || {
+ self.count += 1;
+ let mut z = self.seed.wrapping_add(self.count.wrapping_mul(0x9E37_79B9_7F4A_7C15));
+ z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+ z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+ z ^ (z >> 31)
+ };
+ let (a, b) = (next(), next());
+ let id = format!(
+ "{:08x}-{:04x}-4{:03x}-{:04x}-{:012x}",
+ a >> 32,
+ (a >> 16) & 0xffff,
+ a & 0xfff,
+ 0x8000 | (b >> 48) & 0x3fff,
+ b & 0xffff_ffff_ffff
+ );
+ pdfcraft_annot::Meta { date: self.date.clone(), id }
+ }
+ }
+
+ /// Perform an edit on a working copy (the caller discards it on error).
+ pub(crate) fn run_edit(doc: &mut pdfcraft_cos::Document, edit: &Edit, cx: &mut EditCtx) -> Result<(), EditError> {
+ match edit {
+ Edit::RotatePages { pages, degrees } => pdfcraft_organize::rotate_pages(doc, pages, *degrees)?,
+ Edit::DeletePages { pages } => pdfcraft_organize::delete_pages(doc, pages)?,
+ Edit::MovePages { pages, to } => pdfcraft_organize::move_pages(doc, pages, *to)?,
+ Edit::ReversePages { pages } => pdfcraft_organize::reverse_pages(doc, pages)?,
+ Edit::InsertBlankPage { at, width, height } => {
+ pdfcraft_organize::insert_blank_page(doc, *at, *width, *height)?;
+ }
+ Edit::SetInfo { key, value } => pdfcraft_organize::set_info(doc, key, value)?,
+ Edit::DuplicatePages { pages, at } => pdfcraft_organize::duplicate_pages(doc, pages, *at)?,
+ Edit::ReplacePages { pages, name, bytes, src_pages } => {
+ let src = open_source(name, bytes)?;
+ pdfcraft_organize::replace_pages(doc, pages, &src, src_pages)?;
+ }
+ Edit::SetPageBox { pages, which, spec } => pdfcraft_organize::set_page_box(doc, pages, *which, *spec)?,
+ Edit::SetTransition { pages, spec } => pdfcraft_organize::set_transition(doc, pages, spec)?,
+ Edit::InsertPagesFrom { name, bytes, pages, at, field_conflicts } => {
+ let src = open_source(name, bytes)?;
+ let pages = match pages {
+ Some(p) => p.clone(),
+ None => (0..pdfcraft_organize::page_count(&src)?).collect(),
+ };
+ // The file's bookmarks come along under one named after it, as in Combine Files.
+ let title = std::path::Path::new(name).file_stem().map_or_else(|| name.clone(), |s| s.to_string_lossy().into_owned());
+ let outcome = pdfcraft_organize::insert_file_pages(doc, &src, &title, &pages, *at, *field_conflicts)?;
+ cx.renamed_fields = outcome.renamed_fields;
+ }
+ Edit::AddBookmark { parent, index, title, page, left, top } => {
+ pdfcraft_organize::add_bookmark_at(doc, parent, *index, title, *page, *left, *top)?;
+ }
+ Edit::RenameBookmark { path, title } => pdfcraft_organize::rename_bookmark(doc, path, title)?,
+ Edit::DeleteBookmark { path } => pdfcraft_organize::delete_bookmark(doc, path)?,
+ Edit::MoveBookmark { from, to_parent, index } => {
+ pdfcraft_organize::move_bookmark(doc, from, to_parent, *index)?;
+ }
+ Edit::SetBookmarkPage { path, page } => pdfcraft_organize::set_bookmark_page(doc, path, *page)?,
+ Edit::SetBookmarkColor { path, color } => pdfcraft_organize::set_bookmark_color(doc, path, *color)?,
+ Edit::SetBookmarkStyle { path, bold, italic } => pdfcraft_organize::set_bookmark_style(doc, path, *bold, *italic)?,
+ Edit::BookmarksFromStructure => {
+ let entries: Vec<_> = pdfcraft_a11y::headings(doc)
+ .into_iter()
+ .map(|h| pdfcraft_organize::OutlineEntry { level: h.level, title: h.title, page: h.page, element: h.obj })
+ .collect();
+ pdfcraft_organize::add_bookmark_tree(doc, "Untitled", &entries)?;
+ }
+ Edit::NumberPages { from, to, style, prefix, first } => pdfcraft_organize::number_pages(doc, *from, *to, *style, prefix, *first)?,
+ Edit::AddMeasurement(m) => {
+ measure::add(doc, m, &cx.meta())?;
+ }
+ Edit::SetMeasurementScale { page, bbox, name, scale } => measure::set_scale(doc, *page, *bbox, name, scale)?,
+ Edit::AddAnnotation(a) => {
+ pdfcraft_annot::add_annotation(doc, a, &cx.meta())?;
+ }
+ Edit::AddCustomStamp { page, rect, name, file, author } => {
+ let src = mark_source(doc, file)?;
+ let (sw, sh) = (src.size.0.max(1.0), src.size.1.max(1.0));
+ let natural = rect[2] == rect[0] && rect[3] == rect[1];
+ let rotation = pdfcraft_organize::page_rotation(doc, *page)?;
+ // The picture as displayed: a quarter turn swaps its sides in user space.
+ let (dw, dh) = if matches!(rotation, 90 | 270) { (sh, sw) } else { (sw, sh) };
+ let rect = if natural {
+ let k = (200.0 / sw.max(sh)).min(1.0);
+ let (w, h) = (dw * k, dh * k);
+ [rect[0] - w / 2.0, rect[1] - h / 2.0, rect[0] + w / 2.0, rect[1] + h / 2.0]
+ } else {
+ fit_picture(*rect, dw, dh)
+ };
+ let shape = Shape::CustomStamp { rect, name: name.clone(), picture: src.xobject, image: src.image, size: (sw, sh) };
+ let style = pdfcraft_annot::Style::default_for(&shape);
+ let new = NewAnnotation { page: *page, shape, style, contents: name.clone(), author: author.clone() };
+ let index = pdfcraft_annot::add_annotation(doc, &new, &cx.meta())?;
+ pdfcraft_annot::orient_image_stamp(doc, *page, index, rotation)?;
+ }
+ Edit::DeleteAnnotation { page, index } => pdfcraft_annot::delete_annotation(doc, *page, *index)?,
+ Edit::SetAnnotationContents { page, index, text } => pdfcraft_annot::set_contents(doc, *page, *index, text, &cx.meta())?,
+ Edit::ReplyToAnnotation { page, index, text, author } => {
+ pdfcraft_annot::add_reply(doc, *page, *index, text, author, &cx.meta())?;
+ }
+ Edit::SetAnnotationStatus { page, index, state, author } => {
+ pdfcraft_annot::set_review_state(doc, *page, *index, *state, author, &cx.meta())?;
+ }
+ Edit::EraseInk { page, index, path, radius } => {
+ pdfcraft_annot::erase_ink(doc, *page, *index, path, *radius, &cx.meta())?;
+ }
+ Edit::AddAttachment { name, bytes, description, mime } => {
+ pdfcraft_organize::add_attachment(doc, name, bytes, description.as_deref(), mime.as_deref(), cx.date.as_deref())?;
+ }
+ Edit::DeleteAttachment { key } => pdfcraft_organize::delete_attachment(doc, key)?,
+ Edit::ReplaceText { page, quads, text, author, strike, caret } => {
+ // One `/NM` each: the caret replies to the strikeout, and XFDF names that reply by
+ // the strikeout's `/NM` (#2666).
+ let (strike_meta, caret_meta) = (cx.meta(), cx.meta());
+ pdfcraft_annot::add_text_replacement(doc, *page, quads, text, author, strike, caret, &strike_meta, &caret_meta)?;
+ }
+ Edit::MarkAnnotation { page, index, marked, author } => {
+ pdfcraft_annot::set_marked(doc, *page, *index, *marked, author, &cx.meta())?;
+ }
+ Edit::LockAnnotation { page, index, locked } => pdfcraft_annot::set_locked(doc, *page, *index, *locked)?,
+ Edit::MoveAnnotation { page, index, dx, dy } => pdfcraft_annot::move_annotation(doc, *page, *index, *dx, *dy, &cx.meta())?,
+ Edit::ReshapeAnnotation { page, index, points } => pdfcraft_annot::set_points(doc, *page, *index, points, &cx.meta())?,
+ Edit::ResizeAnnotation { page, index, rect } => pdfcraft_annot::set_rect(doc, *page, *index, *rect, &cx.meta())?,
+ Edit::StyleAnnotation { page, index, color, opacity, width, endings } => {
+ pdfcraft_annot::set_style(doc, *page, *index, *color, *opacity, *width, endings.as_deref(), &cx.meta())?;
+ }
+ Edit::FillAnnotation { page, index, fill } => pdfcraft_annot::set_fill(doc, *page, *index, *fill, &cx.meta())?,
+ Edit::FontSizeAnnotation { page, index, size } => pdfcraft_annot::set_font_size(doc, *page, *index, *size, &cx.meta())?,
+ Edit::SetAnnotationInfo { page, index, author, subject, icon } => {
+ pdfcraft_annot::set_info(doc, *page, *index, author.as_deref(), subject.as_deref(), *icon, &cx.meta())?;
+ }
+ Edit::SetFieldValue { name, value } => {
+ let mut set = |doc: &mut pdfcraft_cos::Document, value: &FieldValue| match cx.js.as_mut() {
+ Some(js) => pdfcraft_forms::set_value_with(doc, name, value, js),
+ None => pdfcraft_forms::set_value(doc, name, value),
+ };
+ match set(doc, value) {
+ Ok(()) => {}
+ // A date the field's format doesn't read may be typed by another of an XFA date
+ // field's patterns: it is kept in the first. Only a format refusal is tried
+ // again: it comes before any of the field's scripts run, so they run once.
+ Err(refused @ pdfcraft_forms::FormError::Format(_)) => match xfa::typed_date(doc, cx.xfa.as_deref(), name, value) {
+ Some(typed) => set(doc, &typed)?,
+ None => return Err(refused.into()),
+ },
+ Err(refused) => return Err(refused.into()),
+ }
+ }
+ Edit::ApplyScriptChanges { changes } => match cx.js.as_mut() {
+ Some(js) => pdfcraft_forms::apply_script_changes(doc, changes, js)?,
+ None => pdfcraft_forms::apply_script_changes(doc, changes, &mut pdfcraft_forms::NoScripts)?,
+ },
+ Edit::XfaEvent { som, activity } => {
+ let tpl = cx.xfa.clone().ok_or_else(|| EditError::Invalid("this is not a laid-out XFA form, or JavaScript is off".into()))?;
+ let mut run =
+ xfa::XfaRun { page_count: cx.pages, out: &mut cx.xfa_out, datasets: cx.xfa_datasets, ran_away: false, time_scale: cx.xfa_time_scale };
+ let ran = xfa::on_event(doc, &tpl, som, activity, &mut run);
+ cx.xfa_datasets = run.datasets;
+ cx.xfa_ran_away |= run.ran_away;
+ ran.map_err(EditError::Invalid)?;
+ }
+ Edit::SetFieldImage { name, image } => {
+ let (img, _) = embed_image(doc, name, image)?;
+ let px = match &*doc.get(img) {
+ pdfcraft_cos::Object::Stream(s) => (s.dict.int(b"Width").unwrap_or(1) as u32, s.dict.int(b"Height").unwrap_or(1) as u32),
+ _ => (1, 1),
+ };
+ // An XFA image field keeps the picture in the data too (as Designer saves it), and a
+ // laid-out form shows it from there: so only pictures the layout can show, and only
+ // for image fields (a laid-out one carries its SOM path; a static form's field name
+ // is its path).
+ let is_xfa = pdfcraft_xfa::read_packets(doc).ok().flatten().is_some();
+ let image_field = is_xfa
+ && pdfcraft_forms::fields(doc).iter().any(|f| f.name == *name && f.button == Some(pdfcraft_forms::af::ButtonAction::ImportIcon));
+ if image_field {
+ let Some(content_type) = image_content_type(image) else {
+ return Err(EditError::Invalid(format!("{name}: an XFA form keeps a PNG, JPEG, GIF, BMP or TIFF picture; choose one of those")));
+ };
+ pdfcraft_forms::set_button_icon(doc, name, img, px)?;
+ let som = pdfcraft_xfa::fields_by_som(doc).into_iter().find(|(_, n)| n == name).map(|(s, _)| s).unwrap_or_else(|| name.clone());
+ let path = match cx.xfa.as_deref() {
+ Some(tpl) => pdfcraft_xfa::data_path(tpl, &som),
+ None => pdfcraft_xfa::som_to_path(&som),
+ };
+ let r =
+ pdfcraft_xfa::write_data_image(doc, &path, content_type, image, cx.xfa_datasets).map_err(|e| EditError::Write(e.to_string()))?;
+ if !r.written && r.warnings.is_empty() {
+ return Err(EditError::Write(format!("{name}: the picture could not be written into the form's data")));
+ }
+ cx.xfa_datasets = r.stream.or(cx.xfa_datasets);
+ cx.xfa_out.errors.extend(r.warnings);
+ xfa_after_data_change(doc, cx, false)?;
+ } else {
+ pdfcraft_forms::set_button_icon(doc, name, img, px)?;
+ }
+ }
+ Edit::ResetForm { names } => {
+ pdfcraft_forms::reset(doc, names.as_deref())?;
+ }
+ Edit::AddField { page, rect, kind, name } => {
+ pdfcraft_forms::add_field(doc, *page, *rect, kind, name.as_deref())?;
+ }
+ Edit::SetFieldProps { name, props } => {
+ pdfcraft_forms::set_props(doc, name, props)?;
+ }
+ Edit::DuplicateField { name, pages } => {
+ if pdfcraft_forms::duplicate_field(doc, name, pages)? == 0 {
+ return Err(EditError::Form(pdfcraft_forms::FormError::Invalid(format!("{name} is already on those pages"))));
+ }
+ }
+ Edit::DeleteField { name } => pdfcraft_forms::delete_field(doc, name)?,
+ Edit::SetTabOrder { pages, order } => pdfcraft_forms::set_tab_order(doc, pages, *order)?,
+ Edit::MoveInTabOrder { name, earlier } => pdfcraft_forms::move_in_tab_order(doc, name, *earlier)?,
+ // As after a script edit: the values the new order gives show at once.
+ Edit::SetCalculationOrder { names } => {
+ pdfcraft_forms::set_calculation_order(doc, names)?;
+ match cx.js.as_mut() {
+ Some(js) => pdfcraft_forms::recalculate_with(doc, js)?,
+ None => pdfcraft_forms::recalculate(doc)?,
+ };
+ }
+ Edit::SetInitialView(v) => pdfcraft_organize::set_initial_view(doc, v)?,
+ Edit::AutoTagText => {
+ a11y::autotag_text(doc).map_err(|e| EditError::Accessibility(e.to_string()))?;
+ }
+ Edit::SetAltText { figure, alt } => {
+ let r = pdfcraft_cos::ObjRef::new(*figure, doc.generation(*figure));
+ a11y::set_alt(doc, r, alt.as_deref()).map_err(|e| EditError::Accessibility(e.to_string()))?;
+ }
+ Edit::AutoTagFormFields => {
+ a11y::tag_form_fields(doc).map_err(EditError::Accessibility)?;
+ }
+ Edit::SetTagProperty { object, property, value } => {
+ a11y::set_tag_property(doc, *object, *property, value.as_deref()).map_err(|e| EditError::Accessibility(e.to_string()))?;
+ }
+ Edit::MoveTag { object, anchor, placement } => {
+ a11y::move_tag(doc, *object, *anchor, *placement).map_err(|e| EditError::Accessibility(e.to_string()))?;
+ }
+ Edit::EditTextLine { page, line, text } => {
+ pdfcraft_edit::replace_line(doc, *page, *line, text)?;
+ }
+ Edit::SetFieldScript { name, event, script } => {
+ pdfcraft_forms::set_field_script(doc, name, event, script.as_deref())?;
+ match cx.js.as_mut() {
+ Some(js) => pdfcraft_forms::recalculate_with(doc, js)?,
+ None => pdfcraft_forms::recalculate(doc)?,
+ };
+ }
+ Edit::ConvertPdfA { level } => {
+ pdfcraft_preflight::convert(doc, *level).map_err(|e| EditError::Invalid(e.to_string()))?;
+ }
+ Edit::RemoveStandardId { standard } => pdfcraft_organize::remove_standard_id(doc, *standard)?,
+ Edit::SetDocumentScript { name, script } => pdfcraft_forms::set_document_script(doc, name, script.as_deref())?,
+ Edit::AddOcrText { page, words } => {
+ pdfcraft_edit::stamp(doc, *page, "OCR", pdfcraft_ocr::text_layer(words))?;
+ }
+ Edit::EditPageImage { page, index, change } => {
++ match change {
++ ImageEdit::Move(to) if !to.iter().all(|v| v.is_finite()) => {
++ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("invalid position".into())));
++ }
++ ImageEdit::Transform(t) if !t.iter().all(|v| v.is_finite()) => {
++ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("the image transform must be finite".into())));
++ }
++ ImageEdit::Crop(keep) if !keep.iter().all(|v| v.is_finite()) => {
++ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("invalid crop".into())));
++ }
++ _ => {}
++ }
+ let img = pdfcraft_edit::page_images(doc, *page)?
+ .into_iter()
+ .nth(*index)
+ .ok_or_else(|| EditError::Edit(pdfcraft_edit::EditError::Invalid(format!("page {} has no image {}", page + 1, index + 1))))?;
+ let c = match change {
+ ImageEdit::Move(to) => pdfcraft_edit::ImageChange::Transform(pdfcraft_edit::rect_to_rect(img.rect, *to)),
++ ImageEdit::Transform(t) => pdfcraft_edit::ImageChange::Transform(*t),
+ ImageEdit::Rotate(q) => {
+ pdfcraft_edit::ImageChange::Transform(pdfcraft_edit::turn_about_centre(img.visible_rect.unwrap_or(img.rect), *q, false, false))
+ }
+ ImageEdit::RotateBy(degrees) => {
+ let t = pdfcraft_edit::turn_by_degrees(img.visible_rect.unwrap_or(img.rect), *degrees)
+ .ok_or_else(|| EditError::Edit(pdfcraft_edit::EditError::Invalid("the rotation angle must be a finite number".into())))?;
+ pdfcraft_edit::ImageChange::Transform(t)
+ }
+ ImageEdit::Flip { horizontal } => pdfcraft_edit::ImageChange::Transform(pdfcraft_edit::turn_about_centre(
+ img.visible_rect.unwrap_or(img.rect),
+ 0,
+ *horizontal,
+ !*horizontal,
+ )),
+ ImageEdit::Replace { name, bytes } => {
+ if img.is_form {
+ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid(
+ "grouped Form artwork cannot be replaced with a bitmap".into(),
+ )));
+ }
+ pdfcraft_edit::ImageChange::Replace(embed_image(doc, name, bytes)?.0)
+ }
+ ImageEdit::Crop(keep) => pdfcraft_edit::ImageChange::Crop(*keep),
+ ImageEdit::Delete => pdfcraft_edit::ImageChange::Delete,
++ ImageEdit::Arrange(order) => pdfcraft_edit::ImageChange::Arrange(*order),
++ ImageEdit::RemoveCrop => pdfcraft_edit::ImageChange::RemoveCrop,
++ };
++ let page_model = pdfcraft_model::pages(doc)
++ .into_iter()
++ .nth(*page)
++ .ok_or_else(|| EditError::Edit(pdfcraft_edit::EditError::Invalid(format!("page {} not found", page + 1))))?;
++ let target_stream_obj = match page_model.dict.get(b"Contents") {
++ None => None,
++ Some(c) => match &*doc.resolve(c) {
++ pdfcraft_cos::Object::Array(a) => a.get(img.stream).and_then(|o| o.as_ref()),
++ _ if img.stream == 0 => c.as_ref(),
++ _ => None,
++ },
+ };
- pdfcraft_edit::change_image(doc, *page, *index, &c)?;
++
++ let added_items: Vec<(usize, Added)> = pdfcraft_edit::list_added(doc).into_iter().filter(|a| a.page == *page).enumerate().collect();
++ let matched_added = if let Some(st_ref) = target_stream_obj {
++ added_items.iter().find(|(_, a)| a.obj == st_ref)
++ } else if let Some(target_ref) = img.object {
++ added_items.iter().find(|(_, a)| matches!(&a.content, AddedContent::Image(ai) if ai.image == target_ref))
++ } else {
++ None
++ };
++
++ let mut ai_to_update = None;
++ if let Some((added_idx, added_item)) = matched_added
++ && let AddedContent::Image(ai) = added_item.content.clone()
++ {
++ let has_active_crop = ai.crop.iter().any(|v| v.abs() > 1e-6)
++ || img.visible_rect.is_some_and(|v| {
++ (v[0] - img.rect[0]).abs() > 1e-4
++ || (v[1] - img.rect[1]).abs() > 1e-4
++ || (v[2] - img.rect[2]).abs() > 1e-4
++ || (v[3] - img.rect[3]).abs() > 1e-4
++ });
++ let rotated_transform = matches!(change, ImageEdit::Transform(t) if t[1].abs() >= 1e-6 || t[2].abs() >= 1e-6);
++ let should_promote = has_active_crop
++ || rotated_transform
++ || matches!(
++ change,
++ ImageEdit::Crop(_) | ImageEdit::RemoveCrop | ImageEdit::RotateBy(_) | ImageEdit::Arrange(_) | ImageEdit::Delete
++ );
++
++ if should_promote {
++ let _ = doc.update_dict(added_item.obj, |d| {
++ d.remove(b"PCAdded");
++ d.remove(b"PCMark");
++ });
++ } else {
++ ai_to_update = Some((*added_idx, ai));
++ }
++ }
++
++ if let Some((added_idx, mut ai)) = ai_to_update {
++ let view = page_model.view_matrix(doc);
++ let det = view[0] * view[3] - view[1] * view[2];
++ if det.abs() < 1e-12 || !det.is_finite() {
++ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("invalid page transform".into())));
++ }
++ let (ia, ib, ic, id) = (view[3] / det, -view[1] / det, -view[2] / det, view[0] / det);
++ let to_display = [ia, ib, ic, id, -(view[4] * ia + view[5] * ic), -(view[4] * ib + view[5] * id)];
++ let apply = |m: [f64; 6], x: f64, y: f64| (m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]);
++ let bbox = |m: [f64; 6], r: [f64; 4]| {
++ let pts = [apply(m, r[0], r[1]), apply(m, r[2], r[1]), apply(m, r[0], r[3]), apply(m, r[2], r[3])];
++ let mut b = [f64::MAX, f64::MAX, f64::MIN, f64::MIN];
++ for (x, y) in pts {
++ b = [b[0].min(x), b[1].min(y), b[2].max(x), b[3].max(y)];
++ }
++ b
++ };
++
++ match change {
++ ImageEdit::Move(to) => {
++ if !to.iter().all(|v| v.is_finite()) {
++ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("invalid position".into())));
++ }
++ ai.rect = bbox(to_display, *to);
++ pdfcraft_edit::update_content(doc, *page, added_idx, &AddedContent::Image(ai))?;
++ }
++ ImageEdit::Transform(t) => {
++ let mul = |m1: [f64; 6], m2: [f64; 6]| {
++ [
++ m1[0] * m2[0] + m1[1] * m2[2],
++ m1[0] * m2[1] + m1[1] * m2[3],
++ m1[2] * m2[0] + m1[3] * m2[2],
++ m1[2] * m2[1] + m1[3] * m2[3],
++ m1[4] * m2[0] + m1[5] * m2[2] + m2[4],
++ m1[4] * m2[1] + m1[5] * m2[3] + m2[5],
++ ]
++ };
++ let t_display = mul(mul(view, *t), to_display);
++ if t_display[0] < 0.0 {
++ ai.flip_h = !ai.flip_h;
++ }
++ if t_display[3] < 0.0 {
++ ai.flip_v = !ai.flip_v;
++ }
++ ai.rect = bbox(t_display, ai.rect);
++ pdfcraft_edit::update_content(doc, *page, added_idx, &AddedContent::Image(ai))?;
++ }
++ ImageEdit::Rotate(q) => {
++ let k = ((4 - q.rem_euclid(4)) % 4) as u8;
++ ai.rotation = (ai.rotation + k) % 4;
++ let r = ai.rect;
++ let (cx, cy) = ((r[0] + r[2]) / 2.0, (r[1] + r[3]) / 2.0);
++ if k % 2 == 1 {
++ let (w, h) = (r[2] - r[0], r[3] - r[1]);
++ ai.rect = [cx - h / 2.0, cy - w / 2.0, cx + h / 2.0, cy + w / 2.0];
++ }
++ pdfcraft_edit::update_content(doc, *page, added_idx, &AddedContent::Image(ai))?;
++ }
++ ImageEdit::Flip { horizontal: true } => {
++ ai.flip_h = !ai.flip_h;
++ pdfcraft_edit::update_content(doc, *page, added_idx, &AddedContent::Image(ai))?;
++ }
++ ImageEdit::Flip { horizontal: false } => {
++ ai.flip_v = !ai.flip_v;
++ pdfcraft_edit::update_content(doc, *page, added_idx, &AddedContent::Image(ai))?;
++ }
++ ImageEdit::Replace { .. } => {
++ let pdfcraft_edit::ImageChange::Replace(new_image) = c else {
++ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("expected replace".into())));
++ };
++ ai.image = new_image;
++ pdfcraft_edit::update_content(doc, *page, added_idx, &AddedContent::Image(ai))?;
++ }
++ ImageEdit::Crop(_) | ImageEdit::RemoveCrop | ImageEdit::RotateBy(_) | ImageEdit::Arrange(_) | ImageEdit::Delete => {
++ pdfcraft_edit::change_image(doc, *page, *index, &c)?;
++ }
++ }
++ } else {
++ pdfcraft_edit::change_image(doc, *page, *index, &c)?;
++ }
+ }
+ Edit::MoveObjects { page, objects, offset } => pdfcraft_edit::move_objects(doc, *page, objects, *offset)?,
+ Edit::EditTextBlock { page, block, text, style } => {
+ pdfcraft_edit::rewrite_block(doc, *page, *block, Some(text), style)?;
+ }
+ Edit::RegisterTextFont { page, bytes } => {
+ pdfcraft_edit::text::register_text_font(doc, *page, bytes)?;
+ }
+ Edit::MarkDecorative { figure } => {
+ let r = pdfcraft_cos::ObjRef::new(*figure, doc.generation(*figure));
+ a11y::mark_decorative(doc, r).map_err(|e| EditError::Accessibility(e.to_string()))?;
+ }
+ Edit::MarkTagArtifact { object } => {
+ a11y::mark_tag_artifact(doc, *object).map_err(|e| EditError::Accessibility(e.to_string()))?;
+ }
+ Edit::AddHeaderFooter { pages, settings, replace } => {
+ let date = cx.today;
+ pdfcraft_edit::add_header_footer(doc, pages, settings, *replace, &pdfcraft_edit::Context { date })?;
+ }
+ Edit::AddWatermark { pages, settings, replace, file } => {
+ let mut s = settings.clone();
+ if let Some(f) = file {
+ s.source = Some(mark_source(doc, f)?);
+ }
+ pdfcraft_edit::add_watermark(doc, pages, &s, *replace)?
+ }
+ Edit::AddBackground { pages, settings, replace, file } => {
+ let mut s = settings.clone();
+ if let Some(f) = file {
+ s.source = Some(mark_source(doc, f)?);
+ }
+ pdfcraft_edit::add_background(doc, pages, &s, *replace)?
+ }
+ Edit::RemoveMarks { kind } => {
+ let n = pdfcraft_model::pages(doc).len();
+ if pdfcraft_edit::remove_marks(doc, &(0..n).collect::<Vec<_>>(), *kind)? == 0 {
+ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("there is nothing to remove".into())));
+ }
+ }
+ Edit::AddText { page, text } => {
+ pdfcraft_edit::add_content(doc, *page, &AddedContent::Text(text.clone()))?;
+ }
+ Edit::AddImage { page, rect, name, bytes } => {
+ let (image, natural) = embed_image(doc, name, bytes)?;
+ let rect = match rect {
+ Some(r) => *r,
+ None => {
+ let p = pdfcraft_model::pages(doc).swap_remove(*page);
+ let (pw, ph) = p.display_size(doc);
+ let k = ((pw * 0.8) / natural.0).min((ph * 0.8) / natural.1).min(1.0);
+ let (w, h) = (natural.0 * k, natural.1 * k);
+ [(pw - w) / 2.0, (ph - h) / 2.0, (pw + w) / 2.0, (ph + h) / 2.0]
+ }
+ };
+ pdfcraft_edit::add_content(doc, *page, &AddedContent::Image(pdfcraft_edit::AddedImage::new(rect, image)))?;
+ }
+ Edit::UpdateContent { page, index, content } => pdfcraft_edit::update_content(doc, *page, *index, content)?,
+ Edit::DeleteContent { page, index } => pdfcraft_edit::delete_content(doc, *page, *index)?,
+ Edit::ReplaceImage { page, index, name, bytes } => {
+ let item = pdfcraft_edit::list_added(doc).into_iter().filter(|a| a.page == *page).nth(*index);
+ let Some(AddedContent::Image(old)) = item.map(|a| a.content) else {
+ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("that item is not an image".into())));
+ };
+ let (image, _) = embed_image(doc, name, bytes)?;
+ pdfcraft_edit::update_content(doc, *page, *index, &AddedContent::Image(pdfcraft_edit::AddedImage { image, ..old }))?;
+ }
+ Edit::PasteContent { page, content, file } => {
+ let content = match content {
+ AddedContent::Text(_) => content.clone(),
+ AddedContent::Image(img) => {
+ let Some((name, bytes)) = file else {
+ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("a pasted image needs its picture".into())));
+ };
+ // The same picture in this document (copied here, pasted here before, or an
+ // identical file): drawn again from the one image object rather than stored twice.
+ let image = if copy_image::is_picture(doc, img.image, bytes) {
+ img.image
+ } else {
+ match copy_image::added_picture(doc, bytes) {
+ Some(image) => image,
+ None => embed_image(doc, name, bytes)?.0,
+ }
+ };
+ AddedContent::Image(pdfcraft_edit::AddedImage { image, ..img.clone() })
+ }
+ };
+ pdfcraft_edit::add_content(doc, *page, &content)?;
+ }
+ Edit::ApplyRedactions { pages } => {
+ cx.redaction_overlays = pdfcraft_redact::apply(doc, pages.as_deref())?.overlays;
+ }
+ Edit::ClearRedactions => {
+ pdfcraft_redact::clear_marks(doc, None)?;
+ }
+ Edit::AddLink { page, rect, action, style } => {
+ pdfcraft_annot::links::add(doc, *page, *rect, action, style)?;
+ }
+ Edit::SetLink { page, index, rect, action, style } => pdfcraft_annot::links::set(doc, *page, *index, *rect, action.as_ref(), style.as_ref())?,
+ Edit::DeleteLink { page, index } => pdfcraft_annot::links::delete(doc, *page, *index)?,
+ Edit::RemoveLinks { pages } => {
+ if pdfcraft_annot::links::remove_all(doc, pages.as_deref())? == 0 {
+ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("there are no links to remove".into())));
+ }
+ }
+ Edit::AddLinks { links, style } => {
+ if pdfcraft_annot::links::add_many(doc, links, style)? == 0 {
+ return Err(EditError::Edit(pdfcraft_edit::EditError::Invalid("no web addresses were found".into())));
+ }
+ }
+ Edit::ImportData { bytes, .. } => {
+ // An XFA form takes XFA data files (XDP, datasets, or a data document) as its data;
+ // XFDF, FDF, Acrobat's XML and tables go the usual way.
+ let text = (pdfcraft_xfa::read_packets(doc).ok().flatten().is_some()).then(|| decode_data_file(bytes)).flatten();
+ match text {
+ Some(Ok(text)) if is_xfa_data_file(&text) => {
+ let expect_root = cx.xfa.as_ref().and_then(|t| t.root.common.name.clone());
+ let r = pdfcraft_xfa::import_data(doc, &text, expect_root.as_deref(), cx.xfa_datasets)
+ .map_err(|e| EditError::Write(e.to_string()))?;
+ cx.xfa_datasets = r.stream.or(cx.xfa_datasets);
+ cx.xfa_out.errors.extend(r.warnings);
+ cx.xfa_out.console.push(format!("Imported XFA data: {} node(s)", r.nodes));
+ xfa_after_data_change(doc, cx, true)?;
+ }
+ Some(Err(why)) => return Err(EditError::Invalid(why)),
+ _ => {
+ pdfcraft_xfdf::import(doc, bytes)?;
+ }
+ }
+ }
+ Edit::RemoveHidden { which } => {
+ pdfcraft_redact::sanitize::remove_hidden(doc, which)?;
+ }
+ Edit::Sanitize => {
+ pdfcraft_redact::sanitize::sanitize(doc)?;
+ }
+ Edit::Flatten { comments, fields } => {
+ // An XFA form's fields baked into the pages: the XFA goes too, or Adobe's viewers
+ // would lay the form out again from its template over the baked pages. A dynamic
+ // form that was never laid out keeps its XFA: without it only placeholders remain.
+ let shape = (*fields).then(|| pdfcraft_xfa::xfa_shape(doc)).flatten();
+ let n = pdfcraft_model::pages(doc).len();
+ pdfcraft_edit::flatten(doc, &(0..n).collect::<Vec<_>>(), *comments, *fields)?;
+ match shape {
+ Some(shape) if shape.strippable() => strip_xfa(doc, cx)?,
+ Some(_) => cx.xfa_removed.push("The XFA was kept: this dynamic form was not laid out, so its fields were not baked in".into()),
+ None => {}
+ }
+ }
+ Edit::XfaToStatic => {
+ let Some(shape) = pdfcraft_xfa::xfa_shape(doc) else {
+ return Err(EditError::Invalid("this document is not an XFA form".into()));
+ };
+ if !shape.strippable() {
+ return Err(EditError::Invalid("this dynamic XFA form was not laid out, so there is no static form to keep".into()));
+ }
+ strip_xfa(doc, cx)?;
+ }
+ Edit::FlattenFillSign => {
+ let n = pdfcraft_model::pages(doc).len();
+ pdfcraft_edit::flatten_fill_sign(doc, &(0..n).collect::<Vec<_>>())?;
+ }
+ Edit::Protect(p) => {
+ p.validate()?;
+ let seed = cx.entropy();
+ // Without a permissions password nothing is restricted, so the owner password is a
+ // random one nobody needs.
+ let random_owner: String = cx.entropy().iter().map(|b| format!("{b:02x}")).collect();
+ let params = pdfcraft_cos::NewEncryption {
+ algorithm: p.algorithm,
+ user_password: p.open_password.as_deref().unwrap_or(""),
+ owner_password: p.permissions_password.as_deref().unwrap_or(&random_owner),
+ permissions: p.permission_bits(),
+ encrypt_metadata: p.encrypt_metadata,
+ seed,
+ };
+ doc.set_encryption(&params).map_err(|e| EditError::Protection(e.to_string()))?;
+ }
+ Edit::RemoveProtection => {
+ if doc.output_handler().is_none() {
+ return Err(EditError::Protection("the document isn't protected".into()));
+ }
+ doc.remove_encryption();
+ }
+ Edit::Batch { edits, .. } => {
+ for e in edits {
+ run_edit(doc, e, cx)?;
+ }
+ }
+ }
+ Ok(())
+ }
+
+ /// The singular or the plural wording, by count. Both are written out: a language forms its plural
+ /// its own way, and `one` and `many` may differ in more than an "s".
+ fn plural(one: &'static str, many: &'static str, n: usize) -> Label {
+ Label::of(if n == 1 { one } else { many })
+ }
diff --cc crates/engine/src/lib.rs
index 84806678b,78e5ea1eb..cbb339ba1
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@@ -96,81 -117,8 +117,14 @@@ pub enum ImageEdit
name: String,
bytes: Arc<Vec<u8>>,
},
+ /// Apply an arbitrary 2D affine transform matrix in user space.
+ Transform([f64; 6]),
Delete,
+ /// Change the stacking order.
+ Arrange(ArrangeOrder),
+ /// Remove any private crop on the image.
+ RemoveCrop,
}
- pub use pdfcraft_fonts::{MAX_SIGNATURE_CHARS, ScriptOutline, script_missing, script_outline, undrawable_message};
-
- /// Fill & Sign: `text` in the script font as a typed signature, its left edge at `at` (user
- /// space, vertically centred) and `height` points tall. `None` for text with no outlines.
- ///
- /// Left, centred and upright are as displayed on a page turned by `rotation` (its `/Rotate`):
- /// the box runs along the displayed axes, like an image signature's
- /// ([`SignatureImage::rect`]), and the outlines are turned back so the name reads across.
- pub fn typed_signature_shape(at: [f64; 2], text: &str, height: f64, rotation: i64) -> Option<Shape> {
- let o = script_outline(text);
- let [left, bottom, right, top] = o.bounds();
- let span = (top - bottom).max(0.1);
- let width = right - left;
- if o.contours.is_empty() || o.width <= 0.0 || !(width > 0.0 && height > 0.0) {
- return None;
- }
- let k = height / span;
- let rect = signature_image::upright_box(rotation, at, width * k, height)?;
- // Displayed right and up as user-space unit vectors: a point at (nx, ny) of the displayed box
- // is at this fraction of the user-space box. Exact for an unturned page.
- let [a, b, c, d, ..] = pdfcraft_model::view_matrix_for(rotation, [0.0; 4]);
- let to_user = |nx: f64, ny: f64| [a * nx + c * ny + (-a).max(0.0) + (-c).max(0.0), b * nx + d * ny + (-b).max(0.0) + (-d).max(0.0)];
- let contours = o.contours.iter().map(|c| c.iter().map(|p| to_user((p[0] - left) / width, (p[1] - bottom) / span)).collect()).collect();
- Some(Shape::TypedSignature { rect, contours })
- }
- /// `at` moved `right` and `up` points as displayed on a page turned by `rotation` (its `/Rotate`).
- pub fn displayed_offset(rotation: i64, at: [f64; 2], right: f64, up: f64) -> [f64; 2] {
- let [a, b, c, d, ..] = pdfcraft_model::view_matrix_for(rotation, [0.0; 4]);
- [at[0] + a * right + c * up, at[1] + b * right + d * up]
- }
-
- /// The user-space box `width` x `height` points as displayed on a page turned by `rotation`,
- /// with its displayed top-left corner at `at`: where typed text and text boxes go. `None` for a
- /// non-finite point.
- pub fn text_box_at(rotation: i64, at: [f64; 2], width: f64, height: f64) -> Option<[f64; 4]> {
- signature_image::upright_box(rotation, displayed_offset(rotation, at, 0.0, -height / 2.0), width, height)
- }
-
- /// `text` in the script font as the graphic of a visible digital signature, as Fill & Sign types
- /// it. `None` for text with no outlines.
- pub fn typed_signature_graphic(text: &str) -> Option<pdfcraft_sign::Graphic> {
- let o = script_outline(text);
- o.contours.iter().any(|c| c.len() > 2).then_some(pdfcraft_sign::Graphic::Outlines(o.contours))
- }
-
- pub use links::{
- MAX_REMOTE_DOCUMENT_BYTES, RemoteDocumentPathError, read_remote_document, remote_document_path_is_absolute, resolve_remote_document_path,
- };
- /// Comment geometry helpers (text-box line breaking) for frontends.
- pub use pdfcraft_annot::appearance as annot_text;
- pub use pdfcraft_annot::links::{Highlight as LinkHighlight, LinkAction, LinkItem, LinkStyle};
- pub use pdfcraft_annot::{
- AppearanceCache, AttachIcon, FillMark, LineEnding, Markup, NOTE_SIZE, NewAnnotation, NoteIcon, OverlayFont, OverlayLook, Props as CommentProps,
- ReviewState, Rgb, Shape, StampGroup, StampKind, Style, rect_quad,
- };
- pub use pdfcraft_forms::detect;
- pub use pdfcraft_optimize as optimize;
- pub use pdfcraft_preflight as pdfa;
- pub use pdfcraft_print as print;
- pub use pdfcraft_redact::codes::{CODE_SETS as REDACTION_CODE_SETS, CodeSet as RedactionCodeSet};
- pub use pdfcraft_redact::patterns::{
- MAX_WORDS as REDACT_MAX_WORDS, PATTERNS as REDACT_PATTERNS, Pattern as RedactPattern, find as find_pattern, word_list as redact_word_list,
- };
- pub use pdfcraft_redact::sanitize::{HIDDEN, Hidden};
- pub use pdfcraft_sign as sign;
- pub use pdfcraft_sign::{SignOptions, SignatureInfo, Status as SignatureStatus, TrustStore};
- pub use pdfcraft_xfdf::Format as DataFormat;
/// Forms ▸ Merge data files into spreadsheet: the field values of each file (FDF, XFDF or a
/// filled-in PDF form), as CSV with one row per file.
diff --cc crates/engine/src/reexports.rs
index 000000000,208a8e450..41bac6041
mode 000000,100644..100644
--- a/crates/engine/src/reexports.rs
+++ b/crates/engine/src/reexports.rs
@@@ -1,0 -1,53 +1,53 @@@
+ //! What the engine re-exports from the other pdfcraft crates, so frontends need only this one.
+
+ pub use pdfcraft_organize::{BoxSpec, FieldConflicts, PageBox, SplitBy, Transition, TransitionSpec, mime_for_name, split_ranges};
+
+ pub use pdfcraft_organize::LabelStyle;
+ pub use pdfcraft_organize::Standard;
+ pub use pdfcraft_organize::check_custom_key;
+ pub use pdfcraft_organize::view::{InitialView, Layout as InitialLayout, Magnification, Navigation};
+
+ pub use pdfcraft_cos::Algorithm;
+ pub use pdfcraft_create::{CONVERTIBLE, CreateError, ImageResolution, SourceKind, decode_text, source_kind};
+ pub use pdfcraft_edit::added::{
+ CHAR_SPACING_LIMIT as ADDED_CHAR_SPACING_LIMIT, paste_place as added_paste_place, paste_rect as added_paste_rect, text_rect as added_text_rect,
+ text_width as added_text_width,
+ };
+ pub use pdfcraft_edit::{
+ Added, AddedImage, AddedText, Align as TextAlign, Background, Content as AddedContent, Family as FontFamily, HeaderFooter, MarkKind, Watermark,
+ };
+ pub use pdfcraft_forms::{
+ BorderStyle, CalculatedField, CalculationIssue, CalculationOrder, CheckStyle, Field as FormField, FieldAction, FieldChange, FieldFont,
+ FieldKind as FormFieldKind, FieldProps, FieldValue, Look as FieldLook, LookPatch as FieldLookPatch, NewField, TabOrder, Trigger as FieldTrigger,
+ Widget as FormWidget, af as form_scripts, appearance as form_appearance, appearance::auto_text_size_by as field_auto_text_size_by,
+ calculations_changed as form_calculations_changed, flags as field_flags,
+ };
+
+ pub use pdfcraft_a11y as a11y;
+ pub use pdfcraft_edit::{BlockKey, BlockStyle, PageImage, RangeStyle, TextBlock, TextLine, block_overlapping, first_undrawable};
+ pub use pdfcraft_measure as measure;
+ pub use pdfcraft_xfa::Report as XfaLayout;
+
-pub use pdfcraft_edit::{EditableObject, MAX_MOVE_OBJECTS, ObjectKind, ObjectTarget};
++pub use pdfcraft_edit::{ArrangeOrder, EditableObject, MAX_MOVE_OBJECTS, ObjectKind, ObjectTarget};
+
+ pub use pdfcraft_fonts::{MAX_SIGNATURE_CHARS, ScriptOutline, script_missing, script_outline, undrawable_message};
+
+ /// Comment geometry helpers (text-box line breaking) for frontends.
+ pub use pdfcraft_annot::appearance as annot_text;
+ pub use pdfcraft_annot::links::{Highlight as LinkHighlight, LinkAction, LinkItem, LinkStyle};
+ pub use pdfcraft_annot::{
+ AppearanceCache, AttachIcon, FillMark, LineEnding, Markup, NOTE_SIZE, NewAnnotation, NoteIcon, OverlayFont, OverlayLook, Props as CommentProps,
+ ReviewState, Rgb, Shape, StampGroup, StampKind, Style, rect_quad,
+ };
+ pub use pdfcraft_forms::detect;
+ pub use pdfcraft_optimize as optimize;
+ pub use pdfcraft_preflight as pdfa;
+ pub use pdfcraft_print as print;
+ pub use pdfcraft_redact::codes::{CODE_SETS as REDACTION_CODE_SETS, CodeSet as RedactionCodeSet};
+ pub use pdfcraft_redact::patterns::{
+ MAX_WORDS as REDACT_MAX_WORDS, PATTERNS as REDACT_PATTERNS, Pattern as RedactPattern, find as find_pattern, word_list as redact_word_list,
+ };
+ pub use pdfcraft_redact::sanitize::{HIDDEN, Hidden};
+ pub use pdfcraft_sign as sign;
+ pub use pdfcraft_sign::{SignOptions, SignatureInfo, Status as SignatureStatus, TrustStore};
+ pub use pdfcraft_xfdf::Format as DataFormat;
diff --cc crates/engine/src/session.rs
index 000000000,c3e34d90b..5c8373afb
mode 000000,100644..100644
--- a/crates/engine/src/session.rs
+++ b/crates/engine/src/session.rs
@@@ -1,0 -1,1590 +1,1592 @@@
+ //! The session: the open documents and the operations on them.
+
+ use std::sync::{Arc, OnceLock};
+
+ use pdfcraft_cos::{SaveOptions, write_full, write_incremental};
+ use pdfcraft_render::{LayerOp, OpenError, ReadingColors, RenderConfig, RenderPool, inspect};
+
+ #[cfg(test)]
+ use crate::check_refresh_panic;
+ use crate::edit::{EditCtx, check_permission, run_edit};
+ use crate::history::{Keys, MAX_UNDO, Scope, keys_after, scope_of, uses_scripts};
+ use crate::{
+ BookmarkPage, BookmarkRow, CombineSource, Combined, DataFormat, DocId, Document, Edit, EditError, Hidden, ImageResolution,
+ LOW_RESOLUTION_PRINT_DPI, Label, ObjectKind, OptimizeReport, RecoverySnapshot, SignOptions, SourceKind, SplitPart, SummarySort, TrustStore,
+ XFA_REMOVED_PREFIX, XFA_SCRIPTS_OFF, apply_layer_state, comment_list, comment_summary, decode_text, display_bytes, guard, info_fields, js,
+ local_utc_offset, note_warnings, open_source, open_source_with, optimize, outline_rows, parse_ymd, print, print_raster, render_threads,
+ scan_colours, set_default_layer_state, shown_under_redactions, signatures_of, source_kind, sync_xfa_state, undrawn_notices, use_layer_choices,
+ writable, xfa, xfa_sync_datasets,
+ };
+
+ #[derive(Default)]
+ pub struct Session {
+ pub(crate) docs: Vec<Document>,
+ pub(crate) next_id: u64,
+ /// Seconds since the Unix epoch, injected so saves are deterministic in tests.
+ clock: Option<fn() -> i64>,
+ /// Seconds to add to UTC for local time, read from whoever knows the zone (a browser, say).
+ /// Separate from `clock` on purpose: `clock` alone is the test shortcut that takes the
+ /// injected time AS local time and zeroes the zone, so injecting only it leaves either the
+ /// local dates or the UTC ones wrong by the zone's offset.
+ utc_offset: Option<fn() -> i64>,
+ /// Certificates trusted for signing (Acrobat: Trusted Certificates).
+ pub(crate) trust: Arc<TrustStore>,
+ /// Preferences ▸ JavaScript ▸ Enable Acrobat JavaScript, inverted (on by default).
+ pub(crate) js_off: bool,
+ /// Preferences ▸ Date format, when not the default (see [`dates`]).
+ pub(crate) date_format: Option<String>,
+ /// Preferences ▸ Date format ▸ Language, when not following the interface language.
+ pub(crate) date_language: Option<String>,
+ /// What the XFA scripts' time limits are multiplied by (`None`: 1); see
+ /// [`Session::with_xfa_time_scale`].
+ pub(crate) xfa_time_scale: Option<u32>,
+ }
+
+ impl Session {
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Use a fixed clock (tests) instead of the system time.
+ pub fn with_clock(mut self, clock: fn() -> i64) -> Self {
+ self.clock = Some(clock);
+ self
+ }
+
+ /// Multiply the time an XFA form's scripts may take by `factor` (tests): the 3 s the
+ /// scripts of an opening or a change share, the 5 s of a click's, the 10 s the script
+ /// engine has to start, and each script's own 1 s or 3 s. A test that checks what the
+ /// scripts do passes a large factor, so that a busy machine does not stop them. On native
+ /// builds, 0 stops every script before it starts; the wasm build has no wall clock, so
+ /// there the factor has no effect.
+ pub fn with_xfa_time_scale(mut self, factor: u32) -> Self {
+ self.xfa_time_scale = Some(factor);
+ self
+ }
+
+ /// A real clock for a host that has neither a clock nor a time zone of its own (a
+ /// `wasm32-unknown-unknown` build: `now()` would be empty and `local_utc_offset()` is 0, so
+ /// Fill & Sign stamps 1 Jan 1970 and `/ModDate` is never written). `clock` is the UTC time in
+ /// seconds since the epoch; `utc_offset` is the local zone's seconds east of UTC, asked on every
+ /// use because the zone changes with the date (daylight saving). Unlike
+ /// [`Session::with_clock`], which is a test shortcut, nothing here is taken as local time.
+ pub fn with_wall_clock(mut self, clock: fn() -> i64, utc_offset: fn() -> i64) -> Self {
+ self.clock = Some(clock);
+ self.utc_offset = Some(utc_offset);
+ self
+ }
+
+ /// Seconds to add to UTC for the local time of this session: the injected zone, else 0 under
+ /// the test clock (which is already local), else the system's.
+ fn local_offset(&self) -> i64 {
+ match (self.utc_offset, self.clock) {
+ (Some(zone), _) => zone(),
+ (None, Some(_)) => 0,
+ (None, None) => local_utc_offset(),
+ }
+ }
+
+ /// Seconds since the Unix epoch from the session clock (0 when unknown).
+ pub fn now_secs(&self) -> i64 {
+ self.now().unwrap_or(0)
+ }
+
+ pub(crate) fn now(&self) -> Option<i64> {
+ if let Some(c) = self.clock {
+ return Some(c());
+ }
+ #[cfg(not(target_arch = "wasm32"))]
+ return std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).ok().map(|d| d.as_secs() as i64);
+ #[cfg(target_arch = "wasm32")]
+ return None;
+ }
+
+ /// Today's date in local time: (year, month, day). With an injected clock (tests) the clock
+ /// is taken as local time.
+ /// A dynamic stamp's second line: "By Ada at 2:14 pm, Oct 02, 2026" (local time).
+ pub fn stamp_by_line(&self, author: &str) -> String {
+ let offset = self.local_offset();
+ let d = self.now().map(|t| pdfcraft_cos::pdf_date(t + offset)).unwrap_or_default();
+ let num = |a: usize, b: usize| d.get(a..b).and_then(|s| s.parse::<u32>().ok()).unwrap_or(0);
+ let (y, mo, day, hh, mm) = (num(2, 6), num(6, 8), num(8, 10), num(10, 12), num(12, 14));
+ const MONTHS: [&str; 12] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+ let h12 = if hh % 12 == 0 { 12 } else { hh % 12 };
+ let who = if author.trim().is_empty() { String::new() } else { format!("By {} ", author.trim()) };
+ format!("{who}at {h12}:{mm:02} {}, {} {day:02}, {y}", if hh < 12 { "am" } else { "pm" }, MONTHS[(mo.clamp(1, 12) - 1) as usize])
+ }
+
+ pub fn today(&self) -> (i64, u32, u32) {
+ let offset = self.local_offset();
+ self.now().map(|t| pdfcraft_cos::pdf_date(t + offset)).as_deref().and_then(parse_ymd).unwrap_or((1970, 1, 1))
+ }
+
+ /// Open a document from bytes. Rendering starts lazily when pages are requested.
+ ///
+ /// `password` is tried as either the user or owner password when the file is encrypted.
+ /// Open saved revision `n` (1 = the oldest) of a document as a new, unsaved document named
+ /// "<name> (revision n)".
+ pub fn open_revision(&mut self, id: DocId, n: usize) -> Result<DocId, String> {
+ let doc = self.get(id).ok_or("no such document")?;
+ let ends = doc.revision_ends();
+ let end = *n.checked_sub(1).and_then(|i| ends.get(i)).ok_or_else(|| format!("the document has {} revision(s)", ends.len()))?;
+ let name = format!("{} (revision {n}).pdf", doc.name.trim_end_matches(".pdf"));
+ let (bytes, password) = (Arc::new(doc.bytes[..end.min(doc.bytes.len())].to_vec()), doc.password.clone());
+ self.open(name, None, bytes, password.as_deref()).map_err(|e| e.to_string())
+ }
+
+ pub(crate) fn doc_mut(&mut self, id: DocId) -> Result<&mut Document, EditError> {
+ self.docs.iter_mut().find(|d| d.id == id).ok_or(EditError::NoDocument)
+ }
+
+ /// Apply an edit. On success the previous state is undoable and the view data is refreshed.
+ pub fn apply(&mut self, id: DocId, edit: Edit) -> Result<(), EditError> {
+ let now = self.now();
+ let today = self.today();
+ let js_off = self.js_off;
+ let xfa_time_scale = self.xfa_time_scale.unwrap_or(1);
+ let doc = self.doc_mut(id)?;
+ doc.edit_notices.clear();
+ let name = doc.name.clone();
+ let is_xfa = doc.info.xfa.is_some();
+ let mut scope = scope_of(&edit);
+ let mut cx = EditCtx::new(now, doc.generation ^ (id.0 << 48));
+ if !js_off {
+ cx.xfa = doc.xfa_template.clone();
+ }
+ cx.xfa_time_scale = xfa_time_scale;
+ cx.pages = doc.info.pages.len();
+ cx.today = today;
+ let reason = doc.read_only_reason.clone().unwrap_or_default();
+ let signed = doc.is_signed();
+ let editor = doc.editor.as_mut().ok_or(EditError::ReadOnly(reason))?;
+ if let Some(p) = editor.cos.permissions() {
+ check_permission(&edit, &p)?;
+ }
+ // Rewriting an OCR word (invisible text over a scan) also hides the scanned word: cover it
+ // in the paper's colour and draw the new text in the ink's.
+ let edit = match edit {
+ Edit::EditTextBlock { page, block, text, mut style } => {
+ // Only invisible text is sampled; the blocks are usually cached from opening it.
+ if style.cover.is_none()
+ && let Some(info) = doc.info.pages.get(page)
+ && let Some(b) = editor.text_blocks(page).ok().and_then(|b| b.get(block).filter(|b| b.invisible).cloned())
+ && let Some((paper, ink)) = guard(|| scan_colours::sample(&editor.cos, info, page, &b)).ok().flatten()
+ {
+ style.cover = Some(paper);
+ style.color = style.color.or(Some(ink));
+ }
+ Edit::EditTextBlock { page, block, text, style }
+ }
+ other => other,
+ };
+ // Nothing to bake: leave undo history and the dirty flag alone.
+ if matches!(&edit, Edit::FlattenFillSign) && !pdfcraft_annot::has_visible_fill_sign(&editor.cos) {
+ return Ok(());
+ }
+ let mut next = editor.cos.clone();
+ if !js_off && uses_scripts(&edit) {
+ cx.js = Some(js::JsRunner::new(&next, &name));
+ }
+ cx.renamed_fields.clear();
+ cx.redaction_overlays.clear();
+ // `next` is a copy: if the edit fails or crashes, the document is unchanged.
+ guard(|| run_edit(&mut next, &edit, &mut cx))
+ .unwrap_or_else(|m| Err(EditError::Invalid(format!("{} failed unexpectedly ({m}); the document was not changed", edit.label()))))?;
+ // Redaction removed what its own interpreter places under the marks. The marks were drawn
+ // over the page as the renderer shows it, so the renderer has the last word.
+ if let Edit::ApplyRedactions { pages } = &edit {
+ let marks: Vec<pdfcraft_redact::Mark> =
+ pdfcraft_redact::marks(&editor.cos).into_iter().filter(|m| pages.as_ref().is_none_or(|p| p.contains(&m.page))).collect();
+ guard(|| shown_under_redactions(&next, &marks, &cx.redaction_overlays, &doc.info.pages, doc.password.as_deref()))
+ .unwrap_or_else(|m| Err(EditError::Invalid(format!("{} failed unexpectedly ({m}); the document was not changed", edit.label()))))?;
+ }
+ // Renamed fields are said, not slipped in: a repair-log note (with the caveat that
+ // scripts were left alone) and a count in the undo step's label.
+ let renamed_note = |renamed: &[(String, String)]| {
+ (!renamed.is_empty()).then(|| {
+ let shown: Vec<String> = renamed.iter().take(5).map(|(old, new)| format!("{old} → {new}")).collect();
+ let more = renamed.len().saturating_sub(shown.len());
+ let more = if more > 0 { format!(", and {more} more") } else { String::new() };
+ format!(
+ "inserted pages renamed {} form field{} to keep their names separate ({}{more}); scripts that refer to the old names were not rewritten",
+ renamed.len(),
+ if renamed.len() == 1 { "" } else { "s" },
+ shown.join(", ")
+ )
+ })
+ };
+ if let Some(note) = renamed_note(&cx.renamed_fields) {
+ next.note_repair(note);
+ }
+ // Only Insert from File renames fields; its label says so in a wording the interface
+ // translates (the count lives in the repair note).
+ let label = match (&edit, cx.renamed_fields.len()) {
+ (_, 0) => edit.label(),
+ (Edit::InsertPagesFrom { name, .. }, n) => Label::with(
+ if n == 1 { "Insert pages from {name} — 1 field renamed" } else { "Insert pages from {name} — fields renamed" },
+ name.as_str(),
+ ),
+ _ => edit.label(),
+ };
+ // An XFA form's scripts answer the change: exit and validate scripts of the field, then
+ // every calculation (and a reset recalculates). They read the data, so it is brought up
+ // to date first.
+ if let Some(tpl) = cx.xfa.clone() {
+ if is_xfa && matches!(scope_of(&edit), Scope::Form | Scope::Full | Scope::Content) {
+ let datasets = &mut cx.xfa_datasets;
+ let notes = guard(|| xfa_sync_datasets(&mut next, Some(&tpl), datasets))
+ .unwrap_or_else(|m| Err(format!("writing the XFA data failed unexpectedly ({m})")))
+ .map_err(EditError::Write)?;
+ cx.xfa_out.errors.extend(notes);
+ }
+ fn collect(e: &Edit, changed: &mut Vec<String>, reset: &mut bool) {
+ match e {
+ Edit::SetFieldValue { name, .. } => changed.push(name.clone()),
+ Edit::ResetForm { .. } => *reset = true,
+ Edit::Batch { edits, .. } => edits.iter().for_each(|e| collect(e, changed, reset)),
+ _ => {}
+ }
+ }
+ let mut changed: Vec<String> = Vec::new();
+ let mut reset = false;
+ collect(&edit, &mut changed, &mut reset);
+ if !changed.is_empty() || reset {
+ let mut run = xfa::XfaRun {
+ page_count: cx.pages,
+ out: &mut cx.xfa_out,
+ datasets: cx.xfa_datasets,
+ ran_away: false,
+ time_scale: cx.xfa_time_scale,
+ };
+ // Every changed field's scripts, then the calculations once (after a reset,
+ // only those).
+ let ran = guard(|| xfa::on_changes(&mut next, &tpl, &changed, &mut run))
+ .unwrap_or_else(|m| Err(format!("the form's scripts failed unexpectedly ({m})")));
+ cx.xfa_datasets = run.datasets;
+ cx.xfa_ran_away |= run.ran_away;
+ if let Err(e) = ran {
+ cx.xfa_out.errors.push(e);
+ }
+ }
+ }
+ // XFA forms keep their values in the datasets packet too, for Adobe's viewers.
+ let mut xfa_notes = Vec::new();
+ if is_xfa && matches!(scope_of(&edit), Scope::Form | Scope::Full | Scope::Content) {
+ let (tpl, datasets) = (cx.xfa.as_deref(), &mut cx.xfa_datasets);
+ xfa_notes = guard(|| xfa_sync_datasets(&mut next, tpl, datasets))
+ .unwrap_or_else(|m| Err(format!("writing the XFA data failed unexpectedly ({m})")))
+ .map_err(EditError::Write)?;
+ // Rebuilding from stale data would discard accepted widget values.
+ if xfa_notes.is_empty() {
+ let reflow = guard(|| xfa::relayout_changed_text(&mut next, tpl, &doc.form))
+ .unwrap_or_else(|m| Err(format!("laying out the XFA text failed unexpectedly ({m})")))
+ .map_err(EditError::Write)?;
+ if let Some(warnings) = reflow {
+ xfa_notes.extend(warnings);
+ // Layout replaces pages and widgets, even if the page count is unchanged.
+ // Undo/redo must rebuild these too instead of refreshing only field values.
+ scope = Scope::Full;
+ }
+ }
+ }
+ // Signed documents are only ever saved incrementally: an edit that needs a full rewrite
+ // (applying redactions, changing security, sanitizing) would invalidate the signatures.
+ // So does any edit to a file rebuilt from object headers: it has no chain to append to.
+ let rewrites = |c: &pdfcraft_cos::Document| c.full_save_required() || c.encryption_changed();
+ if signed && ((rewrites(&next) && !rewrites(&editor.cos)) || (next.is_modified() && next.revisions().is_empty())) {
+ return Err(EditError::SignedRewrite(edit.label().to_string()));
+ }
+ // What this edit drew with `?` (a value or comment text its font can't draw, stored as
+ // typed): reported, never silent (AGENTS.md §4).
+ let notices = if matches!(scope_of(&edit), Scope::Form | Scope::Comments | Scope::Full) {
+ guard(|| undrawn_notices(&editor.cos, &next)).unwrap_or_default()
+ } else {
+ Vec::new()
+ };
+ let previous = std::mem::replace(&mut editor.cos, next);
+ let keys = keys_after(&edit).unwrap_or_else(|| editor.keys.clone());
+ let previous_keys = std::mem::replace(&mut editor.keys, keys);
+ editor.undo.push((label, previous, previous_keys, scope));
+ if editor.undo.len() > MAX_UNDO {
+ editor.undo.remove(0);
+ }
+ editor.redo.clear();
+ Self::adopt_keys(doc);
+ let refreshed = guard(|| if scope == Scope::Content { Self::refresh_content(doc, Some(&edit)) } else { Self::refresh_scoped(doc, scope) })
+ .unwrap_or_else(|m| Err(EditError::Reopen(m)));
+ if let Err(e) = refreshed {
+ // Roll back: the edit produced something we cannot display.
+ if let Some(ed) = doc.editor.as_mut()
+ && let Some((_, prev, keys, _)) = ed.undo.pop()
+ {
+ ed.cos = prev;
+ ed.keys = keys;
+ }
+ Self::adopt_keys(doc);
+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {
+ Self::show_released(doc);
+ }
+ return Err(e);
+ }
+ doc.dirty = true;
+ doc.generation += 1;
+ doc.edit_notices = notices;
+ if !cx.xfa_removed.is_empty() {
+ let removed: Vec<String> = cx.xfa_removed.iter().map(|n| format!("{XFA_REMOVED_PREFIX}{n}")).collect();
+ doc.xfa_warnings.retain(|w| w.starts_with(XFA_REMOVED_PREFIX));
+ note_warnings(&mut doc.xfa_warnings, &removed);
+ note_warnings(&mut doc.info.warnings, &removed);
+ }
+ note_warnings(&mut doc.xfa_warnings, &xfa_notes);
+ let notes = doc.xfa_warnings.clone();
+ note_warnings(&mut doc.info.warnings, &notes);
+ if let Some(js) = cx.js {
+ doc.js_output.append(js.output);
+ }
+ doc.js_output.append(cx.xfa_out);
+ if cx.xfa_ran_away {
+ doc.xfa_template = None;
+ doc.xfa_scripts_off = true;
+ doc.js_output.errors.push(XFA_SCRIPTS_OFF.into());
+ }
+ Ok(())
+ }
+
+ pub fn undo(&mut self, id: DocId) -> Result<Label, EditError> {
+ let doc = self.doc_mut(id)?;
+ let editor = doc.editor.as_mut().ok_or(EditError::NothingToUndo)?;
+ let (label, prev, keys, scope) = editor.undo.pop().ok_or(EditError::NothingToUndo)?;
+ let current = std::mem::replace(&mut editor.cos, prev);
+ let current_keys = std::mem::replace(&mut editor.keys, keys);
+ editor.redo.push((label.clone(), current, current_keys, scope));
+ Self::adopt_keys(doc);
+ let refreshed = guard(|| Self::refresh_scoped(doc, scope)).unwrap_or_else(|m| Err(EditError::Reopen(m)));
+ if let Err(e) = refreshed {
+ if let Some(ed) = doc.editor.as_mut()
+ && let Some((label, current, current_keys, scope)) = ed.redo.pop()
+ {
+ let prev = std::mem::replace(&mut ed.cos, current);
+ let keys = std::mem::replace(&mut ed.keys, current_keys);
+ ed.undo.push((label, prev, keys, scope));
+ }
+ Self::adopt_keys(doc);
+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {
+ Self::show_released(doc);
+ }
+ return Err(e);
+ }
+ doc.edit_notices.clear();
+ Self::sync_dirty(doc);
+ doc.generation += 1;
+ Ok(label)
+ }
+
+ pub fn redo(&mut self, id: DocId) -> Result<Label, EditError> {
+ let doc = self.doc_mut(id)?;
+ let editor = doc.editor.as_mut().ok_or(EditError::NothingToRedo)?;
+ let (label, next, keys, scope) = editor.redo.pop().ok_or(EditError::NothingToRedo)?;
+ let current = std::mem::replace(&mut editor.cos, next);
+ let current_keys = std::mem::replace(&mut editor.keys, keys);
+ editor.undo.push((label.clone(), current, current_keys, scope));
+ Self::adopt_keys(doc);
+ let refreshed = guard(|| Self::refresh_scoped(doc, scope)).unwrap_or_else(|m| Err(EditError::Reopen(m)));
+ if let Err(e) = refreshed {
+ if let Some(ed) = doc.editor.as_mut()
+ && let Some((label, current, current_keys, scope)) = ed.undo.pop()
+ {
+ let next = std::mem::replace(&mut ed.cos, current);
+ let keys = std::mem::replace(&mut ed.keys, current_keys);
+ ed.redo.push((label, next, keys, scope));
+ }
+ Self::adopt_keys(doc);
+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {
+ Self::show_released(doc);
+ }
+ return Err(e);
+ }
+ doc.edit_notices.clear();
+ Self::sync_dirty(doc);
+ doc.generation += 1;
+ Ok(label)
+ }
+
+ /// Unsaved when the working graph is not the last opened or saved file. Undo back to that
+ /// file is clean; undo past a later save is not, because the restored snapshot's own base
+ /// is an earlier revision.
+ fn sync_dirty(doc: &mut Document) {
+ doc.dirty = doc.editor.as_ref().is_some_and(|e| e.unsaved_file || e.cos.is_modified() || !Arc::ptr_eq(e.cos.bytes(), &e.saved));
+ }
+
+ /// Use the current state's password for viewing (protection edits change it).
+ fn adopt_keys(doc: &mut Document) {
+ if let Some(e) = doc.editor.as_ref() {
+ doc.password = e.keys.render.clone();
+ doc.config.password = e.keys.render.as_deref().map(Arc::from);
+ }
+ }
+
+ /// Rebuild the working bytes and the view data that `scope` may have changed. Metadata edits
+ /// keep the renderer; other scopes also replace it.
+ /// Comment and form edits skip the full re-inspection (seconds on very large files): the
+ /// comment list and field values are re-read from the object graph instead.
+ fn refresh_scoped(doc: &mut Document, scope: Scope) -> Result<(), EditError> {
+ if scope == Scope::Full || doc.info.encrypted != doc.editor.as_ref().is_some_and(|e| e.cos.output_handler().is_some()) {
+ return Self::refresh(doc);
+ }
+ if scope == Scope::Content {
+ return Self::refresh_content(doc, None);
+ }
+ if scope == Scope::Links {
+ return Self::refresh_links(doc);
+ }
+ // Metadata edits keep the renderer, which holds the working file anyway.
+ if scope != Scope::Metadata {
+ Self::release_working(doc);
+ }
+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };
+ // Comment edits, and form edits (a script may change annotation properties), may change
+ // annotation dictionaries, invalidating cached appearances.
+ if matches!(scope, Scope::Comments | Scope::Form) {
+ editor.appearances.clear();
+ }
+ let bytes = if editor.cos.is_modified() {
+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)
+ } else {
+ editor.cos.bytes().clone()
+ };
+ if scope == Scope::Metadata {
+ for (field, value) in info_fields(&mut doc.info, &editor.cos) {
+ *field = value;
+ }
+ doc.info.custom = pdfcraft_organize::custom_info(&editor.cos);
+ doc.info.file_size = bytes.len();
+ #[cfg(test)]
+ check_refresh_panic();
+ if !doc.signatures.is_empty() {
+ let signatures = signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache);
+ doc.signatures = Arc::new(signatures);
+ }
+ doc.bytes = bytes;
+ return Ok(());
+ }
+ let mut form = pdfcraft_forms::fields(&editor.cos);
+ xfa::mark_script_buttons(&editor.cos, &mut form);
+ let form = Arc::new(form);
+ match scope {
+ Scope::Metadata => return Ok(()),
+ Scope::Comments => {
+ doc.info.annotations = comment_list(&editor.cos);
+ // Link indexes are positions in /Annots, so comment insertion/deletion can move them.
+ doc.links = OnceLock::new();
+ }
+ Scope::Form => {
+ // PERF: keystroke path, index once. A linear find per field is O(F^2);
+ // forms reach 10k fields.
+ let mut by_name = std::collections::HashMap::with_capacity(form.len());
+ for x in form.iter() {
+ // First match wins (do not simplify to collect: it keeps the last).
+ by_name.entry(x.name.as_str()).or_insert(x);
+ }
+ for f in &mut doc.info.fields {
+ if let Some(ff) = by_name.get(f.name.as_str()) {
+ f.value = match ff.kind {
+ pdfcraft_forms::FieldKind::CheckBox | pdfcraft_forms::FieldKind::Radio => {
+ Some(ff.value.first().cloned().unwrap_or_else(|| "Off".into()))
+ }
+ _ if ff.value.is_empty() => None,
+ _ => Some(ff.value.join(", ")),
+ };
+ }
+ }
+ }
+ Scope::Links => return Self::refresh_links(doc),
+ // Handled above; kept as a full refresh so the match stays total.
+ Scope::Full => return Self::refresh(doc),
+ // Handled above (content-only refresh); the arm keeps the match total.
+ Scope::Content => return Self::refresh_content(doc, None),
+ }
+ doc.info.file_size = bytes.len();
+ doc.form = form;
+ let signatures = if doc.signatures.is_empty() { Vec::new() } else { signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache) };
+ doc.display = display_bytes(Some(editor), &bytes);
+ doc.signatures = Arc::new(signatures);
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.bytes = bytes;
+ Ok(())
+ }
+
+ /// Which derived lists a content-only edit can change: added content (`None`, from
+ /// undo/redo, re-reads both: always correct, rarely paid).
+ pub(crate) fn content_refresh_lists(edit: Option<&Edit>) -> (bool, bool) {
+ if let Some(Edit::Batch { edits, .. }) = edit {
+ // A batch of content edits (from a script, say) changes what its parts change.
+ return edits.iter().fold((false, false), |(added, marks), part| {
+ let (a, m) = Self::content_refresh_lists(Some(part));
+ (added || a, marks || m)
+ });
+ }
+ let touches_added = edit.is_none_or(|e| {
+ matches!(
+ e,
+ Edit::AddText { .. }
+ | Edit::AddImage { .. }
+ | Edit::UpdateContent { .. }
+ | Edit::DeleteContent { .. }
+ | Edit::ReplaceImage { .. }
+ | Edit::PasteContent { .. }
+ ) || matches!(e, Edit::MoveObjects { objects, .. } if objects.iter().any(|o| o.kind == ObjectKind::Added))
+ });
+ let touches_marks = edit.is_none_or(|e| {
+ matches!(e, Edit::AddHeaderFooter { .. } | Edit::AddWatermark { .. } | Edit::AddBackground { .. } | Edit::RemoveMarks { .. })
+ });
+ (touches_added, touches_marks)
+ }
+
+ /// Rebuild working bytes, display bytes and renderer after a content-only edit: page
+ /// content streams, resources and added content/marks. The page tree, annotations, form
+ /// fields, links, outline and fonts are unchanged, so the full re-inspection (seconds on
+ /// very large files) is skipped. `edit` selects which derived lists are re-read (`None`,
+ /// from undo/redo, re-reads both: always correct, rarely paid). The cached display
+ /// appearances are kept: content edits leave every annotation dictionary alone.
+ fn refresh_content(doc: &mut Document, edit: Option<&Edit>) -> Result<(), EditError> {
+ Self::release_working(doc);
+ sync_xfa_state(doc);
+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };
+ let bytes = if editor.cos.is_modified() {
+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)
+ } else {
+ editor.cos.bytes().clone()
+ };
+ // The edit must still leave a file the viewer can open; anything else rolls back above.
+ pdfcraft_render::check_pages(bytes.clone(), doc.password.as_deref(), doc.info.pages.len()).map_err(|e| EditError::Reopen(e.to_string()))?;
+ let (touches_added, touches_marks) = Self::content_refresh_lists(edit);
+ if touches_added || touches_marks {
+ doc.marker_scan = OnceLock::new();
+ }
+ doc.info.file_size = bytes.len();
+ let signatures = if doc.signatures.is_empty() { Vec::new() } else { signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache) };
+ doc.display = display_bytes(Some(editor), &bytes);
+ doc.signatures = Arc::new(signatures);
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.bytes = bytes;
+ doc.fonts_stale = true;
+ Ok(())
+ }
+
+ /// Let go of the working file before the next one is written (gap 13). The working file is
+ /// the original plus one appended revision, so on a 1 GiB file keeping the old one (in the
+ /// working bytes, the display bytes and the renderer) while writing the new one held three
+ /// copies at once; this keeps two. Until the refresh finishes, the working and display bytes
+ /// are the original's (already held by the editor, so free) and the renderer draws nothing.
+ /// A failed edit rolls back and refreshes again, which replaces all three; where a refresh
+ /// still fails, [`Self::show_released`] draws the original rather than nothing. Save writes
+ /// from the editor, never from these.
+ pub(crate) fn release_working(doc: &mut Document) {
+ let Some(original) = doc.editor.as_ref().map(|e| e.cos.bytes().clone()) else { return };
+ // Dropping the pool stops its workers; each lets go of the file when it exits.
+ doc.renderer = RenderPool::new_inline(Arc::new(Vec::new()), doc.config.clone());
+ doc.display = original.clone();
+ doc.bytes = original;
+ #[cfg(test)]
+ check_refresh_panic();
+ }
+
+ /// After a refresh failed: draw the display bytes it left (the original, once released),
+ /// so the page still shows a document.
+ fn show_released(doc: &mut Document) {
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ }
+
+ /// Rebuild working bytes, inspection and renderer from the current edit state.
+ pub(crate) fn refresh(doc: &mut Document) -> Result<(), EditError> {
+ Self::refresh_with_indexes(doc, true, true)
+ }
+
+ /// Reinspect a link edit while preserving the page-content marker scan cache.
+ fn refresh_links(doc: &mut Document) -> Result<(), EditError> {
+ Self::refresh_with_indexes(doc, false, true)
+ }
+
+ fn refresh_with_indexes(doc: &mut Document, invalidate_markers: bool, invalidate_links: bool) -> Result<(), EditError> {
+ // A full refresh may follow structural or annotation changes: cached appearances
+ // may be stale, so they are rebuilt below.
+ if let Some(editor) = doc.editor.as_mut() {
+ editor.appearances.clear();
+ }
+ Self::release_working(doc);
+ sync_xfa_state(doc);
+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };
+ let bytes = if editor.cos.is_modified() {
+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)
+ } else {
+ editor.cos.bytes().clone()
+ };
+ let info = inspect(bytes.clone(), doc.password.as_deref()).map_err(|e| EditError::Reopen(e.to_string()))?;
+ // Keep the user's layer choices where the layers still exist.
+ let mut info = info;
+ for l in &mut info.layers {
+ if let Some(old) = doc.info.layers.iter().find(|o| o.id == l.id) {
+ l.visible = old.visible;
+ }
+ }
+ note_warnings(&mut info.warnings, &doc.xfa_warnings);
+ // As in `build_document`: the inspection reads only `/Info`, so fields stated only in XMP
+ // are filled in again after every full refresh.
+ for (field, value) in info_fields(&mut info, &editor.cos) {
+ if field.is_none() {
+ *field = value;
+ }
+ }
+ doc.info = info;
+ doc.fonts_stale = false;
+ let mut form = pdfcraft_forms::fields(&editor.cos);
+ xfa::mark_script_buttons(&editor.cos, &mut form);
+ doc.form = Arc::new(form);
+ if invalidate_markers {
+ doc.marker_scan = OnceLock::new();
+ }
+ if invalidate_links {
+ doc.links = OnceLock::new();
+ }
+ let signatures = signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache);
+ doc.display = display_bytes(Some(editor), &bytes);
+ doc.signatures = Arc::new(signatures);
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.bytes = bytes;
+ Ok(())
+ }
+
+ /// The bytes to write for Save: an incremental update of the file as opened/last saved,
+ /// with `/ModDate` stamped. Call `mark_saved` after writing them successfully.
+ ///
+ /// A file whose cross-reference data had to be rebuilt is written in full even when nothing
+ /// was edited: its bytes as opened are the damaged file, and this save is how the repair the
+ /// user was told about reaches the disk (#1937). Not a signed one: a full rewrite would
+ /// break its signatures, so with no edits it keeps its bytes, damage and all.
+ pub fn save_bytes(&self, id: DocId) -> Result<Arc<Vec<u8>>, EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ let Some(editor) = doc.editor.as_ref() else { return Ok(doc.bytes.clone()) };
+ let on_saved = Arc::ptr_eq(editor.cos.bytes(), &editor.saved);
+ if !editor.cos.is_modified() && on_saved && (!editor.cos.reconstructed() || doc.is_signed()) {
+ return Ok(editor.saved.clone());
+ }
+ // What the user removed again before saving (a cleared redaction mark) stays out of the file.
+ let opts = SaveOptions { mod_date: self.now().map(pdfcraft_cos::pdf_date), drop_unlinked: true, ..SaveOptions::default() };
+ // A restored snapshot can be based on an earlier revision. Append to the last saved
+ // file so that revision stays in the chain. A full rewrite (redaction, new encryption,
+ // a reconstructed file) still writes the current graph on its own.
+ let rewrite = editor.cos.full_save_required() || editor.cos.encryption_changed() || editor.cos.revisions().is_empty();
- let cos = writable(&editor.cos)?;
++ let mut cos = writable(&editor.cos)?;
++ pdfcraft_edit::text::subset_document_fonts(cos.to_mut())?;
+ guard(|| {
+ if on_saved || rewrite {
+ write_incremental(&cos, &opts)
+ } else {
+ let mut base = pdfcraft_cos::Document::open_with_password(editor.saved.clone(), editor.saved_keys.reopen.as_deref())?;
+ base.overlay_changes_from(&cos)?;
+ write_incremental(&base, &opts)
+ }
+ })
+ .map_err(EditError::Write)?
+ .map(Arc::new)
+ .map_err(|e| EditError::Write(e.to_string()))
+ }
+
+ /// A compact, garbage-collected rewrite (Save As ▸ "Optimized" / Reduce File Size groundwork).
+ pub fn save_full_bytes(&self, id: DocId) -> Result<Arc<Vec<u8>>, EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ if doc.is_signed() {
+ return Err(EditError::Signed);
+ }
+ let editor = doc.editor.as_ref().ok_or_else(|| EditError::ReadOnly(doc.read_only_reason.clone().unwrap_or_default()))?;
+ let opts = SaveOptions { mod_date: self.now().map(pdfcraft_cos::pdf_date), ..SaveOptions::default() };
- let cos = writable(&editor.cos)?;
++ let mut cos = writable(&editor.cos)?;
++ pdfcraft_edit::text::subset_document_fonts(cos.to_mut())?;
+ guard(|| write_full(&cos, &opts)).map_err(EditError::Write)?.map(Arc::new).map_err(|e| EditError::Write(e.to_string()))
+ }
+
+ /// Check that `bytes`, from [`Self::save_bytes`] or [`Self::save_full_bytes`], reopen as this
+ /// document before they are written (#1698): [`Self::mark_saved`] only finds out after the
+ /// file has been replaced. Same error as `mark_saved`.
+ pub fn check_save(&self, id: DocId, bytes: &Arc<Vec<u8>>) -> Result<(), EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ let Some(editor) = doc.editor.as_ref() else { return Ok(()) };
+ pdfcraft_cos::Document::open_with_password(bytes.clone(), editor.keys.reopen.as_deref()).map_err(|e| EditError::Reopen(e.to_string()))?;
+ pdfcraft_render::check_pages(bytes.clone(), doc.password.as_deref(), doc.info.pages.len()).map_err(|e| EditError::Reopen(e.to_string()))
+ }
+
+ /// Record a successful save of `bytes` (to `path`, if any): rebase editing on the saved file
+ /// so the next save appends only newer edits. Undo history is kept.
+ pub fn mark_saved(&mut self, id: DocId, bytes: Arc<Vec<u8>>, path: Option<String>) -> Result<(), EditError> {
+ let doc = self.doc_mut(id)?;
+ if let Some(editor) = doc.editor.as_mut() {
+ // An encrypted file needs the password it is protected with now (the owner
+ // password when known, so saving never downgrades this session's rights).
+ let keys = editor.keys.clone();
+ // The saved file carries no Password-field values (#3943, #3944); the open document keeps them.
+ let typed = pdfcraft_forms::password_values(&editor.cos);
+ editor.cos =
+ pdfcraft_cos::Document::open_with_password(bytes.clone(), keys.reopen.as_deref()).map_err(|e| EditError::Reopen(e.to_string()))?;
+ pdfcraft_forms::restore_password_values(&mut editor.cos, &typed).map_err(|e| EditError::Reopen(e.to_string()))?;
+ if !typed.is_empty() && doc.info.xfa.is_some() {
+ let mut datasets = None;
+ let _ = xfa_sync_datasets(&mut editor.cos, doc.xfa_template.as_deref(), &mut datasets);
+ }
+ editor.saved = bytes;
+ editor.saved_keys = keys;
+ editor.unsaved_file = false;
+ }
+ if let Some(p) = path {
+ doc.name = std::path::Path::new(&p).file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| p.clone());
+ doc.path = Some(p);
+ }
+ doc.dirty = false;
+ doc.generation += 1;
+ Self::refresh(doc).inspect_err(|_| Self::show_released(doc))
+ }
+
+ /// Enter the permissions (owner) password of a document opened with its user password,
+ /// lifting its restrictions for this session (Acrobat asks for it before changing security).
+ /// Not an edit: nothing is marked unsaved and there is no undo step. Undo and redo states
+ /// are unlocked as well, and saving keeps the rights. Unencrypted documents and documents
+ /// opened by the owner need nothing.
+ pub fn unlock(&mut self, id: DocId, password: &str) -> Result<(), EditError> {
+ let doc = self.doc_mut(id)?;
+ let editor = doc.editor.as_mut().ok_or_else(|| EditError::ReadOnly(doc.read_only_reason.clone().unwrap_or_default()))?;
+ if editor.cos.permissions().is_none_or(|p| p.owner) {
+ return Ok(());
+ }
+ editor.cos.unlock(password).map_err(|e| match e {
+ pdfcraft_cos::CosError::WrongPassword => EditError::WrongPassword,
+ other => EditError::Protection(other.to_string()),
+ })?;
+ // Saving a state that keeps the security it was opened with reopens it with the same
+ // passwords, so it reopens as owner.
+ let reopen_as_owner = |cos: &pdfcraft_cos::Document, keys: &mut Keys| {
+ if !cos.encryption_changed() {
+ keys.reopen = Some(password.to_owned());
+ }
+ };
+ reopen_as_owner(&editor.cos, &mut editor.keys);
+ // Other states with the same restricted access are unlocked too; states opened with
+ // other passwords (protection changed and saved since) stay as they are.
+ for (_, cos, keys, _) in editor.undo.iter_mut().chain(editor.redo.iter_mut()) {
+ if cos.permissions().is_some_and(|p| !p.owner) && cos.unlock(password).is_ok() {
+ reopen_as_owner(cos, keys);
+ }
+ }
+ Ok(())
+ }
+
+ /// File ▸ Revert: back to the last saved version (or the file as opened). Undo history is
+ /// cleared, as in Acrobat.
+ pub fn revert(&mut self, id: DocId) -> Result<(), EditError> {
+ let doc = self.doc_mut(id)?;
+ let editor = doc.editor.as_mut().ok_or_else(|| EditError::ReadOnly(doc.read_only_reason.clone().unwrap_or_default()))?;
+ let base = editor.saved.clone();
+ // The saved file opens with the passwords it was saved with. The current snapshot may
+ // be an older revision (undo past that save), so its own base is not the saved file.
+ let mut candidates = vec![editor.saved_keys.clone(), editor.keys.clone()];
+ candidates.extend(editor.undo.iter().rev().map(|s| s.2.clone()));
+ candidates.push(Keys::default());
+ let (cos, keys) = candidates
+ .into_iter()
+ .find_map(|k| pdfcraft_cos::Document::open_with_password(base.clone(), k.reopen.as_deref()).ok().map(|c| (c, k)))
+ .ok_or_else(|| EditError::Reopen("the saved file can't be opened".into()))?;
+ editor.cos = cos;
+ editor.keys = keys;
+ editor.undo.clear();
+ editor.redo.clear();
+ Self::adopt_keys(doc);
+ Self::sync_dirty(doc);
+ doc.generation += 1;
+ Self::refresh(doc).inspect_err(|_| Self::show_released(doc))
+ }
+
+ /// The document's file changed on disk (a LaTeX or Typst build rewrote it, #431): open
+ /// `bytes`, the file as it is now, in its place. Everything opening does runs again (XFA
+ /// layout and scripts, signatures, repairs), but the document keeps its id, name and path,
+ /// so its tab and view stay with it. Undo history goes, as with Revert. The password it was
+ /// opened with is tried; on any failure the document is left as it was.
+ pub fn reload(&mut self, id: DocId, bytes: Arc<Vec<u8>>) -> Result<(), OpenError> {
+ let old = self.docs.iter().position(|d| d.id == id).ok_or_else(|| OpenError::Invalid("the document is not open".into()))?;
+ let doc = &self.docs[old];
+ let (name, path, generation) = (doc.name.clone(), doc.path.clone(), doc.generation);
+ let password = doc.editor.as_ref().and_then(|e| e.keys.reopen.clone()).or_else(|| doc.password.clone());
+ let new_id = self.open(name, path, bytes, password.as_deref())?;
+ let at = self.docs.iter().position(|d| d.id == new_id).ok_or_else(|| OpenError::Invalid("the new version was not kept".into()))?;
+ let mut doc = self.docs.remove(at);
+ doc.id = id;
+ // How the document is shown is the reader's, not the file's: reading colours and hidden
+ // comments stay as they were (#3443). `open` built the renderer with the defaults.
+ if let Some(old) = self.docs.get(old)
+ && (doc.config.reading_colors != old.config.reading_colors || doc.config.hide_comments != old.config.hide_comments)
+ {
+ doc.config.reading_colors = old.config.reading_colors;
+ doc.config.hide_comments = old.config.hide_comments;
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ }
+ // Caches keyed by the edit generation (edit lines, images, measurements) must see a new
+ // one; there is nothing new to autosave.
+ doc.generation = generation + 1;
+ doc.snapshot_generation = doc.generation;
+ // `open` pushed the new version last, so the old one is still at `old`.
+ *self.docs.get_mut(old).ok_or_else(|| OpenError::Invalid("the document is not open".into()))? = doc;
+ Ok(())
+ }
+
+ /// The page count of another PDF (Replace Pages, Insert Pages dialogs).
+ pub fn page_count_of(&self, name: &str, bytes: &Arc<Vec<u8>>) -> Result<usize, EditError> {
+ Ok(pdfcraft_organize::page_count(&open_source(name, bytes)?)?)
+ }
+
+ /// A new blank document (Create ▸ Blank page).
+ pub fn create_blank(&self, width: f64, height: f64, pages: usize) -> Result<Arc<Vec<u8>>, EditError> {
+ self.write_new(&pdfcraft_create::blank(width, height, pages)?)
+ }
+
+ /// A new document with one page per image (PNG, JPEG).
+ pub fn create_from_images(&self, images: &[(String, Vec<u8>)]) -> Result<Arc<Vec<u8>>, EditError> {
+ self.write_new(&pdfcraft_create::from_images(images)?)
+ }
+
+ /// Create image pages at embedded resolution or a fixed dpi, without resampling.
+ pub fn create_from_images_with_resolution(&self, images: &[(String, Vec<u8>)], resolution: ImageResolution) -> Result<Arc<Vec<u8>>, EditError> {
+ self.write_new(&pdfcraft_create::from_images_with_resolution(images, resolution)?)
+ }
+
+ /// A new document from plain text (US Letter, 11 pt Helvetica). Text Helvetica can't draw is
+ /// refused, naming the line and the character (never set as `?`).
+ pub fn create_from_text(&self, title: &str, text: &str) -> Result<Arc<Vec<u8>>, EditError> {
+ self.write_new(&pdfcraft_create::from_text(title, text, pdfcraft_create::LETTER, 11.0)?)
+ }
+
+ /// [`Self::create_from_text`] for a report PdfCraft writes from documents (comment summaries,
+ /// compare reports), which can quote any language: characters Helvetica can't draw are written
+ /// as `[U+XXXX]`, and the report's first line says so, rather than the report being refused.
+ pub(crate) fn create_report(&self, title: &str, text: &str) -> Result<Arc<Vec<u8>>, EditError> {
+ let (doc, _escaped) = pdfcraft_create::from_text_escaped(title, text, pdfcraft_create::LETTER, 11.0)?;
+ self.write_new(&doc)
+ }
+
+ /// Convert a file Create understands (an image or plain text) to PDF bytes; a PDF is checked
+ /// (it must open and allow copying pages) and returned as it is.
+ pub fn convert_to_pdf(&self, name: &str, bytes: &Arc<Vec<u8>>) -> Result<(SourceKind, Arc<Vec<u8>>), EditError> {
+ let Some(kind) = source_kind(name, bytes) else {
+ return Err(EditError::Source(format!("{name}: this file type can't be converted; use a PDF, an image or a .txt file")));
+ };
+ let title = name.rsplit_once('.').map_or(name, |(s, _)| s);
+ // Image decoders read untrusted bytes: a panic in one must not take the app down.
+ let created = guard(|| match kind {
+ SourceKind::Pdf => open_source(name, bytes).map(|_| bytes.clone()),
+ SourceKind::Image => self.create_from_images(&[(name.to_string(), bytes.to_vec())]),
+ SourceKind::Text => self.create_from_text(title, &decode_text(bytes)),
+ })
+ .map_err(|_| EditError::Source(format!("{name}: the file could not be read")))?;
+ Ok((kind, created?))
+ }
+
+ /// A file for Combine as PDF bytes: an image or text file is converted; a PDF is returned as
+ /// it is, unchecked (Combine reads it itself, with its password), as is a file named .pdf
+ /// without a `%PDF-` header, which the reader may still open.
+ pub fn as_pdf(&self, name: &str, bytes: &Arc<Vec<u8>>) -> Result<Arc<Vec<u8>>, EditError> {
+ let pdf = match source_kind(name, bytes) {
+ Some(SourceKind::Pdf) => true,
+ Some(SourceKind::Image | SourceKind::Text) => false,
+ None => name.to_ascii_lowercase().ends_with(".pdf"),
+ };
+ if pdf { Ok(bytes.clone()) } else { self.convert_to_pdf(name, bytes).map(|(_, pdf)| pdf) }
+ }
+
+ /// Reduce File Size: Acrobat's defaults (images above 225 ppi to 150 ppi, JPEG medium
+ /// quality; thumbnails dropped), identical resources merged, unused objects dropped, objects
+ /// packed into compressed object streams. Returns the bytes and how many objects were
+ /// merged. The open document is not changed (Acrobat saves the reduced copy as a new file).
+ pub fn reduced_bytes(&self, id: DocId) -> Result<(Arc<Vec<u8>>, usize), EditError> {
+ let (bytes, report) = self.optimized_bytes(id, &optimize::Settings::default(), &[])?;
+ Ok((bytes, report.merged))
+ }
+
+ /// Optimize PDF ▸ Advanced optimization: `settings` for images and objects, plus Remove
+ /// Hidden Information's `discard` categories (user data). A full rewrite: signed documents
+ /// are refused. The open document is not changed. This is [`Self::optimize_job`] run in
+ /// place, without progress.
+ pub fn optimized_bytes(&self, id: DocId, settings: &optimize::Settings, discard: &[Hidden]) -> Result<(Arc<Vec<u8>>, OptimizeReport), EditError> {
+ self.optimize_job(id, settings, discard)?.run(|_| true)
+ }
+
+ /// Export comments and/or form data: XFDF and FDF carry either or both; XML, CSV and text
+ /// are form data only.
+ pub fn export_data(&self, id: DocId, format: DataFormat, comments: bool, fields: bool) -> Result<Vec<u8>, EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ let cos = match doc.editor.as_ref() {
+ Some(e) => e.cos.clone(),
+ None => {
+ pdfcraft_cos::Document::open_with_password(doc.bytes.clone(), doc.password.as_deref()).map_err(|e| EditError::Write(e.to_string()))?
+ }
+ };
+ // An XFA form's data is its datasets, as Acrobat exports it: XML or an XDP.
+ let xfa = doc.info.xfa.is_some();
+ if format == DataFormat::Xdp && !xfa {
+ return Err(EditError::Invalid("XDP holds XFA form data; this document is not an XFA form (use .xml, .csv or .txt)".into()));
+ }
+ guard(|| match format {
+ DataFormat::Xfdf => Ok(pdfcraft_xfdf::export_xfdf(&cos, comments, fields, &doc.name).into_bytes()),
+ DataFormat::Fdf => pdfcraft_xfdf::export_fdf(&cos, comments, fields, &doc.name).map_err(|e| e.to_string()),
+ DataFormat::Xml | DataFormat::Xdp if xfa => {
+ pdfcraft_xfa::export_data(&cos, format == DataFormat::Xdp, &doc.name).map(String::into_bytes).map_err(|e| e.to_string())
+ }
+ other => Ok(pdfcraft_xfdf::export_data(&cos, other).into_bytes()),
+ })
+ .map_err(EditError::Write)?
+ .map_err(EditError::Write)
+ }
+
+ /// The print-ready PDF for `settings` (sheets laid out for the paper; see `pdfcraft-print`).
+ pub fn print_pdf(&self, id: DocId, settings: &print::Settings) -> Result<Vec<u8>, EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ if !doc.allows_printing() {
+ return Err(EditError::NotPermitted("printing"));
+ }
+ // Table 22, bit 12 clear: only a low-level representation may be printed, so the pages
+ // always go as pictures, at no more than the low resolution.
+ let low_res = doc.permissions().is_some_and(|p| !p.print_high_quality()).then(|| print::Raster {
+ dpi: settings.raster.map_or(LOW_RESOLUTION_PRINT_DPI, |r| r.dpi.min(LOW_RESOLUTION_PRINT_DPI)),
+ grayscale: settings.raster.is_some_and(|r| r.grayscale),
+ });
+ // Print as image: the pages used become pictures first, then the picture document is
+ // imposed in their place (its page k is the k-th distinct source page used).
+ if let Some(raster) = low_res.as_ref().or(settings.raster.as_ref()) {
+ let mut distinct: Vec<usize> = Vec::new();
+ for &p in &settings.pages {
+ if !distinct.contains(&p) {
+ distinct.push(p);
+ }
+ }
+ let bytes = print_raster::rasterize(doc, &distinct, raster, settings.content).map_err(EditError::Print)?;
+ let pictures = pdfcraft_cos::Document::open(Arc::new(bytes)).map_err(|e| EditError::Print(e.to_string()))?;
+ let remapped = print::Settings {
+ pages: settings.pages.iter().map(|p| distinct.iter().position(|d| d == p).unwrap_or(0)).collect(),
+ content: print::Content::Document,
+ raster: None,
+ ..settings.clone()
+ };
+ return pdfcraft_print::impose(&pictures, &remapped).map_err(|e| EditError::Print(e.to_string()));
+ }
+ let mut cos = match doc.editor.as_ref() {
+ Some(e) => e.cos.clone(),
+ None => {
+ pdfcraft_cos::Document::open_with_password(doc.bytes.clone(), doc.password.as_deref()).map_err(|e| EditError::Write(e.to_string()))?
+ }
+ };
+ // #3046: the layers print as they are shown. Once the Layers panel (or a set-layer
+ // action) has changed one, the print copy's default configuration says which are on, so a
+ // hidden layer stays off on paper too; untouched, the document's own configuration prints.
+ if !doc.config.layers.is_empty() {
+ set_default_layer_state(&mut cos, &doc.info.layers);
+ }
+ pdfcraft_print::impose(&cos, settings).map_err(|e| EditError::Print(e.to_string()))
+ }
+
+ /// For each page, whether its text mostly runs bottom-to-top ([`pdfcraft_print::text_reads_up`]);
+ /// only `pages` are read, the others are `false`.
+ pub fn print_text_up(&self, id: DocId, pages: &[usize]) -> Vec<bool> {
+ let Some(doc) = self.get(id) else { return Vec::new() };
+ let cos = match doc.editor.as_ref() {
+ Some(e) => e.cos.clone(),
+ None => match pdfcraft_cos::Document::open_with_password(doc.bytes.clone(), doc.password.as_deref()) {
+ Ok(c) => c,
+ Err(_) => return Vec::new(),
+ },
+ };
+ (0..doc.info.pages.len()).map(|i| pages.contains(&i) && pdfcraft_print::text_reads_up(&cos, i)).collect()
+ }
+
+ /// Combine whole files, in order, into new PDF bytes (one bookmark per file).
+ pub fn combine(&self, sources: &[(String, Arc<Vec<u8>>)]) -> Result<Arc<Vec<u8>>, EditError> {
+ let docs = sources.iter().map(|(n, b)| open_source(n, b)).collect::<Result<Vec<_>, _>>()?;
+ let named: Vec<(&str, &pdfcraft_cos::Document)> = sources.iter().map(|(n, _)| n.as_str()).zip(docs.iter()).collect();
+ let out = pdfcraft_organize::combine(&named)?;
+ self.write_new(&out)
+ }
+
+ /// Combine Files with a page range per file ("1-3, 6"; `None` or empty for all pages).
+ pub fn combine_ranges(&self, sources: &[CombineSource]) -> Result<Arc<Vec<u8>>, EditError> {
+ self.combine_unlocked(sources, &[])
+ }
+
+ /// Combine sources one at a time, in order (Create ▸ Multiple files), to the same result as
+ /// [`Self::combine_ranges`]. Each item is a source's bookmark title, its PDF bytes (see
+ /// [`Self::convert_to_pdf`]) and its page range (`None` for all pages). Items are pulled one at a
+ /// time: a source is opened, its pages are copied into the result, and its bytes are released
+ /// before the next item is read. So the number of sources is not limited, and one source's
+ /// document is held at a time. An item's error stops the combine and is returned as it is.
+ /// `Ok(None)` when there are no sources.
+ pub fn combine_each<I, E>(&self, sources: I) -> Result<Option<Arc<Vec<u8>>>, E>
+ where
+ I: IntoIterator<Item = Result<CombineSource, E>>,
+ E: From<EditError>,
+ {
+ let mut combiner = pdfcraft_organize::Combiner::new();
+ let mut added = false;
+ for source in sources {
+ let (title, bytes, range) = source?;
+ let doc = open_source(&title, &bytes)?;
+ let range = range.as_deref().map(str::trim).filter(|r| !r.is_empty());
+ let pages = match range {
+ Some(r) => {
+ let n = pdfcraft_organize::page_count(&doc).map_err(EditError::from)?;
+ let p = pdfcraft_print::select_pages(n, Some(r), &[], pdfcraft_print::Subset::All, false)
+ .map_err(|e| EditError::Print(format!("{title}: {e}")))?;
+ Some(p)
+ }
+ None => None,
+ };
+ combiner.add(&title, &doc, pages.as_deref()).map_err(EditError::from)?;
+ added = true;
+ }
+ if !added {
+ return Ok(None);
+ }
+ let out = combiner.finish().map_err(EditError::from)?;
+ Ok(Some(self.write_new(&out)?))
+ }
+
+ /// [`Self::combine_ranges`] with the password each encrypted source is opened with, by
+ /// position (missing or `None`: no password). The result is not encrypted.
+ pub fn combine_unlocked(&self, sources: &[CombineSource], passwords: &[Option<&str>]) -> Result<Arc<Vec<u8>>, EditError> {
+ Ok(self.combine_unlocked_reporting(sources, passwords, pdfcraft_organize::FieldConflicts::Rename)?.bytes)
+ }
+
+ /// The pre-flight over byte sources: what combining them, in order, would rename in each one
+ /// (whole files; page ranges are the combine's to apply). A source that cannot be opened
+ /// previews as nothing — its row already says why it cannot be combined.
+ pub fn combine_field_conflicts(&self, sources: &[CombineSource], passwords: &[Option<&str>]) -> Vec<Vec<(String, String)>> {
+ let docs: Vec<Option<pdfcraft_cos::Document>> =
+ sources.iter().enumerate().map(|(i, (n, b, _))| open_source_with(n, b, passwords.get(i).copied().flatten()).ok()).collect();
+ let refs: Vec<&pdfcraft_cos::Document> = docs.iter().filter_map(Option::as_ref).collect();
+ let mut opened = pdfcraft_organize::combine_field_conflicts(&refs).into_iter();
+ // One preview per source, in step with it: a file that cannot be opened has none.
+ docs.iter().map(|d| if d.is_some() { opened.next().unwrap_or_default() } else { Default::default() }).collect()
+ }
+
+ /// [`Self::combine_unlocked`] reporting what the conflict resolution renamed.
+ pub fn combine_unlocked_reporting(
+ &self,
+ sources: &[CombineSource],
+ passwords: &[Option<&str>],
+ field_conflicts: pdfcraft_organize::FieldConflicts,
+ ) -> Result<Combined, EditError> {
+ let docs = sources
+ .iter()
+ .enumerate()
+ .map(|(i, (n, b, _))| open_source_with(n, b, passwords.get(i).copied().flatten()))
+ .collect::<Result<Vec<_>, _>>()?;
+ let mut pages = Vec::with_capacity(docs.len());
+ for ((name, _, range), d) in sources.iter().zip(&docs) {
+ let range = range.as_deref().map(str::trim).filter(|r| !r.is_empty());
+ pages.push(match range {
+ Some(r) => {
+ let n = pdfcraft_organize::page_count(d)?;
+ let p = pdfcraft_print::select_pages(n, Some(r), &[], pdfcraft_print::Subset::All, false)
+ .map_err(|e| EditError::Print(format!("{name}: {e}")))?;
+ Some(p)
+ }
+ None => None,
+ });
+ }
+ let named: Vec<(&str, &pdfcraft_cos::Document, Option<&[usize]>)> =
+ sources.iter().zip(docs.iter()).zip(&pages).map(|(((n, _, _), d), p)| (n.as_str(), d, p.as_deref())).collect();
+ let out = pdfcraft_organize::combine_selected_with(&named, field_conflicts)?;
+ let bytes = self.write_new(&out.doc)?;
+ Ok(Combined { bytes, renamed_fields: out.renamed_fields })
+ }
+
+ /// [`Self::combine_unlocked`] where sources with the same `groups` key (by position) are one
+ /// file split into several runs placed apart: each file is opened and copied once, so it keeps
+ /// one bookmark, its links between its own pages, its fields and its attachments whole (see
+ /// `pdfcraft_organize::combine_grouped`). A group's later sources use its first source's bytes
+ /// and password; a source without a key is a file of its own.
+ pub fn combine_grouped(&self, sources: &[CombineSource], groups: &[u64], passwords: &[Option<&str>]) -> Result<Arc<Vec<u8>>, EditError> {
+ Ok(self.combine_grouped_reporting(sources, groups, passwords, pdfcraft_organize::FieldConflicts::Rename)?.bytes)
+ }
+
+ /// [`Self::combine_grouped`] reporting what the conflict resolution renamed.
+ pub fn combine_grouped_reporting(
+ &self,
+ sources: &[CombineSource],
+ groups: &[u64],
+ passwords: &[Option<&str>],
+ field_conflicts: pdfcraft_organize::FieldConflicts,
+ ) -> Result<Combined, EditError> {
+ let (mut keys, mut docs, mut file): (Vec<Option<u64>>, Vec<pdfcraft_cos::Document>, Vec<usize>) = (Vec::new(), Vec::new(), Vec::new());
+ for (i, (name, bytes, _)) in sources.iter().enumerate() {
+ let key = groups.get(i).copied();
+ let known = key.and_then(|k| keys.iter().position(|g| *g == Some(k)));
+ let at = match known {
+ Some(at) => at,
+ None => {
+ docs.push(open_source_with(name, bytes, passwords.get(i).copied().flatten())?);
+ keys.push(key);
+ docs.len() - 1
+ }
+ };
+ file.push(at);
+ }
+ let mut pages = Vec::with_capacity(sources.len());
+ for ((name, _, range), at) in sources.iter().zip(&file) {
+ let range = range.as_deref().map(str::trim).filter(|r| !r.is_empty());
+ let Some(d) = docs.get(*at) else { return Err(EditError::Write(format!("{name}: not opened"))) };
+ pages.push(match range {
+ Some(r) => {
+ let n = pdfcraft_organize::page_count(d)?;
+ let p = pdfcraft_print::select_pages(n, Some(r), &[], pdfcraft_print::Subset::All, false)
+ .map_err(|e| EditError::Print(format!("{name}: {e}")))?;
+ Some(p)
+ }
+ None => None,
+ });
+ }
+ let mut runs: Vec<pdfcraft_organize::Run<'_>> = Vec::with_capacity(sources.len());
+ for (((name, _, _), at), p) in sources.iter().zip(&file).zip(&pages) {
+ let Some(d) = docs.get(*at) else { return Err(EditError::Write(format!("{name}: not opened"))) };
+ runs.push((*at, name.as_str(), d, p.as_deref()));
+ }
+ let out = pdfcraft_organize::combine_grouped_with(&runs, field_conflicts)?;
+ let bytes = self.write_new(&out.doc)?;
+ Ok(Combined { bytes, renamed_fields: out.renamed_fields })
+ }
+
+ /// New PDF bytes containing copies of `pages` of the document (Extract Pages).
+ pub fn extract(&self, id: DocId, pages: &[usize]) -> Result<Arc<Vec<u8>>, EditError> {
+ let src = self.cos(id)?;
+ if src.permissions().is_some_and(|p| !p.assemble()) {
+ return Err(EditError::NotPermitted("extracting pages"));
+ }
+ let out = pdfcraft_organize::extract_pages(src, pages)?;
+ self.write_new(&out)
+ }
+
+ /// Split the document into several new PDFs.
+ pub fn split(&self, id: DocId, by: &pdfcraft_organize::SplitBy) -> Result<Vec<SplitPart>, EditError> {
+ let src = self.cos(id)?;
+ if src.permissions().is_some_and(|p| !p.assemble()) {
+ return Err(EditError::NotPermitted("splitting the document"));
+ }
+ let n = pdfcraft_organize::page_count(src)?;
+ pdfcraft_organize::split_ranges(n, by)
+ .into_iter()
+ .map(|r| {
+ let doc = pdfcraft_organize::extract_pages(src, &r.clone().collect::<Vec<_>>())?;
+ Ok((r.start + 1, r.end, self.write_new(&doc)?))
+ })
+ .collect()
+ }
+
+ /// Split into parts of at most `max_bytes` each (Acrobat's "File size"): pages are taken in
+ /// order while their size (as single-page files, an over-estimate because shared fonts and
+ /// images count once per part) fits; a page larger than the limit is a part of its own.
+ pub fn split_by_size(&self, id: DocId, max_bytes: usize) -> Result<Vec<SplitPart>, EditError> {
+ let src = self.cos(id)?;
+ if src.permissions().is_some_and(|p| !p.assemble()) {
+ return Err(EditError::NotPermitted("splitting the document"));
+ }
+ let n = pdfcraft_organize::page_count(src)?;
+ let mut cuts = Vec::new();
+ let mut used = 0usize;
+ for p in 0..n {
+ let size = self.write_unchecked(&pdfcraft_organize::extract_pages(src, &[p])?)?.len();
+ if used > 0 && used + size > max_bytes {
+ cuts.push(p);
+ used = 0;
+ }
+ used += size;
+ }
+ self.split(id, &pdfcraft_organize::SplitBy::Before(cuts))
+ }
+
+ /// Web addresses in the text of every page (Create links from URLs): (page, one rectangle
+ /// per line in user space, URI). Text that already has a link over it is skipped.
+ pub fn find_urls(&self, id: DocId) -> Vec<(usize, Vec<[f64; 4]>, String)> {
+ let Some(doc) = self.get(id) else { return Vec::new() };
+ let config = RenderConfig { password: doc.password.as_deref().map(Arc::from), ..Default::default() };
+ let mut r = pdfcraft_render::PageRenderer::new(doc.bytes.clone(), config);
+ let mut out = Vec::new();
+ for page in 0..doc.info.pages.len() {
+ let res = r.render(pdfcraft_render::RenderRequest { page, kind: pdfcraft_render::RequestKind::Text, scale: 1.0, ..Default::default() });
+ let Some(text) = res.text else { continue };
+ let found: std::cell::RefCell<Vec<(std::ops::Range<usize>, String)>> = Default::default();
+ let hits = text.find_with(|chars| {
+ let urls = pdfcraft_annot::links::find_urls(chars);
+ let ranges = urls.iter().map(|u| u.0.clone()).collect();
+ *found.borrow_mut() = urls;
+ ranges
+ });
+ for (glyphs, (_, uri)) in hits.into_iter().zip(found.into_inner()) {
+ let rects: Vec<[f64; 4]> = text
+ .line_rects(glyphs)
+ .into_iter()
+ .map(|v| {
+ let q = doc.info.pages[page].view_rect_to_quad(v);
+ let xs = [q[0], q[2], q[4], q[6]];
+ let ys = [q[1], q[3], q[5], q[7]];
+ [
+ xs.iter().copied().fold(f64::MAX, f64::min),
+ ys.iter().copied().fold(f64::MAX, f64::min),
+ xs.iter().copied().fold(f64::MIN, f64::max),
+ ys.iter().copied().fold(f64::MIN, f64::max),
+ ]
+ })
+ .filter(|r| {
+ !doc.links().iter().any(|l| l.page == page && l.rect[0] < r[2] && r[0] < l.rect[2] && l.rect[1] < r[3] && r[1] < l.rect[3])
+ })
+ .collect();
+ if !rects.is_empty() {
+ out.push((page, rects, uri));
+ }
+ }
+ }
+ out
+ }
+
+ /// A page of the bookmark list in outline order: up to `limit` bookmarks from position `offset`.
+ /// The document's own structure is read for it, so every bookmark can be reached by paging.
+ pub fn bookmark_page(&self, id: DocId, offset: usize, limit: usize) -> Option<BookmarkPage> {
+ let doc = self.get(id)?;
+ if let Some(editor) = doc.editor.as_ref() {
+ let page = pdfcraft_organize::bookmark_page(&editor.cos, offset, limit);
+ let rows = page
+ .bookmarks
+ .into_iter()
+ .map(|b| {
+ let view = b.view.map_or_else(Default::default, |(kind, numbers)| {
+ let numbers: Vec<Option<f32>> = numbers.iter().map(|n| n.map(|n| n as f32)).collect();
+ pdfcraft_render::DestView::from_operands(Some(&kind), &numbers)
+ });
+ BookmarkRow { path: b.path, title: b.title, open: b.open, page: b.page, view, color: b.color, italic: b.italic, bold: b.bold }
+ })
+ .collect();
+ return Some(BookmarkPage { rows, next: page.next, truncated: false });
+ }
+ let all = outline_rows(&doc.info.outline);
+ let end = offset.saturating_add(limit);
+ let rows = all.iter().skip(offset).take(limit).cloned().collect();
+ Some(BookmarkPage { rows, next: (end < all.len()).then_some(end), truncated: doc.info.outline_more })
+ }
+
+ /// Top-level bookmarks as split points: (first page of each part, its bookmark's title).
+ pub fn bookmark_splits(&self, id: DocId) -> Vec<(usize, String)> {
+ let Some(doc) = self.get(id) else { return Vec::new() };
+ let top: Vec<(Option<usize>, String)> = match doc.editor.as_ref() {
+ Some(editor) => pdfcraft_organize::top_level_bookmarks(&editor.cos).into_iter().map(|b| (b.page, b.title)).collect(),
+ None => doc.info.outline.iter().map(|o| (o.page, o.title.clone())).collect(),
+ };
+ let mut out: Vec<(usize, String)> = top.into_iter().filter_map(|(page, title)| Some((page?, title))).collect();
+ out.sort_by_key(|x| x.0);
+ out.dedup_by_key(|x| x.0);
+ out
+ }
+
+ /// Open freshly created bytes (combine / extract) as a new, unsaved document.
+ pub fn open_new(&mut self, name: impl Into<String>, bytes: Arc<Vec<u8>>) -> Result<DocId, OpenError> {
+ let id = self.open(name, None, bytes, None)?;
+ if let Some(d) = self.docs.iter_mut().find(|d| d.id == id) {
+ d.dirty = true;
+ if let Some(e) = d.editor.as_mut() {
+ e.unsaved_file = true;
+ }
+ // Unsaved work with no edit yet still needs its first recovery snapshot.
+ d.generation += 1;
+ }
+ Ok(id)
+ }
+
+ fn cos(&self, id: DocId) -> Result<&pdfcraft_cos::Document, EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ doc.editor.as_ref().map(|e| &e.cos).ok_or_else(|| EditError::ReadOnly(doc.read_only_reason.clone().unwrap_or_default()))
+ }
+
+ /// A new file (Combine, Extract, Split, Create) as bytes, checked like a save before anyone
+ /// writes it (#1698, #2166): it reopens, and shows the pages it was built from.
+ fn write_new(&self, doc: &pdfcraft_cos::Document) -> Result<Arc<Vec<u8>>, EditError> {
+ let bytes = self.write_unchecked(doc)?;
+ let expected = pdfcraft_organize::page_count(doc)?;
+ pdfcraft_cos::Document::open(bytes.clone()).map_err(|e| EditError::Reopen(e.to_string()))?;
+ pdfcraft_render::check_pages(bytes.clone(), None, expected).map_err(|e| EditError::Reopen(e.to_string()))?;
+ Ok(bytes)
+ }
+
+ /// [`Self::write_new`] without the check, for bytes nobody writes: measuring a part's size.
+ /// Like a save, a new file never carries a typed Password-field value (#3926): Extract and
+ /// Split copy the fields of the pages they take.
+ fn write_unchecked(&self, doc: &pdfcraft_cos::Document) -> Result<Arc<Vec<u8>>, EditError> {
+ let opts = SaveOptions { mod_date: self.now().map(pdfcraft_cos::pdf_date), ..SaveOptions::default() };
+ let doc = writable(doc)?;
+ write_full(&doc, &opts).map(Arc::new).map_err(|e| EditError::Write(e.to_string()))
+ }
+
+ /// Whether a changed document still needs a recovery snapshot. This does not consume it.
+ pub fn has_pending_autosave(&self) -> bool {
+ self.docs.iter().any(|d| d.dirty && d.generation != d.snapshot_generation)
+ }
+
+ /// Documents with unsaved changes made since the last call: their current working file,
+ /// for crash recovery. Encrypted documents stay encrypted in the snapshot.
+ pub fn autosave_snapshots(&mut self) -> Vec<RecoverySnapshot> {
+ let mut out = Vec::new();
+ for d in &mut self.docs {
+ if d.dirty && d.generation != d.snapshot_generation {
+ // The working bytes hold typed Password-field values (#3926, #3944): a recovery file
+ // is written from a copy without them, and none is written if that copy fails.
+ let bytes =
+ match d.editor.as_ref().filter(|e| pdfcraft_forms::has_password_values(&e.cos) || pdfcraft_xfa::has_password_values(&e.cos)) {
+ Some(e) => match writable(&e.cos)
+ .and_then(|c| write_incremental(&c, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string())))
+ {
+ Ok(b) => Arc::new(b),
+ Err(_) => continue,
+ },
+ None => d.bytes.clone(),
+ };
+ d.snapshot_generation = d.generation;
+ out.push(RecoverySnapshot {
+ doc: d.id,
+ name: d.name.clone(),
+ path: d.path.clone(),
+ bytes,
+ encrypted: d.info.encrypted || d.editor.as_ref().is_some_and(|e| e.cos.security().is_some()),
+ });
+ }
+ }
+ out
+ }
+
+ /// Mark a document opened from a recovery file: it has unsaved changes and belongs at
+ /// `path` (where Save writes), as when the session ended.
+ pub fn mark_recovered(&mut self, id: DocId, path: Option<String>) {
+ if let Some(d) = self.docs.iter_mut().find(|d| d.id == id) {
+ d.path = path;
+ d.dirty = true;
+ if let Some(e) = d.editor.as_mut() {
+ e.unsaved_file = true;
+ }
+ d.generation += 1;
+ d.snapshot_generation = d.generation; // its bytes are already in the recovery store
+ }
+ }
+
+ /// Show or hide a layer (optional content group) for viewing. Returns `true` if it changed;
+ /// callers must drop cached rasters and text for the document.
+ pub fn set_layer_visible(&mut self, id: DocId, layer: usize, visible: bool) -> bool {
+ let Some(doc) = self.docs.iter_mut().find(|d| d.id == id) else { return false };
+ let Some(l) = doc.info.layers.get_mut(layer) else { return false };
+ if l.visible == visible {
+ return false;
+ }
+ l.visible = visible;
+ use_layer_choices(doc);
+ true
+ }
+
+ /// Run a set-layer-visibility action (`SetOCGState`): apply `changes` in order, naming each
+ /// layer by its optional content group; groups that aren't layers are skipped. With
+ /// `preserve_rb`, a layer turned on turns off the other layers of its radio-button groups.
+ /// Returns `true` if any layer changed; callers must drop cached rasters and text for the
+ /// document, as for [`Self::set_layer_visible`].
+ pub fn set_layer_state(&mut self, id: DocId, changes: &[(LayerOp, (u32, u16))], preserve_rb: bool) -> bool {
+ let Some(doc) = self.docs.iter_mut().find(|d| d.id == id) else { return false };
+ if !apply_layer_state(&mut doc.info.layers, &doc.info.layer_groups, changes, preserve_rb) {
+ return false;
+ }
+ use_layer_choices(doc);
+ true
+ }
+
+ /// Show each layer as the file opens (Acrobat's Layers ▸ Reset to Initial Visibility). Returns
+ /// `true` if any layer changed; callers must drop cached rasters and text for the document,
+ /// as for [`Self::set_layer_visible`].
+ pub fn reset_layers(&mut self, id: DocId) -> bool {
+ let Some(doc) = self.docs.iter_mut().find(|d| d.id == id) else { return false };
+ let mut changed = false;
+ for l in &mut doc.info.layers {
+ changed |= l.visible != l.initial;
+ l.visible = l.initial;
+ }
+ if changed {
+ use_layer_choices(doc);
+ }
+ changed
+ }
+
+ /// Hide or show every comment on the page (Acrobat's Comments ▸ Hide all comments). Form
+ /// fields and links still draw. Returns whether anything changed.
+ pub fn set_hide_comments(&mut self, id: DocId, hide: bool) -> bool {
+ let Some(doc) = self.docs.iter_mut().find(|d| d.id == id) else { return false };
+ if doc.config.hide_comments == hide {
+ return false;
+ }
+ doc.config.hide_comments = hide;
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.generation += 1;
+ true
+ }
+
+ /// Set the document's reading colours (Acrobat's Replace Document Colors). Returns whether
+ /// anything changed; callers must drop cached rasters and text for the document.
+ pub fn set_reading_colors(&mut self, id: DocId, colors: ReadingColors) -> bool {
+ let Some(doc) = self.docs.iter_mut().find(|d| d.id == id) else { return false };
+ if doc.config.reading_colors == colors {
+ return false;
+ }
+ doc.config.reading_colors = colors;
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.generation += 1;
+ true
+ }
+
+ /// The document's reading-colours setting; `None` when no such document is open.
+ pub fn reading_colors(&self, id: DocId) -> Option<ReadingColors> {
+ Some(self.get(id)?.config.reading_colors)
+ }
+
+ /// How the document's pages are drawn for viewing: its password and view settings (layer
+ /// visibility, hidden comments, reading colours). `None` when no such document is open.
+ pub fn render_config(&self, id: DocId) -> Option<RenderConfig> {
+ Some(self.get(id)?.config.clone())
+ }
+
+ /// Acrobat's Summarize Comments ("Comments only" layout): a new PDF listing every comment
+ /// with its number, author, type, date, text and replies, grouped by page.
+ pub fn summarize_comments(&self, id: DocId, sort: SummarySort) -> Result<Arc<Vec<u8>>, EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ let text = comment_summary(&doc.name, &doc.info.annotations, sort);
+ self.create_report(&format!("Summary of Comments on {}", doc.name), &text)
+ }
+
+ /// The certificates trusted for signing.
+ pub fn trusted_certificates(&self) -> &[pdfcraft_sign::Certificate] {
+ &self.trust.certs
+ }
+
+ /// Replace the trusted certificates, revalidate every open document's signatures,
+ /// and rebuild its display copy and renderer to match (working file untouched,
+ /// generation/dirty unchanged: trust alone is not an edit).
+ pub fn set_trusted_certificates(&mut self, certs: Vec<pdfcraft_sign::Certificate>) {
+ self.trust = Arc::new(TrustStore { certs });
+ for doc in &mut self.docs {
+ doc.trust = self.trust.clone();
+ let Some(editor) = doc.editor.as_mut() else { continue };
+ // Keep verdict refresh and renderer refresh together. Viewer caches are
+ // invalidated by the UI trust path; trust alone changes no document artwork.
+ let signatures = if doc.signatures.is_empty() { Vec::new() } else { signatures_of(&editor.cos, &doc.bytes, &doc.trust, &doc.sig_cache) };
+ doc.display = display_bytes(Some(editor), &doc.bytes);
+ doc.signatures = Arc::new(signatures);
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ }
+ }
+
+ /// The signing time as a PDF date in local time with its offset (`D:…+02'00'`).
+ pub fn signing_date(&self) -> String {
+ let offset = self.local_offset();
+ let local = pdfcraft_cos::pdf_date(self.now().unwrap_or(0) + offset);
+ let stamp = local.trim_end_matches('Z');
+ if offset == 0 {
+ return format!("{stamp}Z");
+ }
+ let (sign, m) = if offset < 0 { ('-', -offset / 60) } else { ('+', offset / 60) };
+ format!("{stamp}{sign}{:02}'{:02}'", m / 60, m % 60)
+ }
+
+ /// Sign the document's current state with `id` (Use a certificate ▸ Digitally sign). Returns
+ /// the signed file; the caller saves it and then calls [`Session::mark_signed`]. An empty
+ /// `opts.date` takes the session clock.
+ pub fn sign(&self, doc: DocId, id: &pdfcraft_sign::DigitalId, mut opts: SignOptions) -> Result<Arc<Vec<u8>>, EditError> {
+ let d = self.get(doc).ok_or(EditError::NoDocument)?;
+ // Encrypted documents are signed under their permissions (the signer checks them).
+ let editor = d.editor.as_ref().ok_or_else(|| EditError::ReadOnly(d.read_only_reason.clone().unwrap_or_default()))?;
+ if opts.date.is_empty() {
+ opts.date = self.signing_date();
+ }
+ // A typed Password-field value is not signed into the file (#3926), as it isn't saved.
+ let cos = writable(&editor.cos)?;
+ Ok(Arc::new(pdfcraft_sign::sign(&cos, id, &opts)?))
+ }
+
+ /// [`Session::sign`], embedding an RFC 3161 signature timestamp (PAdES B-T) produced by
+ /// `tsa`. The transport lives with the caller; the engine never opens a socket.
+ pub fn sign_with_timestamp(
+ &self,
+ doc: DocId,
+ id: &pdfcraft_sign::DigitalId,
+ mut opts: SignOptions,
+ tsa: &dyn pdfcraft_sign::TimestampAuthority,
+ ) -> Result<Arc<Vec<u8>>, EditError> {
+ let d = self.get(doc).ok_or(EditError::NoDocument)?;
+ let editor = d.editor.as_ref().ok_or_else(|| EditError::ReadOnly(d.read_only_reason.clone().unwrap_or_default()))?;
+ if opts.date.is_empty() {
+ opts.date = self.signing_date();
+ }
+ let cos = writable(&editor.cos)?;
+ let signed = Arc::new(pdfcraft_sign::sign_with_timestamp(&cos, id, &opts, tsa)?);
+ // Checked like a save before anyone writes it (#2166).
+ self.check_save(doc, &signed)?;
+ Ok(signed)
+ }
+
+ /// Append a standalone document timestamp (RFC 3161, `/ETSI.RFC3161`) covering the file's
+ /// current state. An empty `date` takes the session clock; the transport is the caller's.
+ pub fn timestamp_document(&self, doc: DocId, tsa: &dyn pdfcraft_sign::TimestampAuthority, date: String) -> Result<Arc<Vec<u8>>, EditError> {
+ let d = self.get(doc).ok_or(EditError::NoDocument)?;
+ let editor = d.editor.as_ref().ok_or_else(|| EditError::ReadOnly(d.read_only_reason.clone().unwrap_or_default()))?;
+ let date = if date.is_empty() { self.signing_date() } else { date };
+ let cos = writable(&editor.cos)?;
+ let stamped = Arc::new(pdfcraft_sign::timestamp_document(&cos, tsa, &date)?);
+ self.check_save(doc, &stamped)?;
+ Ok(stamped)
+ }
+
+ /// Embed revocation evidence into the catalog's `/DSS` with `/VRI` entries per signature
+ /// (PAdES B-LT): an incremental update that never rewrites signed bytes.
+ pub fn embed_ltv(&self, doc: DocId, evidence: &pdfcraft_sign::dss::Evidence) -> Result<Arc<Vec<u8>>, EditError> {
+ let d = self.get(doc).ok_or(EditError::NoDocument)?;
+ let editor = d.editor.as_ref().ok_or_else(|| EditError::ReadOnly(d.read_only_reason.clone().unwrap_or_default()))?;
+ let cos = writable(&editor.cos)?;
+ let embedded = Arc::new(pdfcraft_sign::dss::embed(&cos, evidence)?);
+ self.check_save(doc, &embedded)?;
+ Ok(embedded)
+ }
+
+ /// Record that the signed file `bytes` was saved (to `path`): like [`Session::mark_saved`],
+ /// and the edit history before signing is dropped (signing can't be undone).
+ pub fn mark_signed(&mut self, id: DocId, bytes: Arc<Vec<u8>>, path: Option<String>) -> Result<(), EditError> {
+ self.mark_saved(id, bytes, path)?;
+ let doc = self.doc_mut(id)?;
+ if let Some(e) = doc.editor.as_mut() {
+ e.undo.clear();
+ e.redo.clear();
+ }
+ Ok(())
+ }
+
+ pub fn close(&mut self, id: DocId) {
+ self.docs.retain(|d| d.id != id);
+ }
+
+ pub fn get(&self, id: DocId) -> Option<&Document> {
+ self.docs.iter().find(|d| d.id == id)
+ }
+
+ /// Read document `id`'s font list again if content edits since the last full inspection may
+ /// have changed it (Document Properties ▸ Fonts, `doc_info`). A no-op otherwise.
+ pub fn refresh_fonts(&mut self, id: DocId) {
+ let Some(doc) = self.docs.iter_mut().find(|d| d.id == id && d.fonts_stale) else { return };
+ if let Ok(info) = pdfcraft_render::inspect(doc.bytes.clone(), doc.password.as_deref()) {
+ doc.info.fonts = info.fonts;
+ }
+ doc.fonts_stale = false;
+ }
+
+ pub fn docs(&self) -> &[Document] {
+ &self.docs
+ }
+ }