PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
Merge upstream main into prep/4013-merge-main
Cursor Agentb5b42a331866
diff --cc crates/engine/src/edit.rsindex 000000000,faf471207..f372e275emode 000000,100644..100644--- a/crates/engine/src/edit.rs+++ b/crates/engine/src/edit.rs@@@ -1,0 -1,1577 +1,1579 @@@+ //! 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,+ };++ /// 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",+ "Rotate image",+ "Flip image",+ "Replace image",+ "Delete 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::Rotate(_) | ImageEdit::RotateBy(_) => "Rotate image",+ ImageEdit::Crop(_) => "Crop image",+ ImageEdit::Flip { .. } => "Flip image",+ ImageEdit::Replace { .. } => "Replace image",+ ImageEdit::Delete => "Delete image",+ }),+ 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,++ /// Platform CSPRNG (`getrandom::fill`). Tests replace it so Protect can fail closed.++ pub(crate) rng: fn(&mut [u8]) -> Result<(), getrandom::Error>,+ /// 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,++ rng: getrandom::fill,+ 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};++ /// 32 bytes of entropy for new encryption keys, salts and generated owner passwords from the++ /// platform CSPRNG. Fails closed when secure randomness is unavailable.++ fn entropy(&mut self) -> Result<[u8; 32], EditError> {+ 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());++ (self.rng)(&mut out).map_err(|e| EditError::Protection(format!("no secure randomness available: {e}")))?;++ if out == [0u8; 32] {++ return Err(EditError::Protection("no secure randomness available".into()));+ }- out++ Ok(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 } => {+ 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::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,+ };+ 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();++ 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 random_owner = match p.permissions_password {++ Some(_) => String::new(),++ None => 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/tests.rsindex ceb3f1c34,c622af21b..441e103ee--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@@ -1,6 -1,9 +1,9 @@@use std::sync::Arc;+ use super::document::is_placeholder_title;-use super::edit::check_permission;++use super::edit::{EditCtx, check_permission, run_edit};use super::*;+ use pdfcraft_render::{Layer, LayerOp, OpenError, ReadingColors};/// A minimal `n`-page document; page `i` shows "Page i+1".pub(crate) fn fixture(n: usize) -> Vec<u8> {