Skip to content

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

Refactor edit for strict Clippy checks

Dylan M. Taylorde73c35e174a
diff --git a/crates/edit/src/added/draw.rs b/crates/edit/src/added/draw.rs
index 0fc7aa510..61297bcf2 100644
--- a/crates/edit/src/added/draw.rs
+++ b/crates/edit/src/added/draw.rs
@@ -2,7 +2,10 @@ use super::layout::{
Piece, arabic_error, hebrew_error, is_arabic, is_hebrew, is_thai, latin_width, lines, norm, shaped_layout, text_rect, thai_error, wrapped,
};
use super::types::{AddedText, Align, Family};
-use super::*;
+use super::{
+ Content, Dict, Document, EditError, GlyphError, GlyphOutline, HashMap, HashSet, ObjRef, Object, PdfString, ShapedCluster, ShapedScript, Stream,
+ literal, matrix_number, n, shaped_glyph, win_ansi,
+};
fn font_name(base: &str) -> String {
format!("PCF{}", base.replace('-', ""))
diff --git a/crates/edit/src/added/layout.rs b/crates/edit/src/added/layout.rs
index 0e971b92c..67d80be40 100644
--- a/crates/edit/src/added/layout.rs
+++ b/crates/edit/src/added/layout.rs
@@ -1,5 +1,8 @@
use super::types::{AddedImage, AddedText};
-use super::*;
+use super::{
+ Content, Document, EditError, GlyphError, Level, ObjRef, Object, ParagraphBidiInfo, ShapedCluster, ShapedScript, shape_arabic, shape_hebrew,
+ shape_thai,
+};
pub(super) fn nums(doc: &Document, o: Option<&Object>) -> Vec<f64> {
o.map(|o| doc.resolve(o)).and_then(|a| a.as_array().map(|a| a.iter().filter_map(Object::as_f64).collect())).unwrap_or_default()
diff --git a/crates/edit/src/added/store.rs b/crates/edit/src/added/store.rs
index b89d42900..5ce5e15d1 100644
--- a/crates/edit/src/added/store.rs
+++ b/crates/edit/src/added/store.rs
@@ -1,7 +1,7 @@
use super::draw::{draw, params};
use super::layout::{first_undrawable, is_thai, nums, shaped_arabic, thai_error};
use super::types::{Added, AddedImage, AddedText, Align, CHAR_SPACING_LIMIT, Family, MarkerScan, TAG};
-use super::*;
+use super::{Content, Dict, Document, EditError, GlyphError, MarkKind, ObjRef, Object, Stream, check, contents, page_list, place_tagged};
fn parse(doc: &Document, d: &Dict) -> Option<Content> {
let r = nums(doc, d.get(b"Rect"));
diff --git a/crates/edit/src/added/types.rs b/crates/edit/src/added/types.rs
index 0a9f92f92..28b61d586 100644
--- a/crates/edit/src/added/types.rs
+++ b/crates/edit/src/added/types.rs
@@ -1,5 +1,5 @@
use super::layout::norm;
-use super::*;
+use super::{Content, MarkKind, ObjRef, Std14};
pub(super) const TAG: &str = "Added";
diff --git a/crates/edit/src/apply.rs b/crates/edit/src/apply.rs
index 1461dc78e..427f51f94 100644
--- a/crates/edit/src/apply.rs
+++ b/crates/edit/src/apply.rs
@@ -5,7 +5,7 @@ use super::place::{
END, Isolation, add_page_resources, add_resources, begin, check, check_on_top, contents, free_font_name, isolation, page_fonts, page_list, place,
place_inside_wrapper, stream_tag, text_op, undrawable, wrapper_role,
};
-use super::*;
+use super::{Document, EditError, Object, added, helvetica_width};
/// Add a header and footer to `pages` (0-based). With `replace`, existing headers and footers on
/// those pages are removed first (Acrobat's Replace Existing).
diff --git a/crates/edit/src/marks.rs b/crates/edit/src/marks.rs
index 507e2afa8..00c53ec27 100644
--- a/crates/edit/src/marks.rs
+++ b/crates/edit/src/marks.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Document, EditError, Object, Rgb, added};
/// The kinds of page marks.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
diff --git a/crates/edit/src/place.rs b/crates/edit/src/place.rs
index b6d50a646..2f2c24c86 100644
--- a/crates/edit/src/place.rs
+++ b/crates/edit/src/place.rs
@@ -1,5 +1,5 @@
use super::marks::{MarkKind, matrix_number, n};
-use super::*;
+use super::{Dict, Document, EditError, ObjRef, Object, Stream, literal, win_ansi};
pub(crate) fn page_list(doc: &Document) -> Vec<pdfcraft_model::Page> {
pdfcraft_model::pages(doc)
diff --git a/crates/edit/src/tests.rs b/crates/edit/src/tests.rs
index 0f8adc651..7c78d31fc 100644
--- a/crates/edit/src/tests.rs
+++ b/crates/edit/src/tests.rs
@@ -6664,93 +6664,136 @@ fn actual_text_pairs_past_the_marked_content_cap() {
}
}
-/// #2992: the colour a page is painted with before anything else is its background, for exports
-/// that keep a page colour. Edit a PDF ▸ Background's fill is found under the text it goes
-/// behind; a page that paints anything else first, a fill that doesn't cover the page, a
-/// translucent or clipped one, or a colour that isn't plain gray, RGB or CMYK has none.
-#[test]
-fn a_page_painted_first_with_a_full_page_fill_has_that_background() {
- let mut doc = fixture();
- assert_eq!(page_background(&doc, 0).unwrap(), None, "text first");
- add_background(&mut doc, &[0, 1], &Background { color: [0.0, 0.5, 0.5], opacity: 1.0, ..Background::default() }, false).unwrap();
- let doc = reopen(&doc);
- let teal = page_background(&doc, 0).unwrap().expect("Background's fill");
- assert!(teal.iter().zip([0.0, 0.5, 0.5]).all(|(a, b)| (a - b).abs() < 1e-6), "{teal:?}");
- assert!(page_background(&doc, 1).unwrap().is_some(), "on a turned page too");
- assert_eq!(page_background(&doc, 2).unwrap(), None, "a page with no content");
- assert!(page_background(&doc, 9).is_err());
-
- let page = |content: &str, resources: &str| {
- let objs: Vec<String> = vec![
- "<< /Type /Catalog /Pages 2 0 R >>".into(),
- "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".into(),
- format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 600 800] /CropBox [0 0 500 700] /Contents 4 0 R /Resources << {resources} >> >>"),
- format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len()),
- ];
- let mut out = b"%PDF-1.7\n".to_vec();
- let mut offs = Vec::new();
- for (i, o) in objs.iter().enumerate() {
- offs.push(out.len());
- out.extend_from_slice(format!("{} 0 obj\n{o}\nendobj\n", i + 1).as_bytes());
- }
- let x = out.len();
- out.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
- for o in offs {
- out.extend_from_slice(format!("{o:010} 00000 n \n").as_bytes());
- }
- out.extend_from_slice(format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{x}\n%%EOF\n").as_bytes());
- page_background(&Document::open(Arc::new(out)).unwrap(), 0).unwrap()
- };
- let gs = "/ExtGState << /Half << /ca 0.5 >> /Mul << /BM /Multiply >> /Full << /ca 1 /SMask /None >> >>";
- assert_eq!(page("1 g 0 0 600 800 re f", ""), Some([1.0; 3]), "a producer's white page fill");
- assert_eq!(page("0 0 1 0 k 0 0 500 700 re f", ""), Some([1.0, 1.0, 0.0]), "CMYK, covering the crop box");
- assert_eq!(page("/DeviceRGB cs 1 0 0 sc 0 0 500 700 re f", ""), Some([1.0, 0.0, 0.0]), "cs and sc");
- assert_eq!(page("/Full gs q 2 0 0 2 0 0 cm 0 1 0 rg 0 0 300 400 re f Q", gs), Some([0.0, 1.0, 0.0]), "under a cm");
- assert_eq!(page("1 0 0 rg 0 0 300 800 re f", ""), None, "half the page");
- assert_eq!(page("1 0 0 rg 0 0 300 800 re 300 0 300 800 re f", ""), None, "two halves are not one covering rectangle");
- assert_eq!(page("1 0 0 rg 0 0 300 800 re 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "one of the rectangles covers it");
+fn page_background_from_content(content: &str, resources: &str) -> Option<[f64; 3]> {
+ let objects = [
+ "<< /Type /Catalog /Pages 2 0 R >>".to_string(),
+ "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string(),
+ format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 600 800] /CropBox [0 0 500 700] /Contents 4 0 R /Resources << {resources} >> >>"),
+ format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len()),
+ ];
+ let mut bytes = b"%PDF-1.7\n".to_vec();
+ let mut offsets = Vec::new();
+ for (index, object) in objects.iter().enumerate() {
+ offsets.push(bytes.len());
+ bytes.extend_from_slice(format!("{} 0 obj\n{object}\nendobj\n", index + 1).as_bytes());
+ }
+ let xref_offset = bytes.len();
+ bytes.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
+ for offset in offsets {
+ bytes.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
+ }
+ bytes.extend_from_slice(format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());
+ page_background(&Document::open(Arc::new(bytes)).unwrap(), 0).unwrap()
+}
+
+fn assert_page_background_fill_cases(gs: &str) {
+ assert_eq!(page_background_from_content("1 g 0 0 600 800 re f", ""), Some([1.0; 3]), "a producer's white page fill");
+ assert_eq!(page_background_from_content("0 0 1 0 k 0 0 500 700 re f", ""), Some([1.0, 1.0, 0.0]), "CMYK, covering the crop box");
+ assert_eq!(page_background_from_content("/DeviceRGB cs 1 0 0 sc 0 0 500 700 re f", ""), Some([1.0, 0.0, 0.0]), "cs and sc");
+ assert_eq!(page_background_from_content("/Full gs q 2 0 0 2 0 0 cm 0 1 0 rg 0 0 300 400 re f Q", gs), Some([0.0, 1.0, 0.0]), "under a cm");
+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 300 800 re f", ""), None, "half the page");
+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 300 800 re 300 0 300 800 re f", ""), None, "two halves are not one covering rectangle");
+ assert_eq!(
+ page_background_from_content("1 0 0 rg 0 0 300 800 re 0 0 600 800 re f", ""),
+ Some([1.0, 0.0, 0.0]),
+ "one of the rectangles covers it"
+ );
// #2994 review: a second rectangle that cuts a hole: any one under even-odd, one wound the
// other way under nonzero.
- assert_eq!(page("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f*", ""), None, "even-odd hole");
- assert_eq!(page("1 0 0 rg 0 0 600 800 re 300 100 -200 200 re f", ""), None, "nonzero, reversed inner rectangle");
- assert_eq!(page("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f", ""), Some([1.0, 0.0, 0.0]), "nonzero, same winding: no hole");
- assert_eq!(page("1 0 0 rg q -1 0 0 1 600 0 cm 0 0 600 800 re Q 100 100 200 200 re f", ""), None, "reversed by a mirroring cm");
- assert_eq!(page("/Half gs 1 0 0 rg 0 0 600 800 re f", gs), None, "translucent");
- assert_eq!(page("/Mul gs 1 0 0 rg 0 0 600 800 re f", gs), None, "blended");
- assert_eq!(page("0 0 100 100 re W n 1 0 0 rg 0 0 600 800 re f", ""), None, "clipped to a corner");
- assert_eq!(page("0 0 600 800 re W n 1 0 0 rg 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "a page-sized clip");
- assert_eq!(page("/Pattern cs /P1 scn 0 0 600 800 re f", ""), None, "a pattern");
- assert_eq!(page("BT ET 0 0 600 800 re S 1 0 0 rg 0 0 600 800 re f", ""), None, "a stroke first");
- assert_eq!(page("0 0 m 600 0 l 600 800 l 0 800 l h f", ""), None, "a path that isn't a rectangle");
- assert_eq!(page("1 0 0 rg 0 0 600 800 re 100 100 m 200 100 l 200 200 l h f*", ""), None, "a page fill with a hole cut in it");
+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f*", ""), None, "even-odd hole");
+ assert_eq!(page_background_from_content("1 0 0 rg 0 0 600 800 re 300 100 -200 200 re f", ""), None, "nonzero, reversed inner rectangle");
+ assert_eq!(
+ page_background_from_content("1 0 0 rg 0 0 600 800 re 100 100 200 200 re f", ""),
+ Some([1.0, 0.0, 0.0]),
+ "nonzero, same winding: no hole"
+ );
+ assert_eq!(
+ page_background_from_content("1 0 0 rg q -1 0 0 1 600 0 cm 0 0 600 800 re Q 100 100 200 200 re f", ""),
+ None,
+ "reversed by a mirroring cm"
+ );
+ assert_eq!(page_background_from_content("/Half gs 1 0 0 rg 0 0 600 800 re f", gs), None, "translucent");
+ assert_eq!(page_background_from_content("/Mul gs 1 0 0 rg 0 0 600 800 re f", gs), None, "blended");
+ assert_eq!(page_background_from_content("0 0 100 100 re W n 1 0 0 rg 0 0 600 800 re f", ""), None, "clipped to a corner");
+ assert_eq!(page_background_from_content("0 0 600 800 re W n 1 0 0 rg 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "a page-sized clip");
+ assert_eq!(page_background_from_content("/Pattern cs /P1 scn 0 0 600 800 re f", ""), None, "a pattern");
+ assert_eq!(page_background_from_content("BT ET 0 0 600 800 re S 1 0 0 rg 0 0 600 800 re f", ""), None, "a stroke first");
+ assert_eq!(page_background_from_content("0 0 m 600 0 l 600 800 l 0 800 l h f", ""), None, "a path that isn't a rectangle");
+ assert_eq!(
+ page_background_from_content("1 0 0 rg 0 0 600 800 re 100 100 m 200 100 l 200 200 l h f*", ""),
+ None,
+ "a page fill with a hole cut in it"
+ );
+}
+
+fn assert_page_background_transform_and_clip_cases() {
// #2994 review: a rectangle turned 45° about the crop box's centre covers it only if the crop
// box's corners are inside it; its bounding box covering the crop box isn't enough. This one
// reaches 500 from the centre along each axis (its box covers the 500 × 700 crop box) but
// 354 along the diagonals, short of the corners. One reaching 707 covers them.
let turned = "0.70710678 0.70710678 -0.70710678 0.70710678 250 350 cm";
- assert_eq!(page(&format!("1 0 0 rg {turned} -353.553 -353.553 707.107 707.107 re f"), ""), None, "a turned fill short of the corners");
- assert_eq!(page(&format!("1 0 0 rg {turned} -500 -500 1000 1000 re f"), ""), Some([1.0, 0.0, 0.0]), "a turned fill over them");
+ assert_eq!(
+ page_background_from_content(&format!("1 0 0 rg {turned} -353.553 -353.553 707.107 707.107 re f"), ""),
+ None,
+ "a turned fill short of the corners"
+ );
+ assert_eq!(
+ page_background_from_content(&format!("1 0 0 rg {turned} -500 -500 1000 1000 re f"), ""),
+ Some([1.0, 0.0, 0.0]),
+ "a turned fill over them"
+ );
// The same for a clip.
- assert_eq!(page(&format!("{turned} -353.553 -353.553 707.107 707.107 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""), None, "a turned clip");
assert_eq!(
- page(&format!("{turned} -500 -500 1000 1000 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""),
+ page_background_from_content(&format!("{turned} -353.553 -353.553 707.107 707.107 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""),
+ None,
+ "a turned clip"
+ );
+ assert_eq!(
+ page_background_from_content(&format!("{turned} -500 -500 1000 1000 re W n 1 0 0 rg -2000 -2000 4000 4000 re f"), ""),
Some([1.0, 0.0, 0.0]),
"a turned clip over the corners"
);
// Clips add up: two that each cover the page leave it covered, one that doesn't among them
// doesn't.
- assert_eq!(page("0 0 600 800 re W n 0 0 550 750 re W n 1 0 0 rg 0 0 600 800 re f", ""), Some([1.0, 0.0, 0.0]), "two covering clips");
- assert_eq!(page("0 0 600 800 re W n 0 0 300 750 re W n 1 0 0 rg 0 0 600 800 re f", ""), None, "the second clip doesn't cover");
+ assert_eq!(
+ page_background_from_content("0 0 600 800 re W n 0 0 550 750 re W n 1 0 0 rg 0 0 600 800 re f", ""),
+ Some([1.0, 0.0, 0.0]),
+ "two covering clips"
+ );
+ assert_eq!(
+ page_background_from_content("0 0 600 800 re W n 0 0 300 750 re W n 1 0 0 rg 0 0 600 800 re f", ""),
+ None,
+ "the second clip doesn't cover"
+ );
// Past 64 clipping rectangles the clip counts as unknown.
let clips = "0 0 600 800 re W n ".repeat(65);
- assert_eq!(page(&format!("{clips}1 0 0 rg 0 0 600 800 re f"), ""), None, "too many clips to follow");
+ assert_eq!(page_background_from_content(&format!("{clips}1 0 0 rg 0 0 600 800 re f"), ""), None, "too many clips to follow");
// A rectangle drawn the other way round (negative width) covers the page all the same.
- assert_eq!(page("1 0 0 rg 600 0 -600 800 re f", ""), Some([1.0, 0.0, 0.0]), "drawn clockwise");
+ assert_eq!(page_background_from_content("1 0 0 rg 600 0 -600 800 re f", ""), Some([1.0, 0.0, 0.0]), "drawn clockwise");
// The crop box counts as covered within half a percent of its size (2.5 × 3.5 here), the
// edge of that included.
- assert_eq!(page("1 0 0 rg 2 3 496 694 re f", ""), Some([1.0, 0.0, 0.0]), "within the tolerance");
- assert_eq!(page("1 0 0 rg 2.5 3.5 495 693 re f", ""), Some([1.0, 0.0, 0.0]), "on the tolerance's edge");
- assert_eq!(page("1 0 0 rg 3 4 494 692 re f", ""), None, "past the tolerance");
+ assert_eq!(page_background_from_content("1 0 0 rg 2 3 496 694 re f", ""), Some([1.0, 0.0, 0.0]), "within the tolerance");
+ assert_eq!(page_background_from_content("1 0 0 rg 2.5 3.5 495 693 re f", ""), Some([1.0, 0.0, 0.0]), "on the tolerance's edge");
+ assert_eq!(page_background_from_content("1 0 0 rg 3 4 494 692 re f", ""), None, "past the tolerance");
+}
+
+/// #2992: page background detection follows the first full-page fill under text and ignores
+/// partial, translucent, clipped, or unsupported fills.
+#[test]
+fn a_page_painted_first_with_a_full_page_fill_has_that_background() {
+ let gs = "/ExtGState << /Half << /ca 0.5 >> /Mul << /BM /Multiply >> /Full << /ca 1 /SMask /None >> >>";
+ let mut doc = fixture();
+ assert_eq!(page_background(&doc, 0).unwrap(), None, "text first");
+ add_background(&mut doc, &[0, 1], &Background { color: [0.0, 0.5, 0.5], opacity: 1.0, ..Background::default() }, false).unwrap();
+ let doc = reopen(&doc);
+ let teal = page_background(&doc, 0).unwrap().expect("Background's fill");
+ assert!(teal.iter().zip([0.0, 0.5, 0.5]).all(|(a, b)| (a - b).abs() < 1e-6), "{teal:?}");
+ assert!(page_background(&doc, 1).unwrap().is_some(), "on a turned page too");
+ assert_eq!(page_background(&doc, 2).unwrap(), None, "a page with no content");
+ assert!(page_background(&doc, 9).is_err());
+
+ assert_page_background_fill_cases(gs);
+ assert_page_background_transform_and_clip_cases();
}
#[test]
diff --git a/crates/edit/src/text/blocks.rs b/crates/edit/src/text/blocks.rs
index 8d3d224da..615e7699a 100644
--- a/crates/edit/src/text/blocks.rs
+++ b/crates/edit/src/text/blocks.rs
@@ -1,7 +1,7 @@
use super::interp::{Carry, interpret};
use super::lines::{content_streams, page_dict, reading_lines, rewritten_contents, splice, text_lines};
use super::rewrite::{LineEdit, coincident_ops, rewrite_block};
-use super::*;
+use super::{Document, EditError, HashMap, Object, Op, Pieces, TextLine, group_blocks, regions};
/// An editable text region: adjacent runs on visual rows, followed by aligned rows.
/// A region may contain several source fonts, sizes, colours and weights.
diff --git a/crates/edit/src/text/editor.rs b/crates/edit/src/text/editor.rs
index b2bd2b9f9..f7aa1f47b 100644
--- a/crates/edit/src/text/editor.rs
+++ b/crates/edit/src/text/editor.rs
@@ -2,7 +2,7 @@ use super::blocks::{BlockStyle, TextBlock};
use super::fallback::MAX_TYPE3_GLYPHS;
use super::lines::{page_dict, text_lines};
use super::rewrite::rewrite_block_from;
-use super::*;
+use super::{DecodeBudget, Document, EditError, Metrics, Object, TextLine, TextSession};
/// An embedded sfnt source face, read only for the inline editor. Bytes stay in memory and
/// are never installed, copied into assets, or used as a font for another document.
diff --git a/crates/edit/src/text/fallback.rs b/crates/edit/src/text/fallback.rs
index 0c19a6680..b8f45a221 100644
--- a/crates/edit/src/text/fallback.rs
+++ b/crates/edit/src/text/fallback.rs
@@ -1,6 +1,8 @@
use super::interp::Ts;
use super::lines::page_dict;
-use super::*;
+use super::{
+ CraftFont, Dict, Document, EditError, GlyphError, HashMap, Metrics, Object, Op, PdfString, Stream, TextLine, japanese_glyph_from, parse,
+};
/// Text → the runs that show it: each run's font resource name and the bytes shown in that font.
pub(super) type Encoder = Box<dyn Fn(&str) -> Option<Vec<(String, Vec<u8>)>>>;
diff --git a/crates/edit/src/text/interp.rs b/crates/edit/src/text/interp.rs
index ca0d63cef..e4248aede 100644
--- a/crates/edit/src/text/interp.rs
+++ b/crates/edit/src/text/interp.rs
@@ -1,6 +1,6 @@
use super::fallback::is_type3_fallback;
use super::rewrite::vertical_advance;
-use super::*;
+use super::{Dict, Document, EditError, HashMap, Matrix, Metrics, Object, Op, Rc};
/// Text and graphics state captured for rewriting.
#[derive(Clone, Debug, PartialEq)]
@@ -472,6 +472,280 @@ type CachedFont = (Rc<Metrics>, Option<String>, Result<Option<f64>, String>);
/// A `Do` met while interpreting: its operator index, XObject name and the state there.
type Invocation = (usize, Vec<u8>, Ts);
+#[derive(Default)]
+struct MarkedContent {
+ regions: Vec<Option<usize>>,
+ layers: Vec<Option<Vec<u8>>>,
+ actual_text: Vec<Option<(usize, usize, String)>>,
+}
+
+impl MarkedContent {
+ fn begin(&mut self, doc: &Document, op: &Op, index: usize, logical_text: Option<&Dict>, shown_count: usize) {
+ // Marked text paragraphs/headings are authoritative boundaries. Ignore artifacts and
+ // inner spans, which inherit their enclosing region.
+ let region = matches!(op.name(0), Some(b"P" | b"H" | b"H1" | b"H2" | b"H3" | b"H4" | b"H5" | b"H6" | b"LI" | b"TD" | b"TH"));
+ self.regions.push(if region { Some(index) } else { self.regions.last().copied().flatten() });
+ // A layer named in the resources is told apart by its name, an inline one by where it opens.
+ let layer = op.is("BDC") && op.name(0) == Some(b"OC".as_slice());
+ self.layers
+ .push(layer.then(|| op.operands.get(1).and_then(Object::as_name).map_or_else(|| format!("@{index}").into_bytes(), <[u8]>::to_vec)));
+ // The property list is inline or named in the resources' /Properties (§14.6.2).
+ let list = logical_text.and_then(|properties| match op.operands.get(1) {
+ Some(Object::Name(name)) => properties.get(name).and_then(|object| doc.dict(object)),
+ other => other.and_then(Object::as_dict).cloned(),
+ });
+ let logical = list.as_ref().and_then(|dict| dict.get(b"ActualText")).and_then(|value| match value {
+ Object::String(value) if value.bytes.len() <= 4_000_000 => Some(value.to_text()),
+ _ => None,
+ });
+ self.actual_text.push(logical.map(|text| (shown_count, index, text)));
+ }
+
+ fn end(&mut self, index: usize, shown: &mut Vec<Shown>) {
+ self.regions.pop();
+ self.layers.pop();
+ if let Some(Some((start, open, logical))) = self.actual_text.pop() {
+ let tail = shown.split_off(start.min(shown.len()));
+ let mut items = tail.into_iter();
+ if let Some(mut first) = items.next() {
+ for item in items {
+ first.glyph_count = first.glyph_count.saturating_add(item.glyph_count);
+ first.extra_ops.push(item.op);
+ first.extra_ops.extend(item.extra_ops);
+ first.rect = [
+ first.rect[0].min(item.rect[0]),
+ first.rect[1].min(item.rect[1]),
+ first.rect[2].max(item.rect[2]),
+ first.rect[3].max(item.rect[3]),
+ ];
+ first.frame = union(first.frame, item.frame);
+ first.ink.extend(item.ink);
+ }
+ first.extra_ops.extend([open, index]);
+ // Only right-to-left ActualText is already in typing order and must stay out of
+ // bidi recovery. Word and Chrome also wrap Latin ligatures mid-word.
+ first.logical_order = logical.chars().any(crate::bidi::is_rtl);
+ first.actual_text = true;
+ first.text = logical;
+ first.start_x = first.rect[0];
+ first.end_x = first.rect[2];
+ first.end_y = first.baseline;
+ first.advance = (first.end_x - first.start_x) / first.tm.then(&first.state.ctm).0[0].abs().max(1e-6);
+ shown.push(first);
+ }
+ }
+ }
+}
+
+struct TextRunState<'a> {
+ ts: &'a mut Ts,
+ tm: &'a mut Matrix,
+ tlm: &'a mut Matrix,
+ at_bt: &'a (usize, Ts),
+ bt: usize,
+ marked: &'a MarkedContent,
+ carry: &'a mut Carry,
+ out: &'a mut Vec<Shown>,
+}
+
+fn show_text(op: &Op, i: usize, state: &mut TextRunState<'_>) -> Result<(), EditError> {
+ let ts = &mut *state.ts;
+ let tm = &mut *state.tm;
+ let tlm = &mut *state.tlm;
+ let at_bt = state.at_bt;
+ let bt = state.bt;
+ let marked = state.marked;
+ let carry = &mut *state.carry;
+ let out = &mut *state.out;
+ if matches!(op.op.as_slice(), b"'" | b"\"") {
+ if op.is("\"") {
+ ts.word_spacing = op.num(0).unwrap_or(ts.word_spacing);
+ ts.char_spacing = op.num(1).unwrap_or(ts.char_spacing);
+ }
+ *tlm = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, -ts.leading]).then(tlm);
+ *tm = *tlm;
+ }
+ let Some((name, m)) = ts.font.clone() else { return Ok(()) };
+ // Pieces: strings, and TJ number adjustments.
+ let pieces: Vec<Object> = match op.op.as_slice() {
+ // A surplus array (`[(A)] [(B)] TJ`) is malformed, but the operator still
+ // takes the one immediately before it, as the renderer and every other
+ // reader here do (#3569) -- not the first, which a reader counting operands
+ // from the front of a surplus list would otherwise take.
+ b"TJ" => op.operands.last().and_then(Object::as_array).cloned().unwrap_or_default(),
+ _ => op.operands.last().cloned().into_iter().collect(),
+ };
+ // Tc is already included in the pen advance; TJ may encode tracking instead.
+ let tracking = if op.is("TJ") { tj_tracking(&pieces, &m, ts.size, ts.scale) } else { 0.0 };
+ let trm0 = tm.then(&ts.ctm);
+ let start = trm0.apply(0.0, ts.rise);
+ let mut text = String::new();
+ let mut decodable = true;
+ let mut x_text = 0.0;
+ // Vertical text (§9.4.4): the pen moves along y instead, and each glyph is centred
+ // on it horizontally; `half` is half the widest glyph.
+ let vertical = ts.vertical;
+ let (mut y_text, mut half) = (0.0, 0.0_f64);
+ // Where each word's glyphs start and end along the run (text space), and whether
+ // the next glyph continues the last word.
+ let mut words: Vec<(f64, f64)> = Vec::new();
+ let mut in_word = false;
+ let mut glyph_count = 0_usize;
+ for p in &pieces {
+ match p {
+ Object::String(s) => {
+ for (code, len) in m.codes(&s.bytes) {
+ glyph_count = glyph_count.saturating_add(1);
+ let shown = m.text_of(code);
+ let blank = m.is_space(code, len) || shown.as_deref().is_some_and(|t| !t.is_empty() && t.chars().all(char::is_whitespace));
+ match shown {
+ Some(t) => {
+ carry.text_left = carry
+ .text_left
+ .checked_sub(t.len())
+ .ok_or_else(|| EditError::Invalid("the page's text is too large to read".into()))?;
+ text.push_str(&t);
+ }
+ None => decodable = false,
+ }
+ let spacing = ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };
+ if let Some(w1) = vertical {
+ half = half.max((m.width(code) * ts.size * ts.scale).abs() / 2.0);
+ if !blank {
+ let ink_end = y_text + w1 * ts.size;
+ let (lo, hi) = (y_text.min(ink_end), y_text.max(ink_end));
+ match words.last_mut() {
+ Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),
+ _ => words.push((lo, hi)),
+ }
+ }
+ in_word = !blank;
+ y_text += w1 * ts.size + spacing;
+ continue;
+ }
+ if !blank {
+ let ink_end = x_text + m.width(code) * ts.size * ts.scale;
+ // A negative font size or `Tz` runs the glyphs backwards:
+ // the word is the union of its glyphs, whichever way they go.
+ let (lo, hi) = (x_text.min(ink_end), x_text.max(ink_end));
+ match words.last_mut() {
+ Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),
+ _ => words.push((lo, hi)),
+ }
+ }
+ in_word = !blank;
+ let w = m.width(code) * ts.size + ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };
+ x_text += w * ts.scale;
+ }
+ }
+ other => {
+ if let Some(n) = other.as_f64() {
+ if vertical.is_some() {
+ // Down by n/1000 em, not scaled by `Tz`.
+ let dy = -n / 1000.0 * ts.size;
+ if -dy > ts.size * 0.2 && !text.ends_with(' ') {
+ text.push(' ');
+ }
+ if dy.abs() > ts.size.abs() * 0.2 {
+ in_word = false;
+ }
+ y_text += dy;
+ continue;
+ }
+ let dx = -n / 1000.0 * ts.size * ts.scale;
+ // A large gap inside TJ reads as a space.
+ if dx - tracking > (ts.size * ts.scale).abs() * 0.2 && !text.ends_with(' ') {
+ text.push(' ');
+ }
+ // Tracking and kerning keep a word together; a larger jump
+ // ends it (whatever the sign of the size or `Tz`).
+ if dx - tracking > (ts.size * ts.scale).abs() * 0.2 || dx < -(ts.size * ts.scale).abs() * 0.2 {
+ in_word = false;
+ }
+ x_text += dx;
+ }
+ }
+ }
+ }
+ *tm = Matrix([1.0, 0.0, 0.0, 1.0, x_text, y_text]).then(tm);
+ let end = tm.then(&ts.ctm).apply(0.0, ts.rise);
+ // The box from `a` to `b` along the run: from descent to ascent across it, or for
+ // vertical text, the widest glyph's width centred on the pen.
+ let span = |a: f64, b: f64| match vertical {
+ Some(_) => [trm0.apply(-half, ts.rise + a), trm0.apply(half, ts.rise + a), trm0.apply(-half, ts.rise + b), trm0.apply(half, ts.rise + b)],
+ None => [
+ trm0.apply(a, ts.rise + m.descent * ts.size),
+ trm0.apply(b, ts.rise + m.descent * ts.size),
+ trm0.apply(a, ts.rise + m.ascent * ts.size),
+ trm0.apply(b, ts.rise + m.ascent * ts.size),
+ ],
+ };
+ let corners = span(0.0, if vertical.is_some() { y_text } else { x_text });
+ let rect = corners.iter().fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);
+ // The same corners along and across the baseline: the run's own box, not its
+ // upright bounding box turned (which is wider by the box's height on a slant).
+ let dir = direction(&trm0);
+ let frame = corners
+ .iter()
+ .map(|&p| to_frame(dir, p))
+ .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);
+ let ink = words
+ .iter()
+ .map(|&(a, b)| {
+ span(a, b).iter().fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |r, p| [r[0].min(p.0), r[1].min(p.1), r[2].max(p.0), r[3].max(p.1)])
+ })
+ .collect();
+ let size_user = (trm0.0[2].powi(2) + trm0.0[3].powi(2)).sqrt() * ts.size;
+ // A numeric-only TJ adjusts the current text matrix but paints no glyphs.
+ // It must not create a phantom editable line or enlarge its neighbours' boxes.
+ if !pieces.iter().any(|p| matches!(p, Object::String(s) if !s.bytes.is_empty())) {
+ return Ok(());
+ }
+ out.push(Shown {
+ op: i,
+ extra_ops: Vec::new(),
+ glyph_count,
+ // Vertical text: the TJ adjustment that undoes the run is n = -1000 y / size; the
+ // preview divides by size × `Tz`, so `Tz` is put back here.
+ advance: if vertical.is_some() { y_text * ts.scale } else { x_text },
+ tracking: 0.0,
+ tm: Matrix([
+ tm.0[0],
+ tm.0[1],
+ tm.0[2],
+ tm.0[3],
+ tm.0[4] - x_text * tm.0[0] - y_text * tm.0[2],
+ tm.0[5] - x_text * tm.0[1] - y_text * tm.0[3],
+ ]),
+ state: ts.clone(),
+ tlm: *tlm,
+ bt_op: at_bt.0,
+ bt_state: at_bt.1.clone(),
+ text,
+ rect,
+ frame,
+ ink,
+ baseline: start.1,
+ start_x: start.0,
+ end_x: end.0,
+ end_y: end.1,
+ bt,
+ font: name,
+ base_font: m.base_font.clone(),
+ face: ts.face.clone(),
+ size: if size_user > 0.0 { size_user } else { ts.size },
+ bold: m.bold,
+ italic: m.italic,
+ visual_order: m.visual_order,
+ decodable,
+ scope: marked.regions.last().copied().flatten(),
+ paint: Paint { layers: marked.layers.iter().flatten().cloned().collect(), gs: ts.gs.clone() },
+ logical_order: false,
+ actual_text: false,
+ });
+ Ok(())
+}
+
pub(super) fn interpret(
doc: &Document,
ops: &[Op],
@@ -490,66 +764,17 @@ pub(super) fn interpret(
let mut stack: Vec<Ts> = std::mem::take(&mut carry.stack);
let (mut tm, mut tlm) = (Matrix::IDENTITY, Matrix::IDENTITY);
let mut bt = 0usize;
- let mut marked = std::mem::take(&mut carry.marked);
- let mut layers = std::mem::take(&mut carry.layers);
- let mut actual: Vec<Option<(usize, usize, String)>> = Vec::new();
+ let mut marked =
+ MarkedContent { regions: std::mem::take(&mut carry.marked), layers: std::mem::take(&mut carry.layers), ..MarkedContent::default() };
for (i, op) in ops.iter().enumerate() {
match op.op.as_slice() {
// No depth cap: every `EMC` pops, so a capped push would pair it with the enclosing
// sequence (#3573). Both stacks stay bounded by the number of operators.
b"BMC" | b"BDC" => {
- // Marked text paragraphs/headings are authoritative boundaries. Ignore
- // artifacts and inner spans, which inherit their enclosing region.
- let region = matches!(op.name(0), Some(b"P" | b"H" | b"H1" | b"H2" | b"H3" | b"H4" | b"H5" | b"H6" | b"LI" | b"TD" | b"TH"));
- marked.push(if region { Some(i) } else { marked.last().copied().flatten() });
- // A layer named in the resources is told apart by its name, an inline one by where it opens.
- let layer = op.is("BDC") && op.name(0) == Some(b"OC".as_slice());
- layers.push(layer.then(|| op.operands.get(1).and_then(Object::as_name).map_or_else(|| format!("@{i}").into_bytes(), <[u8]>::to_vec)));
- // The property list is inline or named in the resources' /Properties (§14.6.2).
- let list = logical_text.and_then(|properties| match op.operands.get(1) {
- Some(Object::Name(n)) => properties.get(n).and_then(|o| doc.dict(o)),
- other => other.and_then(Object::as_dict).cloned(),
- });
- let logical = list.as_ref().and_then(|d| d.get(b"ActualText")).and_then(|s| match s {
- Object::String(s) if s.bytes.len() <= 4_000_000 => Some(s.to_text()),
- _ => None,
- });
- actual.push(logical.map(|s| (out.len(), i, s)));
+ marked.begin(doc, op, i, logical_text, out.len());
}
b"EMC" => {
- marked.pop();
- layers.pop();
- if let Some(Some((start, open, logical))) = actual.pop() {
- let tail = out.split_off(start.min(out.len()));
- let mut items = tail.into_iter();
- if let Some(mut first) = items.next() {
- for shown in items {
- first.glyph_count = first.glyph_count.saturating_add(shown.glyph_count);
- first.extra_ops.push(shown.op);
- first.extra_ops.extend(shown.extra_ops);
- first.rect = [
- first.rect[0].min(shown.rect[0]),
- first.rect[1].min(shown.rect[1]),
- first.rect[2].max(shown.rect[2]),
- first.rect[3].max(shown.rect[3]),
- ];
- first.frame = union(first.frame, shown.frame);
- first.ink.extend(shown.ink);
- }
- first.extra_ops.extend([open, i]);
- // Only right-to-left ActualText is already in typing order and must stay
- // out of the line's bidi recovery. Word and Chrome wrap Latin ligatures
- // (`fi`, `fl`) in ActualText spans mid-word; those keep joining their line.
- first.logical_order = logical.chars().any(crate::bidi::is_rtl);
- first.actual_text = true;
- first.text = logical;
- first.start_x = first.rect[0];
- first.end_x = first.rect[2];
- first.end_y = first.baseline;
- first.advance = (first.end_x - first.start_x) / first.tm.then(&first.state.ctm).0[0].abs().max(1e-6);
- out.push(first);
- }
- }
+ marked.end(i, &mut out);
}
b"q" => stack.push(ts.clone()),
b"Q" => {
@@ -650,207 +875,16 @@ pub(super) fn interpret(
tm = tlm;
}
b"Tj" | b"TJ" | b"'" | b"\"" => {
- if matches!(op.op.as_slice(), b"'" | b"\"") {
- if op.is("\"") {
- ts.word_spacing = op.num(0).unwrap_or(ts.word_spacing);
- ts.char_spacing = op.num(1).unwrap_or(ts.char_spacing);
- }
- tlm = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, -ts.leading]).then(&tlm);
- tm = tlm;
- }
- let Some((name, m)) = ts.font.clone() else { continue };
- // Pieces: strings, and TJ number adjustments.
- let pieces: Vec<Object> = match op.op.as_slice() {
- // A surplus array (`[(A)] [(B)] TJ`) is malformed, but the operator still
- // takes the one immediately before it, as the renderer and every other
- // reader here do (#3569) -- not the first, which a reader counting operands
- // from the front of a surplus list would otherwise take.
- b"TJ" => op.operands.last().and_then(Object::as_array).cloned().unwrap_or_default(),
- _ => op.operands.last().cloned().into_iter().collect(),
- };
- // Tc is already included in the pen advance; TJ may encode tracking instead.
- let tracking = if op.is("TJ") { tj_tracking(&pieces, &m, ts.size, ts.scale) } else { 0.0 };
- let trm0 = tm.then(&ts.ctm);
- let start = trm0.apply(0.0, ts.rise);
- let mut text = String::new();
- let mut decodable = true;
- let mut x_text = 0.0;
- // Vertical text (§9.4.4): the pen moves along y instead, and each glyph is centred
- // on it horizontally; `half` is half the widest glyph.
- let vertical = ts.vertical;
- let (mut y_text, mut half) = (0.0, 0.0_f64);
- // Where each word's glyphs start and end along the run (text space), and whether
- // the next glyph continues the last word.
- let mut words: Vec<(f64, f64)> = Vec::new();
- let mut in_word = false;
- let mut glyph_count = 0_usize;
- for p in &pieces {
- match p {
- Object::String(s) => {
- for (code, len) in m.codes(&s.bytes) {
- glyph_count = glyph_count.saturating_add(1);
- let shown = m.text_of(code);
- let blank =
- m.is_space(code, len) || shown.as_deref().is_some_and(|t| !t.is_empty() && t.chars().all(char::is_whitespace));
- match shown {
- Some(t) => {
- carry.text_left = carry
- .text_left
- .checked_sub(t.len())
- .ok_or_else(|| EditError::Invalid("the page's text is too large to read".into()))?;
- text.push_str(&t);
- }
- None => decodable = false,
- }
- let spacing = ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };
- if let Some(w1) = vertical {
- half = half.max((m.width(code) * ts.size * ts.scale).abs() / 2.0);
- if !blank {
- let ink_end = y_text + w1 * ts.size;
- let (lo, hi) = (y_text.min(ink_end), y_text.max(ink_end));
- match words.last_mut() {
- Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),
- _ => words.push((lo, hi)),
- }
- }
- in_word = !blank;
- y_text += w1 * ts.size + spacing;
- continue;
- }
- if !blank {
- let ink_end = x_text + m.width(code) * ts.size * ts.scale;
- // A negative font size or `Tz` runs the glyphs backwards:
- // the word is the union of its glyphs, whichever way they go.
- let (lo, hi) = (x_text.min(ink_end), x_text.max(ink_end));
- match words.last_mut() {
- Some(word) if in_word => *word = (word.0.min(lo), word.1.max(hi)),
- _ => words.push((lo, hi)),
- }
- }
- in_word = !blank;
- let w = m.width(code) * ts.size + ts.char_spacing + if m.is_space(code, len) { ts.word_spacing } else { 0.0 };
- x_text += w * ts.scale;
- }
- }
- other => {
- if let Some(n) = other.as_f64() {
- if vertical.is_some() {
- // Down by n/1000 em, not scaled by `Tz`.
- let dy = -n / 1000.0 * ts.size;
- if -dy > ts.size * 0.2 && !text.ends_with(' ') {
- text.push(' ');
- }
- if dy.abs() > ts.size.abs() * 0.2 {
- in_word = false;
- }
- y_text += dy;
- continue;
- }
- let dx = -n / 1000.0 * ts.size * ts.scale;
- // A large gap inside TJ reads as a space.
- if dx - tracking > (ts.size * ts.scale).abs() * 0.2 && !text.ends_with(' ') {
- text.push(' ');
- }
- // Tracking and kerning keep a word together; a larger jump
- // ends it (whatever the sign of the size or `Tz`).
- if dx - tracking > (ts.size * ts.scale).abs() * 0.2 || dx < -(ts.size * ts.scale).abs() * 0.2 {
- in_word = false;
- }
- x_text += dx;
- }
- }
- }
- }
- tm = Matrix([1.0, 0.0, 0.0, 1.0, x_text, y_text]).then(&tm);
- let end = tm.then(&ts.ctm).apply(0.0, ts.rise);
- // The box from `a` to `b` along the run: from descent to ascent across it, or for
- // vertical text, the widest glyph's width centred on the pen.
- let span = |a: f64, b: f64| match vertical {
- Some(_) => {
- [trm0.apply(-half, ts.rise + a), trm0.apply(half, ts.rise + a), trm0.apply(-half, ts.rise + b), trm0.apply(half, ts.rise + b)]
- }
- None => [
- trm0.apply(a, ts.rise + m.descent * ts.size),
- trm0.apply(b, ts.rise + m.descent * ts.size),
- trm0.apply(a, ts.rise + m.ascent * ts.size),
- trm0.apply(b, ts.rise + m.ascent * ts.size),
- ],
- };
- let corners = span(0.0, if vertical.is_some() { y_text } else { x_text });
- let rect = corners
- .iter()
- .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);
- // The same corners along and across the baseline: the run's own box, not its
- // upright bounding box turned (which is wider by the box's height on a slant).
- let dir = direction(&trm0);
- let frame = corners
- .iter()
- .map(|&p| to_frame(dir, p))
- .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p.0), b[1].min(p.1), b[2].max(p.0), b[3].max(p.1)]);
- let ink = words
- .iter()
- .map(|&(a, b)| {
- span(a, b)
- .iter()
- .fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |r, p| [r[0].min(p.0), r[1].min(p.1), r[2].max(p.0), r[3].max(p.1)])
- })
- .collect();
- let size_user = (trm0.0[2].powi(2) + trm0.0[3].powi(2)).sqrt() * ts.size;
- // A numeric-only TJ adjusts the current text matrix but paints no glyphs.
- // It must not create a phantom editable line or enlarge its neighbours' boxes.
- if !pieces.iter().any(|p| matches!(p, Object::String(s) if !s.bytes.is_empty())) {
- continue;
- }
- out.push(Shown {
- op: i,
- extra_ops: Vec::new(),
- glyph_count,
- // Vertical text: the TJ adjustment that undoes the run is n = -1000 y / size; the
- // preview divides by size × `Tz`, so `Tz` is put back here.
- advance: if vertical.is_some() { y_text * ts.scale } else { x_text },
- tracking: 0.0,
- tm: Matrix([
- tm.0[0],
- tm.0[1],
- tm.0[2],
- tm.0[3],
- tm.0[4] - x_text * tm.0[0] - y_text * tm.0[2],
- tm.0[5] - x_text * tm.0[1] - y_text * tm.0[3],
- ]),
- state: ts.clone(),
- tlm,
- bt_op: at_bt.0,
- bt_state: at_bt.1.clone(),
- text,
- rect,
- frame,
- ink,
- baseline: start.1,
- start_x: start.0,
- end_x: end.0,
- end_y: end.1,
- bt,
- font: name,
- base_font: m.base_font.clone(),
- face: ts.face.clone(),
- size: if size_user > 0.0 { size_user } else { ts.size },
- bold: m.bold,
- italic: m.italic,
- visual_order: m.visual_order,
- decodable,
- scope: marked.last().copied().flatten(),
- paint: Paint { layers: layers.iter().flatten().cloned().collect(), gs: ts.gs.clone() },
- logical_order: false,
- actual_text: false,
- });
+ let mut state = TextRunState { ts: &mut ts, tm: &mut tm, tlm: &mut tlm, at_bt: &at_bt, bt, marked: &marked, carry, out: &mut out };
+ show_text(op, i, &mut state)?;
}
_ => {}
}
}
carry.ts = ts;
carry.stack = stack;
- carry.marked = marked;
- carry.layers = layers;
+ carry.marked = marked.regions;
+ carry.layers = marked.layers;
positioned_tracking(&mut out);
Ok(out)
}
diff --git a/crates/edit/src/text/lines.rs b/crates/edit/src/text/lines.rs
index 7543adeb3..c48522984 100644
--- a/crates/edit/src/text/lines.rs
+++ b/crates/edit/src/text/lines.rs
@@ -1,6 +1,6 @@
use super::fallback::{same_font, same_paint};
use super::interp::{Carry, Origin, Pen, Shown, TextState, Ts, direction, interpret, to_frame, union};
-use super::*;
+use super::{DecodeBudget, Dict, Document, EditError, HashMap, Matrix, Object, Op, Pieces, Stream, TextLine, parse, serialize_ops};
impl TextLine {
/// The baseline's height in user space.
diff --git a/crates/edit/src/text/rewrite.rs b/crates/edit/src/text/rewrite.rs
index dd58c7289..513077a02 100644
--- a/crates/edit/src/text/rewrite.rs
+++ b/crates/edit/src/text/rewrite.rs
@@ -1,11 +1,14 @@
use super::blocks::{BlockStyle, TextBlock, paragraph_separator, wrap};
use super::fallback::{
- Encoder, MAX_TYPE3_GLYPHS, drop_unused_fallback_fonts, needs_type3, no_japanese_font, source_encodes, source_family, source_program_completes,
- source_show, source_space, source_width, type3_encode, type3_font,
+ Encoder, MAX_TYPE3_GLYPHS, Type3Fallback, drop_unused_fallback_fonts, needs_type3, no_japanese_font, source_encodes, source_family,
+ source_program_completes, source_show, source_space, source_width, type3_encode, type3_font,
};
-use super::interp::{Carry, interpret};
+use super::interp::{Carry, Origin, TextState, interpret};
use super::lines::{content_streams, page_dict, rewritten_contents, splice, text_lines};
-use super::*;
+use super::{
+ Dict, Document, EditError, HashMap, Matrix, Metrics, Object, Op, PdfString, Pieces, TextLine, TextSession, group_blocks, is_centred, parse,
+ rewrite_styled_block,
+};
/// What replacing a line did.
#[derive(Clone, Debug, PartialEq)]
@@ -206,6 +209,532 @@ pub(crate) fn rewrite_block_with_limit(
TextSession::open(doc, page, block)?.commit_with_limit(doc, text, style, max_glyphs)
}
+struct RewriteDispatch {
+ upright: bool,
+ use_styled_path: bool,
+}
+
+fn choose_rewrite_path(
+ doc: &Document,
+ fonts: &Dict,
+ block: &TextBlock,
+ members: &[&TextLine],
+ first: &TextLine,
+ text: Option<&str>,
+ style: &BlockStyle,
+) -> Result<RewriteDispatch, EditError> {
+ let registered_face = fonts.iter().any(|(name, _)| name.starts_with(b"PCFull"));
+ // Hebrew is written back in drawing order by the single-style path. Styled regions do not
+ // reorder right-to-left runs.
+ let hebrew = text.unwrap_or(&block.text).chars().any(crate::bidi::is_hebrew);
+ if hebrew && (!style.ranges.is_empty() || style.resource.is_some()) {
+ return Err(EditError::Invalid(
+ "formatting part of right-to-left (Hebrew) text, or choosing a document font for it, isn't supported yet".into(),
+ ));
+ }
+ // Turned text is rewritten in its own text space by the single-style path. Styled layout uses
+ // page x-coordinates and cannot safely apply those operations to rotated runs.
+ let upright = members.iter().all(|line| line.upright());
+ if !upright && (!style.ranges.is_empty() || style.resource.is_some()) {
+ return Err(EditError::Invalid("formatting part of turned text, or choosing a document font for it, isn't supported yet".into()));
+ }
+ let visual_indic = members.iter().any(|line| line.visual_order);
+ let has_special_text = text.is_some_and(|draft| {
+ draft.contains(['\n', '\r'])
+ || pdfcraft_fonts::source_shaping::required(draft)
+ || !pdfcraft_fonts::embedding::matching_faces(&block.base_font).is_empty()
+ });
+ let has_multiple_runs = block.rows.iter().any(|row| row.len() > 1)
+ || members.iter().any(|line| line.font != first.font || line.size != first.size || line.color != first.color);
+ let source_requires_styled_path =
+ has_special_text || registered_face || text.is_some_and(|draft| source_program_completes(doc, fonts, first, draft)) || has_multiple_runs;
+ let explicit_styled_text = !style.ranges.is_empty() || style.resource.is_some();
+ Ok(RewriteDispatch {
+ upright,
+ use_styled_path: upright
+ && !hebrew
+ && !visual_indic
+ && (explicit_styled_text || (source_requires_styled_path && style.family.is_none() && style.bold.is_none())),
+ })
+}
+
+/// The paragraph's text for writing back: explicit line breaks stay (#1443), and so does each typed
+/// U+0020 space: a run of them is not folded into one (#4199, #3797). `\r\n` and a lone `\r` are
+/// breaks too; other white space is written as one space.
+fn paragraph_text(text: &str) -> String {
+ text.replace("\r\n", "\n")
+ .chars()
+ .map(|c| match c {
+ '\r' => '\n',
+ c if c != '\n' && paragraph_separator(c) => ' ',
+ c => c,
+ })
+ .collect()
+}
+
+/// Where a paragraph sits on its page, for choosing the width it is laid out in.
+struct ParaGeometry {
+ rect: [f64; 4],
+ frame: [f64; 4],
+ crop: [f64; 4],
+ upright: bool,
+ /// The text-to-user scale.
+ k: f64,
+ /// The size in text space.
+ size: f64,
+ /// The requested horizontal move, in points.
+ dx: f64,
+ single_line: bool,
+ anchored_right: bool,
+ centred: bool,
+}
+
+impl ParaGeometry {
+ /// A paragraph keeps its width (or takes the one asked for); a single line grows to the right
+ /// (to the left when right-to-left), up to the page's margin.
+ fn width(&self, requested: Option<f64>) -> Result<f64, EditError> {
+ let [left, _, right, _] = self.rect;
+ let own = (right - left).max(self.size * self.k);
+ let width = match requested {
+ // Capped at the largest page PDF allows (14 400 pt), even for text set larger than that
+ // (`clamp` panics when its minimum is the larger, or NaN).
+ Some(w) if w.is_finite() => w.clamp((self.size * self.k).min(14_400.0), 14_400.0),
+ Some(_) => return Err(EditError::Invalid("the paragraph's width must be a number".into())),
+ // Turned text: the page's margins are along another axis. A single line grows (below).
+ None if !self.upright => (self.frame[2] - self.frame[0]).max(self.size * self.k),
+ None if self.anchored_right => own.max(right + self.dx - (self.crop[0] + 36.0)),
+ // A centred line is not stretched to the margin: its own box is the frame it is centred in.
+ None if self.single_line && !self.centred => own.max(self.crop[2] - 36.0 - (left + self.dx)),
+ None => own,
+ };
+ if width.is_finite() { Ok(width) } else { Err(EditError::Invalid("the paragraph's width must be a number".into())) }
+ }
+}
+
+/// How far a baseline starting at `origin` and running along `direction` goes before it is 36 pt
+/// from the page edge `low` or `high`.
+fn margin_reach(origin: f64, direction: f64, low: f64, high: f64) -> f64 {
+ if direction > 1e-6 {
+ (high - 36.0 - origin) / direction
+ } else if direction < -1e-6 {
+ (low + 36.0 - origin) / direction
+ } else {
+ f64::INFINITY
+ }
+}
+
+/// A turned single line grows to fit, up to where its baseline reaches the page's margin.
+fn turned_line_width(first: &TextLine, crop: [f64; 4], offset: [f64; 2], width: f64, text: &str, advance: &Advance<'_>) -> f64 {
+ let (x0, y0) = (first.origin.x + offset[0], first.origin.baseline + offset[1]);
+ let (ux, uy) = first.direction();
+ let tx = margin_reach(x0, ux, crop[0], crop[2]);
+ let ty = margin_reach(y0, uy, crop[1], crop[3]);
+ let cap = width.max(tx.min(ty)).min(14_400.0);
+ text.split('\n').map(|line| advance.of(line)).fold(width, f64::max).min(cap)
+}
+
+/// The widths of the paragraph's text in the font it will be written in, in user space.
+struct Advance<'a> {
+ /// The source font, when its glyphs are reused.
+ source: Option<&'a Metrics>,
+ type3: Option<&'a Type3Fallback>,
+ family: crate::added::Family,
+ bold: bool,
+ italic: bool,
+ size: f64,
+ space: f64,
+ char_spacing: f64,
+ word_spacing: f64,
+ scale: f64,
+ k: f64,
+}
+
+impl Advance<'_> {
+ fn of(&self, s: &str) -> f64 {
+ let extra = s.chars().count() as f64 * self.char_spacing;
+ let t = match (self.source, self.type3) {
+ (Some(m), _) => {
+ let visual_s = if m.visual_order { crate::indic::to_visual(s) } else { s.to_owned() };
+ source_width(m, &visual_s, self.size, self.space, self.char_spacing, self.word_spacing)
+ }
+ (None, Some(fallback)) => {
+ // Each character's count in `s`, from one pass over `s`.
+ let mut counts: HashMap<char, usize> = HashMap::new();
+ for c in s.chars() {
+ let count = counts.entry(c).or_insert(0);
+ *count = count.saturating_add(1);
+ }
+ fallback.widths.iter().map(|(ch, width)| counts.get(ch).copied().unwrap_or(0) as f64 * width * self.size).sum::<f64>() + extra
+ }
+ (None, None) => self.family.std14(self.bold, self.italic).text_width(s, self.size) + extra,
+ };
+ t * self.scale * self.k
+ }
+}
+
+/// The font a rewritten paragraph is shown in, and how its text is encoded.
+struct FontChoice {
+ show_font: String,
+ encode: Encoder,
+ /// The stand-in face to tell the caller about.
+ substituted: Option<String>,
+}
+
+/// What [`choose_font`] needs to know about the paragraph.
+struct FontInputs<'a> {
+ /// The source font, when its glyphs are reused.
+ source: Option<&'a Metrics>,
+ type3: Option<&'a Type3Fallback>,
+ font_name: &'a str,
+ flat: &'a str,
+ source_base_font: &'a str,
+ family: crate::added::Family,
+ bold: bool,
+ italic: bool,
+ family_requested: bool,
+}
+
+fn choose_font(inputs: &FontInputs<'_>, fonts_res: &mut Dict) -> Result<FontChoice, EditError> {
+ if let Some(m) = inputs.source.cloned() {
+ let name = inputs.font_name.to_owned();
+ return Ok(FontChoice {
+ show_font: name.clone(),
+ encode: Box::new(move |s: &str| m.encode(s).map(|bytes| vec![(name.clone(), bytes)])),
+ substituted: None,
+ });
+ }
+ if let Some(fallback) = inputs.type3.cloned() {
+ let substituted = Some(format!("{} Type3", fallback.family));
+ let first = fallback.names.first().cloned().ok_or_else(no_japanese_font)?;
+ return Ok(FontChoice { show_font: first, encode: Box::new(move |s: &str| type3_encode(&fallback, s)), substituted });
+ }
+ let flat = inputs.flat;
+ let win = pdfcraft_fonts::win_ansi(flat);
+ let back: String = win.iter().map(|c| char::from_u32(u32::from(*c)).unwrap_or('?')).collect();
+ let base = inputs.family.base_font(inputs.bold, inputs.italic);
+ if flat.chars().zip(back.chars()).any(|(a, c)| c == '?' && a != '?') {
+ return Err(EditError::Invalid(format!("\"{flat}\" has characters neither {} nor {base} can show", inputs.source_base_font)));
+ }
+ let mut f = Dict::new();
+ f.set(b"Type".to_vec(), Object::name("Font"));
+ f.set(b"Subtype".to_vec(), Object::name("Type1"));
+ f.set(b"BaseFont".to_vec(), Object::name(base));
+ f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));
+ // Named after its face, as the line and region rewrites name theirs: one name for every
+ // stand-in would repoint the paragraphs set in an earlier one at this face (#4280).
+ let name = format!("PCEd{}", base.replace('-', ""));
+ fonts_res.set(name.clone().into_bytes(), Object::Dict(f));
+ let substituted = (!inputs.family_requested).then(|| base.to_string());
+ let shown = name.clone();
+ Ok(FontChoice { show_font: name, encode: Box::new(move |s: &str| Some(vec![(shown.clone(), pdfcraft_fonts::win_ansi(s))])), substituted })
+}
+
+/// The paragraph's move in the space it is drawn in: the move is in page space, so it is taken
+/// back through the CTM's linear part. Checked before the fallback fonts are written: a refused
+/// paragraph leaves the document as it was.
+fn drawn_movement(ctm: [f64; 6], dx: f64, dy: f64) -> Result<Option<(f64, f64)>, EditError> {
+ if dx == 0.0 && dy == 0.0 {
+ return Ok(None);
+ }
+ let back = Matrix([ctm[0], ctm[1], ctm[2], ctm[3], 0.0, 0.0])
+ .invert()
+ .ok_or_else(|| EditError::Invalid("the paragraph is drawn in a space it can't be moved in".into()))?;
+ Ok(Some(back.apply(dx, dy)))
+}
+
+/// The paragraph's first text matrix, taken from where its text starts to where it is written.
+fn emit_text_matrix(first: &Origin, emit: &Origin) -> Result<[f64; 6], EditError> {
+ if first.ctm == emit.ctm {
+ return Ok(first.tm);
+ }
+ let emit_inv = Matrix(emit.ctm).invert().ok_or_else(|| EditError::Invalid("the paragraph has a singular transform".into()))?;
+ Ok(Matrix(first.tm).then(&Matrix(first.ctm)).then(&emit_inv).0)
+}
+
+/// Line spacing in text space: the paragraph's own (scaled with the size), or 1.2 × the size.
+struct LeadScale {
+ k: f64,
+ size: f64,
+ old_size: f64,
+ leading: f64,
+}
+
+fn line_lead(block: &TextBlock, lines: &[TextLine], style: &BlockStyle, scale: &LeadScale) -> f64 {
+ if let Some(m) = style.line_spacing {
+ return scale.size * m.clamp(0.5, 5.0);
+ }
+ // From the first two rows (a row may hold several runs).
+ let rows = block.rows.first().zip(block.rows.get(1)).and_then(|(upper, lower)| upper.first().zip(lower.first()));
+ if let Some((upper, lower)) = rows.and_then(|(upper, lower)| lines.get(*upper).zip(lines.get(*lower))) {
+ return (upper.frame_origin().1 - lower.frame_origin().1) / scale.k * scale.size / scale.old_size;
+ }
+ if scale.leading > 0.0 { scale.leading } else { scale.size * 1.2 }
+}
+
+/// The stroking twin of a fill colour operator.
+fn stroke_twin(fill: &Op) -> Op {
+ let name = match fill.op.as_slice() {
+ b"g" => "G",
+ b"rg" => "RG",
+ b"k" => "K",
+ b"cs" => "CS",
+ b"sc" => "SC",
+ _ => "SCN",
+ };
+ Op::new(name, fill.operands.clone())
+}
+
+/// Underlines in text space (the paragraph's text matrix), in its fill colour.
+fn underline_ops(fill: &[Op], tm: &[f64; 6], size: f64, underlines: &[(f64, f64, f64)]) -> Vec<Op> {
+ let n = pdfcraft_content::num;
+ let mut ops = vec![Op::new("q", vec![]), Op::new("cm", tm.iter().map(|v| n(*v)).collect())];
+ ops.extend(fill.iter().map(stroke_twin));
+ ops.push(Op::new("w", vec![n(size * 0.06)]));
+ for (x0, x1, y) in underlines {
+ ops.push(Op::new("m", vec![n(*x0), n(*y)]));
+ ops.push(Op::new("l", vec![n(*x1), n(*y)]));
+ }
+ ops.push(Op::new("S", vec![]));
+ ops.push(Op::new("Q", vec![]));
+ ops
+}
+
+/// Alignment: each line's offset from the left edge.
+struct Alignment {
+ align: Option<crate::added::Align>,
+ width: f64,
+ k: f64,
+ anchored_right: bool,
+ right_edge: f64,
+ rtl: bool,
+}
+
+impl Alignment {
+ /// `visible` is the width the line is aligned on, in user space; the offset is in text space.
+ fn offset(&self, visible: f64) -> f64 {
+ let free = (self.width - visible).max(0.0) / self.k;
+ match self.align {
+ Some(crate::added::Align::Center) => free / 2.0,
+ // A right-to-left line anchored at its right edge may start left of the old box.
+ Some(crate::added::Align::Right) if self.anchored_right => (self.right_edge - visible) / self.k,
+ Some(crate::added::Align::Right) => free,
+ // A justified right-to-left paragraph ends its last line at the right edge.
+ Some(crate::added::Align::Justify) if self.rtl => free,
+ _ => 0.0,
+ }
+ }
+}
+
+/// Everything the wrapped lines of one paragraph are written with.
+struct LineWriter<'a> {
+ advance: &'a Advance<'a>,
+ alignment: Alignment,
+ encode: &'a Encoder,
+ source: Option<&'a Metrics>,
+ justify: bool,
+ /// Whether `Tw` reaches every shown space.
+ word_spacing_reaches_spaces: bool,
+ width: f64,
+ scale: f64,
+ k: f64,
+ size: f64,
+ space: f64,
+ char_spacing: f64,
+ lead: f64,
+}
+
+/// What carries over from one line to the next.
+struct LineCursor {
+ x: f64,
+ tw_set: f64,
+ shown_font: String,
+}
+
+impl LineWriter<'_> {
+ /// Justify: each line but the last fills the width. A stretched line shows only its words, as
+ /// before #4199: word spacing would reach the spaces before its first word and after its
+ /// last, so they are left out. Nothing to stretch over, or a paragraph drawn at `0 Tz`, isn't
+ /// justified.
+ fn stretch(&self, body: &str, last: bool) -> f64 {
+ let interior = body.matches(' ').count();
+ if self.justify && !last && interior > 0 && self.scale.abs() > 1e-6 {
+ Some((self.width - self.advance.of(body)).max(0.0) / self.k / self.scale / interior as f64).filter(|tw| tw.is_finite()).unwrap_or(0.0)
+ } else {
+ 0.0
+ }
+ }
+
+ /// The text to show for a line and the width it is aligned on. Other lines show every space
+ /// typed. A left-to-right one is aligned on its width up to its last word; a right-to-left
+ /// one on its whole width, since the spaces typed after its last word are drawn on its left
+ /// and the ones before its first on its right.
+ fn shown<'t>(&self, line: &'t str, body: &'t str, tw: f64) -> (&'t str, f64) {
+ if tw > 0.0 {
+ (body, self.advance.of(body))
+ } else if crate::bidi::rtl_base(line) {
+ (line, self.advance.of(line))
+ } else {
+ (line, self.advance.of(line.trim_end_matches(' ')))
+ }
+ }
+
+ /// Writes one wrapped line, returning its underline (x0, x1, y) in text space.
+ fn write_line(&self, index: usize, line: &str, last: bool, cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<(f64, f64, f64), EditError> {
+ let n = pdfcraft_content::num;
+ let body = line.trim_matches(' ');
+ let interior = body.matches(' ').count();
+ let tw = self.stretch(body, last);
+ let (shown, visible) = self.shown(line, body, tw);
+ let dx = if tw > 0.0 { 0.0 } else { self.alignment.offset(visible) };
+ if index > 0 || dx != 0.0 {
+ ops.push(Op::new("Td", vec![n(dx - cursor.x), n(if index > 0 { -self.lead } else { 0.0 })]));
+ }
+ cursor.x = dx;
+ // Word spacing reaches only single-byte code 32 (ISO 32000-1 §9.3.3), so where a space is
+ // shown with another code (a composite font, a generated Type 3 font, a subset without a
+ // space) the extra space follows each space as a TJ adjustment instead.
+ let stretch = if self.word_spacing_reaches_spaces { 0.0 } else { tw };
+ let tw = tw - stretch;
+ if tw != cursor.tw_set {
+ ops.push(Op::new("Tw", vec![n(tw)]));
+ cursor.tw_set = tw;
+ }
+ // Each wrapped line in typing order; drawn left to right (right-to-left runs reversed).
+ let visual = crate::bidi::to_visual(shown);
+ // Stretched without word spacing: shown up to and including each space, then moved on.
+ let pieces: Vec<&str> = if stretch > 0.0 { visual.split_inclusive(' ').collect() } else { vec![visual.as_str()] };
+ for piece in pieces {
+ self.show_piece(piece, line, tw, cursor, ops)?;
+ if stretch > 0.0 && piece.ends_with(' ') {
+ ops.push(Op::new("TJ", vec![Object::Array(vec![n(-1000.0 * stretch / self.size)])]));
+ }
+ }
+ let tw = tw + stretch;
+ // Underlined to the line's last word, over its stretched gaps.
+ let w = (visible + tw * interior as f64 * self.scale * self.k) / self.k;
+ Ok((dx, dx + w, -(index as f64) * self.lead - self.size * 0.12))
+ }
+
+ fn show_piece(&self, piece: &str, line: &str, tw: f64, cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<(), EditError> {
+ let n = pdfcraft_content::num;
+ if let Some(metrics) = self.source {
+ let indic_piece = if metrics.visual_order { crate::indic::to_visual(piece) } else { piece.to_owned() };
+ ops.extend(source_show(metrics, &indic_piece, self.size, self.space, self.char_spacing, tw)?);
+ return Ok(());
+ }
+ for (font, bytes) in (self.encode)(piece).ok_or_else(|| EditError::Invalid(format!("\"{line}\" can't be shown")))? {
+ if font != cursor.shown_font {
+ ops.push(Op::new("Tf", vec![Object::name(&font), n(self.size)]));
+ cursor.shown_font = font;
+ }
+ ops.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));
+ }
+ Ok(())
+ }
+
+ /// Writes every wrapped line, returning their underlines.
+ fn write_all(&self, wrapped: &[String], cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<Vec<(f64, f64, f64)>, EditError> {
+ wrapped.iter().enumerate().map(|(i, line)| self.write_line(i, line, i + 1 == wrapped.len(), cursor, ops)).collect()
+ }
+}
+
+/// The operators that write a paragraph in its own graphics state, so a new colour (or anything
+/// else) stops at the paragraph.
+struct BlockPlan<'a> {
+ block: &'a TextBlock,
+ lines: &'a [TextLine],
+ style: &'a BlockStyle,
+ emit: &'a Origin,
+ after: &'a TextState,
+ movement: Option<(f64, f64)>,
+ state: TextState,
+ tm: [f64; 6],
+ size: f64,
+ underline: bool,
+}
+
+fn block_ops(plan: &BlockPlan<'_>, writer: &LineWriter<'_>, wrapped: &[String], show_font: String) -> Result<Vec<Op>, EditError> {
+ let n = pdfcraft_content::num;
+ let mut ops = vec![Op::new("q", vec![])];
+ ops.extend(reveal_ops(plan.block, plan.lines, plan.style, plan.emit.ctm)?);
+ // Moved: a translation inside that state.
+ if let Some((ax, ay)) = plan.movement {
+ ops.push(Op::new("cm", vec![n(1.0), n(0.0), n(0.0), n(1.0), n(ax), n(ay)]));
+ }
+ // Painted as the paragraph was, including what its text object set before the first show.
+ ops.extend(plan.state.paint_ops(plan.after));
+ ops.push(Op::new("BT", vec![]));
+ let mut state = plan.state.clone();
+ state.word_spacing = 0.0;
+ // The font the next run is shown in: the one the BT sets, until a run of another fallback subset.
+ let mut cursor = LineCursor { x: 0.0, tw_set: 0.0, shown_font: show_font.clone() };
+ state.font = Some((show_font, plan.size));
+ if let Some([r, g, bl]) = plan.style.color {
+ state.fill = vec![Op::new("rg", vec![n(r), n(g), n(bl)])];
+ }
+ ops.extend(state.ops());
+ ops.push(Op::new("Tm", plan.tm.iter().map(|v| n(*v)).collect()));
+ let underlines = writer.write_all(wrapped, &mut cursor, &mut ops)?;
+ ops.push(Op::new("ET", vec![]));
+ if plan.underline {
+ ops.extend(underline_ops(&state.fill, &plan.tm, plan.size, &underlines));
+ }
+ ops.push(Op::new("Q", vec![]));
+ Ok(ops)
+}
+
+/// Whether text shown earlier in the same text object stays first: the paragraph then goes where
+/// its last row was, after any backgrounds between the rows, or between two halves of the text
+/// object. The paragraph's own operators (and another drawing on the same baseline: a fake-bold
+/// second copy, an invisible text layer) go, so the new text is all that may show.
+fn shows_before_paragraph(ops: &[Op], from: usize, to: usize, dropped: &std::collections::HashSet<usize>) -> bool {
+ ops.get(from..to)
+ .unwrap_or_default()
+ .iter()
+ .enumerate()
+ .any(|(i, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !dropped.contains(&(from + i)))
+}
+
+/// A paragraph's single style, with the text-space values read from where it starts.
+struct ParaStyle {
+ state: TextState,
+ size: f64,
+ old_size: f64,
+ k: f64,
+}
+
+/// Spacing and scaling (text state), with the chosen values.
+fn paragraph_style(o: &Origin, style: &BlockStyle) -> Result<(String, ParaStyle), EditError> {
+ let (font_name, old_size) = o.state.font.clone().ok_or_else(|| EditError::Invalid("the paragraph has no font".into()))?;
+ let k = o.k.max(1e-6);
+ // The size in text space: points ÷ the text-to-user scale.
+ let size = style.size.map_or(old_size, |pt| (pt / k).max(0.1));
+ let mut state = o.state.clone();
+ if let Some(c) = style.char_spacing {
+ state.char_spacing = c / k;
+ }
+ if let Some(sc) = style.scale {
+ state.scale = (sc / 100.0).clamp(0.1, 10.0);
+ }
+ Ok((font_name, ParaStyle { state, size, old_size, k }))
+}
+
+/// The font the paragraph's existing runs use, for reusing its glyphs.
+struct SourceFont {
+ metrics: Option<Metrics>,
+ reuse: bool,
+ space: f64,
+}
+
+fn source_font(doc: &Document, fonts_res: &Dict, font_name: &str, first: &TextLine, flat: &str, style: &BlockStyle) -> SourceFont {
+ let metrics = fonts_res.get(font_name.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|d| Metrics::from_dict(doc, &d));
+ let visual_indic = metrics.as_ref().is_some_and(|m| m.visual_order) || first.visual_order;
+ let indic_text = if visual_indic { crate::indic::to_visual(flat) } else { flat.to_owned() };
+ let reuse = style.family.is_none() && style.bold.is_none() && metrics.as_ref().is_some_and(|m| source_encodes(m, &indic_text));
+ let space = metrics.as_ref().map_or(0.33, |m| source_space(doc, fonts_res, m));
+ SourceFont { metrics, reuse, space }
+}
+
/// [`rewrite_block_with_limit`] with the page's [`text_lines`], read from `doc` as it is now.
pub(crate) fn rewrite_block_from(
doc: &mut Document,
@@ -228,86 +757,26 @@ pub(crate) fn rewrite_block_from(
let p = page_dict(doc, page)?;
let mut res = p.dict.get(b"Resources").map(|r| doc.resolve(r)).and_then(|r| r.as_dict().cloned()).unwrap_or_default();
let mut fonts_res = res.get(b"Font").map(|f| doc.resolve(f)).and_then(|f| f.as_dict().cloned()).unwrap_or_default();
- let registered_face = fonts_res.iter().any(|(name, _)| name.starts_with(b"PCFull"));
- // Hebrew is written back in drawing order (and with the Hebrew fallback face) by the
- // single-style path below; the styled region path does not reorder right-to-left runs.
- let hebrew = text.unwrap_or(&b.text).chars().any(crate::bidi::is_hebrew);
- if hebrew && (!style.ranges.is_empty() || style.resource.is_some()) {
- return Err(EditError::Invalid(
- "formatting part of right-to-left (Hebrew) text, or choosing a document font for it, isn't supported yet".into(),
- ));
- }
- // Text turned on the page (a landscape page drawn a quarter turn round) is rewritten in its
- // own text space below; the styled region path lays rows out along the page's x axis.
- let upright = members.iter().all(|line| line.upright());
- if !upright && (!style.ranges.is_empty() || style.resource.is_some()) {
- return Err(EditError::Invalid("formatting part of turned text, or choosing a document font for it, isn't supported yet".into()));
- }
- let visual_indic = members.iter().any(|line| line.visual_order);
- if upright
- && !hebrew
- && !visual_indic
- && (!style.ranges.is_empty()
- || style.resource.is_some()
- || (text.is_some_and(|draft| {
- // A row break, `\n` or a carriage return, takes the path that keeps untouched rows.
- draft.contains(['\n', '\r'])
- || pdfcraft_fonts::source_shaping::required(draft)
- || !pdfcraft_fonts::embedding::matching_faces(&b.base_font).is_empty()
- }) || registered_face
- || text.is_some_and(|draft| source_program_completes(doc, &fonts_res, first, draft))
- || b.rows.iter().any(|row| row.len() > 1)
- || members.iter().any(|line| line.font != first.font || line.size != first.size || line.color != first.color))
- && style.family.is_none()
- && style.bold.is_none())
- {
+ let dispatch = choose_rewrite_path(doc, &fonts_res, &b, &members, first, text, style)?;
+ if dispatch.use_styled_path {
return rewrite_styled_block(doc, page, &b, &lines, text, style, max_glyphs);
}
+ let upright = dispatch.upright;
let streams = content_streams(doc, &p.dict)?;
let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());
let ops = pieces.parse().ops;
- // Explicit line breaks stay (#1443), and so does each typed U+0020 space: a run of them is
- // not folded into one (#4199, #3797). `\r\n` and a lone `\r` are breaks too; other white
- // space is written as one space.
- let text: String = text
- .unwrap_or(&b.text)
- .replace("\r\n", "\n")
- .chars()
- .map(|c| match c {
- '\r' => '\n',
- c if c != '\n' && paragraph_separator(c) => ' ',
- c => c,
- })
- .collect();
+ let text = paragraph_text(text.unwrap_or(&b.text));
// The characters to show, for choosing fonts: the breaks are moves, not glyphs.
let flat = text.replace('\n', " ");
let o = &first.origin;
let last = members.last().copied().unwrap_or(first);
let emit = &last.origin;
- let (font_name, old_size) = o.state.font.clone().ok_or_else(|| EditError::Invalid("the paragraph has no font".into()))?;
- let k = o.k.max(1e-6);
- // The size in text space: points ÷ the text-to-user scale.
- let size = style.size.map_or(old_size, |pt| (pt / k).max(0.1));
- // Spacing and scaling (text state), with the chosen values.
- let mut ts_state = o.state.clone();
- if let Some(c) = style.char_spacing {
- ts_state.char_spacing = c / k;
- }
- if let Some(sc) = style.scale {
- ts_state.scale = (sc / 100.0).clamp(0.1, 10.0);
- }
- let o_state = ts_state.clone();
- let metrics = fonts_res.get(font_name.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned()).map(|d| Metrics::from_dict(doc, &d));
- let visual_indic = metrics.as_ref().is_some_and(|m| m.visual_order) || first.visual_order;
- let indic_text = if visual_indic { crate::indic::to_visual(&flat) } else { flat.clone() };
- let reuse = style.family.is_none() && style.bold.is_none() && metrics.as_ref().is_some_and(|m| source_encodes(m, &indic_text));
- let space = metrics.as_ref().map_or(0.33, |m| source_space(doc, &fonts_res, m));
+ let (font_name, ParaStyle { state: o_state, size, old_size, k }) = paragraph_style(o, style)?;
+ let source = source_font(doc, &fonts_res, &font_name, first, &flat, style);
+ let reuse = source.reuse;
// The chosen style also determines the real Japanese fallback outlines and advances.
let (family, bold, italic) = style.family.unwrap_or((source_family(&b.base_font), b.bold, b.italic));
let bold = style.bold.unwrap_or(bold);
- // The face is chosen after `bold` settles, so a bold request measures with the bold metrics.
- let face = family.std14(bold, italic);
- let std_width = move |s: &str, size: f64| -> f64 { face.text_width(s, size) };
let [dx, dy] = style.offset.unwrap_or([0.0, 0.0]);
if !(dx.is_finite() && dy.is_finite()) {
return Err(EditError::Invalid("the paragraph can't be moved that far".into()));
@@ -327,287 +796,79 @@ pub(crate) fn rewrite_block_from(
// Turned text is left alone: its centre lives along its own baseline, not in page space.
let crop = p.crop(doc);
let centred = upright && !rtl && style.width.is_none() && style.align.is_none() && is_centred(&b, &lines, (crop[0] + crop[2]) / 2.0, first.size);
- // A paragraph keeps its width (or takes the one asked for); a single line grows to the right
- // (to the left when right-to-left), up to the page's margin.
- let width = match style.width {
- // Capped at the largest page PDF allows (14 400 pt), even for text set larger than that
- // (`clamp` panics when its minimum is the larger, or NaN).
- Some(w) if w.is_finite() => w.clamp((size * k).min(14_400.0), 14_400.0),
- Some(_) => return Err(EditError::Invalid("the paragraph's width must be a number".into())),
- // Turned text: the page's margins are along another axis. A single line grows (below).
- None if !upright => (frame[2] - frame[0]).max(size * k),
- None if anchored_right => (b.rect[2] - b.rect[0]).max(size * k).max(b.rect[2] + dx - (crop[0] + 36.0)),
- // A centred line is not stretched to the margin: its own box is the frame it is centred in.
- None if members.len() == 1 && !centred => (b.rect[2] - b.rect[0]).max(size * k).max(crop[2] - 36.0 - (b.rect[0] + dx)),
- None => (b.rect[2] - b.rect[0]).max(size * k),
- };
- if !width.is_finite() {
- return Err(EditError::Invalid("the paragraph's width must be a number".into()));
- }
+ let geometry = ParaGeometry { rect: b.rect, frame, crop, upright, k, size, dx, single_line: members.len() == 1, anchored_right, centred };
+ let width = geometry.width(style.width)?;
let align = if centred { Some(crate::added::Align::Center) } else { style.align.or(rtl.then_some(crate::added::Align::Right)) };
// Where a right-aligned line ends, from the paragraph's left edge (user space).
let right_edge = if anchored_right { (b.rect[2] - b.rect[0]).max(0.0) } else { width };
- // The move and the width are checked here, before the fallback fonts are written: a refused
- // paragraph leaves the document as it was. The move is in page space, so it is taken back through
- // the CTM's linear part into the space the paragraph is drawn in.
- let movement = if dx != 0.0 || dy != 0.0 {
- let c = emit.ctm;
- let back = Matrix([c[0], c[1], c[2], c[3], 0.0, 0.0])
- .invert()
- .ok_or_else(|| EditError::Invalid("the paragraph is drawn in a space it can't be moved in".into()))?;
- Some(back.apply(dx, dy))
- } else {
- None
- };
- let tm = if o.ctm == emit.ctm {
- o.tm
- } else {
- let emit_inv = Matrix(emit.ctm).invert().ok_or_else(|| EditError::Invalid("the paragraph has a singular transform".into()))?;
- Matrix(o.tm).then(&Matrix(o.ctm)).then(&emit_inv).0
- };
+ let movement = drawn_movement(emit.ctm, dx, dy)?;
+ let tm = emit_text_matrix(o, emit)?;
let type3 = if !reuse && needs_type3(&flat) { Some(type3_font(doc, &mut fonts_res, &flat, family, bold, max_glyphs)?) } else { None };
- let advance = |s: &str| -> f64 {
- let t = match (&metrics, reuse) {
- (Some(m), true) => {
- let visual_s = if m.visual_order { crate::indic::to_visual(s) } else { s.to_owned() };
- source_width(m, &visual_s, size, space, o_state.char_spacing, o_state.word_spacing)
- }
- _ if let Some(fallback) = &type3 => {
- // Each character's count in `s`, from one pass over `s`.
- let mut counts: HashMap<char, usize> = HashMap::new();
- for c in s.chars() {
- let count = counts.entry(c).or_insert(0);
- *count = count.saturating_add(1);
- }
- fallback.widths.iter().map(|(ch, width)| counts.get(ch).copied().unwrap_or(0) as f64 * width * size).sum::<f64>()
- + s.chars().count() as f64 * o_state.char_spacing
- }
- _ => std_width(s, size) + s.chars().count() as f64 * o_state.char_spacing,
- };
- t * o_state.scale * k
+ let source_metrics = source.metrics.as_ref().filter(|_| reuse);
+ let advance = Advance {
+ source: source_metrics,
+ type3: type3.as_ref(),
+ family,
+ bold,
+ italic,
+ size,
+ space: source.space,
+ char_spacing: o_state.char_spacing,
+ word_spacing: o_state.word_spacing,
+ scale: o_state.scale,
+ k,
};
- // A turned single line grows to fit, up to where its baseline reaches the page's margin.
let width = if !upright && style.width.is_none() && members.len() == 1 {
- let crop = p.crop(doc);
- let (x0, y0) = (first.origin.x + dx, first.origin.baseline + dy);
- let (ux, uy) = first.direction();
- let tx = if ux > 1e-6 {
- (crop[2] - 36.0 - x0) / ux
- } else if ux < -1e-6 {
- (crop[0] + 36.0 - x0) / ux
- } else {
- f64::INFINITY
- };
- let ty = if uy > 1e-6 {
- (crop[3] - 36.0 - y0) / uy
- } else if uy < -1e-6 {
- (crop[1] + 36.0 - y0) / uy
- } else {
- f64::INFINITY
- };
- let cap = width.max(tx.min(ty)).min(14_400.0);
- text.split('\n').map(&advance).fold(width, f64::max).min(cap)
+ turned_line_width(first, crop, [dx, dy], width, &text, &advance)
} else {
width
};
let right_edge = if anchored_right { right_edge } else { width };
- let wrapped = wrap(&text, width + 0.5, advance);
- let mut substituted = None;
- let new_font = !reuse;
- let (show_font, encode): (String, Encoder) = if let Some(m) = metrics.clone().filter(|_| reuse) {
- let name = font_name.clone();
- (font_name.clone(), Box::new(move |s: &str| m.encode(s).map(|bytes| vec![(name.clone(), bytes)])))
- } else if let Some(fallback) = type3.clone() {
- substituted = Some(format!("{} Type3", fallback.family));
- let first = fallback.names.first().cloned().ok_or_else(no_japanese_font)?;
- (first, Box::new(move |s: &str| type3_encode(&fallback, s)))
- } else {
- let win = pdfcraft_fonts::win_ansi(&flat);
- let back: String = win.iter().map(|c| char::from_u32(u32::from(*c)).unwrap_or('?')).collect();
- let base = family.base_font(bold, italic);
- if flat.chars().zip(back.chars()).any(|(a, c)| c == '?' && a != '?') {
- return Err(EditError::Invalid(format!("\"{flat}\" has characters neither {} nor {base} can show", b.base_font)));
- }
- let mut f = Dict::new();
- f.set(b"Type".to_vec(), Object::name("Font"));
- f.set(b"Subtype".to_vec(), Object::name("Type1"));
- f.set(b"BaseFont".to_vec(), Object::name(base));
- f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));
- // Named after its face, as the line and region rewrites name theirs: one name for every
- // stand-in would repoint the paragraphs set in an earlier one at this face (#4280).
- let name = format!("PCEd{}", base.replace('-', ""));
- fonts_res.set(name.clone().into_bytes(), Object::Dict(f));
- if style.family.is_none() {
- substituted = Some(base.to_string());
- }
- let shown = name.clone();
- (name, Box::new(move |s: &str| Some(vec![(shown.clone(), pdfcraft_fonts::win_ansi(s))])))
- };
- // Line spacing in text space: the paragraph's own (scaled with the size), or 1.2 × the size.
- let lead = match style.line_spacing {
- Some(m) => size * m.clamp(0.5, 5.0),
- // From the first two rows (a row may hold several runs).
- None if let Some((upper, lower)) = b
- .rows
- .first()
- .zip(b.rows.get(1))
- .and_then(|(upper, lower)| upper.first().zip(lower.first()))
- .and_then(|(upper, lower)| lines.get(*upper).zip(lines.get(*lower))) =>
- {
- (upper.frame_origin().1 - lower.frame_origin().1) / k * size / old_size
- }
- None if o_state.leading > 0.0 => o_state.leading,
- None => size * 1.2,
- };
- let n = pdfcraft_content::num;
- // The paragraph's operators go, and so does another drawing on the same baseline (a fake-bold
- // second copy, an invisible text layer): the new text is all that may show.
- let drop = dropped;
- // Text shown earlier in the same text object stays first: the paragraph then goes where its
- // last row was, after any backgrounds between the rows, or between two halves of the text object.
+ let wrapped = wrap(&text, width + 0.5, |s| advance.of(s));
+ let font = choose_font(
+ &FontInputs {
+ source: source_metrics,
+ type3: type3.as_ref(),
+ font_name: &font_name,
+ flat: &flat,
+ source_base_font: &b.base_font,
+ family,
+ bold,
+ italic,
+ family_requested: style.family.is_some(),
+ },
+ &mut fonts_res,
+ )?;
+ let lead = line_lead(&b, &lines, style, &LeadScale { k, size, old_size, leading: o_state.leading });
let start = last.ops.first().copied().unwrap_or(emit.bt_op);
- let split = ops
- .get(emit.bt_op..start)
- .unwrap_or_default()
- .iter()
- .enumerate()
- .any(|(i, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !drop.contains(&(emit.bt_op + i)));
+ let split = shows_before_paragraph(&ops, emit.bt_op, start, &dropped);
// What the text after the paragraph expects, and what is in force where the paragraph is
// drawn: the state at its BT (or where it was split).
let after = if split { &emit.state } else { &emit.bt_state };
- // In its own graphics state, so a new colour (or anything else) stops at the paragraph.
- let mut block_ops = vec![Op::new("q", vec![])];
- block_ops.extend(reveal_ops(&b, &lines, style, emit.ctm)?);
- // Moved: a translation inside that state.
- if let Some((ax, ay)) = movement {
- block_ops.push(Op::new("cm", vec![n(1.0), n(0.0), n(0.0), n(1.0), n(ax), n(ay)]));
- }
- // Painted as the paragraph was, including what its text object set before the first show.
- block_ops.extend(o_state.paint_ops(after));
- block_ops.push(Op::new("BT", vec![]));
- let mut state = o_state.clone();
- state.word_spacing = 0.0;
- // The font the next run is shown in: the one the BT sets, until a run of another fallback subset.
- let mut shown_font = show_font.clone();
- state.font = Some((show_font, size));
- if let Some([r, g, bl]) = style.color {
- state.fill = vec![Op::new("rg", vec![n(r), n(g), n(bl)])];
- }
- block_ops.extend(state.ops());
- block_ops.push(Op::new("Tm", tm.iter().map(|v| n(*v)).collect()));
- // Alignment: each line's offset from the left edge, in text space.
- // `visible` is the width the line is aligned on (see the loop below).
- let offset = |visible: f64| -> f64 {
- let free = (width - visible).max(0.0) / k;
- match align {
- Some(crate::added::Align::Center) => free / 2.0,
- // A right-to-left line anchored at its right edge may start left of the old box.
- Some(crate::added::Align::Right) if anchored_right => (right_edge - visible) / k,
- Some(crate::added::Align::Right) => free,
- // A justified right-to-left paragraph ends its last line at the right edge.
- Some(crate::added::Align::Justify) if rtl => free,
- _ => 0.0,
- }
- };
- // Justify: each line but the last fills the width. Word spacing reaches only single-byte code 32
- // (ISO 32000-1 §9.3.3), so where a space is shown with another code (a composite font, a
- // generated Type 3 font, a subset without a space) the extra space follows each space as a
- // TJ adjustment instead, and code 32, which may then be a letter, gets none.
- let justify = align == Some(crate::added::Align::Justify);
- let word_spacing_reaches_spaces = match metrics.as_ref().filter(|_| reuse) {
+ // Word spacing reaches only single-byte code 32 (ISO 32000-1 §9.3.3); see `write_line`.
+ let word_spacing_reaches_spaces = match source_metrics {
Some(m) => m.encode(" ").is_some_and(|b| m.codes(&b).iter().all(|(c, len)| m.is_space(*c, *len))),
None => type3.is_none(),
};
- let mut x = 0.0;
- let mut tw_set = 0.0;
- let mut underlines: Vec<(f64, f64, f64)> = Vec::new(); // (x0, x1, y) in text space
- for (i, line) in wrapped.iter().enumerate() {
- // A stretched (justified) line shows only its words, as before #4199: word spacing would
- // reach the spaces before its first word and after its last, so they are left out, and
- // the line fills the width from the left edge. Nothing to stretch over, or a paragraph
- // drawn at `0 Tz`, isn't justified.
- let body = line.trim_matches(' ');
- let interior = body.matches(' ').count();
- let tw = if justify && i + 1 < wrapped.len() && interior > 0 && o_state.scale.abs() > 1e-6 {
- Some((width - advance(body)).max(0.0) / k / o_state.scale / interior as f64).filter(|tw| tw.is_finite())
- } else {
- None
- }
- .unwrap_or(0.0);
- // Other lines show every space typed. A left-to-right one is aligned on its width up to
- // its last word; a right-to-left one on its whole width, since the spaces typed after its
- // last word are drawn on its left and the ones before its first on its right.
- let (shown, visible) = if tw > 0.0 {
- (body, advance(body))
- } else if crate::bidi::rtl_base(line) {
- (line.as_str(), advance(line))
- } else {
- (line.as_str(), advance(line.trim_end_matches(' ')))
- };
- let dx = if tw > 0.0 { 0.0 } else { offset(visible) };
- if i > 0 || dx != 0.0 {
- block_ops.push(Op::new("Td", vec![n(dx - x), n(if i > 0 { -lead } else { 0.0 })]));
- }
- x = dx;
- let stretch = if word_spacing_reaches_spaces { 0.0 } else { tw };
- let tw = tw - stretch;
- if tw != tw_set {
- block_ops.push(Op::new("Tw", vec![n(tw)]));
- tw_set = tw;
- }
- // Each wrapped line in typing order; drawn left to right (right-to-left runs reversed).
- let visual = crate::bidi::to_visual(shown);
- // Stretched without word spacing: shown up to and including each space, then moved on.
- let pieces = if stretch > 0.0 { visual.split_inclusive(' ').collect() } else { vec![visual.as_str()] };
- for piece in pieces {
- if let Some(metrics) = metrics.as_ref().filter(|_| reuse) {
- let indic_piece = if metrics.visual_order { crate::indic::to_visual(piece) } else { piece.to_owned() };
- block_ops.extend(source_show(metrics, &indic_piece, size, space, o_state.char_spacing, tw)?);
- } else {
- for (font, bytes) in encode(piece).ok_or_else(|| EditError::Invalid(format!("\"{line}\" can't be shown")))? {
- if font != shown_font {
- block_ops.push(Op::new("Tf", vec![Object::name(&font), n(size)]));
- shown_font = font;
- }
- block_ops.push(Op::new("Tj", vec![Object::String(PdfString::literal(bytes))]));
- }
- }
- if stretch > 0.0 && piece.ends_with(' ') {
- block_ops.push(Op::new("TJ", vec![Object::Array(vec![n(-1000.0 * stretch / size)])]));
- }
- }
- let tw = tw + stretch;
- // Underlined to the line's last word, over its stretched gaps.
- let w = (visible + tw * interior as f64 * o_state.scale * k) / k;
- underlines.push((dx, dx + w, -(i as f64) * lead - size * 0.12));
- }
- block_ops.push(Op::new("ET", vec![]));
- if style.underline == Some(true) {
- // In text space (the paragraph's text matrix), in its fill colour.
- let colour: Vec<Op> = state
- .fill
- .iter()
- .map(|f| match f.op.as_slice() {
- b"g" => Op::new("G", f.operands.clone()),
- b"rg" => Op::new("RG", f.operands.clone()),
- b"k" => Op::new("K", f.operands.clone()),
- b"cs" => Op::new("CS", f.operands.clone()),
- b"sc" => Op::new("SC", f.operands.clone()),
- _ => Op::new("SCN", f.operands.clone()),
- })
- .collect();
- block_ops.push(Op::new("q", vec![]));
- block_ops.push(Op::new("cm", tm.iter().map(|v| n(*v)).collect()));
- block_ops.extend(colour);
- block_ops.push(Op::new("w", vec![n(size * 0.06)]));
- for (x0, x1, y) in underlines {
- block_ops.push(Op::new("m", vec![n(x0), n(y)]));
- block_ops.push(Op::new("l", vec![n(x1), n(y)]));
- }
- block_ops.push(Op::new("S", vec![]));
- block_ops.push(Op::new("Q", vec![]));
- }
- block_ops.push(Op::new("Q", vec![]));
+ let writer = LineWriter {
+ advance: &advance,
+ alignment: Alignment { align, width, k, anchored_right, right_edge, rtl },
+ encode: &font.encode,
+ source: source_metrics,
+ justify: align == Some(crate::added::Align::Justify),
+ word_spacing_reaches_spaces,
+ width,
+ scale: o_state.scale,
+ k,
+ size,
+ space: source.space,
+ char_spacing: o_state.char_spacing,
+ lead,
+ };
+ let plan =
+ BlockPlan { block: &b, lines: &lines, style, emit, after, movement, state: o_state, tm, size, underline: style.underline == Some(true) };
+ let mut block_ops = block_ops(&plan, &writer, &wrapped, font.show_font.clone())?;
+ let n = pdfcraft_content::num;
block_ops.extend(after.ops().into_iter().filter(|op| !op.is("Tf") || after.font.is_some()));
if split {
block_ops.insert(0, Op::new("ET", vec![]));
@@ -617,9 +878,10 @@ pub(crate) fn rewrite_block_from(
let at = if split { start } else { emit.bt_op };
let new_data = splice(&pieces, &ops, |i| {
let insert = if i == at { std::mem::take(&mut block_ops) } else { Vec::new() };
- (insert, !drop.contains(&i))
+ (insert, !dropped.contains(&i))
});
let contents = rewritten_contents(doc, &streams, new_data);
+ let new_font = !reuse;
if new_font {
res.set(b"Font".to_vec(), Object::Dict(fonts_res));
}
@@ -630,7 +892,7 @@ pub(crate) fn rewrite_block_from(
d.set(b"Resources".to_vec(), Object::Dict(res));
}
})?;
- Ok(LineEdit { substituted })
+ Ok(LineEdit { substituted: font.substituted })
}
/// The cover (when [`BlockStyle::cover`] asks for one) and visible rendering that start a
diff --git a/crates/edit/src/text_regions.rs b/crates/edit/src/text_regions.rs
index 7516cb793..be5b4dffa 100644
--- a/crates/edit/src/text_regions.rs
+++ b/crates/edit/src/text_regions.rs
@@ -1,6 +1,11 @@
//! Geometry-based regions and mixed-style rewriting of existing text.
-use super::*;
+use super::{
+ BlockStyle, CraftFont, Dict, Document, EditError, HashMap, LineEdit, MAX_TYPE3_GLYPHS, Matrix, Metrics, Object, Op, PdfString, Pieces,
+ RangeStyle, TextBlock, TextLine, Type3Glyph, coincident_ops, content_streams, fallback_face, japanese_glyph_from, needs_type3, no_fallback_font,
+ no_glyph_for, page_dict, paragraph_separator, reveal_ops, rewritten_contents, same_base_font, same_font, source_encodes, source_family,
+ source_program, source_show, source_space, source_width, splice, strip_subset_tag, type3_faces, type3_glyph, union, write_type3_glyphs,
+};
#[path = "text_regions/grouping.rs"]
mod grouping;
diff --git a/crates/edit/src/text_regions/grouping.rs b/crates/edit/src/text_regions/grouping.rs
index 29004b8e3..b8a5abca1 100644
--- a/crates/edit/src/text_regions/grouping.rs
+++ b/crates/edit/src/text_regions/grouping.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{HashMap, Matrix, TextBlock, TextLine, paragraph_separator, same_base_font, same_font, strip_subset_tag, union};
fn same_plane(a: &TextLine, b: &TextLine) -> bool {
let at = Matrix(a.origin.tm).then(&Matrix(a.origin.ctm));
diff --git a/crates/edit/src/text_regions/styled.rs b/crates/edit/src/text_regions/styled.rs
index 09baf1ac7..e8b3b683d 100644
--- a/crates/edit/src/text_regions/styled.rs
+++ b/crates/edit/src/text_regions/styled.rs
@@ -1,5 +1,10 @@
use super::grouping::{across, is_centred, row_rect};
-use super::*;
+use super::{
+ BlockStyle, CraftFont, Dict, Document, EditError, HashMap, LineEdit, MAX_TYPE3_GLYPHS, Matrix, Metrics, Object, Op, PdfString, Pieces,
+ RangeStyle, TextBlock, TextLine, Type3Glyph, coincident_ops, content_streams, fallback_face, japanese_glyph_from, needs_type3, no_fallback_font,
+ no_glyph_for, page_dict, reveal_ops, rewritten_contents, source_encodes, source_family, source_program, source_show, source_space, source_width,
+ splice, type3_faces, type3_glyph, write_type3_glyphs,
+};
// The draft is capped at 4 MiB; also bound the outline data prepared across all fallback faces.
// A glyph budget worth 64 full batches (15,360 glyphs with the production batch size).
@@ -13,122 +18,462 @@ struct FallbackGroup {
positions: Vec<usize>,
}
-/// Shape in the source or an explicitly registered matching full face. Never use interface fonts.
-fn shape_source(
- doc: &Document,
- fonts: &Dict,
- name: &str,
- text: &str,
-) -> Result<Option<(Vec<u8>, pdfcraft_fonts::source_shaping::ShapedRun, String)>, EditError> {
- if !pdfcraft_fonts::source_shaping::required(text) {
- return Ok(None);
- }
- let source =
- fonts.get(name.as_bytes()).and_then(|f| doc.dict(f)).ok_or_else(|| EditError::Invalid("the shaped text has no font resource".into()))?;
- let family = Metrics::from_dict(doc, &source).base_font;
- let mut candidates = vec![source];
- candidates.extend(
- fonts
- .iter()
- .filter_map(|(_, f)| doc.dict(f))
- .filter(|f| pdfcraft_fonts::embedding::face_key(&Metrics::from_dict(doc, f).base_font) == pdfcraft_fonts::embedding::face_key(&family)),
- );
- for font in candidates {
- if let Some(bytes) = pdfcraft_fonts::pdf::embedded_sfnt(doc, &font)
- && pdfcraft_fonts::embedding::covers(&bytes, text)
- && let Ok(shaped) = pdfcraft_fonts::source_shaping::shape(&bytes, text)
+struct FallbackBuilder {
+ groups: Vec<FallbackGroup>,
+ names: std::collections::BTreeMap<(String, bool, char), usize>,
+ glyphs: usize,
+ per_font: usize,
+ budget: usize,
+}
+
+struct FontResolver<'a> {
+ doc: &'a mut Document,
+ fonts: &'a mut Dict,
+ metrics: &'a mut std::collections::BTreeMap<String, Metrics>,
+ full_faces: HashMap<String, String>,
+ programs: HashMap<String, Option<std::sync::Arc<Vec<u8>>>>,
+}
+
+impl FontResolver<'_> {
+ fn encodable_font(&mut self, source: &TextLine, text: &str, requested: Option<&str>) -> Result<Option<String>, EditError> {
+ if let Some(resource) = requested {
+ if !self.metrics.get(resource).is_some_and(|metrics| source_encodes(metrics, text)) {
+ return Err(EditError::Invalid(format!(
+ "the selected font resource {resource} cannot show U+{:04X}",
+ text.chars().next().map_or(0, u32::from)
+ )));
+ }
+ return Ok(Some(resource.to_owned()));
+ }
+ if self.metrics.get(&source.font).is_some_and(|metrics| source_encodes(metrics, text)) {
+ return Ok(Some(source.font.clone()));
+ }
+ if let Some((name, _)) = self.metrics.iter().find(|(_, metrics)| {
+ pdfcraft_fonts::embedding::face_key(&metrics.base_font) == pdfcraft_fonts::embedding::face_key(&source.base_font)
+ && source_encodes(metrics, text)
+ }) {
+ return Ok(Some(name.clone()));
+ }
+ if let Some(face) =
+ pdfcraft_fonts::embedding::matching_faces(&source.base_font).into_iter().find(|face| pdfcraft_fonts::embedding::covers(face.bytes, text))
{
- return Ok(Some((bytes, shaped, family)));
+ return self.embed_face(face.name(), face.bytes, face.family, "the full source font could not be loaded").map(Some);
}
+ let Some(bytes) = self
+ .programs
+ .entry(source.font.clone())
+ .or_insert_with(|| source_program(self.doc, self.fonts, &source.font).map(std::sync::Arc::new))
+ .clone()
+ .filter(|bytes| pdfcraft_fonts::embedding::covers(bytes, text))
+ else {
+ return Ok(None);
+ };
+ let key = format!("source {}", source.font);
+ if let Some(name) = self.full_faces.get(&key) {
+ return Ok(Some(name.clone()));
+ }
+ let family = pdfcraft_fonts::embedding::names(&bytes).map_or_else(|_| source.base_font.clone(), |(family, _)| family);
+ self.embed_face(key, &bytes, &family, "the source font could not be loaded").map(Some)
+ }
+
+ fn embed_face(&mut self, key: String, bytes: &[u8], family: &str, missing_message: &str) -> Result<String, EditError> {
+ if let Some(name) = self.full_faces.get(&key) {
+ return Ok(name.clone());
+ }
+ let name = pdfcraft_fonts::embedding::embed(self.doc, self.fonts, bytes, family).map_err(EditError::Invalid)?;
+ let font =
+ self.fonts.get(name.as_bytes()).and_then(|resource| self.doc.dict(resource)).ok_or_else(|| EditError::Invalid(missing_message.into()))?;
+ self.metrics.insert(name.clone(), Metrics::from_dict(self.doc, &font));
+ self.full_faces.insert(key, name.clone());
+ Ok(name)
+ }
+
+ fn substitute_font(&mut self, source: &TextLine) -> String {
+ let family = source_family(&source.base_font);
+ let base = family.base_font(source.bold, source.italic);
+ let name = format!("PCEd{}", base.replace('-', ""));
+ let mut font = Dict::new();
+ font.set(b"Type".to_vec(), Object::name("Font"));
+ font.set(b"Subtype".to_vec(), Object::name("Type1"));
+ font.set(b"BaseFont".to_vec(), Object::name(base));
+ font.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));
+ self.metrics.entry(name.clone()).or_insert_with(|| Metrics::from_dict(self.doc, &font));
+ self.fonts.set(name.clone().into_bytes(), Object::Dict(font));
+ name
}
- Err(EditError::Invalid("complex text needs the complete source TrueType/OpenType face; load that font before editing".into()))
}
-/// For each output row (a range of the draft's characters), whether it is exactly the source row
-/// at the same position: the same characters, none of them inserted or changed by the edit.
-fn untouched_rows(block: &TextBlock, draft: &str, rows: &[std::ops::Range<usize>]) -> Vec<bool> {
- let old: Vec<char> = block.editor_text.chars().collect();
- let new: Vec<char> = draft.chars().collect();
- let prefix = old.iter().zip(&new).take_while(|(a, b)| a == b).count();
- let suffix = old.iter().rev().zip(new.iter().rev()).take(old.len().min(new.len()).saturating_sub(prefix)).take_while(|(a, b)| a == b).count();
- // The source character a draft character is, if the edit left it alone.
- let origin = |i: usize| {
- if i < prefix {
- Some(i)
- } else if i >= new.len().saturating_sub(suffix) {
- (old.len() + i).checked_sub(new.len())
+struct PreparedCharacters {
+ values: Vec<StyledChar>,
+ substituted: Option<String>,
+}
+
+struct CharacterPreparation<'a> {
+ doc: &'a mut Document,
+ first: &'a TextLine,
+ lines: &'a [TextLine],
+ draft: &'a str,
+ spans: Vec<(std::ops::Range<usize>, usize)>,
+ style: &'a BlockStyle,
+ overrides: &'a HashMap<usize, &'a RangeStyle>,
+ fonts: &'a mut Dict,
+ metrics: &'a mut std::collections::BTreeMap<String, Metrics>,
+ max_glyphs: usize,
+}
+
+impl CharacterPreparation<'_> {
+ fn prepare(self) -> Result<PreparedCharacters, EditError> {
+ let Self { doc, first, lines, draft, spans, style, overrides, fonts, metrics, max_glyphs } = self;
+ let mut chars = Vec::new();
+ let mut substituted = None;
+ let mut fallback = FallbackBuilder::new(max_glyphs);
+ let mut resolver = FontResolver { doc, fonts, metrics, full_faces: HashMap::new(), programs: HashMap::new() };
+ for (range, index) in spans {
+ let source = lines.get(index).unwrap_or(first);
+ let start = range.start;
+ for (offset, ch) in draft.get(range).unwrap_or_default().char_indices() {
+ if ch == '\n' {
+ chars.push((ch, index, source.font.clone()));
+ continue;
+ }
+ if ch == '\r' {
+ let crlf = start.checked_add(offset).and_then(|at| draft.get(at.saturating_add(1)..)).is_some_and(|rest| rest.starts_with('\n'));
+ chars.push((if crlf { '\r' } else { '\n' }, index, source.font.clone()));
+ continue;
+ }
+ let text = ch.to_string();
+ let requested = overrides.get(&index).and_then(|range| range.resource.as_deref()).or(style.resource.as_deref());
+ let name = if let Some(name) = resolver.encodable_font(source, &text, requested)? {
+ name
+ } else if needs_type3(&text) {
+ fallback.prepare(source, ch, &text, chars.len())?
+ } else {
+ let name = resolver.substitute_font(source);
+ substituted = Some(source_family(&source.base_font).base_font(source.bold, source.italic).to_owned());
+ name
+ };
+ chars.push((ch, index, name));
+ }
+ }
+ drop(resolver);
+ for group in fallback.groups {
+ let written = write_type3_glyphs(doc, fonts, group.face, false, group.glyphs, fallback.per_font);
+ for name in &written.names {
+ let font = fonts
+ .get(name.as_bytes())
+ .and_then(|resource| doc.dict(resource))
+ .ok_or_else(|| EditError::Invalid("the fallback font could not be loaded".into()))?;
+ metrics.insert(name.clone(), Metrics::from_dict(doc, &font));
+ }
+ for position in group.positions {
+ let item = chars.get_mut(position).ok_or_else(|| EditError::Invalid("the fallback character is missing".into()))?;
+ let (font, _) = written.codes.get(&item.0).ok_or_else(|| EditError::Invalid("the fallback glyph is missing".into()))?;
+ item.2 = written.names.get(*font).cloned().ok_or_else(|| EditError::Invalid("the fallback font is missing".into()))?;
+ }
+ substituted = Some(written.family.to_owned());
+ }
+ Ok(PreparedCharacters { values: chars, substituted })
+ }
+}
+
+impl FallbackBuilder {
+ fn new(max_glyphs: usize) -> Self {
+ let per_font = max_glyphs.clamp(1, MAX_TYPE3_GLYPHS);
+ Self {
+ groups: Vec::new(),
+ names: std::collections::BTreeMap::new(),
+ glyphs: 0,
+ per_font,
+ budget: per_font.saturating_mul(MAX_STYLED_FALLBACK_BATCHES),
+ }
+ }
+
+ fn prepare(&mut self, source: &TextLine, ch: char, text: &str, position: usize) -> Result<String, EditError> {
+ let key = (source.base_font.clone(), source.bold, ch);
+ let group_index = if let Some(index) = self.names.get(&key) {
+ *index
} else {
- None
+ let (faces, _) = type3_faces(text, source_family(&source.base_font), source.bold)?;
+ let face = fallback_face(&faces, &[ch], |face, ch| japanese_glyph_from(face, ch).is_ok()).ok_or_else(|| no_fallback_font(text))?;
+ let index = self.groups.iter().position(|group| std::ptr::eq(group.face, face)).unwrap_or_else(|| {
+ let index = self.groups.len();
+ self.groups.push(FallbackGroup { face, seen: Default::default(), glyphs: Vec::new(), positions: Vec::new() });
+ index
+ });
+ self.names.insert(key, index);
+ index
+ };
+ let group = self.groups.get_mut(group_index).ok_or_else(|| EditError::Invalid("the fallback face is missing".into()))?;
+ if group.seen.insert(ch) {
+ if self.glyphs >= self.budget {
+ return Err(EditError::Invalid(format!(
+ "the replacement needs more than {} fallback glyphs; edit a smaller paragraph or load a complete font",
+ self.budget
+ )));
+ }
+ let (path, width) = type3_glyph(group.face, ch)?.ok_or_else(|| no_glyph_for(group.face, ch))?;
+ let code = u8::try_from((group.glyphs.len() % self.per_font).saturating_add(1))
+ .map_err(|_| EditError::Invalid("replacement text has too many unique characters".into()))?;
+ group.glyphs.push(Type3Glyph { code, ch, path, width });
+ self.glyphs = self.glyphs.saturating_add(1);
}
- };
- let mut source_rows = Vec::new();
- let mut start = 0;
- for (i, ch) in old.iter().enumerate() {
- if *ch == '\n' {
- source_rows.push(start..i);
- start = i + 1;
+ group.positions.push(position);
+ Ok(String::new())
+ }
+}
+
+struct StyledLines<'a> {
+ lines: Vec<TextLine>,
+ spans: Vec<(std::ops::Range<usize>, usize)>,
+ underlines: HashMap<usize, bool>,
+ overrides: HashMap<usize, &'a RangeStyle>,
+}
+
+type StyledChar = (char, usize, String);
+type StyledRows = Vec<Vec<StyledChar>>;
+type RowRanges = Vec<std::ops::Range<usize>>;
+type ShapedRunCache = HashMap<(usize, usize), (Vec<u8>, pdfcraft_fonts::source_shaping::ShapedRun, String)>;
+
+struct ShapedRows {
+ runs: ShapedRunCache,
+ advances: HashMap<(usize, usize), f64>,
+}
+
+fn prepare_shaped_rows(
+ doc: &Document,
+ fonts: &Dict,
+ rows: &[Vec<StyledChar>],
+ kept: &[bool],
+ advance: impl Fn(&StyledChar) -> f64,
+) -> Result<ShapedRows, EditError> {
+ let mut runs = HashMap::new();
+ let mut advances = HashMap::new();
+ for (row_index, row) in rows.iter().enumerate().filter(|(index, _)| !kept.get(*index).copied().unwrap_or(false)) {
+ let mut at = 0;
+ while let Some(item) = row.get(at) {
+ let mut end = at + 1;
+ while row.get(end).is_some_and(|next| next.1 == item.1 && next.2 == item.2) {
+ end += 1;
+ }
+ let segment = row.get(at..end).unwrap_or_default();
+ advances.insert((row_index, at), segment.iter().map(&advance).sum::<f64>());
+ let text: String = segment.iter().map(|character| character.0).collect();
+ if let Some((bytes, shaped, family)) = shape_source(doc, fonts, &item.2, &text)? {
+ runs.insert((row_index, at), (bytes, shaped, family));
+ }
+ at = end;
}
}
- source_rows.push(start..old.len());
- // A line break inside a source run would pair editor rows with the wrong visual rows.
- if source_rows.len() != block.rows.len() {
- return vec![false; rows.len()];
+ Ok(ShapedRows { runs, advances })
+}
+
+fn embed_shaped_resources(doc: &mut Document, fonts: &mut Dict, runs: &ShapedRunCache) -> Result<HashMap<(usize, usize), String>, EditError> {
+ let mut resources = HashMap::new();
+ for (key, (bytes, shaped, family)) in runs {
+ let mappings: Vec<_> = shaped.glyphs.iter().map(|glyph| (glyph.text.clone(), glyph.id)).collect();
+ let resource = pdfcraft_fonts::embedding::embed_mapping(doc, fonts, bytes, family, &mappings).map_err(EditError::Invalid)?;
+ resources.insert(*key, resource);
}
- rows.iter()
- .enumerate()
- .map(|(r, range)| {
- source_rows.get(r).is_some_and(|source| {
- !range.is_empty() && range.len() == source.len() && range.clone().zip(source.clone()).all(|(i, j)| origin(i) == Some(j))
- })
- })
- .collect()
+ Ok(resources)
}
-/// Rewrite visual rows while keeping the source style on each surviving character. Resource
-/// names may differ between Unicode subsets of the same face; encoding searches those subsets.
-pub(crate) fn rewrite_styled_block(
- doc: &mut Document,
- page: usize,
- block: &TextBlock,
+fn validate_contextual_rows(rows: &[Vec<StyledChar>], kept: &[bool]) -> Result<(), EditError> {
+ for (row, _) in rows.iter().zip(kept).filter(|(_, retained)| !**retained) {
+ let text: String = row.iter().map(|character| character.0).collect();
+ if pdfcraft_fonts::source_shaping::required(&text)
+ && row.first().is_some_and(|first| row.iter().any(|character| character.1 != first.1 || character.2 != first.2))
+ {
+ return Err(EditError::Invalid(
+ "contextual/bidi text across font or style boundaries needs a uniform full-face row; mixed contextual runs are not yet supported"
+ .into(),
+ ));
+ }
+ }
+ Ok(())
+}
+
+fn calibration_factors(
lines: &[TextLine],
- text: Option<&str>,
+ metrics: &std::collections::BTreeMap<String, Metrics>,
style: &BlockStyle,
- max_glyphs: usize,
-) -> Result<LineEdit, EditError> {
- let first = block.lines.first().and_then(|i| lines.get(*i)).ok_or_else(|| EditError::Invalid("the paragraph has no source runs".into()))?;
+ overrides: &HashMap<usize, &RangeStyle>,
+ space_of: impl Fn(&str, &Metrics) -> f64,
+) -> HashMap<usize, f64> {
+ let mut calibration = HashMap::new();
+ for (index, source) in lines.iter().enumerate() {
+ if let Some(metrics) = metrics.get(&source.font) {
+ let nominal = source_width(
+ metrics,
+ &source.text,
+ source.origin.state.font.as_ref().map_or(1.0, |(_, size)| *size),
+ space_of(&source.font, metrics),
+ source.origin.state.char_spacing,
+ source.origin.state.word_spacing,
+ ) * source.origin.state.scale
+ * across(source);
+ let changed_face =
+ style.resource.is_some() || overrides.get(&index).is_some_and(|range| range.family.is_some() || range.resource.is_some());
+ let factor = if nominal > 0.0 && !changed_face { ((source.rect[2] - source.rect[0]) / nominal).clamp(0.5, 2.0) } else { 1.0 };
+ calibration.insert(index, factor);
+ }
+ }
+ calibration
+}
+
+fn validated_ranges<'a>(draft: &str, style: &'a BlockStyle) -> Result<Vec<&'a RangeStyle>, EditError> {
+ let mut ranges: Vec<_> = style.ranges.iter().collect();
+ ranges.sort_by_key(|range| range.range.start);
+ let invalid_range = ranges.iter().any(|range| {
+ range.range.start >= range.range.end
+ || draft.get(range.range.clone()).is_none()
+ || [range.size, range.char_spacing, range.scale].iter().flatten().any(|value| !value.is_finite())
+ || range.size.is_some_and(|value| value <= 0.0 || value > 14_400.0)
+ || range.color.is_some_and(|color| color.iter().any(|value| !value.is_finite() || !(0.0..=1.0).contains(value)))
+ });
+ if ranges.len() > 1024 || invalid_range || ranges.windows(2).any(|pair| pair[0].range.end > pair[1].range.start) {
+ return Err(EditError::Invalid("text style ranges must be disjoint UTF-8 boundaries with finite formatting (at most 1024 ranges)".into()));
+ }
+ Ok(ranges)
+}
+
+fn replacement_text<'a>(block: &'a TextBlock, text: Option<&'a str>) -> Result<&'a str, EditError> {
let draft = match text {
- Some(t) if t != block.text => t,
+ Some(text) if text != block.text => text,
_ => &block.editor_text,
};
if draft.len() > 4_000_000 {
return Err(EditError::Invalid("the replacement text is too large".into()));
}
- if draft == block.editor_text && *style == BlockStyle::default() {
- return Ok(LineEdit { substituted: None });
+ Ok(draft)
+}
+
+fn has_no_effective_style_change(block: &TextBlock, draft: &str, style: &BlockStyle) -> bool {
+ draft == block.editor_text && *style == BlockStyle::default()
+}
+
+fn page_font_metrics(
+ doc: &Document,
+ resource_dict: &Dict,
+ block: &TextBlock,
+ lines: &[TextLine],
+) -> (Dict, std::collections::BTreeMap<String, Metrics>) {
+ let mut fonts = resource_dict.get(b"Font").and_then(|resource| doc.resolve(resource).as_dict().cloned()).unwrap_or_default();
+ for line in lines.iter().filter(|line| line.font.starts_with("PCRange")) {
+ let mut font = Dict::new();
+ font.set(b"Type".to_vec(), Object::name("Font"));
+ font.set(b"Subtype".to_vec(), Object::name("Type1"));
+ font.set(b"BaseFont".to_vec(), Object::name(&line.base_font));
+ font.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));
+ fonts.set(line.font.as_bytes().to_vec(), Object::Dict(font));
}
- let mut ranges: Vec<_> = style.ranges.iter().collect();
- ranges.sort_by_key(|r| r.range.start);
- if ranges.len() > 1024
- || ranges.iter().any(|r| {
- r.range.start >= r.range.end
- || draft.get(r.range.clone()).is_none()
- || [r.size, r.char_spacing, r.scale].iter().flatten().any(|n| !n.is_finite())
- || r.size.is_some_and(|n| n <= 0.0 || n > 14400.0)
- || r.color.is_some_and(|c| c.iter().any(|n| !n.is_finite() || !(0.0..=1.0).contains(n)))
- })
- || ranges.windows(2).any(|r| r[0].range.end > r[1].range.start)
+ let mut metrics = std::collections::BTreeMap::new();
+ for (name, object) in fonts.iter().take(256) {
+ if let Some(font) = doc.resolve(object).as_dict() {
+ metrics.insert(String::from_utf8_lossy(name).into_owned(), Metrics::from_dict(doc, font));
+ }
+ }
+ for index in &block.lines {
+ if let Some(line) = lines.get(*index)
+ && !metrics.contains_key(&line.font)
+ && let Some(font) = fonts.get(line.font.as_bytes()).and_then(|resource| doc.resolve(resource).as_dict().cloned())
+ {
+ metrics.insert(line.font.clone(), Metrics::from_dict(doc, &font));
+ }
+ }
+ (fonts, metrics)
+}
+
+fn paragraph_geometry(doc: &Document, page: &pdfcraft_model::Page, block: &TextBlock, style: &BlockStyle) -> Result<(f64, f64, f64), EditError> {
+ if [style.size, style.line_spacing, style.char_spacing, style.scale, style.width].iter().flatten().any(|value| !value.is_finite())
+ || style.color.is_some_and(|color| color.iter().any(|value| !value.is_finite()))
{
- return Err(EditError::Invalid("text style ranges must be disjoint UTF-8 boundaries with finite formatting (at most 1024 ranges)".into()));
+ return Err(EditError::Invalid("the paragraph's formatting must use finite numbers".into()));
}
- let source_count = lines.len();
+ let [dx, dy] = style.offset.unwrap_or([0.0, 0.0]);
+ if !dx.is_finite() || !dy.is_finite() || style.width.is_some_and(|width| !width.is_finite()) {
+ return Err(EditError::Invalid("the paragraph's position and width must be finite".into()));
+ }
+ let natural = if block.invisible || block.rows.len() == 1 {
+ (page.crop(doc)[2] - 36.0 - (block.rect[0] + dx)).max(block.rect[2] - block.rect[0])
+ } else {
+ block.rect[2] - block.rect[0]
+ };
+ Ok((dx, dy, style.width.unwrap_or(natural).clamp(1.0, 14_400.0)))
+}
+
+fn wrap_styled_rows(
+ chars: &[StyledChar],
+ width: f64,
+ measure: impl Fn(&[StyledChar]) -> Result<f64, EditError>,
+) -> Result<(StyledRows, RowRanges), EditError> {
+ let mut rows: Vec<Vec<StyledChar>> = Vec::new();
+ let mut row_ranges = Vec::new();
+ let mut row_start = 0;
+ let mut row = Vec::new();
+ let mut row_width = 0.0;
+ let mut at = 0;
+ while at < chars.len() {
+ let Some(item) = chars.get(at) else { break };
+ if item.0 == '\r' {
+ at += 1;
+ continue;
+ }
+ if item.0 == '\n' {
+ row_ranges.push(row_start..row_start + row.len());
+ rows.push(std::mem::take(&mut row));
+ row_width = 0.0;
+ at += 1;
+ row_start = at;
+ continue;
+ }
+ let mut end = at + 1;
+ if !item.0.is_whitespace() {
+ // A word ends at a space, or where Chinese or Japanese text may break between characters.
+ while let (Some(before), Some(current)) = (chars.get(end - 1), chars.get(end))
+ && !current.0.is_whitespace()
+ && !crate::linebreak::between(before.0, current.0)
+ {
+ end += 1;
+ }
+ }
+ let word = chars.get(at..end).unwrap_or_default();
+ let word_width = measure(word)?;
+ if !row.is_empty() && !item.0.is_whitespace() && row_width + word_width > width + 0.5 {
+ while row.last().is_some_and(|c: &StyledChar| c.0.is_whitespace()) {
+ row.pop();
+ }
+ row_ranges.push(row_start..row_start + row.len());
+ rows.push(std::mem::take(&mut row));
+ row_width = 0.0;
+ row_start = at;
+ }
+ row.extend_from_slice(word);
+ row_width += word_width;
+ at = end;
+ }
+ if !row.is_empty() {
+ row_ranges.push(row_start..row_start + row.len());
+ rows.push(row);
+ }
+ Ok((rows, row_ranges))
+}
+
+fn apply_range_styles<'a>(
+ first: &TextLine,
+ block: &TextBlock,
+ lines: &[TextLine],
+ draft: &str,
+ ranges: &[&'a RangeStyle],
+ style: &BlockStyle,
+) -> StyledLines<'a> {
let mut styled_lines = lines.to_vec();
let mut styled_spans = Vec::new();
let mut underlines = HashMap::new();
let mut overrides = HashMap::new();
for (span, source) in block.edited_spans(draft) {
let mut edges = vec![span.start, span.end];
- for r in &ranges {
- for edge in [r.range.start, r.range.end] {
+ for range in ranges {
+ for edge in [range.range.start, range.range.end] {
if span.contains(&edge) {
edges.push(edge);
}
@@ -138,8 +483,8 @@ pub(crate) fn rewrite_styled_block(
edges.dedup();
for bounds in edges.windows(2) {
let (Some(start), Some(end)) = (bounds.first().copied(), bounds.get(1).copied()) else { continue };
+ let selected = ranges.iter().find(|range| range.range.contains(&start)).copied();
let mut index = source;
- let selected = ranges.iter().find(|r| r.range.contains(&start)).copied();
if selected.is_some() || style.family.is_some() || style.bold.is_some() {
let default_range = RangeStyle {
range: start..end,
@@ -151,10 +496,10 @@ pub(crate) fn rewrite_styled_block(
char_spacing: None,
scale: None,
};
- let r = selected.unwrap_or(&default_range);
+ let range = selected.unwrap_or(&default_range);
let mut line = lines.get(source).unwrap_or(first).clone();
if let Some((family, bold, italic)) =
- r.family.or(style.family).or_else(|| style.bold.map(|b| (source_family(&line.base_font), b, line.italic)))
+ range.family.or(style.family).or_else(|| style.bold.map(|b| (source_family(&line.base_font), b, line.italic)))
{
let base = family.base_font(bold, italic);
line.font = format!("PCRange{}", base.replace('-', ""));
@@ -162,225 +507,192 @@ pub(crate) fn rewrite_styled_block(
line.bold = bold;
line.italic = italic;
}
- if let Some(resource) = &r.resource {
+ if let Some(resource) = &range.resource {
line.font = resource.clone();
}
- if let Some(size) = r.size {
+ if let Some(size) = range.size {
line.size = size;
}
- if let Some(color) = r.color {
+ if let Some(color) = range.color {
line.color = color;
line.origin.state.fill = vec![Op::new("rg", color.map(Object::Real).to_vec())];
}
- if let Some(spacing) = r.char_spacing {
+ if let Some(spacing) = range.char_spacing {
line.origin.state.char_spacing = spacing / line.origin.k.max(1e-6);
}
- if let Some(scale) = r.scale {
+ if let Some(scale) = range.scale {
line.origin.state.scale = (scale / 100.0).clamp(0.1, 10.0);
}
index = styled_lines.len();
styled_lines.push(line);
- if let Some(r) = selected {
- overrides.insert(index, r);
+ if let Some(range) = selected {
+ overrides.insert(index, range);
}
- if let Some(underline) = r.underline {
+ if let Some(underline) = range.underline {
underlines.insert(index, underline);
}
}
styled_spans.push((start..end, index));
}
}
- let lines = styled_lines.as_slice();
- let p = page_dict(doc, page)?;
- let mut res = p.dict.get(b"Resources").and_then(|r| doc.resolve(r).as_dict().cloned()).unwrap_or_default();
- let mut fonts = res.get(b"Font").and_then(|r| doc.resolve(r).as_dict().cloned()).unwrap_or_default();
- for line in lines.iter().filter(|line| line.font.starts_with("PCRange")) {
- let mut f = Dict::new();
- f.set(b"Type".to_vec(), Object::name("Font"));
- f.set(b"Subtype".to_vec(), Object::name("Type1"));
- f.set(b"BaseFont".to_vec(), Object::name(&line.base_font));
- f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));
- fonts.set(line.font.as_bytes().to_vec(), Object::Dict(f));
- }
- let mut metrics = std::collections::BTreeMap::new();
- for (name, object) in fonts.iter().take(256) {
- if let Some(font) = doc.resolve(object).as_dict() {
- metrics.insert(String::from_utf8_lossy(name).into_owned(), Metrics::from_dict(doc, font));
- }
+ StyledLines { lines: styled_lines, spans: styled_spans, underlines, overrides }
+}
+
+/// Shape in the source or an explicitly registered matching full face. Never use interface fonts.
+fn shape_source(
+ doc: &Document,
+ fonts: &Dict,
+ name: &str,
+ text: &str,
+) -> Result<Option<(Vec<u8>, pdfcraft_fonts::source_shaping::ShapedRun, String)>, EditError> {
+ if !pdfcraft_fonts::source_shaping::required(text) {
+ return Ok(None);
}
- for index in &block.lines {
- if let Some(line) = lines.get(*index)
- && !metrics.contains_key(&line.font)
- && let Some(font) = fonts.get(line.font.as_bytes()).and_then(|f| doc.resolve(f).as_dict().cloned())
+ let source =
+ fonts.get(name.as_bytes()).and_then(|f| doc.dict(f)).ok_or_else(|| EditError::Invalid("the shaped text has no font resource".into()))?;
+ let family = Metrics::from_dict(doc, &source).base_font;
+ let mut candidates = vec![source];
+ candidates.extend(
+ fonts
+ .iter()
+ .filter_map(|(_, f)| doc.dict(f))
+ .filter(|f| pdfcraft_fonts::embedding::face_key(&Metrics::from_dict(doc, f).base_font) == pdfcraft_fonts::embedding::face_key(&family)),
+ );
+ for font in candidates {
+ if let Some(bytes) = pdfcraft_fonts::pdf::embedded_sfnt(doc, &font)
+ && pdfcraft_fonts::embedding::covers(&bytes, text)
+ && let Ok(shaped) = pdfcraft_fonts::source_shaping::shape(&bytes, text)
{
- metrics.insert(line.font.clone(), Metrics::from_dict(doc, &font));
+ return Ok(Some((bytes, shaped, family)));
}
}
- if [style.size, style.line_spacing, style.char_spacing, style.scale, style.width].iter().flatten().any(|v| !v.is_finite())
- || style.color.is_some_and(|c| c.iter().any(|v| !v.is_finite()))
- {
- return Err(EditError::Invalid("the paragraph's formatting must use finite numbers".into()));
- }
- let [dx, dy] = style.offset.unwrap_or([0.0, 0.0]);
- if !dx.is_finite() || !dy.is_finite() || style.width.is_some_and(|w| !w.is_finite()) {
- return Err(EditError::Invalid("the paragraph's position and width must be finite".into()));
- }
- // A visual row grows even when it contains several source/font runs. Multi-row
- // paragraphs retain their container width; an explicit width always wins.
- let natural = if block.invisible || block.rows.len() == 1 {
- (p.crop(doc)[2] - 36.0 - (block.rect[0] + dx)).max(block.rect[2] - block.rect[0])
- } else {
- block.rect[2] - block.rect[0]
+ Err(EditError::Invalid("complex text needs the complete source TrueType/OpenType face; load that font before editing".into()))
+}
+
+/// For each output row (a range of the draft's characters), whether it is exactly the source row
+/// at the same position: the same characters, none of them inserted or changed by the edit.
+fn untouched_rows(block: &TextBlock, draft: &str, rows: &[std::ops::Range<usize>]) -> Vec<bool> {
+ let old: Vec<char> = block.editor_text.chars().collect();
+ let new: Vec<char> = draft.chars().collect();
+ let prefix = old.iter().zip(&new).take_while(|(a, b)| a == b).count();
+ let suffix = old.iter().rev().zip(new.iter().rev()).take(old.len().min(new.len()).saturating_sub(prefix)).take_while(|(a, b)| a == b).count();
+ // The source character a draft character is, if the edit left it alone.
+ let origin = |i: usize| {
+ if i < prefix {
+ Some(i)
+ } else if i >= new.len().saturating_sub(suffix) {
+ (old.len() + i).checked_sub(new.len())
+ } else {
+ None
+ }
};
- let width = style.width.unwrap_or(natural).clamp(1.0, 14_400.0);
- // Each tuple is a character, its source style and an encodable resource name.
- let mut chars = Vec::new();
- let mut substituted = None;
- let mut fallback_groups: Vec<FallbackGroup> = Vec::new();
- let mut fallback_names: std::collections::BTreeMap<(String, bool, char), usize> = std::collections::BTreeMap::new();
- let mut fallback_glyphs = 0_usize;
- let per_font = max_glyphs.clamp(1, MAX_TYPE3_GLYPHS);
- let fallback_budget = per_font.saturating_mul(MAX_STYLED_FALLBACK_BATCHES);
- let mut full_faces: HashMap<String, String> = HashMap::new();
- let mut programs: HashMap<String, Option<std::sync::Arc<Vec<u8>>>> = HashMap::new();
- for (range, index) in styled_spans {
- let source = lines.get(index).unwrap_or(first);
- let start = range.start;
- for (offset, ch) in draft.get(range).unwrap_or_default().char_indices() {
- if ch == '\n' {
- chars.push((ch, index, source.font.clone()));
- continue;
- }
- // A carriage return breaks the row too. Before `\n` the pair is one break, so the
- // CR stays a `\r` the rows skip. Either way it keeps its place among the draft's
- // characters, which rows are counted in.
- if ch == '\r' {
- let crlf = start.checked_add(offset).and_then(|at| draft.get(at.saturating_add(1)..)).is_some_and(|rest| rest.starts_with('\n'));
- chars.push((if crlf { '\r' } else { '\n' }, index, source.font.clone()));
- continue;
- }
- let s = ch.to_string();
- let name = if let Some(resource) = overrides.get(&index).and_then(|r| r.resource.as_ref()).or(style.resource.as_ref()) {
- if !metrics.get(resource).is_some_and(|m| source_encodes(m, &s)) {
- return Err(EditError::Invalid(format!("the selected font resource {resource} cannot show U+{:04X}", u32::from(ch))));
- }
- resource.clone()
- } else if metrics.get(&source.font).is_some_and(|m| source_encodes(m, &s)) {
- source.font.clone()
- } else if let Some((name, _)) = metrics.iter().find(|(_, m)| {
- pdfcraft_fonts::embedding::face_key(&m.base_font) == pdfcraft_fonts::embedding::face_key(&source.base_font) && source_encodes(m, &s)
- }) {
- name.clone()
- } else if let Some(face) =
- pdfcraft_fonts::embedding::matching_faces(&source.base_font).into_iter().find(|f| pdfcraft_fonts::embedding::covers(f.bytes, &s))
- {
- let key = face.name();
- if let Some(name) = full_faces.get(&key) {
- name.clone()
- } else {
- let name = pdfcraft_fonts::embedding::embed(doc, &mut fonts, face.bytes, face.family).map_err(EditError::Invalid)?;
- let font = fonts
- .get(name.as_bytes())
- .and_then(|f| doc.dict(f))
- .ok_or_else(|| EditError::Invalid("the full source font could not be loaded".into()))?;
- metrics.insert(name.clone(), Metrics::from_dict(doc, &font));
- full_faces.insert(key, name.clone());
- name
- }
- } else if let Some(bytes) = programs
- .entry(source.font.clone())
- .or_insert_with(|| source_program(doc, &fonts, &source.font).map(std::sync::Arc::new))
- .clone()
- .filter(|bytes| pdfcraft_fonts::embedding::covers(bytes, &s))
- {
- // The document's own complete program of this font has the glyph: draw it with
- // that face rather than another family's fallback.
- let key = format!("source {}", source.font);
- if let Some(name) = full_faces.get(&key) {
- name.clone()
- } else {
- let family = pdfcraft_fonts::embedding::names(&bytes).map_or_else(|_| source.base_font.clone(), |(family, _)| family);
- let name = pdfcraft_fonts::embedding::embed(doc, &mut fonts, &bytes, &family).map_err(EditError::Invalid)?;
- let font = fonts
- .get(name.as_bytes())
- .and_then(|f| doc.dict(f))
- .ok_or_else(|| EditError::Invalid("the source font could not be loaded".into()))?;
- metrics.insert(name.clone(), Metrics::from_dict(doc, &font));
- full_faces.insert(key, name.clone());
- name
- }
- } else {
- let family = source_family(&source.base_font);
- if needs_type3(&s) {
- let key = (source.base_font.clone(), source.bold, ch);
- let group_index = if let Some(index) = fallback_names.get(&key) {
- *index
- } else {
- // Keep the old per-character face choice: a serif Japanese character
- // and a Cyrillic character may need different faces even in one style.
- // Hebrew uses the separate RTL path before reaching this writer.
- let (faces, _) = type3_faces(&s, family, source.bold)?;
- let face =
- fallback_face(&faces, &[ch], |face, ch| japanese_glyph_from(face, ch).is_ok()).ok_or_else(|| no_fallback_font(&s))?;
- let index = fallback_groups.iter().position(|group| std::ptr::eq(group.face, face)).unwrap_or_else(|| {
- let index = fallback_groups.len();
- fallback_groups.push(FallbackGroup { face, seen: Default::default(), glyphs: Vec::new(), positions: Vec::new() });
- index
- });
- fallback_names.insert(key, index);
- index
- };
- let group = fallback_groups.get_mut(group_index).ok_or_else(|| EditError::Invalid("the fallback face is missing".into()))?;
- if group.seen.insert(ch) {
- if fallback_glyphs >= fallback_budget {
- return Err(EditError::Invalid(format!(
- "the replacement needs more than {fallback_budget} fallback glyphs; edit a smaller paragraph or load a complete font"
- )));
- }
- let (path, width) = type3_glyph(group.face, ch)?.ok_or_else(|| no_glyph_for(group.face, ch))?;
- let code = u8::try_from((group.glyphs.len() % per_font).saturating_add(1))
- .map_err(|_| EditError::Invalid("replacement text has too many unique characters".into()))?;
- group.glyphs.push(Type3Glyph { code, ch, path, width });
- fallback_glyphs = fallback_glyphs.saturating_add(1);
- }
- group.positions.push(chars.len());
- // Filled from the prepared font/code map before measuring or drawing.
- String::new()
- } else {
- let base = family.base_font(source.bold, source.italic);
- let name = format!("PCEd{}", base.replace('-', ""));
- let mut f = Dict::new();
- f.set(b"Type".to_vec(), Object::name("Font"));
- f.set(b"Subtype".to_vec(), Object::name("Type1"));
- f.set(b"BaseFont".to_vec(), Object::name(base));
- f.set(b"Encoding".to_vec(), Object::name("WinAnsiEncoding"));
- metrics.entry(name.clone()).or_insert_with(|| Metrics::from_dict(doc, &f));
- fonts.set(name.clone().into_bytes(), Object::Dict(f));
- substituted = Some(base.to_string());
- name
- }
- };
- chars.push((ch, index, name));
+ let mut source_rows = Vec::new();
+ let mut start = 0;
+ for (i, ch) in old.iter().enumerate() {
+ if *ch == '\n' {
+ source_rows.push(start..i);
+ start = i + 1;
}
}
- // All fallback outlines have now succeeded. Batch by actual face, preserving source
- // style indices; the existing writer then coalesces adjacent equal-font/style characters.
- for group in fallback_groups {
- let fallback = write_type3_glyphs(doc, &mut fonts, group.face, false, group.glyphs, per_font);
- for name in &fallback.names {
- let font = fonts
- .get(name.as_bytes())
- .and_then(|f| doc.dict(f))
- .ok_or_else(|| EditError::Invalid("the fallback font could not be loaded".into()))?;
- metrics.insert(name.clone(), Metrics::from_dict(doc, &font));
- }
- for position in group.positions {
- let item = chars.get_mut(position).ok_or_else(|| EditError::Invalid("the fallback character is missing".into()))?;
- let (font, _) = fallback.codes.get(&item.0).ok_or_else(|| EditError::Invalid("the fallback glyph is missing".into()))?;
- item.2 = fallback.names.get(*font).cloned().ok_or_else(|| EditError::Invalid("the fallback font is missing".into()))?;
+ source_rows.push(start..old.len());
+ // A line break inside a source run would pair editor rows with the wrong visual rows.
+ if source_rows.len() != block.rows.len() {
+ return vec![false; rows.len()];
+ }
+ rows.iter()
+ .enumerate()
+ .map(|(r, range)| {
+ source_rows.get(r).is_some_and(|source| {
+ !range.is_empty() && range.len() == source.len() && range.clone().zip(source.clone()).all(|(i, j)| origin(i) == Some(j))
+ })
+ })
+ .collect()
+}
+
+struct RewriteAnchor<'a> {
+ lead: &'a TextLine,
+ drop: std::collections::HashSet<usize>,
+ start: usize,
+ split: bool,
+}
+
+fn rewrite_anchor<'a>(
+ block: &TextBlock,
+ lines: &'a [TextLine],
+ first: &'a TextLine,
+ ops: &[Op],
+ kept_lines: &std::collections::HashSet<usize>,
+ kept: &mut [bool],
+) -> RewriteAnchor<'a> {
+ let rewritten: Vec<&TextLine> = block.lines.iter().filter(|index| !kept_lines.contains(index)).filter_map(|index| lines.get(*index)).collect();
+ let lead = rewritten
+ .last()
+ .copied()
+ .filter(|_| !rewritten.iter().flat_map(|line| &line.ops).any(|index| ops.get(*index).is_some_and(|op| op.is("'") || op.is("\""))));
+ let (members, lead) = match lead {
+ Some(lead) if !kept_lines.is_empty() => (rewritten, lead),
+ _ => {
+ kept.iter_mut().for_each(|value| *value = false);
+ let all: Vec<&TextLine> = block.lines.iter().filter_map(|index| lines.get(*index)).collect();
+ let last = all.last().copied().unwrap_or(first);
+ (all, last)
}
- substituted = Some(fallback.family.to_owned());
+ };
+ let origin = &lead.origin;
+ let mut drop = coincident_ops(lines, &members);
+ drop.extend(members.iter().flat_map(|line| line.ops.iter().copied()));
+ let start = lead.ops.first().copied().unwrap_or(origin.bt_op);
+ let split = ops
+ .get(origin.bt_op..start)
+ .unwrap_or_default()
+ .iter()
+ .enumerate()
+ .any(|(index, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !drop.contains(&(origin.bt_op + index)));
+ RewriteAnchor { lead, drop, start, split }
+}
+
+/// Rewrite visual rows while keeping the source style on each surviving character. Resource
+/// names may differ between Unicode subsets of the same face; encoding searches those subsets.
+pub(crate) fn rewrite_styled_block(
+ doc: &mut Document,
+ page: usize,
+ block: &TextBlock,
+ lines: &[TextLine],
+ text: Option<&str>,
+ style: &BlockStyle,
+ max_glyphs: usize,
+) -> Result<LineEdit, EditError> {
+ let first = block.lines.first().and_then(|i| lines.get(*i)).ok_or_else(|| EditError::Invalid("the paragraph has no source runs".into()))?;
+ let draft = replacement_text(block, text)?;
+ if has_no_effective_style_change(block, draft, style) {
+ return Ok(LineEdit { substituted: None });
+ }
+ let ranges = validated_ranges(draft, style)?;
+ let source_count = lines.len();
+ let styled = apply_range_styles(first, block, lines, draft, &ranges, style);
+ let lines = styled.lines.as_slice();
+ let styled_spans = styled.spans;
+ let underlines = styled.underlines;
+ let overrides = styled.overrides;
+ let p = page_dict(doc, page)?;
+ let mut res = p.dict.get(b"Resources").and_then(|resource| doc.resolve(resource).as_dict().cloned()).unwrap_or_default();
+ let (mut fonts, mut metrics) = page_font_metrics(doc, &res, block, lines);
+ let (dx, dy, width) = paragraph_geometry(doc, &p, block, style)?;
+ let prepared = CharacterPreparation {
+ doc,
+ first,
+ lines,
+ draft,
+ spans: styled_spans,
+ style,
+ overrides: &overrides,
+ fonts: &mut fonts,
+ metrics: &mut metrics,
+ max_glyphs,
}
+ .prepare()?;
+ let chars = prepared.values;
+ let substituted = prepared.substituted;
let size_of = |source: &TextLine, index: usize| {
overrides.get(&index).and_then(|r| r.size).or(style.size).unwrap_or(source.size).max(0.1) / source.origin.k.max(1e-6)
};
@@ -400,23 +712,7 @@ pub(crate) fn rewrite_styled_block(
spaces.borrow_mut().insert(name.to_owned(), w);
w
};
- let mut calibration = HashMap::new();
- for (index, source) in lines.iter().enumerate() {
- if let Some(m) = metrics.get(&source.font) {
- let nominal = source_width(
- m,
- &source.text,
- source.origin.state.font.as_ref().map_or(1.0, |(_, s)| *s),
- space_of(&source.font, m),
- source.origin.state.char_spacing,
- source.origin.state.word_spacing,
- ) * source.origin.state.scale
- * across(source);
- let changed_face = style.resource.is_some() || overrides.get(&index).is_some_and(|r| r.family.is_some() || r.resource.is_some());
- let factor = if nominal > 0.0 && !changed_face { ((source.rect[2] - source.rect[0]) / nominal).clamp(0.5, 2.0) } else { 1.0 };
- calibration.insert(index, factor);
- }
- }
+ let calibration = calibration_factors(lines, &metrics, style, &overrides, space_of);
let advance = |item: &(char, usize, String)| -> f64 {
let source = lines.get(item.1).unwrap_or(first);
let Some(m) = metrics.get(&item.2) else { return 0.0 };
@@ -466,58 +762,7 @@ pub(crate) fn rewrite_styled_block(
}
Ok(width)
};
- let mut rows: Vec<Vec<(char, usize, String)>> = Vec::new();
- // Each row's characters, as indexes into the draft's characters (`chars` holds all of them).
- let mut row_ranges = Vec::new();
- let mut row_start = 0;
- let mut row = Vec::new();
- let mut row_width = 0.0;
- // Wrap at word boundaries, retaining explicit source row breaks and whitespace.
- let mut at = 0;
- while at < chars.len() {
- let Some(item) = chars.get(at) else { break };
- // The CR of a CRLF: the `\n` after it breaks the row.
- if item.0 == '\r' {
- at += 1;
- continue;
- }
- if item.0 == '\n' {
- row_ranges.push(row_start..row_start + row.len());
- rows.push(std::mem::take(&mut row));
- row_width = 0.0;
- at += 1;
- row_start = at;
- continue;
- }
- let mut end = at + 1;
- if !item.0.is_whitespace() {
- // A word ends at a space, or where Chinese or Japanese text may break between characters.
- while let (Some(before), Some(c)) = (chars.get(end - 1), chars.get(end))
- && !c.0.is_whitespace()
- && !crate::linebreak::between(before.0, c.0)
- {
- end += 1;
- }
- }
- let word = chars.get(at..end).unwrap_or_default();
- let w = measure(word)?;
- if !row.is_empty() && !item.0.is_whitespace() && row_width + w > width + 0.5 {
- while row.last().is_some_and(|c: &(char, usize, String)| c.0.is_whitespace()) {
- row.pop();
- }
- row_ranges.push(row_start..row_start + row.len());
- rows.push(std::mem::take(&mut row));
- row_width = 0.0;
- row_start = at;
- }
- row.extend_from_slice(word);
- row_width += w;
- at = end;
- }
- if !row.is_empty() {
- row_ranges.push(row_start..row_start + row.len());
- rows.push(row);
- }
+ let (rows, row_ranges) = wrap_styled_rows(&chars, width, measure)?;
let streams = content_streams(doc, &p.dict)?;
let pieces = Pieces::join(&streams.iter().map(|(_, d)| d.as_slice()).collect::<Vec<_>>());
let ops = pieces.parse().ops;
@@ -531,65 +776,18 @@ pub(crate) fn rewrite_styled_block(
};
let kept_lines: std::collections::HashSet<usize> =
kept.iter().enumerate().filter(|(_, k)| **k).filter_map(|(r, _)| block.rows.get(r)).flatten().copied().collect();
- let rewritten: Vec<&TextLine> = block.lines.iter().filter(|i| !kept_lines.contains(i)).filter_map(|i| lines.get(*i)).collect();
- // The rewrite goes where the last rewritten row was drawn, after any backgrounds painted
- // between the rows. A dropped `'` or `"` also moved to the next line, which a kept row relies on.
- let lead =
- rewritten.last().copied().filter(|_| !rewritten.iter().flat_map(|l| &l.ops).any(|i| ops.get(*i).is_some_and(|op| op.is("'") || op.is("\""))));
- let (members, lead) = match lead {
- Some(lead) if !kept_lines.is_empty() => (rewritten, lead),
- _ => {
- kept.iter_mut().for_each(|k| *k = false);
- let all: Vec<&TextLine> = block.lines.iter().filter_map(|i| lines.get(*i)).collect();
- let last = all.last().copied().unwrap_or(first);
- (all, last)
- }
- };
+ // The rewrite is placed after the last rewritten row unless a text-show operator there
+ // would make a kept following row depend on that position.
+ let anchor = rewrite_anchor(block, lines, first, &ops, &kept_lines, &mut kept);
+ let RewriteAnchor { lead, drop, start, split } = anchor;
let o = &lead.origin;
- let mut drop = coincident_ops(lines, &members);
- drop.extend(members.iter().flat_map(|l| l.ops.iter().copied()));
- let start = lead.ops.first().copied().unwrap_or(o.bt_op);
- let split = ops
- .get(o.bt_op..start)
- .unwrap_or_default()
- .iter()
- .enumerate()
- .any(|(i, op)| matches!(op.op.as_slice(), b"Tj" | b"TJ" | b"'" | b"\"") && !drop.contains(&(o.bt_op + i)));
// What is in force where the rewrite is drawn, and what the text after it expects.
let after = if split { &o.state } else { &o.bt_state };
- for (row, _) in rows.iter().zip(&kept).filter(|(_, k)| !**k) {
- let text: String = row.iter().map(|v| v.0).collect();
- if pdfcraft_fonts::source_shaping::required(&text) && row.first().is_some_and(|first| row.iter().any(|v| v.1 != first.1 || v.2 != first.2)) {
- return Err(EditError::Invalid(
- "contextual/bidi text across font or style boundaries needs a uniform full-face row; mixed contextual runs are not yet supported"
- .into(),
- ));
- }
- }
- let measured: Vec<_> = rows.iter().map(|r| measure(r)).collect::<Result<_, _>>()?;
- let mut shaped_runs = HashMap::new();
- let mut segment_advances = HashMap::new();
- for (row_index, row) in rows.iter().enumerate().filter(|(r, _)| !kept.get(*r).copied().unwrap_or(false)) {
- let mut at = 0;
- while let Some(item) = row.get(at) {
- let mut end = at + 1;
- while row.get(end).is_some_and(|v| v.1 == item.1 && v.2 == item.2) {
- end += 1;
- }
- segment_advances.insert((row_index, at), row.get(at..end).unwrap_or_default().iter().map(&advance).sum::<f64>());
- let string: String = row.get(at..end).unwrap_or_default().iter().map(|v| v.0).collect();
- if let Some((bytes, shaped, family)) = shape_source(doc, &fonts, &item.2, &string)? {
- shaped_runs.insert((row_index, at), (bytes, shaped, family));
- }
- at = end;
- }
- }
- let mut glyph_resources = HashMap::new();
- for (key, (bytes, shaped, family)) in &shaped_runs {
- let mappings: Vec<_> = shaped.glyphs.iter().map(|g| (g.text.clone(), g.id)).collect();
- let resource = pdfcraft_fonts::embedding::embed_mapping(doc, &mut fonts, bytes, family, &mappings).map_err(EditError::Invalid)?;
- glyph_resources.insert(*key, resource);
- }
+ validate_contextual_rows(&rows, &kept)?;
+ let measured: Vec<_> = rows.iter().map(|row| measure(row)).collect::<Result<_, _>>()?;
+ let shaped = prepare_shaped_rows(doc, &fonts, &rows, &kept, advance)?;
+ let ShapedRows { runs: shaped_runs, advances: segment_advances } = shaped;
+ let glyph_resources = embed_shaped_resources(doc, &mut fonts, &shaped_runs)?;
let n = pdfcraft_content::num;
let mut block_ops = vec![Op::new("q", vec![])];
block_ops.extend(reveal_ops(block, lines, style, o.ctm)?);
diff --git a/crates/edit/src/text_session.rs b/crates/edit/src/text_session.rs
index 893a0e4d2..fe1aa7868 100644
--- a/crates/edit/src/text_session.rs
+++ b/crates/edit/src/text_session.rs
@@ -3,7 +3,10 @@
//! another one's output; the commit writes into the document it was opened on, and refuses if
//! that document has changed since.
-use super::*;
+use super::{
+ BlockStyle, Document, EditError, LineEdit, MAX_TYPE3_GLYPHS, TextBlock, TextEditLayout, TextLine, group_blocks, layout_draft, rewrite_block_from,
+ text_lines,
+};
/// One paragraph being edited: the document as it was opened, and the page's lines then.
pub struct TextSession {