PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
M7: rejoin a wrapped line when the box is widened (#2517)
ihsan mokhlisse2bc2933988a0
diff --git a/.gitignore b/.gitignoreindex 7834b668c..f7922460c 100644--- a/.gitignore+++ b/.gitignore@@ -9,3 +9,4 @@ plan//assets/models# A craft-fonts checkout used as the optional CRAFT_FONTS_DIR build input (CI and releases put it here)./craft-fonts+.claude/diff --git a/crates/edit/src/tests.rs b/crates/edit/src/tests.rsindex 916872a86..800481d7d 100644--- a/crates/edit/src/tests.rs+++ b/crates/edit/src/tests.rs@@ -2807,9 +2807,8 @@ fn a_blank_line_keeps_the_next_paragraph() {// The second row is left in the source stream. A marker around only the rewritten row// would split the paragraph; either there is no marker, or it covers both rows and not the next paragraph.let content = String::from_utf8_lossy(&page_content_bytes(&doc, 0)).into_owned();- if let Some(start) = content.find("/P BMC") {- let end = start + content[start..].find("EMC").unwrap_or(content.len() - start);- let marked = &content[start..end];+ if content.contains("/P BMC") {+ let marked = region_through_matching_close(&content, "/P BMC");assert!(marked.contains("edited row") && marked.contains("second row"), "marker split the paragraph: {content}");assert!(!marked.contains("Second paragraph"), "marker swallowed the next paragraph: {content}");}@@ -2885,8 +2884,7 @@ fn growing_into_a_blank_line_keeps_the_neighbour_after_save() {let texts = |doc: &Document| text::text_blocks(doc, 0).unwrap().into_iter().map(|b| b.text).collect::<Vec<_>>();assert_eq!(texts(&doc), ["One Two Three", "Neighbour"]);let content = String::from_utf8_lossy(&page_content_bytes(&doc, 0)).into_owned();- let marked = content.find("/P BMC").and_then(|start| content[start..].find("EMC").map(|end| content[start..start + end].to_owned()));- let marked = marked.unwrap_or_else(|| panic!("a full rewrite did not mark its rows: {content}"));+ let marked = region_through_matching_close(&content, "/P BMC");for row in ["(One)", "(Two)", "(Three)"] {assert!(marked.contains(row), "{row} is outside the marker: {content}");}@@ -3109,20 +3107,42 @@ fn page_content(doc: &Document) -> String {/// `open` through the next `EMC` contains both strings, and no `EMC` sits inside a text object.fn assert_marker_wraps(content: &str, open: &str, first: &str, second: &str) {- let start = content.find(open).unwrap_or_else(|| panic!("missing {open}: {content}"));- let end = content[start..].find("EMC").map(|at| start + at).unwrap_or_else(|| panic!("missing EMC after {open}: {content}"));- let marked = &content[start..end];+ let marked = region_through_matching_close(content, open);assert!(marked.contains(first) && marked.contains(second), "{open} closed too early: {content}");- let mut text_objects = 0i32;+ assert!(!marker_crosses_a_text_object(content), "a marker opened outside a text object and closed inside it: {content}");+}++/// A marker may sit inside one text object. It may not open outside one and close inside it.+fn marker_crosses_a_text_object(content: &str) -> bool {+ let mut text = 0i32;+ let mut opened_outside = 0i32;+ let mut opened_inside = 0i32;for token in content.split_whitespace() {match token {- "BT" => text_objects += 1,- "ET" => text_objects -= 1,- "EMC" => assert_eq!(text_objects, 0, "EMC inside a text object: {content}"),+ "BT" => text += 1,+ "ET" => text -= 1,+ "BMC" | "BDC" => {+ if text == 0 {+ opened_outside += 1;+ } else {+ opened_inside += 1;+ }+ }+ "EMC" => {+ if text > 0 {+ if opened_inside > 0 {+ opened_inside -= 1;+ } else {+ return true;+ }+ } else if opened_outside > 0 {+ opened_outside -= 1;+ }+ }_ => {}}}- assert_eq!(text_objects, 0, "a text object was left open: {content}");+ text != 0 || opened_outside != 0 || opened_inside != 0}/// A blank line is one extra leading, so the fourth row of a grown paragraph sits on the@@ -3149,6 +3169,45 @@ fn resizing_a_grown_paragraph_keeps_the_neighbour() {}}+/// Narrowing wraps a line. Widening it again rejoins that wrap. A newline that was typed stays.+#[test]+fn a_wrapped_line_rejoins_when_widened_and_a_typed_break_stays() {+ let mut doc = text_page("BT /F1 24 Tf 20 150 Td (Page 1) Tj ET");+ text::rewrite_block(&mut doc, 0, 0, None, &text::BlockStyle { width: Some(45.0), ..Default::default() }).unwrap();+ let block = text::text_blocks(&doc, 0).unwrap().into_iter().next().unwrap();+ assert!(block.editor_text.contains('\n'), "the narrow box did not wrap: {}", block.editor_text);+ assert_eq!(block.reflow_text, "Page 1", "a wrap was kept as a hard break: {}", block.reflow_text);+ text::rewrite_block(&mut doc, 0, 0, Some(&block.reflow_text), &text::BlockStyle { width: Some(200.0), ..Default::default() }).unwrap();+ let lines: Vec<_> = text::text_lines(&doc, 0).unwrap().into_iter().map(|l| l.text).collect();+ assert_eq!(lines, ["Page 1"]);++ let mut typed = text_page("BT /F1 12 Tf 72 700 Td (One) Tj ET");+ text::replace_block(&mut typed, 0, 0, "One\nTwo\nThree\nfour").unwrap();+ let block = text::text_blocks(&typed, 0).unwrap().into_iter().next().unwrap();+ assert_eq!(block.reflow_text, "One\nTwo\nThree\nfour", "a typed break was rejoined: {}", block.reflow_text);+ let width = (block.rect[2] - block.rect[0]) * 6.0;+ text::rewrite_block(&mut typed, 0, 0, Some(&block.reflow_text), &text::BlockStyle { width: Some(width.max(180.0)), ..Default::default() })+ .unwrap();+ assert_eq!(text::text_blocks(&typed, 0).unwrap()[0].editor_text, "One\nTwo\nThree\nfour");+}++/// A file that did not mark its breaks still rejoins a line that fills the measure, and keeps a+/// short line that had room.+#[test]+fn an_unmarked_full_line_rejoins_and_a_short_break_stays() {+ let long = "BT /F1 12 Tf 1 0 0 1 72 700 Tm (This sentence is long enough to fill a measure.) Tj ET \+ BT /F1 12 Tf 1 0 0 1 72 685.6 Tm (Tail) Tj ET";+ let doc = text_page(long);+ let block = text::text_blocks(&doc, 0).unwrap().into_iter().next().unwrap();+ assert_eq!(block.rows.len(), 2, "{}", block.editor_text);+ assert_eq!(block.reflow_text, "This sentence is long enough to fill a measure. Tail", "{}", block.reflow_text);++ let short = "BT /F1 12 Tf 1 0 0 1 72 700 Tm (One) Tj ET BT /F1 12 Tf 1 0 0 1 72 685.6 Tm (Two) Tj ET";+ let doc = text_page(short);+ let block = text::text_blocks(&doc, 0).unwrap().into_iter().next().unwrap();+ assert_eq!(block.reflow_text, "One\nTwo", "{}", block.reflow_text);+}+/// The letter the screenshots edit. Widening example 1, or adding a row there, must leave the/// heading above it and both paragraphs under example 2 as they were.fn letter_page() -> &'static str {@@ -3181,7 +3240,8 @@ fn widening_example_one_does_not_swallow_the_heading_or_split_the_next_paragraphtext::replace_block(&mut doc, 0, idx, "One\nTwo\nThree\nfour").unwrap();let blocks = text::text_blocks(&doc, 0).unwrap();let idx = blocks.iter().position(|b| b.text.contains("four") || b.editor_text.contains("four")).unwrap();- let shown = blocks[idx].editor_text.clone();+ assert_eq!(blocks[idx].reflow_text, "One\nTwo\nThree\nfour", "a typed break was treated as a wrap: {}", blocks[idx].reflow_text);+ let shown = blocks[idx].reflow_text.clone();let width = blocks[idx].rect[2] - blocks[idx].rect[0];text::rewrite_block(&mut doc, 0, idx, Some(&shown), &text::BlockStyle { width: Some((width * 6.0).max(180.0)), ..Default::default() }).unwrap();let doc = reopen(&doc);diff --git a/crates/edit/src/text.rs b/crates/edit/src/text.rsindex eb4520935..7bcff773a 100644--- a/crates/edit/src/text.rs+++ b/crates/edit/src/text.rs@@ -118,6 +118,10 @@ pub struct TextLine {/// `ink`, and whether joining put a space before it. Empty when the line's text was put/// into another order (see [`TextLine::runs`]).runs: Vec<(String, usize, bool)>,+ /// This line continues the previous one because a rewrite wrapped it (`/PCSoft`).+ soft_break: bool,+ /// This line starts after a break a rewrite kept on purpose (`/PCHard`).+ hard_break: bool,}impl TextLine {@@ -154,6 +158,7 @@ mod tests {lines: Vec::new(),rows: Vec::new(),editor_text: text.into(),+ reflow_text: text.into(),spans: Vec::new(),invisible: false,}@@ -204,40 +209,48 @@ mod tests {assert!(!same_base_font("Arial", ""));}+ fn wrapped(text: &str, width: f64) -> Vec<String> {+ wrap(text, width, |s| s.chars().count() as f64).into_iter().map(|(line, _)| line).collect()+ }+#[test]fn paragraph_wrapping_keeps_ideographic_spaces() {+ assert_eq!(wrapped("A B C", 4.0), ["A B", "C"]);+ assert_eq!(wrapped("A\u{a0}B C", 3.0), ["A B", "C"]);+ assert_eq!(wrapped("A\u{2028}B C", 3.0), ["A B", "C"]);+ }++ #[test]+ fn a_wrap_is_marked_soft_and_a_newline_is_not() {let width = |s: &str| s.chars().count() as f64;- assert_eq!(wrap("A B C", 4.0, width), ["A B", "C"]);- assert_eq!(wrap("A\u{a0}B C", 3.0, width), ["A B", "C"]);- assert_eq!(wrap("A\u{2028}B C", 3.0, width), ["A B", "C"]);+ assert_eq!(wrap("Page 1", 5.0, width), [("Page".into(), false), ("1".into(), true)]);+ assert_eq!(wrap("One\nTwo", 10.0, width), [("One".into(), false), ("Two".into(), false)]);}/// #4199: a run of spaces stays a run, before, between and after words; the spaces where a/// row wraps go, and each other white-space character is one space.#[test]fn paragraph_wrapping_keeps_every_space_typed() {- let width = |s: &str| s.chars().count() as f64;- assert_eq!(wrap("a b c", 20.0, width), ["a b c"]);- assert_eq!(wrap(" a b ", 20.0, width), [" a b "]);- assert_eq!(wrap("a\t\tb", 20.0, width), ["a b"]);- assert_eq!(wrap("aa bb cc", 6.0, width), ["aa bb", "cc"]);+ assert_eq!(wrapped("a b c", 20.0), ["a b c"]);+ assert_eq!(wrapped(" a b ", 20.0), [" a b "]);+ assert_eq!(wrapped("a\t\tb", 20.0), ["a b"]);+ assert_eq!(wrapped("aa bb cc", 6.0), ["aa bb", "cc"]);// An indent alone on a row doesn't wrap before its first word.- assert_eq!(wrap(" abc", 3.0, width), [" abc"]);+ assert_eq!(wrapped(" abc", 3.0), [" abc"]);// The rewrite turns `\r\n` and `\r` into `\n` before wrapping.- assert_eq!(wrap(" \tA B\nC ", 3.0, width), [" A", "B", "C "]);- assert_eq!(wrap(" ", 3.0, width), [" "]);- assert_eq!(wrap("", 3.0, width), [""]);+ assert_eq!(wrapped(" \tA B\nC ", 3.0), [" A", "B", "C "]);+ assert_eq!(wrapped(" ", 3.0), [" "]);+ assert_eq!(wrapped("", 3.0), [""]);}#[test]fn japanese_text_wraps_between_characters_but_not_before_closing_marks() {- let width = |s: &str| s.chars().count() as f64;- assert_eq!(wrap("日本語の文章です。", 3.0, width), ["日本語", "の文章", "です。"]);+ assert_eq!(wrapped("日本語の文章です。", 3.0), ["日本語", "の文章", "です。"]);// The comma can't begin a row, so the character before it moves down with it.- assert_eq!(wrap("あいう、えお", 3.0, width), ["あい", "う、え", "お"]);+ assert_eq!(wrapped("あいう、えお", 3.0), ["あい", "う、え", "お"]);// Pieces of one word join without a space; separate words keep theirs.- assert_eq!(wrap("Edit PDFを編集", 6.0, width), ["Edit", "PDFを編集"]);- assert_eq!(wrap("一行目 二行目", 4.0, width), ["一行目 ", "二行目"]);+ assert_eq!(wrapped("Edit PDFを編集", 6.0), ["Edit", "PDFを編集"]);+ assert_eq!(wrapped("一行目 二行目", 4.0), ["一行目 ", "二行目"]);}#[test]diff --git a/crates/edit/src/text/blocks.rs b/crates/edit/src/text/blocks.rsindex 615e7699a..2785f8767 100644--- a/crates/edit/src/text/blocks.rs+++ b/crates/edit/src/text/blocks.rs@@ -25,6 +25,9 @@ pub struct TextBlock {pub rows: Vec<Vec<usize>>,/// Text for the inline editor, with a newline only between visual rows.pub editor_text: String,+ /// What a width change reflows. A wrap rejoins with a space; a break that was typed, or a+ /// short line that still had room for the next word, stays a newline.+ pub reflow_text: String,/// Byte ranges in `editor_text` and their source line indexes.pub spans: Vec<(std::ops::Range<usize>, usize)>,/// Every line is invisible text (rendering mode 3): an OCR layer over a scanned image, whose@@ -337,11 +340,13 @@ pub(crate) fn paragraph_separator(c: char) -> bool {/// new line. A row may also end inside a word of Chinese or Japanese text ([`crate::linebreak`]);/// those pieces join without a space. Every white-space character is written as one space, so/// a run of spaces typed between, before or after words stays (#4199); only the spaces where a-/// row wraps are dropped.-pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec<String> {+/// row wraps are dropped. The bool is true when the line continues the previous one because the+/// next word did not fit, rather than because of a newline.+pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec<(String, bool)> {let mut out = Vec::new();for row in text.split('\n') {let mut line = String::new();+ let mut soft = false;let start = out.len();// The separators read since the last word: each one boundary between `split` pieces.let mut gap = 0usize;@@ -357,7 +362,8 @@ pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Veclet candidate = if i == 0 { format!("{line}{spaces}{piece}") } else { format!("{line}{piece}") };// A row holding only the spaces that indent it doesn't wrap before its first word.if line.chars().any(|c| c != ' ') && advance(&candidate) > width {- out.push(std::mem::take(&mut line));+ out.push((std::mem::take(&mut line), soft));+ soft = true;line = piece.to_string();} else {line = candidate;@@ -366,7 +372,7 @@ pub(super) fn wrap(text: &str, width: f64, advance: impl Fn(&str) -> f64) -> Vec}line.push_str(&" ".repeat(gap));if !line.is_empty() || out.len() == start {- out.push(line);+ out.push((line, soft));}}outdiff --git a/crates/edit/src/text/interp.rs b/crates/edit/src/text/interp.rsindex 16b04b406..e3e4bf26b 100644--- a/crates/edit/src/text/interp.rs+++ b/crates/edit/src/text/interp.rs@@ -301,6 +301,9 @@ pub(super) struct Shown {pub(super) paint: Paint,pub(super) logical_order: bool,pub(super) actual_text: bool,+ /// Set when a `/PCSoft` or `/PCHard` marker was seen since the previous text line.+ pub(super) soft_break: bool,+ pub(super) hard_break: bool,}impl Shown {@@ -549,6 +552,8 @@ struct TextRunState<'a> {marked: &'a MarkedContent,carry: &'a mut Carry,out: &'a mut Vec<Shown>,+ soft_break: bool,+ hard_break: bool,}fn show_text(op: &Op, i: usize, state: &mut TextRunState<'_>) -> Result<(), EditError> {@@ -745,6 +750,8 @@ fn show_text(op: &Op, i: usize, state: &mut TextRunState<'_>) -> Result<(), Editpaint: Paint { layers: marked.layers.iter().flatten().cloned().collect(), gs: ts.gs.clone() },logical_order: false,actual_text: false,+ soft_break: state.soft_break,+ hard_break: state.hard_break,});Ok(())}@@ -769,11 +776,22 @@ pub(super) fn interpret(let mut bt = 0usize;let mut marked =MarkedContent { regions: std::mem::take(&mut carry.marked), layers: std::mem::take(&mut carry.layers), ..MarkedContent::default() };+ // A rewrite names a wrap (`/PCSoft`) or a break it kept (`/PCHard`) in an empty marker+ // before the next line. Neither name is a paragraph region, so it does not change scope.+ let mut soft_break = false;+ let mut hard_break = false;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" => {+ if op.name(0) == Some(b"PCSoft") {+ soft_break = true;+ hard_break = false;+ } else if op.name(0) == Some(b"PCHard") {+ hard_break = true;+ soft_break = false;+ }marked.begin(doc, op, i, logical_text, out.len());}b"EMC" => {@@ -878,8 +896,26 @@ pub(super) fn interpret(tm = tlm;}b"Tj" | b"TJ" | b"'" | b"\"" => {- let mut state = TextRunState { ts: &mut ts, tm: &mut tm, tlm: &mut tlm, at_bt: &at_bt, bt, marked: &marked, carry, out: &mut out };+ let before = out.len();+ let mut state = TextRunState {+ ts: &mut ts,+ tm: &mut tm,+ tlm: &mut tlm,+ at_bt: &at_bt,+ bt,+ marked: &marked,+ carry,+ out: &mut out,+ soft_break,+ hard_break,+ };show_text(op, i, &mut state)?;+ // A numeric-only TJ adjustment shows no glyphs and pushes nothing: the break+ // belongs to whichever text-showing operator comes next.+ if out.len() > before {+ soft_break = false;+ hard_break = false;+ }}_ => {}}diff --git a/crates/edit/src/text/lines.rs b/crates/edit/src/text/lines.rsindex c48522984..78aec5090 100644--- a/crates/edit/src/text/lines.rs+++ b/crates/edit/src/text/lines.rs@@ -280,6 +280,8 @@ fn text_lines_in(doc: &Document, p: &pdfcraft_model::Page, actual_text: bool) ->clips: s.state.render_mode >= 4,unreadable_mode: s.state.unreadable.as_deref().map(str::to_owned),runs: vec![(s.text.clone(), s.ink.len(), false)],+ soft_break: s.soft_break,+ hard_break: s.hard_break,ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),origin: Origin {tm: s.tm.0,@@ -394,6 +396,8 @@ fn add_shown(lines: &mut Vec<TextLine>, last: &mut Option<Pen>, s: Shown, streamclips: s.state.render_mode >= 4,unreadable_mode: s.state.unreadable.as_deref().map(str::to_owned),runs: vec![(s.text.clone(), s.ink.len(), false)],+ soft_break: s.soft_break,+ hard_break: s.hard_break,ops: std::iter::once(s.op).chain(s.extra_ops.iter().copied()).collect(),origin: Origin {tm: s.tm.0,diff --git a/crates/edit/src/text/rewrite.rs b/crates/edit/src/text/rewrite.rsindex 513077a02..9589fad22 100644--- a/crates/edit/src/text/rewrite.rs+++ b/crates/edit/src/text/rewrite.rs@@ -579,13 +579,28 @@ impl LineWriter<'_> {}/// 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> {+ fn write_line(+ &self,+ index: usize,+ line: &str,+ soft: bool,+ 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 {+ // Inside this text object, so the marker starts and ends here. `/PCSoft` rejoins+ // when the box widens. `/PCHard` is a newline that was already in the text.+ let name = if soft { "PCSoft" } else { "PCHard" };+ ops.push(Op::new("BMC", vec![Object::name(name)]));+ ops.push(Op::new("EMC", vec![]));+ }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 })]));}@@ -633,8 +648,12 @@ impl LineWriter<'_> {}/// 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()+ fn write_all(&self, wrapped: &[(String, bool)], cursor: &mut LineCursor, ops: &mut Vec<Op>) -> Result<Vec<(f64, f64, f64)>, EditError> {+ wrapped+ .iter()+ .enumerate()+ .map(|(i, (line, soft))| self.write_line(i, line, *soft, i + 1 == wrapped.len(), cursor, ops))+ .collect()}}@@ -653,7 +672,7 @@ struct BlockPlan<'a> {underline: bool,}-fn block_ops(plan: &BlockPlan<'_>, writer: &LineWriter<'_>, wrapped: &[String], show_font: String) -> Result<Vec<Op>, EditError> {+fn block_ops(plan: &BlockPlan<'_>, writer: &LineWriter<'_>, wrapped: &[(String, bool)], 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)?);diff --git a/crates/edit/src/text_regions/grouping.rs b/crates/edit/src/text_regions/grouping.rsindex 68a83569a..f866daef5 100644--- a/crates/edit/src/text_regions/grouping.rs+++ b/crates/edit/src/text_regions/grouping.rs@@ -299,6 +299,7 @@ fn group_layout(lines: &[TextLine], mixed: bool) -> Vec<TextBlock> {blocks.push(TextBlock {text: String::new(),editor_text: String::new(),+ reflow_text: String::new(),spans: Vec::new(),rect,base_font: first.base_font.clone(),@@ -346,5 +347,53 @@ fn group_layout(lines: &[TextLine], mixed: bool) -> Vec<TextBlock> {block.rect = union(block.rect, rect);block.rows.push(row.clone());}+ for block in &mut blocks {+ block.reflow_text = reflow_text(block, lines);+ }blocks}++/// The text a width change should reflow. A `/PCSoft` line is a wrap and rejoins. A `/PCHard`+/// line, or a short line that is not marked, keeps its newline. An unmarked line that reaches+/// the paragraph's right edge and is wide enough to be a measure rejoins too: that is how a+/// file written elsewhere wraps a body line.+fn reflow_text(block: &TextBlock, lines: &[TextLine]) -> String {+ let parts: Vec<&str> = block.editor_text.split('\n').collect();+ if parts.len() != block.rows.len() {+ return block.editor_text.clone();+ }+ let mut out = String::new();+ for (index, part) in parts.iter().enumerate() {+ if index > 0 {+ if break_is_soft(block, lines, index) {+ if out.ends_with('-') {+ out.pop();+ } else if !out.ends_with(char::is_whitespace) {+ out.push(' ');+ }+ } else {+ out.push('\n');+ }+ }+ out.push_str(part);+ }+ out+}++fn break_is_soft(block: &TextBlock, lines: &[TextLine], row_index: usize) -> bool {+ let Some(line) = block.rows.get(row_index).and_then(|row| row.first()).and_then(|i| lines.get(*i)) else { return false };+ if line.hard_break {+ return false;+ }+ if line.soft_break {+ return true;+ }+ let Some(prev) = block.rows.get(row_index.wrapping_sub(1)).and_then(|row| row_rect(row, lines)) else { return false };+ let Some(next) = block.rows.get(row_index).and_then(|row| row_rect(row, lines)) else { return false };+ let size = line.size.max(1.0);+ let slack = block.rect[2] - prev[2];+ let width = prev[2] - prev[0];+ // Short rows define the right edge by their own letters. A body line that fills the+ // measure leaves almost no room for the next word.+ slack <= size * 0.75 && width >= size * 8.0 && (next[2] - next[0]) + size * 0.25 > slack+}diff --git a/crates/edit/src/text_regions/styled.rs b/crates/edit/src/text_regions/styled.rsindex ccb75b313..f55d52ddc 100644--- a/crates/edit/src/text_regions/styled.rs+++ b/crates/edit/src/text_regions/styled.rs@@ -405,9 +405,12 @@ fn wrap_styled_rows(chars: &[StyledChar],width: f64,measure: impl Fn(&[StyledChar]) -> Result<f64, EditError>,-) -> Result<(StyledRows, RowRanges), EditError> {+) -> Result<(StyledRows, RowRanges, Vec<bool>), EditError> {let mut rows: Vec<Vec<StyledChar>> = Vec::new();let mut row_ranges = Vec::new();+ // True when this row starts because the previous word did not fit, not because of a newline.+ let mut row_soft = Vec::new();+ let mut next_soft = false;let mut row_start = 0;let mut row = Vec::new();let mut row_width = 0.0;@@ -419,6 +422,8 @@ fn wrap_styled_rows(continue;}if item.0 == '\n' {+ row_soft.push(next_soft);+ next_soft = false;row_ranges.push(row_start..row_start + row.len());rows.push(std::mem::take(&mut row));row_width = 0.0;@@ -442,6 +447,8 @@ fn wrap_styled_rows(while row.last().is_some_and(|c: &StyledChar| c.0.is_whitespace()) {row.pop();}+ row_soft.push(next_soft);+ next_soft = true;row_ranges.push(row_start..row_start + row.len());rows.push(std::mem::take(&mut row));row_width = 0.0;@@ -452,10 +459,11 @@ fn wrap_styled_rows(at = end;}if !row.is_empty() {+ row_soft.push(next_soft);row_ranges.push(row_start..row_start + row.len());rows.push(row);}- Ok((rows, row_ranges))+ Ok((rows, row_ranges, row_soft))}fn apply_range_styles<'a>(@@ -822,7 +830,7 @@ pub(crate) fn rewrite_styled_block(}Ok(width)};- let (rows, row_ranges) = wrap_styled_rows(&chars, width, measure)?;+ let (rows, row_ranges, row_soft) = 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;@@ -891,6 +899,14 @@ pub(crate) fn rewrite_styled_block(baseline -= source_leading;continue;}+ if !row.is_empty() && row_index > 0 {+ // An empty marker between lines. `/PCSoft` is a wrap and rejoins when the box+ // widens. `/PCHard` is a newline that was already in the text. Neither is a+ // paragraph region, so the lines stay in one scope.+ let name = if row_soft.get(row_index).copied().unwrap_or(false) { "PCSoft" } else { "PCHard" };+ block_ops.push(Op::new("BMC", vec![Object::name(name)]));+ block_ops.push(Op::new("EMC", vec![]));+ }let w = measured.get(row_index).copied().unwrap_or(0.0);let align = style.align.unwrap_or(if centered { crate::added::Align::Center } else { crate::added::Align::Left });let original_rect = block.rows.get(row_index).and_then(|row| row_rect(row, lines)).unwrap_or(block.rect);diff --git a/crates/ui-egui/src/tools/edit_text_ui.rs b/crates/ui-egui/src/tools/edit_text_ui.rsindex c932ed360..c8bf9867b 100644--- a/crates/ui-egui/src/tools/edit_text_ui.rs+++ b/crates/ui-egui/src/tools/edit_text_ui.rs@@ -399,9 +399,10 @@ pub(crate) fn page_input(cx: PageToolContext<'_>, lines: &[pdfcraft_engine::Textlet width = (l.rect[2] - l.rect[0]) + (to[2] - to[0]) - (from[2] - from[0]);let shift = to[0] - from[0];let style = pdfcraft_engine::BlockStyle { width: Some(width), offset: (shift != 0.0).then_some([shift, 0.0]), ..Default::default() };- // `text` joins rows with spaces. The editor text is what the paragraph actually- // is, line breaks included; a width change must not throw those breaks away.- Edit::EditTextBlock { page, block: d.block, text: l.editor_text.clone(), style }+ // `editor_text` has a newline for every visual row, so a wrap would come back as a+ // hard break and a wider box would not reflow it. `reflow_text` rejoins a wrap+ // and keeps a newline that was typed.+ Edit::EditTextBlock { page, block: d.block, text: l.reflow_text.clone(), style }} else {// Translation must keep the selected source operators. Rewriting unchanged text// would also remove unrelated paragraphs that now overlap this one (#594).diff --git a/crates/ui-egui/tests/it/editing.rs b/crates/ui-egui/tests/it/editing.rsindex 5a124aa39..95ad044b3 100644--- a/crates/ui-egui/tests/it/editing.rs+++ b/crates/ui-egui/tests/it/editing.rs@@ -3738,7 +3738,7 @@ fn the_live_editor_groups_a_repeated_step_and_keeps_the_neighbour() {700.0 - step,700.0 - 2.0 * step);- let mut h = open_letter("repeated.pdf", letter_text(&repeated));+ let mut h = open_letter("repeated.pdf", letter_text(repeated.as_str()));assert!(h.state_mut().execute("edit.edit_text"));h.run_steps(2);click_page(&mut h, 90.0, 700.0 - step + 4.0);@@ -3785,7 +3785,7 @@ fn widening_example_one_keeps_the_heading_and_the_next_paragraph() {BT /F1 14 Tf 72 450 Td (3. Add a row under Alpha. Neighbor stays.) Tj ET \BT /F1 12 Tf 14.4 TL 1 0 0 1 72 410 Tm (Alpha first row.) Tj T* (Alpha next row.) Tj ET \BT /F1 12 Tf 14.4 TL 1 0 0 1 72 366.8 Tm (Neighbor stays.) Tj ET";- let mut h = open_letter("letter.pdf", letter_text(&body));+ let mut h = open_letter("letter.pdf", letter_text(body));assert!(h.state_mut().execute("edit.edit_text"));h.run_steps(2);click_page(&mut h, 90.0, 690.0);diff --git a/parity/acrobat-features.toml b/parity/acrobat-features.tomlindex c7069200a..c9d371cc5 100644--- a/parity/acrobat-features.toml+++ b/parity/acrobat-features.toml@@ -1902,8 +1902,8 @@ milestone = "M7"status = "shipped"commands = ["edit.edit_text"]tools = ["text_edit"]-evidence = ["crates/edit/src/tests.rs::paragraphs_move_and_rewrap_to_a_new_width", "crates/ui-egui/tests/it/editing.rs::dragging_a_paragraph_moves_it_and_its_edge_rewraps_it", "crates/ui-egui/tests/it/editing.rs::a_paragraph_rewraps_from_the_outer_half_of_its_edge_handles", "crates/ui-egui/tests/it/editing.rs::an_open_paragraph_moves_by_its_frame_and_by_the_arrow_keys", "crates/ui-egui/tests/it/editing.rs::arrow_keys_nudge_a_selected_image_instead_of_turning_the_page", "crates/automation/tests/it/automation.rs::editing_existing_text_through_tools"]-notes = "existing paragraphs: drag the box to move it, drag the handle on its left or right edge to rewrap it to a new width (upright pages), including the half of the handle outside the box, which started an area selection instead (#2276); the move is applied in page space through the paragraph's CTM, in its own q … Q; a click still opens it for typing (#40); once open, its frame grabs the box (click to select, drag to move) while the text keeps the caret, and the arrow keys nudge the selected box or image a point, Shift ten points (#1520)"+evidence = ["crates/edit/src/tests.rs::paragraphs_move_and_rewrap_to_a_new_width", "crates/edit/src/tests.rs::a_wrapped_line_rejoins_when_widened_and_a_typed_break_stays", "crates/edit/src/tests.rs::an_unmarked_full_line_rejoins_and_a_short_break_stays", "crates/ui-egui/tests/it/editing.rs::dragging_a_paragraph_moves_it_and_its_edge_rewraps_it", "crates/ui-egui/tests/it/editing.rs::a_paragraph_rewraps_from_the_outer_half_of_its_edge_handles", "crates/ui-egui/tests/it/editing.rs::a_quick_flick_on_either_edge_rewraps_the_paragraph", "crates/ui-egui/tests/it/editing.rs::an_open_paragraph_moves_by_its_frame_and_by_the_arrow_keys", "crates/ui-egui/tests/it/editing.rs::arrow_keys_nudge_a_selected_image_instead_of_turning_the_page", "crates/automation/tests/it/automation.rs::editing_existing_text_through_tools"]+notes = "existing paragraphs: drag the box to move it, drag the handle on its left or right edge to rewrap it to a new width (upright pages), including the half of the handle outside the box, which started an area selection instead (#2276); a wrap rejoins when the box is widened, and a newline that was typed stays; an unmarked line that fills the measure rejoins, a short line does not; the move is applied in page space through the paragraph's CTM, in its own q … Q; a click still opens it for typing (#40); once open, its frame grabs the box (click to select, drag to move) while the text keeps the caret, and the arrow keys nudge the selected box or image a point, Shift ten points (#1520)"[[feature]]id = "edit.paragraph-detection"