PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
fix(ui): formatting restarts a text box's history; the menu claims the box first
RiceDeeaa326f37cdf7
diff --git a/crates/ui-egui/src/content_ui.rs b/crates/ui-egui/src/content_ui.rsindex 04d626088..77edee687 100644--- a/crates/ui-egui/src/content_ui.rs+++ b/crates/ui-egui/src/content_ui.rs@@ -75,6 +75,12 @@ pub struct TextDraft {}impl TextDraft {+ /// Take the shared text box for this box ([`crate::edit_text_ui::forget_typing_before`]): its+ /// own history, or none once the page has its text.+ pub(crate) fn claim_typing(&mut self, ctx: &egui::Context, doc: pdfcraft_engine::DocId) {+ crate::edit_text_ui::forget_typing_before(ctx, input_id(), doc, &mut self.typing_from, &self.style.text);+ }+/// Typing the page doesn't have yet: Undo takes it back in the box before touching the document.pub(crate) fn has_unapplied_typing(&self) -> bool {self.text != self.style.text@@ -604,7 +610,7 @@ pub(crate) fn editor(ctx: &egui::Context, view: &mut DocView, info: &DocInfo, adui.fonts_mut(|f| f.layout_job(job))};let input = input_id();- crate::edit_text_ui::forget_typing_before(ui.ctx(), input, doc_id, &mut t.typing_from, &t.style.text);+ t.claim_typing(ui.ctx(), doc_id);ui.horizontal_top(|ui| {ui.spacing_mut().item_spacing.x = 4.0;let mut edit = egui::TextEdit::multiline(&mut t.text)diff --git a/crates/ui-egui/src/edit_text_ui.rs b/crates/ui-egui/src/edit_text_ui.rsindex 4724cbb6e..a0f73eaf4 100644--- a/crates/ui-egui/src/edit_text_ui.rs+++ b/crates/ui-egui/src/edit_text_ui.rs@@ -277,7 +277,9 @@ pub(crate) fn input_id() -> egui::Id {/// own record of that; which document `doc` last used the history is kept beside it, since a box/// in another tab on the same text would otherwise take that document's typing with its Redo./// When another document's box takes the text box, the box it leaves keeps its history (and-/// caret) aside, and gets it back on its return, so its typing can still be undone there.+/// caret) aside, and gets it back on its return, so its typing can still be undone there. Each+/// box claims the text box when it is drawn, and Undo and Redo from the menu claim it first too,+/// since they can run before the box is drawn again after a tab switch.pub(crate) fn forget_typing_before(ctx: &egui::Context, id: egui::Id, doc: pdfcraft_engine::DocId, from: &mut Option<String>, text: &str) {let owner = id.with("typing-doc");let last = ctx.data(|d| d.get_temp::<pdfcraft_engine::DocId>(owner));@@ -297,11 +299,9 @@ pub(crate) fn forget_typing_before(ctx: &egui::Context, id: egui::Id, doc: pdfcr}// Only the same box, still on the text it opened on, takes its history back.let back = ctx.data_mut(|d| d.remove_temp::<egui::text_edit::TextEditState>(aside(doc))).filter(|_| from.as_deref() == Some(text));- let state = back.unwrap_or_else(|| {- let mut state = egui::TextEdit::load_state(ctx, id).unwrap_or_default();- state.clear_undoer();- state- });+ // A box new to the text box starts with nothing of the last one's: no history, caret or+ // selection.+ let state = back.unwrap_or_default();egui::TextEdit::store_state(ctx, id, state);ctx.data_mut(|d| d.insert_temp(owner, doc));*from = Some(text.to_owned());@@ -421,9 +421,18 @@ impl LineEditor {self.look0 = self.look.clone();self.extras0 = self.extras;self.original = self.text.clone();+ // The page now has this text: the box's history restarts, even when the format left the+ // text as it was, so a Redo from before can't put undone typing back on top of it.+ self.typing_from = None;self.focus = true;}+ /// Take the shared text box for this paragraph ([`forget_typing_before`]): its own history,+ /// or none once the page has its text.+ pub(crate) fn claim_typing(&mut self, ctx: &egui::Context, doc: pdfcraft_engine::DocId) {+ forget_typing_before(ctx, input_id(), doc, &mut self.typing_from, &self.original);+ }+/// Adopt the rewritten paragraph's current geometry before the next overlay frame.pub(crate) fn refresh_source(&mut self, block: &pdfcraft_engine::TextBlock, lines: Vec<pdfcraft_engine::TextLine>) {self.source_rect = block.rect.map(|v| v as f32);@@ -1724,7 +1733,7 @@ pub(crate) fn overlay(ctx: &egui::Context, view: &mut DocView, info: &DocInfo) -if snapshot.changes_with(text.as_str()) { galley } else { unseen(galley) }};let input = input_id();- forget_typing_before(ui.ctx(), input, view_id, &mut ed.typing_from, &ed.original);+ ed.claim_typing(ui.ctx(), view_id);let output = egui::TextEdit::multiline(&mut ed.text).id(input).font(font.clone())diff --git a/crates/ui-egui/src/editing.rs b/crates/ui-egui/src/editing.rsindex 408474eaa..a7ee6b3d5 100644--- a/crates/ui-egui/src/editing.rs+++ b/crates/ui-egui/src/editing.rs@@ -231,12 +231,15 @@ impl PdfCraftApp {fn undo_in_page_box(&mut self) -> bool {let Some(ctx) = self.ctx.clone() else { return false };let Some(view) = self.active.and_then(|i| self.views.get_mut(i)) else { return false };+ let doc = view.id;if let Some(ed) = view.line_editor.as_mut().filter(|ed| ed.has_unsaved_text()) {+ ed.claim_typing(&ctx, doc);let Some(text) = typing_step(&ctx, crate::edit_text_ui::input_id(), &ed.text, true) else { return false };ed.text = text;return true;}if let Some(d) = view.content.draft.as_mut().filter(|d| d.has_unapplied_typing()) {+ d.claim_typing(&ctx, doc);let Some(text) = typing_step(&ctx, crate::content_ui::input_id(), &d.text, true) else { return false };d.text = text;return true;@@ -259,12 +262,15 @@ impl PdfCraftApp {fn redo_in_page_box(&mut self) -> bool {let Some(ctx) = self.ctx.clone() else { return false };let Some(view) = self.active.and_then(|i| self.views.get_mut(i)) else { return false };+ let doc = view.id;if let Some(ed) = view.line_editor.as_mut() {+ ed.claim_typing(&ctx, doc);let Some(text) = typing_step(&ctx, crate::edit_text_ui::input_id(), &ed.text, false) else { return ed.has_unsaved_text() };ed.text = text;return true;}if let Some(d) = view.content.draft.as_mut() {+ d.claim_typing(&ctx, doc);let Some(text) = typing_step(&ctx, crate::content_ui::input_id(), &d.text, false) else { return d.has_unapplied_typing() };d.text = text;return true;diff --git a/crates/ui-egui/tests/it/content.rs b/crates/ui-egui/tests/it/content.rsindex 43771ed72..387cc1aed 100644--- a/crates/ui-egui/tests/it/content.rs+++ b/crates/ui-egui/tests/it/content.rs@@ -1058,6 +1058,42 @@ fn undo_after_a_round_trip_through_another_tab_takes_back_added_text_typing() {assert_eq!(draft(&h).as_deref(), Some("Reviewed"), "Undo takes the typing back in A's box");}+/// Edit ▸ Undo chosen in the same frame as the switch back to tab A's added text box, before it+/// is drawn again: the shared text box still holds tab B's history, from a box on other text, so+/// A's box claims its own back before stepping.+#[test]+fn undo_in_the_frame_of_the_switch_back_takes_back_added_text_typing() {+ let mut h = harness();+ h.state_mut().open_bytes("copy.pdf", None, include_bytes!("../data/form.pdf").to_vec()).unwrap();+ h.run_steps(4);+ let rect = [40.0, 195.0, 240.0, 210.0];+ for (tab, text) in [(0, "Reviewed"), (1, "Approved")] {+ h.state_mut().active = Some(tab);+ let text = pdfcraft_engine::AddedText { rect, text: text.into(), ..Default::default() };+ assert!(h.state_mut().apply_edit(pdfcraft_engine::Edit::AddText { page: 0, text }));+ }+ let open_in = |h: &mut Harness<'static, PdfCraftApp>, tab: usize| {+ h.state_mut().active = Some(tab);+ h.run_steps(2);+ assert!(h.state_mut().execute("edit.text"));+ h.run_steps(3);+ let r = h.state().views[tab].page_screen_rect(0).expect("on screen");+ let k = r.width() / 300.0;+ click(h, r.min + egui::vec2(45.0 * k, 195.0 * k));+ assert_eq!(h.state().views[tab].content.draft.as_ref().and_then(|d| d.index), Some(0), "the editor opened on the text");+ };+ open_in(&mut h, 0);+ h.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::End);+ h.event(egui::Event::Text(" twice".into()));+ h.run_steps(2);+ open_in(&mut h, 1);+ // Back to A and Undo at once: no frame draws A's box in between.+ h.state_mut().active = Some(0);+ assert!(h.state_mut().execute("edit.undo"));+ h.run_steps(3);+ assert_eq!(h.state().views[0].content.draft.as_ref().map(|d| d.text.as_str()), Some("Reviewed"), "Undo takes the typing back in A's box");+}+/// Redo with an added text box open and unchanged reaches the document's waiting Redo, even when/// the box's text ends in a space: closing the unchanged box writes nothing, so it can't clear/// that Redo first.diff --git a/crates/ui-egui/tests/it/editing.rs b/crates/ui-egui/tests/it/editing.rsindex c1acc43fe..da2a703f5 100644--- a/crates/ui-egui/tests/it/editing.rs+++ b/crates/ui-egui/tests/it/editing.rs@@ -6688,6 +6688,116 @@ fn undo_after_a_round_trip_through_another_tab_takes_back_the_typing() {assert_eq!(s.session.get(s.views[0].id).unwrap().can_redo(), Some("Edit text"), "the document's Redo still waits");}+/// Typing taken back with Ctrl+Z, then Bold applied with the paragraph still open: Ctrl+Shift+Z+/// must not bring the typing back on top of the bold, as the box's history is cleared once the+/// page has its text. The format left the text as it was, so the box kept its history and its+/// Redo put "Page 1 more" back (FredApps's review of abc378c0).+#[test]+fn redo_after_formatting_never_brings_back_typing_undone_before_it() {+ let mut h = harness(1, |_| {});+ assert!(h.state_mut().execute("edit.edit_text"));+ h.run_steps(2);+ open_paragraph(&mut h);+ let original = h.state().views[0].line_editor.as_ref().unwrap().text.clone();+ h.key_press_modifiers(Modifiers::COMMAND, Key::End);+ h.event(egui::Event::Text(" more".into()));+ h.run_steps(2);+ h.key_press_modifiers(Modifiers::COMMAND, Key::Z);+ h.run_steps(3);+ assert_eq!(h.state().views[0].line_editor.as_ref().unwrap().text, original, "the typing is taken back");+ h.get_by_label("Bold").click();+ h.run_steps(4);+ assert_eq!(h.state().session.get(h.state().views[0].id).unwrap().can_undo(), Some("Edit text"), "the bold is applied");+ h.key_press_modifiers(Modifiers::COMMAND | Modifiers::SHIFT, Key::Z);+ h.run_steps(3);+ let text = h.state().views[0].line_editor.as_ref().map(|ed| ed.text.clone());+ assert_eq!(text.as_deref(), Some(original.as_str()), "the typing undone before the bold stays undone");+ // Nor through what the menu's Redo runs.+ h.state_mut().redo();+ h.run_steps(3);+ let s = h.state();+ let text = s.views[0].line_editor.as_ref().map(|ed| ed.text.clone());+ assert!(!text.as_deref().unwrap_or_default().contains("more"), "the menu's Redo brings it back: {text:?}");+ assert_eq!(s.session.get(s.views[0].id).unwrap().text_blocks(0)[0].base_font, "Helvetica-Bold", "the bold stays");+}++/// Edit ▸ Undo chosen in the same frame as the switch back to tab A, before A's box is drawn+/// again: the shared text box still holds tab B's history then. Stepping through it put B's+/// typing into A's box; the box now claims its own history back first (CodeRabbit on abc378c0).+#[test]+fn undo_in_the_frame_of_the_switch_back_takes_back_the_typing() {+ let mut h = harness(1, |app| {+ app.open_bytes("copy.pdf", None, fixture(1)).expect("the copy opens");+ });+ let open_in = |h: &mut Harness<'static, PdfCraftApp>, tab: usize| {+ h.state_mut().active = Some(tab);+ h.run_steps(2);+ if h.state().views[tab].line_editor.is_none() {+ assert!(h.state_mut().execute("edit.edit_text"));+ h.run_steps(2);+ }+ let r = h.state().views[tab].page_screen_rect(0).expect("on screen");+ click_at(h, egui::pos2(r.left() + 40.0 / 200.0 * r.width(), r.top() + (300.0 - 158.0) / 300.0 * r.height()));+ assert!(h.state().views[tab].line_editor.is_some(), "the paragraph opens for typing");+ };+ open_in(&mut h, 0);+ let original = h.state().views[0].line_editor.as_ref().unwrap().text.clone();+ h.key_press_modifiers(Modifiers::COMMAND, Key::End);+ h.event(egui::Event::Text(" more".into()));+ h.run_steps(2);+ // In B, a paragraph whose text differs from A's ("Page 1 B", applied with Bold), so B's+ // history can't pass for A's.+ open_in(&mut h, 1);+ h.key_press_modifiers(Modifiers::COMMAND, Key::End);+ h.event(egui::Event::Text(" B".into()));+ h.run_steps(2);+ h.get_by_label("Bold").click();+ h.run_steps(4);+ assert_eq!(h.state().views[1].line_editor.as_ref().map(|ed| ed.text.as_str()), Some("Page 1 B"), "B's paragraph is open on its own text");+ // Back to A and Undo at once: no frame draws A's box in between.+ h.state_mut().active = Some(0);+ assert!(h.state_mut().execute("edit.undo"), "Undo is enabled");+ h.run_steps(3);+ let ed = h.state().views[0].line_editor.clone().expect("the box stays open: Undo takes back the typing");+ assert_eq!(ed.text, original, "the typing is taken back in A's box");+}++/// Redo from the menu chosen in the same frame as a switch to tab B, whose paragraph is open on+/// the same text as A's: the shared text box still holds A's history then, with A's undone+/// typing to redo, so B's box claims its own history back before stepping.+#[test]+fn redo_in_the_frame_of_a_tab_switch_never_brings_another_tabs_typing() {+ let mut h = harness(1, |app| {+ app.open_bytes("copy.pdf", None, fixture(1)).expect("the copy opens");+ });+ let open_in = |h: &mut Harness<'static, PdfCraftApp>, tab: usize| {+ h.state_mut().active = Some(tab);+ h.run_steps(2);+ assert!(h.state_mut().execute("edit.edit_text"));+ h.run_steps(2);+ let r = h.state().views[tab].page_screen_rect(0).expect("on screen");+ click_at(h, egui::pos2(r.left() + 40.0 / 200.0 * r.width(), r.top() + (300.0 - 158.0) / 300.0 * r.height()));+ assert!(h.state().views[tab].line_editor.is_some(), "the paragraph opens for typing");+ };+ open_in(&mut h, 1);+ open_in(&mut h, 0);+ let original = h.state().views[0].line_editor.as_ref().unwrap().text.clone();+ h.key_press_modifiers(Modifiers::COMMAND, Key::End);+ h.event(egui::Event::Text(" secret".into()));+ h.run_steps(2);+ assert!(h.state_mut().execute("edit.undo"));+ h.run_steps(3);+ assert_eq!(h.state().views[0].line_editor.as_ref().unwrap().text, original, "taken back in A");+ // To B and Redo at once: no frame draws B's box in between.+ h.state_mut().active = Some(1);+ h.state_mut().redo();+ h.run_steps(3);+ let s = h.state();+ let b = s.views[1].line_editor.as_ref().map(|ed| ed.text.clone());+ assert!(!b.as_deref().unwrap_or_default().contains("secret"), "A's typing came back in B: {b:?}");+ assert!(!s.session.get(s.views[1].id).unwrap().text_blocks(0)[0].text.contains("secret"), "A's typing reached B's page");+}+/// Two copies of a document, the same paragraph open in each. The paragraph boxes share one text/// box, and so one Undo history: a box opened on the same text as another tab's didn't clear it./// Typing in one tab, taken back with Undo, then came back with Redo in the other tab.