Skip to content

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

refactor(engine): move Document and its display helpers to document.rs

alehelff361fe13837
diff --git a/crates/engine/src/document.rs b/crates/engine/src/document.rs
new file mode 100644
index 000000000..0c85f51af
--- /dev/null
+++ b/crates/engine/src/document.rs
@@ -0,0 +1,713 @@
+//! 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`] 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>,
+}
+
+/// 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()
+ }
+
+ /// 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`]) 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`], 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 --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 91d22accd..15f6629e0 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -23,6 +23,7 @@ pub mod commands;
pub mod compare;
mod copy_image;
pub mod dates;
+mod document;
mod edit;
mod error;
pub mod export;
@@ -135,7 +136,7 @@ pub fn merge_data_files(files: &[(String, Vec<u8>)]) -> Result<String, String> {
/// One file produced by a split: (1-based first page, last page, PDF bytes).
pub type SplitPart = (usize, usize, Arc<Vec<u8>>);
-use std::sync::{Arc, OnceLock};
+use std::sync::Arc;
#[cfg(test)]
thread_local! {
@@ -185,14 +186,14 @@ fn record_link_scan() {
});
}
+pub use document::{Document, TextNotice, display_bytes_for, render_password_for};
+use document::{display_bytes, info_fields, recovered_render_password, same_pages, shown_under_redactions, undrawn_notices};
use edit::EditCtx;
pub use edit::{BATCH_LABELS, EDIT_LABELS, Edit};
pub use error::{EditError, SourceProblem};
-use history::Editor;
pub use history::Label;
pub use open::{OpenContext, PreparedDocument};
-use pdfcraft_cos::{SaveOptions, write_incremental};
-use pdfcraft_render::{DocInfo, Layer, LayerOp, RenderConfig, RenderPool};
+use pdfcraft_render::{Layer, LayerOp, RenderPool};
use protection::unrestricted;
pub use protection::{Changes, Printing, Protection, SecuritySummary};
pub use session::Session;
@@ -205,705 +206,6 @@ pub struct DocId(pub u64);
/// clear) is printed at.
const LOW_RESOLUTION_PRINT_DPI: f64 = 150.0;
-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.
- generation: u64,
- /// The generation last handed out by `autosave_snapshots`.
- 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>>,
- marker_scan: OnceLock<pdfcraft_edit::MarkerScan>,
- links: OnceLock<Vec<pdfcraft_annot::links::LinkItem>>,
- /// Signature fields, validated against the session's trust store (Signatures panel).
- pub signatures: Arc<Vec<SignatureInfo>>,
- trust: Arc<TrustStore>,
- sig_cache: Arc<pdfcraft_sign::DigestCache>,
- editor: Option<Editor>,
- config: RenderConfig,
- /// What field scripts printed or asked for (see [`Session::take_js_output`]).
- 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.
- 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`]).
- 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`]).
- 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`] 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>,
-}
-
-/// 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.
-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()
- }
-
- /// 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`]) 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.
-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.
-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.
-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.
-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`], 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.
-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.
-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(())
-}
-
fn render_threads() -> usize {
std::thread::available_parallelism().map(std::num::NonZeroUsize::get).unwrap_or(4).clamp(2, 8) - 1
}
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index d06faefc8..a30d81b74 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -1,5 +1,6 @@
use std::sync::Arc;
+use super::document::is_placeholder_title;
use super::edit::check_permission;
use super::*;
use pdfcraft_render::{OpenError, ReadingColors};