Skip to content

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

fix(ui): Update draws the page shown without its marks at once, and a page that fails alone

alehel098a1f832172
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index b1abddfdc..dfdb52215 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -307,7 +307,7 @@ impl PdfCraftApp {
/// `true` while any open document still waits for page renders (used by headless capture).
pub fn render_pending(&self) -> bool {
- self.views.iter().any(|v| v.render_pending()) || self.unmarked_page.pending()
+ self.views.iter().any(|v| v.render_pending())
}
}
diff --git a/crates/ui-egui/src/dialogs/marks_ui.rs b/crates/ui-egui/src/dialogs/marks_ui.rs
index 2efc10ecc..d9a5b8815 100644
--- a/crates/ui-egui/src/dialogs/marks_ui.rs
+++ b/crates/ui-egui/src/dialogs/marks_ui.rs
@@ -3,6 +3,8 @@
//! page the range selects, with the marks laid out on it. "Update" opens the same dialog in
//! replace mode.
+use std::collections::{HashMap, HashSet};
+
use egui::{Align, Color32, CornerRadius, Layout, Rect, Stroke, pos2, vec2};
use pdfcraft_engine::{Background, Edit, FontFamily, HeaderFooter, MarkKind, Watermark};
@@ -186,31 +188,35 @@ fn behind(color: [f64; 3], opacity: f64) -> Color32 {
/// In Update, the pages previewed without the marks the dialog replaces. Their thumbnails still
/// have them, so the new marks would be drawn over the old ones, and a new background colour
/// would tint the old one. The document without them is made once per dialog (it costs about a
-/// save), and each page shown is rendered from it off the UI thread, like the thumbnails.
+/// save). The page shown is drawn from it straight away, at the preview's small size, so neither
+/// a blank sheet nor the old marks show while it renders; the pages a step goes to next render
+/// ahead, off the UI thread, so stepping rarely waits.
#[derive(Default)]
pub(crate) struct UnmarkedPage {
/// The document, its edit generation and the kind of mark taken away.
key: Option<(pdfcraft_engine::DocId, u64, MarkKind)>,
+ pages: Option<pdfcraft_engine::UnmarkedPages>,
renderer: Option<pdfcraft_render::RenderPool>,
- /// The page and scale last asked for.
- asked: Option<(usize, u64)>,
- /// The page and scale the texture shows.
- texture: Option<(usize, u64, egui::TextureHandle)>,
+ /// The pages rendered, with the scale (×1000) they were rendered at: the page shown and the
+ /// pages next to it.
+ textures: HashMap<usize, (u64, egui::TextureHandle)>,
+ /// Pages that failed to render: their thumbnails show instead, the other pages still don't.
+ failed: HashSet<usize>,
+ /// The pages asked of the renderer ahead, and not back yet. Nothing waits for them: a step
+ /// is a frame, which takes what has come back first and draws the rest itself.
+ ahead: Vec<(usize, u64)>,
}
impl UnmarkedPage {
- pub(crate) fn pending(&self) -> bool {
- self.renderer.is_some() && self.asked.is_some() && self.texture.as_ref().map(|(p, t, _)| (*p, *t)) != self.asked
- }
-
/// The picture to preview `page` on in place of its thumbnail, or `None` for the thumbnail:
- /// not Update, no marks of `kind` in the document, the pages can't be prepared, or `page` is
- /// still rendering (its thumbnail shows until then, rather than a blank sheet).
+ /// not Update, no marks of `kind` in the document, the pages can't be prepared, or `page`
+ /// fails to render. `near` are the pages a step goes to from it, rendered ahead.
fn picture(
&mut self,
ctx: &egui::Context,
(doc, id): (&pdfcraft_engine::Document, pdfcraft_engine::DocId),
page: usize,
+ near: &[usize],
kind: MarkKind,
replace: bool,
) -> Option<egui::TextureId> {
@@ -218,34 +224,57 @@ impl UnmarkedPage {
if self.key != key {
*self = Self { key, ..Default::default() };
if replace {
- self.renderer = doc.without_marks(kind).ok().flatten().map(|p| p.renderer());
+ self.pages = doc.without_marks(kind).ok().flatten();
+ self.renderer = self.pages.as_ref().map(|p| p.renderer());
}
}
- let renderer = self.renderer.as_ref()?;
+ let (pages, renderer) = (self.pages.as_ref()?, self.renderer.as_ref()?);
// At the preview's size in pixels.
- let p = doc.info.pages.get(page)?;
- let scale = PREVIEW_SIDE * ctx.pixels_per_point() / p.width.max(p.height).max(1.0);
- let asked = (page, (scale * 1000.0) as u64);
- if self.asked != Some(asked) {
- renderer.set_queue(vec![pdfcraft_render::RenderRequest { page, scale, tag: asked.1, ..Default::default() }]);
- self.asked = Some(asked);
- }
- if let Some(out) = renderer.try_recv() {
+ let scale = |page: usize| {
+ let p = doc.info.pages.get(page)?;
+ let s = PREVIEW_SIDE * ctx.pixels_per_point() / p.width.max(p.height).max(1.0);
+ Some((s, (s * 1000.0) as u64))
+ };
+ let load = |ctx: &egui::Context, out: pdfcraft_render::RenderedPage| {
+ let image = crate::canvas::texture_image([out.width as usize, out.height as usize], out.rgba);
+ ctx.load_texture("marks-preview-unmarked", image, egui::TextureOptions::LINEAR)
+ };
+ while let Some(out) = renderer.try_recv() {
+ let at = (out.request.page, out.request.tag);
+ self.ahead.retain(|a| *a != at);
if out.error.is_some() {
- // The thumbnails, as before, rather than no page at all.
- self.renderer = None;
- self.texture = None;
- return None;
+ self.failed.insert(at.0);
+ } else {
+ self.textures.insert(at.0, (at.1, load(ctx, out)));
}
- if (out.request.page, out.request.tag) == asked {
- let image = crate::canvas::texture_image([out.width as usize, out.height as usize], out.rgba);
- self.texture = Some((page, asked.1, ctx.load_texture("marks-preview-unmarked", image, egui::TextureOptions::LINEAR)));
+ }
+ let (s, tag) = scale(page)?;
+ if !self.failed.contains(&page) && self.textures.get(&page).is_none_or(|(t, _)| *t != tag) {
+ match pages.render_page(page, s) {
+ Ok(out) => {
+ self.textures.insert(page, (tag, load(ctx, out)));
+ }
+ Err(_) => {
+ self.failed.insert(page);
+ }
}
}
- if self.pending() {
- ctx.request_repaint_after(std::time::Duration::from_millis(16));
+ // Ahead: the pages a step goes to, not rendered yet at their scale.
+ let wanted: Vec<(usize, u64)> = near
+ .iter()
+ .filter(|p| !self.failed.contains(p))
+ .filter_map(|&p| scale(p).map(|(_, t)| (p, t)))
+ .filter(|(p, t)| self.textures.get(p).is_none_or(|(have, _)| have != t))
+ .collect();
+ if !wanted.is_empty() && wanted != self.ahead {
+ let requests = wanted
+ .iter()
+ .filter_map(|&(p, _)| scale(p).map(|(s, tag)| pdfcraft_render::RenderRequest { page: p, scale: s, tag, ..Default::default() }));
+ renderer.set_queue(requests.collect());
+ self.ahead = wanted;
}
- self.texture.as_ref().filter(|(p, ..)| *p == page).map(|(.., t)| t.id())
+ self.textures.retain(|p, _| *p == page || near.contains(p));
+ self.textures.get(&page).filter(|_| !self.failed.contains(&page)).map(|(_, t)| t.id())
}
}
@@ -450,7 +479,8 @@ pub(crate) fn body(ui: &mut egui::Ui, app: &mut PdfCraftApp, t: &Tokens, kind: M
// frame the engine lays the marks out in. Update draws it without the marks it replaces.
let target = shown_preview(&d.range, &mut d.preview, current, count);
let page = doc.info.pages.get(target).map(|p| (p.width as f64, p.height as f64)).unwrap_or((612.0, 792.0));
- let unmarked = app.unmarked_page.picture(ui.ctx(), (doc, id), target, kind, d.replace);
+ let near: Vec<usize> = [false, true].into_iter().filter_map(|forward| step_preview(&d.range, target, count, forward)).collect();
+ let unmarked = app.unmarked_page.picture(ui.ctx(), (doc, id), target, &near, kind, d.replace);
let picture = unmarked.or_else(|| {
app.views.get_mut(i).and_then(|view| {
view.need_thumbnail(target, true);
diff --git a/crates/ui-egui/tests/it/marks.rs b/crates/ui-egui/tests/it/marks.rs
index e0d429efa..f66bf3986 100644
--- a/crates/ui-egui/tests/it/marks.rs
+++ b/crates/ui-egui/tests/it/marks.rs
@@ -386,8 +386,6 @@ fn update_previews_the_page_without_the_marks_it_replaces() {
let mut app = PdfCraftApp::new();
app.set_option("language", "en").unwrap();
app.open_bytes("doc.pdf", None, pdf.clone()).unwrap();
- // The Pages panel keeps both thumbnails, for stepping to page 2 in Update below.
- app.set_option("panel", "pages").unwrap();
app
});
h.run_steps(4);
@@ -427,30 +425,26 @@ fn update_previews_the_page_without_the_marks_it_replaces() {
assert!(h.state_mut().execute("edit.background.update"));
h.run_steps(2);
h.state_mut().marks_draft.bg.color = [0.6, 0.8, 1.0];
- let white = |i: &egui::ColorImage| at(i, 0.5, 0.75) == egui::Color32::WHITE;
- let (tint, page) = wait_for_preview(&mut h, &uploads, "the page without its background", white);
+ h.step();
+ // Update shows the page without the marks from the frame it opens: neither a blank sheet nor
+ // the old marks while it renders.
+ let shown = |h: &Harness<'static, PdfCraftApp>| preview_picture(h, &uploads).expect("a page is previewed");
+ let (tint, page) = shown(&h);
assert_eq!(tint, egui::Color32::from_rgb(153, 204, 255), "the new colour tints the page");
assert_eq!(at(&page, 0.5, 0.75), egui::Color32::WHITE, "the page is previewed without the yellow background");
assert!(count(&page, red) > 200 && count(&page, blue) > 40 && count(&page, dark) > 1000, "the watermark, header and page content stay");
- // Stepping to page 2 shows its thumbnail until it renders without the background, not a
- // blank sheet: the pages are prepared once, and each renders on its own.
- let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
- while h.state().views[0].thumb(1).is_none() {
- assert!(std::time::Instant::now() < deadline, "page 2's thumbnail never loaded");
- h.step();
- std::thread::sleep(std::time::Duration::from_millis(5));
- }
+ // So does a step to page 2: the pages are prepared once, and each is drawn as it is shown.
h.state_mut().marks_draft.preview = Some(1);
h.step();
- assert!(preview_picture(&h, &uploads).is_some(), "a page shows while page 2 renders");
- wait_for_preview(&mut h, &uploads, "page 2 without its background", white);
+ assert_eq!(at(&shown(&h).1, 0.5, 0.75), egui::Color32::WHITE, "page 2 is previewed without its background at once");
h.get_by_label("Cancel").click();
h.run_steps(2);
assert!(h.state_mut().execute("edit.watermark.update"));
h.run_steps(2);
h.state_mut().marks_draft.wm.text = "NEW".into();
- let (_, page) = wait_for_preview(&mut h, &uploads, "the page without its watermark", |i| count(i, red) == 0);
+ h.step();
+ let (_, page) = shown(&h);
assert_eq!(count(&page, red), 0, "the new watermark isn't previewed over the old one");
assert!(at(&page, 0.5, 0.75) == yellow && count(&page, blue) > 40, "the background and header stay");
h.get_by_label("Cancel").click();
@@ -458,7 +452,7 @@ fn update_previews_the_page_without_the_marks_it_replaces() {
assert!(h.state_mut().execute("edit.header_footer.update"));
h.run_steps(2);
- let (_, page) = wait_for_preview(&mut h, &uploads, "the page without its header", |i| count(i, blue) == 0);
+ let (_, page) = shown(&h);
assert_eq!(count(&page, blue), 0, "the new header isn't previewed over the old one");
assert!(at(&page, 0.5, 0.75) == yellow && count(&page, red) > 200, "the background and watermark stay");
}