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.rsindex 000000000,7023caa55..765594356mode 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.rsindex 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, Scapub 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.rsindex 000000000,208a8e450..a5f1dba41mode 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.rsindex 000000000,c3e34d90b..ab4d0345amode 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, ¬es);+ if let Some(js) = cx.js {+ doc.js_output.append(js.output);+ }+ doc.js_output.append(cx.xfa_out);+ if cx.xfa_ran_away {+ doc.xfa_template = None;+ doc.xfa_scripts_off = true;+ doc.js_output.errors.push(XFA_SCRIPTS_OFF.into());+ }+ Ok(())+ }++ pub fn undo(&mut self, id: DocId) -> Result<Label, EditError> {+ let doc = self.doc_mut(id)?;+ let editor = doc.editor.as_mut().ok_or(EditError::NothingToUndo)?;+ let (label, prev, keys, scope) = editor.undo.pop().ok_or(EditError::NothingToUndo)?;+ let current = std::mem::replace(&mut editor.cos, prev);+ let current_keys = std::mem::replace(&mut editor.keys, keys);+ editor.redo.push((label.clone(), current, current_keys, scope));+ Self::adopt_keys(doc);+ let refreshed = guard(|| Self::refresh_scoped(doc, scope)).unwrap_or_else(|m| Err(EditError::Reopen(m)));+ if let Err(e) = refreshed {+ if let Some(ed) = doc.editor.as_mut()+ && let Some((label, current, current_keys, scope)) = ed.redo.pop()+ {+ let prev = std::mem::replace(&mut ed.cos, current);+ let keys = std::mem::replace(&mut ed.keys, current_keys);+ ed.undo.push((label, prev, keys, scope));+ }+ Self::adopt_keys(doc);+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {+ Self::show_released(doc);+ }+ return Err(e);+ }+ doc.edit_notices.clear();+ Self::sync_dirty(doc);+ doc.generation += 1;+ Ok(label)+ }++ pub fn redo(&mut self, id: DocId) -> Result<Label, EditError> {+ let doc = self.doc_mut(id)?;+ let editor = doc.editor.as_mut().ok_or(EditError::NothingToRedo)?;+ let (label, next, keys, scope) = editor.redo.pop().ok_or(EditError::NothingToRedo)?;+ let current = std::mem::replace(&mut editor.cos, next);+ let current_keys = std::mem::replace(&mut editor.keys, keys);+ editor.undo.push((label.clone(), current, current_keys, scope));+ Self::adopt_keys(doc);+ let refreshed = guard(|| Self::refresh_scoped(doc, scope)).unwrap_or_else(|m| Err(EditError::Reopen(m)));+ if let Err(e) = refreshed {+ if let Some(ed) = doc.editor.as_mut()+ && let Some((label, current, current_keys, scope)) = ed.undo.pop()+ {+ let next = std::mem::replace(&mut ed.cos, current);+ let keys = std::mem::replace(&mut ed.keys, current_keys);+ ed.redo.push((label, next, keys, scope));+ }+ Self::adopt_keys(doc);+ if !matches!(guard(|| Self::refresh(doc)), Ok(Ok(()))) {+ Self::show_released(doc);+ }+ return Err(e);+ }+ doc.edit_notices.clear();+ Self::sync_dirty(doc);+ doc.generation += 1;+ Ok(label)+ }++ /// Unsaved when the working graph is not the last opened or saved file. Undo back to that+ /// file is clean; undo past a later save is not, because the restored snapshot's own base+ /// is an earlier revision.+ fn sync_dirty(doc: &mut Document) {+ doc.dirty = doc.editor.as_ref().is_some_and(|e| e.unsaved_file || e.cos.is_modified() || !Arc::ptr_eq(e.cos.bytes(), &e.saved));+ }++ /// Use the current state's password for viewing (protection edits change it).+ fn adopt_keys(doc: &mut Document) {+ if let Some(e) = doc.editor.as_ref() {+ doc.password = e.keys.render.clone();+ doc.config.password = e.keys.render.as_deref().map(Arc::from);+ }+ }++ /// Rebuild the working bytes and the view data that `scope` may have changed. Metadata edits+ /// keep the renderer; other scopes also replace it.+ /// Comment and form edits skip the full re-inspection (seconds on very large files): the+ /// comment list and field values are re-read from the object graph instead.+ fn refresh_scoped(doc: &mut Document, scope: Scope) -> Result<(), EditError> {+ if scope == Scope::Full || doc.info.encrypted != doc.editor.as_ref().is_some_and(|e| e.cos.output_handler().is_some()) {+ return Self::refresh(doc);+ }+ if scope == Scope::Content {+ return Self::refresh_content(doc, None);+ }+ if scope == Scope::Links {+ return Self::refresh_links(doc);+ }+ // Metadata edits keep the renderer, which holds the working file anyway.+ if scope != Scope::Metadata {+ Self::release_working(doc);+ }+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };+ // Comment edits, and form edits (a script may change annotation properties), may change+ // annotation dictionaries, invalidating cached appearances.+ if matches!(scope, Scope::Comments | Scope::Form) {+ editor.appearances.clear();+ }+ let bytes = if editor.cos.is_modified() {+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)+ } else {+ editor.cos.bytes().clone()+ };+ if scope == Scope::Metadata {+ for (field, value) in info_fields(&mut doc.info, &editor.cos) {+ *field = value;+ }+ doc.info.custom = pdfcraft_organize::custom_info(&editor.cos);+ doc.info.file_size = bytes.len();+ #[cfg(test)]+ check_refresh_panic();+ if !doc.signatures.is_empty() {+ let signatures = signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache);+ doc.signatures = Arc::new(signatures);+ }+ doc.bytes = bytes;+ return Ok(());+ }+ let mut form = pdfcraft_forms::fields(&editor.cos);+ xfa::mark_script_buttons(&editor.cos, &mut form);+ let form = Arc::new(form);+ match scope {+ Scope::Metadata => return Ok(()),+ Scope::Comments => {+ doc.info.annotations = comment_list(&editor.cos);+ // Link indexes are positions in /Annots, so comment insertion/deletion can move them.+ doc.links = OnceLock::new();+ }+ Scope::Form => {+ // PERF: keystroke path, index once. A linear find per field is O(F^2);+ // forms reach 10k fields.+ let mut by_name = std::collections::HashMap::with_capacity(form.len());+ for x in form.iter() {+ // First match wins (do not simplify to collect: it keeps the last).+ by_name.entry(x.name.as_str()).or_insert(x);+ }+ for f in &mut doc.info.fields {+ if let Some(ff) = by_name.get(f.name.as_str()) {+ f.value = match ff.kind {+ pdfcraft_forms::FieldKind::CheckBox | pdfcraft_forms::FieldKind::Radio => {+ Some(ff.value.first().cloned().unwrap_or_else(|| "Off".into()))+ }+ _ if ff.value.is_empty() => None,+ _ => Some(ff.value.join(", ")),+ };+ }+ }+ }+ Scope::Links => return Self::refresh_links(doc),+ // Handled above; kept as a full refresh so the match stays total.+ Scope::Full => return Self::refresh(doc),+ // Handled above (content-only refresh); the arm keeps the match total.+ Scope::Content => return Self::refresh_content(doc, None),+ }+ doc.info.file_size = bytes.len();+ doc.form = form;+ let signatures = if doc.signatures.is_empty() { Vec::new() } else { signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache) };+ doc.display = display_bytes(Some(editor), &bytes);+ doc.signatures = Arc::new(signatures);+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());+ doc.bytes = bytes;+ Ok(())+ }++ /// Which derived lists a content-only edit can change: added content (`None`, from+ /// undo/redo, re-reads both: always correct, rarely paid).+ pub(crate) fn content_refresh_lists(edit: Option<&Edit>) -> (bool, bool) {+ if let Some(Edit::Batch { edits, .. }) = edit {+ // A batch of content edits (from a script, say) changes what its parts change.+ return edits.iter().fold((false, false), |(added, marks), part| {+ let (a, m) = Self::content_refresh_lists(Some(part));+ (added || a, marks || m)+ });+ }+ let touches_added = edit.is_none_or(|e| {+ matches!(+ e,+ Edit::AddText { .. }+ | Edit::AddImage { .. }+ | Edit::UpdateContent { .. }+ | Edit::DeleteContent { .. }+ | Edit::ReplaceImage { .. }+ | Edit::PasteContent { .. }+ ) || matches!(e, Edit::MoveObjects { objects, .. } if objects.iter().any(|o| o.kind == ObjectKind::Added))+ });+ let touches_marks = edit.is_none_or(|e| {+ matches!(e, Edit::AddHeaderFooter { .. } | Edit::AddWatermark { .. } | Edit::AddBackground { .. } | Edit::RemoveMarks { .. })+ });+ (touches_added, touches_marks)+ }++ /// Rebuild working bytes, display bytes and renderer after a content-only edit: page+ /// content streams, resources and added content/marks. The page tree, annotations, form+ /// fields, links, outline and fonts are unchanged, so the full re-inspection (seconds on+ /// very large files) is skipped. `edit` selects which derived lists are re-read (`None`,+ /// from undo/redo, re-reads both: always correct, rarely paid). The cached display+ /// appearances are kept: content edits leave every annotation dictionary alone.+ fn refresh_content(doc: &mut Document, edit: Option<&Edit>) -> Result<(), EditError> {+ Self::release_working(doc);+ sync_xfa_state(doc);+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };+ let bytes = if editor.cos.is_modified() {+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)+ } else {+ editor.cos.bytes().clone()+ };+ // The edit must still leave a file the viewer can open; anything else rolls back above.+ pdfcraft_render::check_pages(bytes.clone(), doc.password.as_deref(), doc.info.pages.len()).map_err(|e| EditError::Reopen(e.to_string()))?;+ let (touches_added, touches_marks) = Self::content_refresh_lists(edit);+ if touches_added || touches_marks {+ doc.marker_scan = OnceLock::new();+ }+ doc.info.file_size = bytes.len();+ let signatures = if doc.signatures.is_empty() { Vec::new() } else { signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache) };+ doc.display = display_bytes(Some(editor), &bytes);+ doc.signatures = Arc::new(signatures);+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());+ doc.bytes = bytes;+ doc.fonts_stale = true;+ Ok(())+ }++ /// Let go of the working file before the next one is written (gap 13). The working file is+ /// the original plus one appended revision, so on a 1 GiB file keeping the old one (in the+ /// working bytes, the display bytes and the renderer) while writing the new one held three+ /// copies at once; this keeps two. Until the refresh finishes, the working and display bytes+ /// are the original's (already held by the editor, so free) and the renderer draws nothing.+ /// A failed edit rolls back and refreshes again, which replaces all three; where a refresh+ /// still fails, [`Self::show_released`] draws the original rather than nothing. Save writes+ /// from the editor, never from these.+ pub(crate) fn release_working(doc: &mut Document) {+ let Some(original) = doc.editor.as_ref().map(|e| e.cos.bytes().clone()) else { return };+ // Dropping the pool stops its workers; each lets go of the file when it exits.+ doc.renderer = RenderPool::new_inline(Arc::new(Vec::new()), doc.config.clone());+ doc.display = original.clone();+ doc.bytes = original;+ #[cfg(test)]+ check_refresh_panic();+ }++ /// After a refresh failed: draw the display bytes it left (the original, once released),+ /// so the page still shows a document.+ fn show_released(doc: &mut Document) {+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());+ }++ /// Rebuild working bytes, inspection and renderer from the current edit state.+ pub(crate) fn refresh(doc: &mut Document) -> Result<(), EditError> {+ Self::refresh_with_indexes(doc, true, true)+ }++ /// Reinspect a link edit while preserving the page-content marker scan cache.+ fn refresh_links(doc: &mut Document) -> Result<(), EditError> {+ Self::refresh_with_indexes(doc, false, true)+ }++ fn refresh_with_indexes(doc: &mut Document, invalidate_markers: bool, invalidate_links: bool) -> Result<(), EditError> {+ // A full refresh may follow structural or annotation changes: cached appearances+ // may be stale, so they are rebuilt below.+ if let Some(editor) = doc.editor.as_mut() {+ editor.appearances.clear();+ }+ Self::release_working(doc);+ sync_xfa_state(doc);+ let Some(editor) = doc.editor.as_mut() else { return Ok(()) };+ let bytes = if editor.cos.is_modified() {+ Arc::new(write_incremental(&editor.cos, &SaveOptions::default()).map_err(|e| EditError::Write(e.to_string()))?)+ } else {+ editor.cos.bytes().clone()+ };+ let info = inspect(bytes.clone(), doc.password.as_deref()).map_err(|e| EditError::Reopen(e.to_string()))?;+ // Keep the user's layer choices where the layers still exist.+ let mut info = info;+ for l in &mut info.layers {+ if let Some(old) = doc.info.layers.iter().find(|o| o.id == l.id) {+ l.visible = old.visible;+ }+ }+ note_warnings(&mut info.warnings, &doc.xfa_warnings);+ // As in `build_document`: the inspection reads only `/Info`, so fields stated only in XMP+ // are filled in again after every full refresh.+ for (field, value) in info_fields(&mut info, &editor.cos) {+ if field.is_none() {+ *field = value;+ }+ }+ doc.info = info;+ doc.fonts_stale = false;+ let mut form = pdfcraft_forms::fields(&editor.cos);+ xfa::mark_script_buttons(&editor.cos, &mut form);+ doc.form = Arc::new(form);+ if invalidate_markers {+ doc.marker_scan = OnceLock::new();+ }+ if invalidate_links {+ doc.links = OnceLock::new();+ }+ let signatures = signatures_of(&editor.cos, &bytes, &doc.trust, &doc.sig_cache);+ doc.display = display_bytes(Some(editor), &bytes);+ doc.signatures = Arc::new(signatures);+ doc.renderer = RenderPool::new(doc.display.clone(), render_threads(), doc.config.clone());+ doc.bytes = bytes;+ Ok(())+ }++ /// The bytes to write for Save: an incremental update of the file as opened/last saved,+ /// with `/ModDate` stamped. Call `mark_saved` after writing them successfully.+ ///+ /// A file whose cross-reference data had to be rebuilt is written in full even when nothing+ /// was edited: its bytes as opened are the damaged file, and this save is how the repair the+ /// user was told about reaches the disk (#1937). Not a signed one: a full rewrite would+ /// break its signatures, so with no edits it keeps its bytes, damage and all.+ pub fn save_bytes(&self, id: DocId) -> Result<Arc<Vec<u8>>, EditError> {+ let doc = self.get(id).ok_or(EditError::NoDocument)?;+ let Some(editor) = doc.editor.as_ref() else { return Ok(doc.bytes.clone()) };+ let on_saved = Arc::ptr_eq(editor.cos.bytes(), &editor.saved);+ if !editor.cos.is_modified() && on_saved && (!editor.cos.reconstructed() || doc.is_signed()) {+ return Ok(editor.saved.clone());+ }+ // What the user removed again before saving (a cleared redaction mark) stays out of the file.+ let opts = SaveOptions { mod_date: self.now().map(pdfcraft_cos::pdf_date), drop_unlinked: true, ..SaveOptions::default() };+ // A restored snapshot can be based on an earlier revision. Append to the last saved+ // file so that revision stays in the chain. A full rewrite (redaction, new encryption,+ // a reconstructed file) still writes the current graph on its own.+ let rewrite = editor.cos.full_save_required() || editor.cos.encryption_changed() || editor.cos.revisions().is_empty();+ let cos = writable(&editor.cos)?;+ 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.rsindex 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();