Skip to content

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

Merge remote-tracking branch 'refs/remotes/origin/main' into fix/background-hidden-by-page-backdrop

alehelfd1382af6ee2
diff --cc crates/engine/src/document.rs
index 000000000,7023caa55..765594356
mode 000000,100644..100644
--- a/crates/engine/src/document.rs
+++ b/crates/engine/src/document.rs
@@@ -1,0 -1,713 +1,770 @@@
+ //! An open document: its working file, view data and edit state.
+
+ use std::sync::{Arc, OnceLock};
+
+ use pdfcraft_cos::{SaveOptions, write_incremental};
+ use pdfcraft_render::{DocInfo, RenderConfig, RenderPool};
+
+ use crate::history::Editor;
+ use crate::{
+ CalculationOrder, CheckStyle, DocId, Edit, EditError, EditableObject, FormFieldKind, Hidden, InitialView, Label, MarkKind, SecuritySummary,
+ SignatureInfo, TabOrder, TrustStore, XfaLayout, a11y, form_appearance, guard, js, measure, optimize, renderer_password, unrestricted,
+ };
+ #[cfg(test)]
+ use crate::{record_link_scan, record_marker_scan};
+
+ pub struct Document {
+ pub id: DocId,
+ pub name: String,
+ pub path: Option<String>,
+ /// The working file: what Save writes.
+ pub bytes: Arc<Vec<u8>>,
+ /// What is displayed (the page view, `page_render`, page images): `bytes`, plus appearances
+ /// drawn for display only for comments that have none ([`display_bytes`]). Never saved.
+ pub display: Arc<Vec<u8>>,
+ pub info: DocInfo,
+ pub renderer: RenderPool,
+ /// The password the document was opened with (needed to read attachments, etc.).
+ pub password: Option<String>,
+ /// `true` when there are edits that have not been saved.
+ pub dirty: bool,
+ /// Bumped on every change to the working file (edit, undo, redo, save); autosave compares it.
+ pub(crate) generation: u64,
+ /// The generation last handed out by `autosave_snapshots`.
+ pub(crate) snapshot_generation: u64,
+ /// Why the document cannot be edited (e.g. encryption), if so.
+ pub read_only_reason: Option<String>,
+ /// Interactive form fields of the current state (empty without a form).
+ pub form: Arc<Vec<pdfcraft_forms::Field>>,
+ pub(crate) marker_scan: OnceLock<pdfcraft_edit::MarkerScan>,
+ pub(crate) links: OnceLock<Vec<pdfcraft_annot::links::LinkItem>>,
+ /// Signature fields, validated against the session's trust store (Signatures panel).
+ pub signatures: Arc<Vec<SignatureInfo>>,
+ pub(crate) trust: Arc<TrustStore>,
+ pub(crate) sig_cache: Arc<pdfcraft_sign::DigestCache>,
+ pub(crate) editor: Option<Editor>,
+ pub(crate) config: RenderConfig,
+ /// What field scripts printed or asked for (see [`Session::take_js_output`]).
+ pub(crate) js_output: js::JsOutput,
+ /// Dynamic XFA forms: what laying the template out produced (pages and fields are
+ /// PdfCraft's; Adobe's viewers draw the form from the XFA packets themselves).
+ pub xfa: Option<XfaLayout>,
+ /// The parsed template of a laid-out XFA form, for its scripts.
+ pub(crate) xfa_template: Option<Arc<pdfcraft_xfa::model::Template>>,
+ /// A script of the XFA form ran away, so its scripts are off (see [`Document::xfa_scripts_off`]).
+ pub(crate) xfa_scripts_off: bool,
+ /// A content-only refresh keeps `info` from before the edit; an edit may have added or
+ /// embedded fonts, so the font list is read again on demand ([`Session::refresh_fonts`]).
+ pub(crate) fonts_stale: bool,
+ /// XFA forms: what was approximated, rewritten or could not be written to the XFA data
+ /// (also in `info.warnings`, kept there when the document is re-read).
+ pub xfa_warnings: Vec<String>,
- /// What the last successful [`Session::apply`](crate::Session::apply) wrote that its fonts can't draw: kept as typed,
- /// drawn with `?` in its place (see [`TextNotice`]). The interface shows it; tools return it.
- pub edit_notices: Vec<TextNotice>,
++ /// What the last successful [`Session::apply`](crate::Session::apply) wants said (see
++ /// [`EditNotice`]): text its fonts can't draw, pages whose own backdrop stays off. The
++ /// interface shows it; tools return it.
++ pub edit_notices: Vec<EditNotice>,
++}
++
++/// Something the last successful edit did that the user should hear about, never left silent
++/// (AGENTS.md §4).
++#[derive(Clone, Debug, PartialEq, Eq)]
++pub enum EditNotice {
++ /// Text stored as typed but drawn with `?`.
++ Undrawn(TextNotice),
++ /// Remove background couldn't turn back on the white backdrop these pages (0-based,
++ /// ascending) paint themselves: their content changed after the background replaced it, so
++ /// turning it on could paint over something (`pdfcraft_edit::backdrops_left_off`). They look
++ /// the same on white paper.
++ BackdropsLeftOff { pages: Vec<usize> },
++}
++
++impl std::fmt::Display for EditNotice {
++ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
++ match self {
++ EditNotice::Undrawn(n) => n.fmt(f),
++ EditNotice::BackdropsLeftOff { pages } => {
++ let (which, own) = if pages.len() == 1 { ("page", "its") } else { ("pages", "their") };
++ write!(
++ f,
++ "{which} {} changed after the background was added, so {own} own white backdrop was not turned back on (it looks the same on white paper)",
++ page_runs(pages)
++ )
++ }
++ }
++ }
++}
++
++/// 0-based pages as 1-based runs: `[0, 1, 2, 5]` is "1-3, 6".
++pub(crate) fn page_runs(pages: &[usize]) -> String {
++ let mut runs: Vec<(usize, usize)> = Vec::new();
++ for &p in pages {
++ match runs.last_mut() {
++ Some((_, end)) if end.checked_add(1) == Some(p) => *end = p,
++ _ => runs.push((p, p)),
++ }
++ }
++ let one = |p: usize| p.saturating_add(1);
++ runs.iter().map(|&(a, b)| if a == b { one(a).to_string() } else { format!("{}-{}", one(a), one(b)) }).collect::<Vec<_>>().join(", ")
+ }
+
+ /// Text an edit stored as typed but drew with `?` in place of `ch`, because the font it is drawn
+ /// with (a form field's, or the standard fonts for comments) can't draw that character. Acrobat
+ /// keeps such text too, drawing it with fonts PdfCraft can't embed yet.
+ #[derive(Clone, Debug, PartialEq, Eq)]
+ pub struct TextNotice {
+ /// The form field's full name, or `None` for a comment.
+ pub field: Option<String>,
+ /// The page (0-based) of the comment or of the field's widget.
+ pub page: usize,
+ pub ch: char,
+ /// Other PDF viewers redraw it from the stored text (a form field, with `/NeedAppearances`
+ /// set); otherwise the `?` shows in every viewer.
+ pub redrawn_elsewhere: bool,
+ }
+
+ impl std::fmt::Display for TextNotice {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let ch = format!("\"{}\" (U+{:04X})", self.ch.escape_debug(), u32::from(self.ch));
+ let page = self.page + 1;
+ match (&self.field, self.redrawn_elsewhere) {
+ (Some(name), true) => write!(
+ f,
+ "form field {name:?} (page {page}) holds {ch}, which its font can't draw: the value is saved, PdfCraft shows ? in its place, and other PDF viewers redraw the field from the value"
+ ),
+ (Some(name), false) => write!(
+ f,
+ "form field {name:?} (page {page}) holds {ch}, which its font can't draw: the value is saved, but this PDF/A document can't ask other viewers to redraw it, so ? shows in its place everywhere"
+ ),
+ (None, _) => write!(
+ f,
+ "a comment on page {page} has {ch}, which the standard fonts can't draw: its text is saved, but its appearance shows ? in its place in every viewer"
+ ),
+ }
+ }
+ }
+
+ /// What `next` drew with `?` that `prev` didn't (a new or redrawn appearance carrying
+ /// `pdfcraft_fonts::UNDRAWN_MARK`), one notice per field or comment, in page order.
+ pub(crate) fn undrawn_notices(prev: &pdfcraft_cos::Document, next: &pdfcraft_cos::Document) -> Vec<TextNotice> {
+ let Ok(pages) = pdfcraft_annot::page_refs(next) else { return Vec::new() };
+ let redrawn_elsewhere = pdfcraft_forms::need_appearances(next);
+ let mut names: Option<std::collections::HashMap<pdfcraft_cos::ObjRef, String>> = None;
+ let mut out: Vec<TextNotice> = Vec::new();
+ for (page, p) in pages.iter().enumerate() {
+ let annots = next.get(*p).as_dict().and_then(|d| d.get(b"Annots").cloned()).map(|a| next.resolve(&a));
+ for r in annots.as_deref().and_then(pdfcraft_cos::Object::as_array).into_iter().flatten().filter_map(pdfcraft_cos::Object::as_ref) {
+ let now = next.get(r);
+ let Some(d) = now.as_dict() else { continue };
+ let Some(ch) = pdfcraft_fonts::undrawn_mark(d) else { continue };
+ // Only what this edit drew: a new annotation, or a new appearance.
+ let was = prev.get(r);
+ if was.as_dict().is_some_and(|w| w.get(b"AP") == d.get(b"AP") && pdfcraft_fonts::undrawn_mark(w) == Some(ch)) {
+ continue;
+ }
+ let field = (d.name(b"Subtype") == Some(b"Widget")).then(|| {
+ let names = names.get_or_insert_with(|| {
+ pdfcraft_forms::fields(next)
+ .into_iter()
+ .flat_map(|f| f.widgets.iter().map(|w| (w.obj, f.name.clone())).collect::<Vec<_>>())
+ .collect()
+ });
+ names.get(&r).cloned().unwrap_or_default()
+ });
+ if field.is_some() && out.iter().any(|n| n.field == field) {
+ continue;
+ }
+ out.push(TextNotice { redrawn_elsewhere: redrawn_elsewhere && field.is_some(), field, page, ch });
+ }
+ }
+ out
+ }
+
+ impl Document {
+ /// How the document opens (Document Properties ▸ Initial View).
+ /// Accessibility ▸ Check for accessibility: the full check (`None` if the document can't be
+ /// read for editing).
+ pub fn accessibility_check(&self, options: &a11y::Options) -> Option<a11y::Report> {
+ self.editor.as_ref().map(|e| a11y::check(&e.cos, options))
+ }
+
+ /// A script of this XFA form ran past its time limit and was abandoned, so the form's
+ /// scripts no longer run in this document (reopening it runs them again). The script's
+ /// error is in the JavaScript output; this is the state, for a viewer to show.
+ pub fn xfa_scripts_off(&self) -> bool {
+ self.xfa_scripts_off
+ }
+
+ /// PDF Optimizer ▸ Audit space usage.
+ pub fn audit_space(&self) -> Vec<optimize::SpaceUse> {
+ self.editor.as_ref().map(|e| optimize::audit_space(&e.cos, self.bytes.len() as u64)).unwrap_or_default()
+ }
+
++ /// The backdrop `page` (0-based) paints itself, which hides a background (Add Background).
++ pub fn page_backdrop(&self, page: usize) -> Option<pdfcraft_edit::Backdrop> {
++ self.editor.as_ref().and_then(|e| pdfcraft_edit::page_backdrop(&e.cos, page).ok().flatten())
++ }
++
++ /// [`Self::page_backdrop`] for each of `pages`, in order, walking the page tree once: the
++ /// way to check many pages. A page out of range has none.
++ pub fn page_backdrops(&self, pages: &[usize]) -> Vec<Option<pdfcraft_edit::Backdrop>> {
++ match &self.editor {
++ Some(e) => pdfcraft_edit::page_backdrops(&e.cos, pages),
++ None => vec![None; pages.len()],
++ }
++ }
++
+ /// Edit a PDF: the images `page` draws (0-based).
+ pub fn page_images(&self, page: usize) -> Vec<pdfcraft_edit::PageImage> {
+ self.editor.as_ref().and_then(|e| pdfcraft_edit::page_images(&e.cos, page).ok()).unwrap_or_default()
+ }
+
+ /// Mixed editable objects on one page. Source inventories are zero-based and added items
+ /// appear once. Rectangles are user-space points, independent of the viewer's zoom.
+ pub fn editable_objects(&self, page: usize) -> Result<Vec<EditableObject>, String> {
+ let editor = self.editor.as_ref().ok_or("the document can't be read")?;
+ pdfcraft_edit::editable_objects(&editor.cos, page).map_err(|e| e.to_string())
+ }
+
+ /// Displayed top-left-origin motion to a user-space vector. Use the linear map only,
+ /// so even a large crop-box origin cannot erase a small drag by cancellation.
+ pub fn object_move_offset(&self, page: usize, delta: [f64; 2]) -> Result<[f64; 2], String> {
+ let p = self.info.pages.get(page).ok_or("the page no longer exists")?;
+ let [x0, y0, x1, y1] = p.crop.map(f64::from);
+ let (a, b) = (delta[0] / f64::from(p.width.max(1e-3)), delta[1] / f64::from(p.height.max(1e-3)));
+ let (u, v) = match p.rotation {
+ 90 => (b, -a),
+ 180 => (-a, -b),
+ 270 => (-b, a),
+ _ => (a, b),
+ };
+ let offset = [u * (x1 - x0), -v * (y1 - y0)];
+ if !offset.iter().all(|v| v.is_finite()) {
+ return Err("the move must be finite and non-zero".into());
+ }
+ Ok(offset)
+ }
+
+ /// Save image as: image `index` on `page` as a file (extension, bytes).
+ pub fn page_image_file(&self, page: usize, index: usize) -> Result<(&'static str, Vec<u8>), String> {
+ self.check_copying().map_err(|e| e.to_string())?;
+ let editor = self.editor.as_ref().ok_or("the document can't be read")?;
+ let img = self.page_images(page).into_iter().nth(index).ok_or_else(|| format!("page {} has no image {}", page + 1, index + 1))?;
+ if img.is_form {
+ return Err("grouped Form artwork is not a bitmap; Save Image As is only available for raster images".into());
+ }
+ pdfcraft_create::image_file(&editor.cos, img.object.ok_or("the image has no object")?)
+ }
+
+ /// Edit a PDF ▸ Edit text: the paragraphs on `page` (0-based).
+ pub fn text_blocks(&self, page: usize) -> Vec<pdfcraft_edit::TextBlock> {
+ self.editor.as_ref().and_then(|e| e.text_blocks(page).ok()).map(|b| b.as_ref().clone()).unwrap_or_default()
+ }
+
+ /// Saved measurement annotations, calculated from their geometry and PDF scales, plus
+ /// the ones that couldn't be read (unsupported formats are skipped, not fatal).
+ pub fn measurements(&self) -> Result<measure::Listing, String> {
+ let e = self.editor.as_ref().ok_or("the document can't be read")?;
+ Ok(measure::list(&e.cos))
+ }
+ pub fn measurement_scale(&self, page: usize, at: measure::Point) -> Result<measure::Scale, String> {
+ let e = self.editor.as_ref().ok_or("the document can't be read")?;
+ measure::scale_at(&e.cos, page, at).map_err(|e| e.to_string())
+ }
+ /// [`Self::measurement_scale`], measuring true size in `unit` (`per_point` of them in a
+ /// point) where the page sets no scale.
+ pub fn measurement_scale_or(&self, page: usize, at: measure::Point, per_point: f64, unit: &str) -> Result<measure::Scale, String> {
+ let e = self.editor.as_ref().ok_or("the document can't be read")?;
+ measure::scale_at_or(&e.cos, page, at, per_point, unit).map_err(|e| e.to_string())
+ }
+ pub fn measurement_to_user(&self, page: usize, point: measure::Point) -> Result<measure::Point, String> {
+ let e = self.editor.as_ref().ok_or("the document can't be read")?;
+ measure::view_to_user(&e.cos, page, point).map_err(|e| e.to_string())
+ }
+ pub fn measurement_to_view(&self, page: usize, point: measure::Point) -> Result<measure::Point, String> {
+ let e = self.editor.as_ref().ok_or("the document can't be read")?;
+ measure::user_to_view(&e.cos, page, point).map_err(|e| e.to_string())
+ }
+ pub fn measurement_paths(&self, page: usize) -> Result<measure::snap::Geometry, String> {
+ let e = self.editor.as_ref().ok_or("the document can't be read")?;
+ measure::snap::geometry(&e.cos, page).map_err(|e| e.to_string())
+ }
+
+ /// A counter that changes with every edit (for caches of derived data).
+ pub fn edit_generation(&self) -> u64 {
+ self.generation
+ }
+
+ /// Edit a PDF ▸ Edit text: the lines of existing text on `page` (0-based).
+ pub fn text_lines(&self, page: usize) -> Vec<pdfcraft_edit::TextLine> {
+ self.editor.as_ref().and_then(|e| pdfcraft_edit::text_lines(&e.cos, page).ok()).unwrap_or_default()
+ }
+
+ /// The form's calculation order: its calculated fields in the order they calculate, what each
+ /// formula reads, what is wrong with the order, and the order Fix order writes.
+ pub fn calculation_order(&self) -> CalculationOrder {
+ self.editor.as_ref().map(|e| pdfcraft_forms::calculation_order(&e.cos, &self.form)).unwrap_or_default()
+ }
+
+ /// Add alternate text: the figures, in document order.
+ pub fn figures(&self) -> Vec<a11y::Figure> {
+ self.editor.as_ref().map(|e| a11y::figures(&e.cos)).unwrap_or_default()
+ }
+
+ /// Reachable indirect structure tags, in document order.
+ pub fn tags(&self) -> Vec<a11y::TagInfo> {
+ self.editor.as_ref().map(|e| a11y::tags(&e.cos)).unwrap_or_default()
+ }
+
+ /// Marked-content items directly owned by one reachable indirect structure tag.
+ pub fn tag_content(&self, object: pdfcraft_cos::ObjRef) -> Result<Vec<a11y::TagContentItem>, a11y::TagError> {
+ self.editor.as_ref().map(|e| a11y::tag_content(&e.cos, object)).unwrap_or_else(|| Ok(Vec::new()))
+ }
+
+ /// The edit that fixes `rule`, for the rules with an automatic fix: the document language
+ /// (`value` is the language), the title (`value` replaces it; else the current title or the
+ /// file name) and the tab order.
+ pub fn accessibility_fix(&self, rule: a11y::Rule, value: Option<&str>) -> Result<Edit, String> {
+ let value = value.map(str::trim).filter(|v| !v.is_empty());
+ match rule {
+ a11y::Rule::PrimaryLanguage => {
+ let mut v = self.initial_view();
+ v.language = Some(value.ok_or("give the document language (for example en-US)")?.to_owned());
+ Ok(Edit::SetInitialView(Box::new(v)))
+ }
+ a11y::Rule::Title => {
+ let title = value
+ .map(str::to_owned)
+ .or_else(|| self.info_value("Title").filter(|t| !t.trim().is_empty()))
+ .unwrap_or_else(|| self.name.trim_end_matches(".pdf").trim_end_matches(".PDF").to_owned());
+ let mut v = self.initial_view();
+ v.display_title = true;
+ Ok(Edit::Batch {
+ label: "Set document title".into(),
+ edits: vec![Edit::SetInfo { key: "Title".into(), value: title }, Edit::SetInitialView(Box::new(v))],
+ })
+ }
+ a11y::Rule::TabOrder => Ok(Edit::SetTabOrder { pages: (0..self.info.pages.len()).collect(), order: TabOrder::Structure }),
+ other => Err(format!("\"{}\" has no automatic fix", other.name())),
+ }
+ }
+
+ pub fn initial_view(&self) -> InitialView {
+ self.editor.as_ref().map(|e| pdfcraft_organize::initial_view(&e.cos)).unwrap_or_default()
+ }
+
+ /// Signed: at least one signature field holds a signature.
+ pub fn is_signed(&self) -> bool {
+ self.signatures.iter().any(|s| s.signed)
+ }
+
+ /// Whether comments are hidden (Comments ▸ Hide all comments).
+ pub fn comments_hidden(&self) -> bool {
+ self.config.hide_comments
+ }
+
+ pub fn can_undo(&self) -> Option<&str> {
+ self.undo_label().map(Label::as_str)
+ }
+
+ pub fn can_redo(&self) -> Option<&str> {
+ self.redo_label().map(Label::as_str)
+ }
+
+ /// What Undo would undo, in parts, for an interface that says it in another language.
+ pub fn undo_label(&self) -> Option<&Label> {
+ self.editor.as_ref().and_then(|e| e.undo.last()).map(|(l, ..)| l)
+ }
+
+ /// What Redo would redo, in parts.
+ pub fn redo_label(&self) -> Option<&Label> {
+ self.editor.as_ref().and_then(|e| e.redo.last()).map(|(l, ..)| l)
+ }
+
+ pub fn editable(&self) -> bool {
+ self.editor.is_some()
+ }
+
+ /// What the opening password allows; `None` when the document is not encrypted.
+ pub fn permissions(&self) -> Option<pdfcraft_cos::Permissions> {
+ self.editor.as_ref().and_then(|e| e.cos.permissions())
+ }
+
+ /// Printing is allowed (Table 22, bit 3).
+ pub fn allows_printing(&self) -> bool {
+ self.permissions().is_none_or(|p| p.print())
+ }
+
+ /// Copying or otherwise extracting text and images is allowed (Table 22, bit 5): copying
+ /// selected text, snapshots, Save Image As, exporting. Assistive technology may read the
+ /// content regardless (§7.6.4.2), so reading aloud and accessibility tools don't ask.
+ pub fn allows_copying(&self) -> bool {
+ self.permissions().is_none_or(|p| p.copy())
+ }
+
+ /// [`Self::allows_copying`], as the error to report when it isn't.
+ pub fn check_copying(&self) -> Result<(), EditError> {
+ if self.allows_copying() { Ok(()) } else { Err(EditError::NotPermitted("copying text and images")) }
+ }
+
+ /// Page changes (insert, delete, rotate, move, extract) are allowed.
+ pub fn allows_assembly(&self) -> bool {
+ self.editable() && self.permissions().is_none_or(|p| p.assemble())
+ }
+
+ /// Redaction marks waiting to be applied.
+ pub fn redaction_marks(&self) -> usize {
+ self.info.annotations.iter().filter(|a| a.subtype == "Redact").count()
+ }
+
+ /// Page marks present (headers and footers, watermarks, backgrounds), for Update/Remove.
+ pub fn marks(&self) -> &[MarkKind] {
+ &self
+ .marker_scan
+ .get_or_init(|| {
+ self.editor
+ .as_ref()
+ .map(|e| {
+ #[cfg(test)]
+ record_marker_scan();
+ pdfcraft_edit::scan_markers(&e.cos)
+ })
+ .unwrap_or_default()
+ })
+ .marks
+ }
+
+ /// Text and images added with Edit a PDF ▸ Add content (still editable).
+ pub fn added(&self) -> &[pdfcraft_edit::Added] {
+ &self
+ .marker_scan
+ .get_or_init(|| {
+ self.editor
+ .as_ref()
+ .map(|e| {
+ #[cfg(test)]
+ record_marker_scan();
+ pdfcraft_edit::scan_markers(&e.cos)
+ })
+ .unwrap_or_default()
+ })
+ .added
+ }
+
+ /// Link annotations, for Edit a PDF ▸ Link.
+ pub fn links(&self) -> &[pdfcraft_annot::links::LinkItem] {
+ self.links.get_or_init(|| {
+ self.editor
+ .as_ref()
+ .map(|e| {
+ #[cfg(test)]
+ record_link_scan();
+ pdfcraft_annot::links::list(&e.cos)
+ })
+ .unwrap_or_default()
+ })
+ }
+
+ /// Changes to content and document information are allowed.
+ pub fn allows_modification(&self) -> bool {
+ self.editable() && self.permissions().is_none_or(|p| p.modify())
+ }
+
+ /// How widget `widget` of text field `name` lays its value out, for asking whether a typed
+ /// value fits it ([`form_appearance::TextBox::fits`]): a field that doesn't scroll takes no
+ /// more than fits. `None` without such a field or widget, or when the document can't be
+ /// edited.
+ pub fn field_text_box(&self, name: &str, widget: usize) -> Option<form_appearance::TextBox> {
+ let cos = &self.editor.as_ref()?.cos;
+ let f = self.form.iter().find(|f| f.name == name)?;
+ let w = f.widgets.get(widget)?;
+ Some(form_appearance::text_box(cos, f, w))
+ }
+
+ /// Filling in form fields is allowed (Table 22, bits 6 and 9).
+ pub fn allows_form_filling(&self) -> bool {
+ self.editable() && self.permissions().is_none_or(|p| p.fill_forms())
+ }
+
+ /// Adding and changing comments is allowed (Table 22, bit 6).
+ pub fn allows_annotation(&self) -> bool {
+ self.editable() && self.permissions().is_none_or(|p| p.annotate())
+ }
+
+ /// The document's security may be changed (Protect, Remove security): it is editable and,
+ /// if encrypted, was opened with the owner password.
+ pub fn allows_security_change(&self) -> bool {
+ self.editable() && self.permissions().is_none_or(|p| unrestricted(&p))
+ }
+
+ /// A password restricts the document and it wasn't opened with the owner password: entering
+ /// that password ([`Session::unlock`](crate::Session::unlock)) lifts the restrictions.
+ pub fn can_unlock(&self) -> bool {
+ self.editable() && self.permissions().is_some_and(|p| !unrestricted(&p))
+ }
+
+ /// A summary of the document's security for Document Properties ▸ Security, including
+ /// protection applied in this session (written by the next save).
+ pub fn security_summary(&self) -> Option<SecuritySummary> {
+ let editor = self.editor.as_ref()?;
+ let h = editor.cos.output_handler()?;
+ let d = h.dict();
+ let stream = d.crypt_filters.iter().find(|(name, _)| *name == d.stm_f).map(|(_, m)| *m);
+ let method = match (d.v, stream) {
+ (1..=3, _) if d.length_bits <= 40 => "RC4, 40-bit",
+ (1..=3, _) | (_, Some(pdfcraft_cos::CryptMethod::Rc4)) => "RC4, 128-bit",
+ (_, Some(pdfcraft_cos::CryptMethod::Aes128)) => "AES, 128-bit",
+ (_, Some(pdfcraft_cos::CryptMethod::Aes256)) => "AES, 256-bit",
+ _ => "Attachments only",
+ };
+ let pending = editor.cos.encryption_changed();
+ let permissions = if pending { pdfcraft_cos::Permissions { bits: h.permissions().bits, owner: false } } else { h.permissions() };
+ Some(SecuritySummary { method: method.into(), owner: h.auth() == pdfcraft_cos::Auth::Owner && !pending, permissions, pending })
+ }
+
+ /// Comment properties of the comment at `(page, index)` (Comment Properties dialog).
+ pub fn comment_props(&self, page: usize, index: usize) -> Option<pdfcraft_annot::Props> {
+ self.editor.as_ref().and_then(|e| pdfcraft_annot::props(&e.cos, page, index))
+ }
+
+ /// A form field's Appearance-tab look (borders, colours, font).
+ pub fn field_look(&self, name: &str) -> Option<pdfcraft_forms::Look> {
+ let e = self.editor.as_ref()?;
+ let f = self.form.iter().find(|f| f.name == name)?;
+ Some(pdfcraft_forms::look(&e.cos, f))
+ }
+
+ /// A check box's or radio button's mark (Field Properties ▸ Options), `None` for other fields.
+ pub fn field_check_style(&self, name: &str) -> Option<CheckStyle> {
+ let e = self.editor.as_ref()?;
+ let f = self.form.iter().find(|f| f.name == name)?;
+ matches!(f.kind, FormFieldKind::CheckBox | FormFieldKind::Radio).then(|| pdfcraft_forms::check_style(&e.cos, f))
+ }
+
+ /// Whether text field `name`'s value is cut off by its box at the field's font size (#4018):
+ /// the page (0-based) of the first widget that cuts it, and how.
+ pub fn field_overflow(&self, name: &str) -> Option<(Option<usize>, pdfcraft_forms::appearance::Overflow)> {
+ let e = self.editor.as_ref()?;
+ let f = self.form.iter().find(|f| f.name == name)?;
+ f.widgets.iter().find_map(|w| pdfcraft_forms::appearance::value_overflow(&e.cos, f, w).map(|o| (w.page, o)))
+ }
+
+ /// Remove Hidden Information: what each category would remove.
+ pub fn hidden_info(&self) -> Vec<(Hidden, usize)> {
+ self.editor.as_ref().map(|e| pdfcraft_redact::sanitize::scan(&e.cos)).unwrap_or_default()
+ }
+
+ /// Verification: faux redactions (opaque covers over extractable text) and redaction
+ /// marks that were never applied. Fails closed: any read error is returned, never an
+ /// empty list.
+ pub fn audit_redactions(&self) -> Result<Vec<pdfcraft_audit::AuditFinding>, String> {
+ let editor = self.editor.as_ref().ok_or("the document can't be read")?;
+ pdfcraft_audit::audit_redactions(&editor.cos).map_err(|e| e.to_string())
+ }
+
+ /// Every page's media, crop, bleed, trim and art boxes (user space), for Set Page Boxes.
+ pub fn page_boxes(&self) -> Vec<[[f64; 4]; 5]> {
+ self.editor.as_ref().and_then(|e| pdfcraft_organize::page_boxes(&e.cos).ok()).unwrap_or_default()
+ }
+
+ /// Current value of a document-information entry (Title, Author, …).
+ pub fn info_value(&self, key: &str) -> Option<String> {
+ self.editor.as_ref().and_then(|e| pdfcraft_organize::info(&e.cos, key))
+ }
+
+ /// Whether the document information has an entry `key`, of any type, listed or not.
+ pub fn has_info(&self, key: &str) -> bool {
+ self.editor.as_ref().is_some_and(|e| pdfcraft_organize::has_info(&e.cos, key))
+ }
+
+ /// The custom document properties as they are now (name, text), Document Properties ▸ Custom.
+ pub fn custom_info(&self) -> Vec<(String, String)> {
+ self.editor.as_ref().map(|e| pdfcraft_organize::custom_info(&e.cos)).unwrap_or_default()
+ }
+
+ /// The name shown on the tab and window: the document title when the document asks for it
+ /// (Initial View ▸ Show: Document Title) and has a real one, else the file name.
+ pub fn display_name(&self) -> String {
+ self.editor
+ .as_ref()
+ .filter(|e| pdfcraft_organize::displays_doc_title(&e.cos))
+ .and_then(|e| pdfcraft_organize::info(&e.cos, "Title"))
+ .map(|t| t.trim().to_owned())
+ .filter(|t| !t.is_empty() && !is_placeholder_title(t))
+ .unwrap_or_else(|| self.name.clone())
+ }
+
+ /// Where each saved revision of the file ends (oldest first; `bytes[..end]` is that
+ /// revision). Unsaved edits aren't a revision yet.
+ pub fn revision_ends(&self) -> Vec<usize> {
+ self.editor.as_ref().map(|e| e.cos.revision_ends()).unwrap_or_default()
+ }
+
+ /// The file as last opened or saved, without unsaved edits: what an incremental save appends
+ /// to. This stays that file when undo has restored an older snapshot.
+ pub fn saved_bytes(&self) -> Arc<Vec<u8>> {
+ self.editor.as_ref().map_or_else(|| self.bytes.clone(), |e| e.saved.clone())
+ }
+
+ /// Notes about damage repaired while opening (Document Properties ▸ Advanced, notices).
+ pub fn repair_log(&self) -> Vec<String> {
+ self.editor.as_ref().map(|e| e.cos.repair_log().to_vec()).unwrap_or_default()
+ }
+ }
+
+ /// A title that names no document: what a web browser writes when it saves a blank page or a
+ /// pop-up as PDF (`about:blank`), another browser-internal address, or a bare "Untitled". Such a
+ /// title says less than the file name, so the file name is shown instead. An address is one
+ /// word: "About: our company" is a real title.
+ pub(crate) fn is_placeholder_title(title: &str) -> bool {
+ let t = title.trim().to_lowercase();
+ let address = !t.contains(char::is_whitespace) && ["about:", "blob:", "data:"].iter().any(|p| t.starts_with(p));
+ address || t == "untitled"
+ }
+
+ /// The working file plus appearances for comments that have none, and for form fields the file
+ /// leaves to the viewer (#3470). Signature artwork is preserved; validation badges belong to the
+ /// viewer and never enter these bytes, which image/text exports and Print as Image also consume.
+ pub(crate) fn display_bytes(editor: Option<&mut Editor>, bytes: &Arc<Vec<u8>>) -> Arc<Vec<u8>> {
+ let Some(e) = editor else { return bytes.clone() };
+ let comments = pdfcraft_annot::with_missing_appearances_cached(&e.cos, &mut e.appearances);
+ let fields = pdfcraft_forms::with_field_appearances_cached(comments.as_ref().unwrap_or(&e.cos), &mut e.field_appearances);
+ let Some(display) = fields.or(comments) else {
+ return bytes.clone();
+ };
+ match write_incremental(&display, &SaveOptions::default()) {
+ Ok(written) => Arc::new(written),
+ Err(err) => {
+ e.cos.note_repair(format!("missing comment or field appearances could not be drawn ({err})"));
+ bytes.clone()
+ }
+ }
+ }
+
+ /// `comments` (the display copy with comment appearances, if it needed any; else the document
+ /// itself) with its form fields drawn from their values where the file leaves that to the viewer.
+ fn with_field_appearances(comments: Option<pdfcraft_cos::Document>, doc: &pdfcraft_cos::Document) -> Option<pdfcraft_cos::Document> {
+ pdfcraft_forms::with_field_appearances(comments.as_ref().unwrap_or(doc)).or(comments)
+ }
+
+ /// The reader shows the same pages in `a` and `b`: count, displayed size and rotation.
+ pub(crate) fn same_pages(a: &[pdfcraft_render::PageInfo], b: &[pdfcraft_render::PageInfo]) -> bool {
+ a.len() == b.len()
+ && a.iter().zip(b).all(|(x, y)| (x.width - y.width).abs() < 0.01 && (x.height - y.height).abs() < 0.01 && x.rotation == y.rotation)
+ }
+
+ /// Each document-information field of `info` with its value in `cos` (`/Info`, else XMP), read
+ /// the way the full inspection reads them: NULs and spaces trimmed, empty is none.
+ pub(crate) fn info_fields<'a>(info: &'a mut DocInfo, cos: &pdfcraft_cos::Document) -> [(&'a mut Option<String>, Option<String>); 6] {
+ let read = |key| pdfcraft_organize::info(cos, key).map(|v| v.trim_matches('\0').trim().to_string()).filter(|v| !v.is_empty());
+ [
+ (&mut info.title, read("Title")),
+ (&mut info.author, read("Author")),
+ (&mut info.subject, read("Subject")),
+ (&mut info.keywords, read("Keywords")),
+ (&mut info.creator, read("Creator")),
+ (&mut info.producer, read("Producer")),
+ ]
+ }
+
+ /// The copy PDFCraft displays when opening `bytes`: with appearances drawn, in memory only, for
+ /// comments that have none and form fields the file leaves to the viewer. Render paths outside the app, such as the CLI, use this so their page
+ /// images agree with the app and independent viewers. It never changes the source document, and an
+ /// unparseable file, a write failure or a parser panic falls back to the original bytes.
+ pub fn display_bytes_for(bytes: Arc<Vec<u8>>, password: Option<&str>) -> Arc<Vec<u8>> {
+ guard(|| {
+ pdfcraft_cos::Document::open_with_password(bytes.clone(), password)
+ .ok()
+ .and_then(|cos| with_field_appearances(pdfcraft_annot::with_missing_appearances(&cos), &cos))
+ .and_then(|display| write_incremental(&display, &SaveOptions::default()).ok())
+ .map(Arc::new)
+ })
+ .ok()
+ .flatten()
+ .unwrap_or(bytes)
+ }
+
+ /// The password to give the renderer (`inspect`, `PageRenderer`) for `bytes` opened with
+ /// `password`. The renderer authenticates only the user password of R2–R4 files, so for their
+ /// owner password this is the user password that owner authentication recovers; otherwise it is
+ /// `password` itself. Render paths outside a [`Session`](crate::Session), such as the CLI, use this so the owner
+ /// password works there as it does in `doc_open`. A file that doesn't open with `password` keeps
+ /// it, so the renderer reports the same error it always did.
+ pub fn render_password_for(bytes: Arc<Vec<u8>>, password: Option<&str>) -> Option<String> {
+ let password = password?;
+ let recovered =
+ guard(|| pdfcraft_cos::Document::open_with_password(bytes, Some(password)).ok().and_then(|d| recovered_render_password(&d))).ok().flatten();
+ Some(recovered.unwrap_or_else(|| password.to_owned()))
+ }
+
+ /// The user password owner authentication recovered from an R2–R4 `cos`, as the renderer takes it.
+ pub(crate) fn recovered_render_password(cos: &pdfcraft_cos::Document) -> Option<String> {
+ cos.security().and_then(|s| s.recovered_user_password()).map(|user| renderer_password(&user))
+ }
+
+ /// Fails when the renderer still draws text under an applied redaction mark.
+ ///
+ /// Redaction decides what lies under a mark from the positions its own interpreter computes, and
+ /// its verify pass reuses them. Where they differ from the renderer's (a standard font without
+ /// /Widths, whose advances the interpreter approximates; a CMap
+ /// that it reads differently), a mark drawn over the text as displayed lies over glyphs the
+ /// interpreter believes are elsewhere: they stay in the file and nothing notices. The renderer is
+ /// what the user saw when placing the marks, so it is asked. `after` is written as a save would
+ /// write it, without the marks' own `overlays` (the box and its label are drawn on purpose), its
+ /// text is extracted, and a glyph still mostly inside a mark fails the edit: the caller keeps
+ /// the document as it was.
+ pub(crate) fn shown_under_redactions(
+ after: &pdfcraft_cos::Document,
+ marks: &[pdfcraft_redact::Mark],
+ overlays: &[pdfcraft_cos::ObjRef],
+ pages: &[pdfcraft_render::PageInfo],
+ password: Option<&str>,
+ ) -> Result<(), EditError> {
+ use pdfcraft_cos::Object;
+ use pdfcraft_redact::RedactError;
+ let mut marked: Vec<usize> = marks.iter().map(|m| m.page).collect();
+ marked.sort_unstable();
+ marked.dedup();
+ if marked.is_empty() {
+ return Ok(());
+ }
+ let mut shown = after.clone();
+ let model = pdfcraft_model::pages(&shown);
+ for &pi in &marked {
+ let Some(page) = model.get(pi) else { continue };
+ let Some(Object::Array(list)) = page.dict.get(b"Contents").map(|c| (*shown.resolve(c)).clone()) else { continue };
+ let kept: Vec<Object> = list.into_iter().filter(|o| !o.as_ref().is_some_and(|r| overlays.contains(&r))).collect();
+ shown.update_dict(page.obj, |d| d.set(b"Contents".to_vec(), Object::Array(kept))).map_err(|e| EditError::Write(e.to_string()))?;
+ }
+ let bytes = write_incremental(&shown, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?;
+ let config = RenderConfig { password: password.map(Arc::from), ..Default::default() };
+ let mut renderer = pdfcraft_render::PageRenderer::new(Arc::new(bytes), config);
+ let mut residue = 0;
+ for &pi in &marked {
+ let request = pdfcraft_render::RenderRequest { page: pi, kind: pdfcraft_render::RequestKind::Text, scale: 1.0, ..Default::default() };
+ // A page that cannot be read back cannot be confirmed clean.
+ let (Some(info), Some(text)) = (pages.get(pi), renderer.render(request).text) else { return Err(RedactError::Unreadable(pi + 1).into()) };
+ let rects: Vec<[f64; 4]> = marks
+ .iter()
+ .filter(|m| m.page == pi)
+ .flat_map(|m| m.rects.iter())
+ .map(|r| [r[0].min(r[2]), r[1].min(r[3]), r[0].max(r[2]), r[1].max(r[3])])
+ .collect();
+ for glyph in text.glyphs.iter().filter(|g| !g.text.trim().is_empty()) {
+ let [x0, y0, x1, y1] = info.view_rect_to_user(glyph.rect).map(f64::from);
+ let area = (x1 - x0) * (y1 - y0);
+ if area.is_nan() || area <= 0.0 {
+ continue;
+ }
+ // Redaction itself takes any glyph a fifth under a mark; one that is half under it
+ // and still drawn was not where redaction thought it was.
+ let under = |r: &[f64; 4]| (x1.min(r[2]) - x0.max(r[0])).max(0.0) * (y1.min(r[3]) - y0.max(r[1])).max(0.0) >= 0.5 * area;
+ if rects.iter().any(under) {
+ residue += 1;
+ }
+ }
+ }
+ if residue > 0 {
+ return Err(RedactError::Residue(residue).into());
+ }
+ Ok(())
+ }
diff --cc crates/engine/src/lib.rs
index c764d6e31,78e5ea1eb..75227e904
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@@ -46,37 -69,35 +69,37 @@@ pub use signature_scan::{PhotoRect, Sca
pub use stamp_preview::StampPreview;
pub use text_preview::TextEditPreview;
- pub use pdfcraft_organize::{BoxSpec, FieldConflicts, PageBox, SplitBy, Transition, TransitionSpec, mime_for_name, split_ranges};
-
- /// One file produced by a split: (1-based first page, last page, PDF bytes).
- 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 reexports::*;
- 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,
+ use bookmarks::outline_rows;
+ pub use bookmarks::{BookmarkPage, BookmarkRow};
+ use comments::comment_list;
+ pub use comments::{SummarySort, comment_kind, comment_summary, comment_type_name};
-pub use document::{Document, TextNotice, display_bytes_for, render_password_for};
++#[cfg(test)]
++use document::page_runs;
++pub use document::{Document, EditNotice, TextNotice, display_bytes_for, render_password_for};
+ use document::{display_bytes, info_fields, recovered_render_password, same_pages, shown_under_redactions, undrawn_notices};
+ pub use edit::{BATCH_LABELS, EDIT_LABELS, Edit};
+ pub use error::{EditError, SourceProblem};
+ pub use fill_sign::{displayed_offset, text_box_at, typed_signature_graphic, typed_signature_shape};
+ pub use history::Label;
+ use layers::{apply_layer_state, set_default_layer_state, use_layer_choices};
+ pub use open::{OpenContext, PreparedDocument};
+ pub use page_filter::{PageOrientation, PageParity, filter_pages};
+ pub use pictures::MarkFile;
+ use pictures::{embed_image, fit_picture, mark_source};
+ use protection::unrestricted;
+ pub use protection::{Changes, Printing, Protection, SecuritySummary};
+ pub use session::Session;
+ pub use sources::{CombineSource, Combined, combine_source_check, source_page_count};
+ use sources::{open_source, open_source_with};
+ #[cfg(test)]
+ use test_hooks::{check_refresh_panic, panic_on_refresh, record_link_scan, record_marker_scan, reset_secondary_scan_counts, secondary_scan_counts};
+ use xfa_form::{
+ XFA_REMOVED_PREFIX, XFA_SCRIPTS_OFF, decode_data_file, image_content_type, is_xfa_data_file, note_warnings, strip_xfa, sync_xfa_state,
+ undrawn_field_warnings, xfa_after_data_change, xfa_layout, xfa_redraw, xfa_sync_datasets, xfa_values_from_datasets,
};
- pub use pdfcraft_a11y as a11y;
- pub use pdfcraft_edit::{Backdrop, 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};
-
/// A change to an existing page image.
#[derive(Clone, Debug, PartialEq)]
pub enum ImageEdit {
diff --cc crates/engine/src/reexports.rs
index 000000000,208a8e450..a5f1dba41
mode 000000,100644..100644
--- a/crates/engine/src/reexports.rs
+++ b/crates/engine/src/reexports.rs
@@@ -1,0 -1,53 +1,53 @@@
+ //! What the engine re-exports from the other pdfcraft crates, so frontends need only this one.
+
+ pub use pdfcraft_organize::{BoxSpec, FieldConflicts, PageBox, SplitBy, Transition, TransitionSpec, mime_for_name, split_ranges};
+
+ pub use pdfcraft_organize::LabelStyle;
+ pub use pdfcraft_organize::Standard;
+ pub use pdfcraft_organize::check_custom_key;
+ pub use pdfcraft_organize::view::{InitialView, Layout as InitialLayout, Magnification, Navigation};
+
+ pub use pdfcraft_cos::Algorithm;
+ pub use pdfcraft_create::{CONVERTIBLE, CreateError, ImageResolution, SourceKind, decode_text, source_kind};
+ pub use pdfcraft_edit::added::{
+ CHAR_SPACING_LIMIT as ADDED_CHAR_SPACING_LIMIT, paste_place as added_paste_place, paste_rect as added_paste_rect, text_rect as added_text_rect,
+ text_width as added_text_width,
+ };
+ pub use pdfcraft_edit::{
+ Added, AddedImage, AddedText, Align as TextAlign, Background, Content as AddedContent, Family as FontFamily, HeaderFooter, MarkKind, Watermark,
+ };
+ pub use pdfcraft_forms::{
+ BorderStyle, CalculatedField, CalculationIssue, CalculationOrder, CheckStyle, Field as FormField, FieldAction, FieldChange, FieldFont,
+ FieldKind as FormFieldKind, FieldProps, FieldValue, Look as FieldLook, LookPatch as FieldLookPatch, NewField, TabOrder, Trigger as FieldTrigger,
+ Widget as FormWidget, af as form_scripts, appearance as form_appearance, appearance::auto_text_size_by as field_auto_text_size_by,
+ calculations_changed as form_calculations_changed, flags as field_flags,
+ };
+
+ pub use pdfcraft_a11y as a11y;
-pub use pdfcraft_edit::{BlockKey, BlockStyle, PageImage, RangeStyle, TextBlock, TextLine, block_overlapping, first_undrawable};
++pub use pdfcraft_edit::{Backdrop, 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_fonts::{MAX_SIGNATURE_CHARS, ScriptOutline, script_missing, script_outline, undrawable_message};
+
+ /// Comment geometry helpers (text-box line breaking) for frontends.
+ pub use pdfcraft_annot::appearance as annot_text;
+ pub use pdfcraft_annot::links::{Highlight as LinkHighlight, LinkAction, LinkItem, LinkStyle};
+ pub use pdfcraft_annot::{
+ AppearanceCache, AttachIcon, FillMark, LineEnding, Markup, NOTE_SIZE, NewAnnotation, NoteIcon, OverlayFont, OverlayLook, Props as CommentProps,
+ ReviewState, Rgb, Shape, StampGroup, StampKind, Style, rect_quad,
+ };
+ pub use pdfcraft_forms::detect;
+ pub use pdfcraft_optimize as optimize;
+ pub use pdfcraft_preflight as pdfa;
+ pub use pdfcraft_print as print;
+ pub use pdfcraft_redact::codes::{CODE_SETS as REDACTION_CODE_SETS, CodeSet as RedactionCodeSet};
+ pub use pdfcraft_redact::patterns::{
+ MAX_WORDS as REDACT_MAX_WORDS, PATTERNS as REDACT_PATTERNS, Pattern as RedactPattern, find as find_pattern, word_list as redact_word_list,
+ };
+ pub use pdfcraft_redact::sanitize::{HIDDEN, Hidden};
+ pub use pdfcraft_sign as sign;
+ pub use pdfcraft_sign::{SignOptions, SignatureInfo, Status as SignatureStatus, TrustStore};
+ pub use pdfcraft_xfdf::Format as DataFormat;
diff --cc crates/engine/src/session.rs
index 000000000,c3e34d90b..ab4d0345a
mode 000000,100644..100644
--- a/crates/engine/src/session.rs
+++ b/crates/engine/src/session.rs
@@@ -1,0 -1,1590 +1,1597 @@@
+ //! 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,
++ BookmarkPage, BookmarkRow, CombineSource, Combined, DataFormat, DocId, Document, Edit, EditError, EditNotice, Hidden, ImageResolution,
++ LOW_RESOLUTION_PRINT_DPI, Label, MarkKind, 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()
++ let mut notices: Vec<EditNotice> = if matches!(scope_of(&edit), Scope::Form | Scope::Comments | Scope::Full) {
++ guard(|| undrawn_notices(&editor.cos, &next)).unwrap_or_default().into_iter().map(EditNotice::Undrawn).collect()
+ } else {
+ Vec::new()
+ };
++ // Pages whose own white backdrop Remove background couldn't turn back on: said, not silent.
++ if matches!(edit, Edit::RemoveMarks { kind: MarkKind::Background }) {
++ let pages = guard(|| pdfcraft_edit::backdrops_left_off(&next)).unwrap_or_default();
++ if !pages.is_empty() {
++ notices.push(EditNotice::BackdropsLeftOff { pages });
++ }
++ }
+ let previous = std::mem::replace(&mut editor.cos, next);
+ let keys = keys_after(&edit).unwrap_or_else(|| editor.keys.clone());
+ let previous_keys = std::mem::replace(&mut editor.keys, keys);
+ editor.undo.push((label, previous, previous_keys, scope));
+ if editor.undo.len() > MAX_UNDO {
+ editor.undo.remove(0);
+ }
+ editor.redo.clear();
+ Self::adopt_keys(doc);
+ let refreshed = guard(|| if scope == Scope::Content { Self::refresh_content(doc, Some(&edit)) } else { Self::refresh_scoped(doc, scope) })
+ .unwrap_or_else(|m| Err(EditError::Reopen(m)));
+ if let Err(e) = refreshed {
+ // Roll back: the edit produced something we cannot display.
+ if let Some(ed) = doc.editor.as_mut()
+ && let Some((_, prev, keys, _)) = ed.undo.pop()
+ {
+ ed.cos = prev;
+ ed.keys = keys;
+ }
+ Self::adopt_keys(doc);
+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {
+ Self::show_released(doc);
+ }
+ return Err(e);
+ }
+ doc.dirty = true;
+ doc.generation += 1;
+ doc.edit_notices = notices;
+ if !cx.xfa_removed.is_empty() {
+ let removed: Vec<String> = cx.xfa_removed.iter().map(|n| format!("{XFA_REMOVED_PREFIX}{n}")).collect();
+ doc.xfa_warnings.retain(|w| w.starts_with(XFA_REMOVED_PREFIX));
+ note_warnings(&mut doc.xfa_warnings, &removed);
+ note_warnings(&mut doc.info.warnings, &removed);
+ }
+ note_warnings(&mut doc.xfa_warnings, &xfa_notes);
+ let notes = doc.xfa_warnings.clone();
+ note_warnings(&mut doc.info.warnings, &notes);
+ if let Some(js) = cx.js {
+ doc.js_output.append(js.output);
+ }
+ doc.js_output.append(cx.xfa_out);
+ if cx.xfa_ran_away {
+ doc.xfa_template = None;
+ doc.xfa_scripts_off = true;
+ doc.js_output.errors.push(XFA_SCRIPTS_OFF.into());
+ }
+ Ok(())
+ }
+
+ pub fn undo(&mut self, id: DocId) -> Result<Label, EditError> {
+ let doc = self.doc_mut(id)?;
+ let editor = doc.editor.as_mut().ok_or(EditError::NothingToUndo)?;
+ let (label, prev, keys, scope) = editor.undo.pop().ok_or(EditError::NothingToUndo)?;
+ let current = std::mem::replace(&mut editor.cos, prev);
+ let current_keys = std::mem::replace(&mut editor.keys, keys);
+ editor.redo.push((label.clone(), current, current_keys, scope));
+ Self::adopt_keys(doc);
+ let refreshed = guard(|| Self::refresh_scoped(doc, scope)).unwrap_or_else(|m| Err(EditError::Reopen(m)));
+ if let Err(e) = refreshed {
+ if let Some(ed) = doc.editor.as_mut()
+ && let Some((label, current, current_keys, scope)) = ed.redo.pop()
+ {
+ let prev = std::mem::replace(&mut ed.cos, current);
+ let keys = std::mem::replace(&mut ed.keys, current_keys);
+ ed.undo.push((label, prev, keys, scope));
+ }
+ Self::adopt_keys(doc);
+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {
+ Self::show_released(doc);
+ }
+ return Err(e);
+ }
+ doc.edit_notices.clear();
+ Self::sync_dirty(doc);
+ doc.generation += 1;
+ Ok(label)
+ }
+
+ pub fn redo(&mut self, id: DocId) -> Result<Label, EditError> {
+ let doc = self.doc_mut(id)?;
+ let editor = doc.editor.as_mut().ok_or(EditError::NothingToRedo)?;
+ let (label, next, keys, scope) = editor.redo.pop().ok_or(EditError::NothingToRedo)?;
+ let current = std::mem::replace(&mut editor.cos, next);
+ let current_keys = std::mem::replace(&mut editor.keys, keys);
+ editor.undo.push((label.clone(), current, current_keys, scope));
+ Self::adopt_keys(doc);
+ let refreshed = guard(|| Self::refresh_scoped(doc, scope)).unwrap_or_else(|m| Err(EditError::Reopen(m)));
+ if let Err(e) = refreshed {
+ if let Some(ed) = doc.editor.as_mut()
+ && let Some((label, current, current_keys, scope)) = ed.undo.pop()
+ {
+ let next = std::mem::replace(&mut ed.cos, current);
+ let keys = std::mem::replace(&mut ed.keys, current_keys);
+ ed.redo.push((label, next, keys, scope));
+ }
+ Self::adopt_keys(doc);
+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {
+ Self::show_released(doc);
+ }
+ return Err(e);
+ }
+ doc.edit_notices.clear();
+ Self::sync_dirty(doc);
+ doc.generation += 1;
+ Ok(label)
+ }
+
+ /// Unsaved when the working graph is not the last opened or saved file. Undo back to that
+ /// file is clean; undo past a later save is not, because the restored snapshot's own base
+ /// is an earlier revision.
+ fn sync_dirty(doc: &mut Document) {
+ doc.dirty = doc.editor.as_ref().is_some_and(|e| e.unsaved_file || e.cos.is_modified() || !Arc::ptr_eq(e.cos.bytes(), &e.saved));
+ }
+
+ /// Use the current state's password for viewing (protection edits change it).
+ fn adopt_keys(doc: &mut Document) {
+ if let Some(e) = doc.editor.as_ref() {
+ doc.password = e.keys.render.clone();
+ doc.config.password = e.keys.render.as_deref().map(Arc::from);
+ }
+ }
+
+ /// Rebuild the working bytes and the view data that `scope` may have changed. Metadata edits
+ /// keep the renderer; other scopes also replace it.
+ /// Comment and form edits skip the full re-inspection (seconds on very large files): the
+ /// comment list and field values are re-read from the object graph instead.
+ fn refresh_scoped(doc: &mut Document, scope: Scope) -> Result<(), EditError> {
+ if scope == Scope::Full || doc.info.encrypted != doc.editor.as_ref().is_some_and(|e| e.cos.output_handler().is_some()) {
+ return Self::refresh(doc);
+ }
+ if scope == Scope::Content {
+ return Self::refresh_content(doc, None);
+ }
+ if scope == Scope::Links {
+ return Self::refresh_links(doc);
+ }
+ // Metadata edits keep the renderer, which holds the working file anyway.
+ if scope != Scope::Metadata {
+ Self::release_working(doc);
+ }
+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };
+ // Comment edits, and form edits (a script may change annotation properties), may change
+ // annotation dictionaries, invalidating cached appearances.
+ if matches!(scope, Scope::Comments | Scope::Form) {
+ editor.appearances.clear();
+ }
+ let bytes = if editor.cos.is_modified() {
+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)
+ } else {
+ editor.cos.bytes().clone()
+ };
+ if scope == Scope::Metadata {
+ for (field, value) in info_fields(&mut doc.info, &editor.cos) {
+ *field = value;
+ }
+ doc.info.custom = pdfcraft_organize::custom_info(&editor.cos);
+ doc.info.file_size = bytes.len();
+ #[cfg(test)]
+ check_refresh_panic();
+ if !doc.signatures.is_empty() {
+ let signatures = signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache);
+ doc.signatures = Arc::new(signatures);
+ }
+ doc.bytes = bytes;
+ return Ok(());
+ }
+ let mut form = pdfcraft_forms::fields(&editor.cos);
+ xfa::mark_script_buttons(&editor.cos, &mut form);
+ let form = Arc::new(form);
+ match scope {
+ Scope::Metadata => return Ok(()),
+ Scope::Comments => {
+ doc.info.annotations = comment_list(&editor.cos);
+ // Link indexes are positions in /Annots, so comment insertion/deletion can move them.
+ doc.links = OnceLock::new();
+ }
+ Scope::Form => {
+ // PERF: keystroke path, index once. A linear find per field is O(F^2);
+ // forms reach 10k fields.
+ let mut by_name = std::collections::HashMap::with_capacity(form.len());
+ for x in form.iter() {
+ // First match wins (do not simplify to collect: it keeps the last).
+ by_name.entry(x.name.as_str()).or_insert(x);
+ }
+ for f in &mut doc.info.fields {
+ if let Some(ff) = by_name.get(f.name.as_str()) {
+ f.value = match ff.kind {
+ pdfcraft_forms::FieldKind::CheckBox | pdfcraft_forms::FieldKind::Radio => {
+ Some(ff.value.first().cloned().unwrap_or_else(|| "Off".into()))
+ }
+ _ if ff.value.is_empty() => None,
+ _ => Some(ff.value.join(", ")),
+ };
+ }
+ }
+ }
+ Scope::Links => return Self::refresh_links(doc),
+ // Handled above; kept as a full refresh so the match stays total.
+ Scope::Full => return Self::refresh(doc),
+ // Handled above (content-only refresh); the arm keeps the match total.
+ Scope::Content => return Self::refresh_content(doc, None),
+ }
+ doc.info.file_size = bytes.len();
+ doc.form = form;
+ let signatures = if doc.signatures.is_empty() { Vec::new() } else { signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache) };
+ doc.display = display_bytes(Some(editor), &bytes);
+ doc.signatures = Arc::new(signatures);
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.bytes = bytes;
+ Ok(())
+ }
+
+ /// Which derived lists a content-only edit can change: added content (`None`, from
+ /// undo/redo, re-reads both: always correct, rarely paid).
+ pub(crate) fn content_refresh_lists(edit: Option<&Edit>) -> (bool, bool) {
+ if let Some(Edit::Batch { edits, .. }) = edit {
+ // A batch of content edits (from a script, say) changes what its parts change.
+ return edits.iter().fold((false, false), |(added, marks), part| {
+ let (a, m) = Self::content_refresh_lists(Some(part));
+ (added || a, marks || m)
+ });
+ }
+ let touches_added = edit.is_none_or(|e| {
+ matches!(
+ e,
+ Edit::AddText { .. }
+ | Edit::AddImage { .. }
+ | Edit::UpdateContent { .. }
+ | Edit::DeleteContent { .. }
+ | Edit::ReplaceImage { .. }
+ | Edit::PasteContent { .. }
+ ) || matches!(e, Edit::MoveObjects { objects, .. } if objects.iter().any(|o| o.kind == ObjectKind::Added))
+ });
+ let touches_marks = edit.is_none_or(|e| {
+ matches!(e, Edit::AddHeaderFooter { .. } | Edit::AddWatermark { .. } | Edit::AddBackground { .. } | Edit::RemoveMarks { .. })
+ });
+ (touches_added, touches_marks)
+ }
+
+ /// Rebuild working bytes, display bytes and renderer after a content-only edit: page
+ /// content streams, resources and added content/marks. The page tree, annotations, form
+ /// fields, links, outline and fonts are unchanged, so the full re-inspection (seconds on
+ /// very large files) is skipped. `edit` selects which derived lists are re-read (`None`,
+ /// from undo/redo, re-reads both: always correct, rarely paid). The cached display
+ /// appearances are kept: content edits leave every annotation dictionary alone.
+ fn refresh_content(doc: &mut Document, edit: Option<&Edit>) -> Result<(), EditError> {
+ Self::release_working(doc);
+ sync_xfa_state(doc);
+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };
+ let bytes = if editor.cos.is_modified() {
+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)
+ } else {
+ editor.cos.bytes().clone()
+ };
+ // The edit must still leave a file the viewer can open; anything else rolls back above.
+ pdfcraft_render::check_pages(bytes.clone(), doc.password.as_deref(), doc.info.pages.len()).map_err(|e| EditError::Reopen(e.to_string()))?;
+ let (touches_added, touches_marks) = Self::content_refresh_lists(edit);
+ if touches_added || touches_marks {
+ doc.marker_scan = OnceLock::new();
+ }
+ doc.info.file_size = bytes.len();
+ let signatures = if doc.signatures.is_empty() { Vec::new() } else { signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache) };
+ doc.display = display_bytes(Some(editor), &bytes);
+ doc.signatures = Arc::new(signatures);
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.bytes = bytes;
+ doc.fonts_stale = true;
+ Ok(())
+ }
+
+ /// Let go of the working file before the next one is written (gap 13). The working file is
+ /// the original plus one appended revision, so on a 1 GiB file keeping the old one (in the
+ /// working bytes, the display bytes and the renderer) while writing the new one held three
+ /// copies at once; this keeps two. Until the refresh finishes, the working and display bytes
+ /// are the original's (already held by the editor, so free) and the renderer draws nothing.
+ /// A failed edit rolls back and refreshes again, which replaces all three; where a refresh
+ /// still fails, [`Self::show_released`] draws the original rather than nothing. Save writes
+ /// from the editor, never from these.
+ pub(crate) fn release_working(doc: &mut Document) {
+ let Some(original) = doc.editor.as_ref().map(|e| e.cos.bytes().clone()) else { return };
+ // Dropping the pool stops its workers; each lets go of the file when it exits.
+ doc.renderer = RenderPool::new_inline(Arc::new(Vec::new()), doc.config.clone());
+ doc.display = original.clone();
+ doc.bytes = original;
+ #[cfg(test)]
+ check_refresh_panic();
+ }
+
+ /// After a refresh failed: draw the display bytes it left (the original, once released),
+ /// so the page still shows a document.
+ fn show_released(doc: &mut Document) {
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ }
+
+ /// Rebuild working bytes, inspection and renderer from the current edit state.
+ pub(crate) fn refresh(doc: &mut Document) -> Result<(), EditError> {
+ Self::refresh_with_indexes(doc, true, true)
+ }
+
+ /// Reinspect a link edit while preserving the page-content marker scan cache.
+ fn refresh_links(doc: &mut Document) -> Result<(), EditError> {
+ Self::refresh_with_indexes(doc, false, true)
+ }
+
+ fn refresh_with_indexes(doc: &mut Document, invalidate_markers: bool, invalidate_links: bool) -> Result<(), EditError> {
+ // A full refresh may follow structural or annotation changes: cached appearances
+ // may be stale, so they are rebuilt below.
+ if let Some(editor) = doc.editor.as_mut() {
+ editor.appearances.clear();
+ }
+ Self::release_working(doc);
+ sync_xfa_state(doc);
+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };
+ let bytes = if editor.cos.is_modified() {
+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)
+ } else {
+ editor.cos.bytes().clone()
+ };
+ let info = inspect(bytes.clone(), doc.password.as_deref()).map_err(|e| EditError::Reopen(e.to_string()))?;
+ // Keep the user's layer choices where the layers still exist.
+ let mut info = info;
+ for l in &mut info.layers {
+ if let Some(old) = doc.info.layers.iter().find(|o| o.id == l.id) {
+ l.visible = old.visible;
+ }
+ }
+ note_warnings(&mut info.warnings, &doc.xfa_warnings);
+ // As in `build_document`: the inspection reads only `/Info`, so fields stated only in XMP
+ // are filled in again after every full refresh.
+ for (field, value) in info_fields(&mut info, &editor.cos) {
+ if field.is_none() {
+ *field = value;
+ }
+ }
+ doc.info = info;
+ doc.fonts_stale = false;
+ let mut form = pdfcraft_forms::fields(&editor.cos);
+ xfa::mark_script_buttons(&editor.cos, &mut form);
+ doc.form = Arc::new(form);
+ if invalidate_markers {
+ doc.marker_scan = OnceLock::new();
+ }
+ if invalidate_links {
+ doc.links = OnceLock::new();
+ }
+ let signatures = signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache);
+ doc.display = display_bytes(Some(editor), &bytes);
+ doc.signatures = Arc::new(signatures);
+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());
+ doc.bytes = bytes;
+ Ok(())
+ }
+
+ /// The bytes to write for Save: an incremental update of the file as opened/last saved,
+ /// with `/ModDate` stamped. Call `mark_saved` after writing them successfully.
+ ///
+ /// A file whose cross-reference data had to be rebuilt is written in full even when nothing
+ /// was edited: its bytes as opened are the damaged file, and this save is how the repair the
+ /// user was told about reaches the disk (#1937). Not a signed one: a full rewrite would
+ /// break its signatures, so with no edits it keeps its bytes, damage and all.
+ pub fn save_bytes(&self, id: DocId) -> Result<Arc<Vec<u8>>, EditError> {
+ let doc = self.get(id).ok_or(EditError::NoDocument)?;
+ let Some(editor) = doc.editor.as_ref() else { return Ok(doc.bytes.clone()) };
+ let on_saved = Arc::ptr_eq(editor.cos.bytes(), &editor.saved);
+ if !editor.cos.is_modified() && on_saved && (!editor.cos.reconstructed() || doc.is_signed()) {
+ return Ok(editor.saved.clone());
+ }
+ // What the user removed again before saving (a cleared redaction mark) stays out of the file.
+ let opts = SaveOptions { mod_date: self.now().map(pdfcraft_cos::pdf_date), drop_unlinked: true, ..SaveOptions::default() };
+ // A restored snapshot can be based on an earlier revision. Append to the last saved
+ // file so that revision stays in the chain. A full rewrite (redaction, new encryption,
+ // a reconstructed file) still writes the current graph on its own.
+ let rewrite = editor.cos.full_save_required() || editor.cos.encryption_changed() || editor.cos.revisions().is_empty();
+ let cos = writable(&editor.cos)?;
+ 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)?;
+ 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
+ }
+ }
diff --cc crates/ui-egui/src/lib.rs
index 4cec41ee9,3446bcd26..0a70a6b2b
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@@ -2938,12 -3000,13 +3000,16 @@@ impl PdfCraftApp
}
"none" => None,
_ => Some(Dialog::About),
+ };
+ if let Some(Dialog::Marks(kind)) = self.dialog {
+ self.marks_draft.opened(kind);
}
}
- ("tools", _) => self.all_tools_expanded = value != "collapsed",
+ ("tools", _) if value == "full" => self.expand_all_tools(),
+ ("tools", _) => {
+ self.all_tools_full = false;
+ self.all_tools_expanded = value != "collapsed";
+ }
("palette", _) => {
self.palette_open = true;
self.palette_query = value.to_string();