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.rsindex 000000000,faf471207..b8a300937mode 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(¶ms).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.rsindex 84806678b,78e5ea1eb..cbb339ba1--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@@ -96,81 -117,8 +117,14 @@@ pub enum ImageEditname: 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.rsindex 000000000,208a8e450..41bac6041mode 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.rsindex 000000000,c3e34d90b..5c8373afbmode 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, ¬es);+ 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+ }+ }