357 lines
17 KiB
Rust
357 lines
17 KiB
Rust
//! Mouse, jumps, search across tabs, failures, tiles (C11.1).
|
|
|
|
use std::collections::HashSet;
|
|
|
|
use ely_office::Tabs as _;
|
|
use gpui::{Entity, Modifiers, MouseButton, TestAppContext, VisualTestContext, point, px};
|
|
|
|
use super::{file, settle, shown, windowed};
|
|
use crate::layout::Zoom;
|
|
use crate::view::PdfView;
|
|
use crate::viewer::Viewer;
|
|
|
|
/// The window point over page points `at` of `page`.
|
|
pub(super) fn over(cx: &mut VisualTestContext, view: &Entity<PdfView>, page: usize, at: (f32, f32)) -> gpui::Point<gpui::Pixels> {
|
|
cx.update(|_, app| {
|
|
let view = view.read(app);
|
|
let laid = view.laid_out();
|
|
let place = laid.placed.iter().find(|p| p.page == page).expect("placed");
|
|
let (offset, origin) = (view.scroll.offset(), view.room.origin);
|
|
point(
|
|
origin.x + offset.x + px(place.x + at.0 * laid.scale),
|
|
origin.y + offset.y + px(place.y + at.1 * laid.scale),
|
|
)
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn a_first_drag_picks_text_before_the_page_is_read() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let path = file(dir.path(), "one.pdf", &[(612.0, 792.0, &["alpha beta gamma"])]);
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[path], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| view.read(app).room.size.width > px(100.0));
|
|
// Glyphs sit near 72 points down; none read yet.
|
|
let (from, to) = (over(cx, &view, 0, (74.0, 62.0)), over(cx, &view, 0, (150.0, 62.0)));
|
|
cx.simulate_mouse_down(from, MouseButton::Left, Modifiers::none());
|
|
cx.simulate_mouse_move(to, MouseButton::Left, Modifiers::none());
|
|
cx.simulate_mouse_up(to, MouseButton::Left, Modifiers::none());
|
|
cx.update(|_, app| view.update(app, |view, cx| view.copy(cx)));
|
|
settle(cx, |app| app.read_from_clipboard().is_some());
|
|
let text = cx.update(|_, app| app.read_from_clipboard().and_then(|item| item.text())).expect("copied");
|
|
assert!(text.starts_with("alpha"), "{text}");
|
|
}
|
|
|
|
#[test]
|
|
fn a_jump_makes_its_page_the_one_being_read() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let pages: &[(f32, f32, &[&str])] = &[(612.0, 792.0, &["one"]), (612.0, 792.0, &["two"]), (612.0, 792.0, &["three"])];
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "three.pdf", pages)], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| view.read(app).room.size.width > px(100.0));
|
|
cx.update(|_, app| view.update(app, |view, cx| view.show(1, 0.0, cx)));
|
|
super::frames(cx);
|
|
assert_eq!(cx.update(|_, app| view.read(app).current), 1);
|
|
}
|
|
|
|
/// A: the word on page three only. B: three pages.
|
|
fn two_tabs<'a>(cx: &'a mut TestAppContext, dir: &std::path::Path) -> (Entity<Viewer>, &'a mut VisualTestContext, u64, u64) {
|
|
let a = file(dir, "a.pdf", &[(612.0, 792.0, &["one"]), (612.0, 792.0, &["two"]), (612.0, 792.0, &["three alpha"])]);
|
|
let b = file(dir, "b.pdf", &[(612.0, 792.0, &["zzz"]), (612.0, 792.0, &["b2"]), (612.0, 792.0, &["b3"])]);
|
|
let (viewer, cx) = windowed(cx, dir, &[a, b], true);
|
|
let (first, second) = cx.update(|_, app| (viewer.read(app).core.tabs[0].id, viewer.read(app).core.tabs[1].id));
|
|
(viewer, cx, first, second)
|
|
}
|
|
|
|
/// Opens find on `tab` and searches `query` at once.
|
|
fn find_in(cx: &mut VisualTestContext, viewer: &Entity<Viewer>, tab: u64, query: &str) {
|
|
cx.update(|window, app| viewer.update(app, |viewer, cx| {
|
|
viewer.core.active = Some(tab);
|
|
viewer.open_find(window, cx);
|
|
let field = viewer.find.as_ref().expect("open").query.clone();
|
|
field.update(cx, |field, cx| field.set_text(query, cx));
|
|
}));
|
|
}
|
|
|
|
fn view_of(cx: &mut VisualTestContext, viewer: &Entity<Viewer>, tab: u64) -> Entity<PdfView> {
|
|
cx.update(|_, app| viewer.read(app).tab(tab).expect("open").view.clone())
|
|
}
|
|
|
|
#[test]
|
|
fn a_hit_found_late_never_moves_another_tab() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx, first, second) = two_tabs(&mut cx, dir.path());
|
|
find_in(cx, &viewer, first, "alpha");
|
|
// Before the batch comes back, the reader turns to B.
|
|
cx.update(|_, app| viewer.update(app, |viewer, _| viewer.core.active = Some(second)));
|
|
settle(cx, |app| viewer.read(app).find.as_ref().is_some_and(|find| find.done == 3));
|
|
let (a, b) = (view_of(cx, &viewer, first), view_of(cx, &viewer, second));
|
|
let state = cx.update(|_, app| (a.read(app).chosen, b.read(app).current));
|
|
assert_eq!(state, (Some(0), 0), "the hit is chosen; B stays on its page");
|
|
}
|
|
|
|
#[test]
|
|
fn a_new_find_box_takes_no_answers_meant_for_the_old() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx, first, second) = two_tabs(&mut cx, dir.path());
|
|
find_in(cx, &viewer, first, "alpha");
|
|
find_in(cx, &viewer, second, "zzz");
|
|
settle(cx, |app| viewer.read(app).find.as_ref().is_some_and(|find| find.done == 3));
|
|
super::frames(cx);
|
|
let (a, b) = (view_of(cx, &viewer, first), view_of(cx, &viewer, second));
|
|
let pages = cx.update(|_, app| (a.read(app).found.len(), b.read(app).found.iter().map(|h| h.0).collect::<Vec<_>>()));
|
|
assert_eq!(pages, (0, vec![0]), "only B's own hit");
|
|
}
|
|
|
|
#[test]
|
|
fn a_tile_that_fails_is_not_asked_again() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "one.pdf", &[(612.0, 792.0, &["x"])])], true);
|
|
let view = shown(cx, &viewer);
|
|
// The document goes away behind the viewer's back.
|
|
let (worker, doc) = cx.update(|_, app| (viewer.read(app).core.worker.clone(), view.read(app).doc));
|
|
worker.lock().expect("the lock").get().expect("started").close(doc).expect("closes");
|
|
cx.update(|_, app| view.update(app, |view, cx| {
|
|
view.tiles.clear();
|
|
cx.notify();
|
|
}));
|
|
settle(cx, |app| !view.read(app).failed.is_empty());
|
|
// Bounded steps: a retry loop would never go quiet.
|
|
for _ in 0..10 {
|
|
super::frames(cx);
|
|
}
|
|
assert!(!cx.update(|_, app| view.read(app).painting), "no new tries, nothing waiting");
|
|
}
|
|
|
|
#[test]
|
|
fn tiles_scrolled_off_a_long_page_go() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "long.pdf", &[(612.0, 14400.0, &["top"])])], true);
|
|
let view = shown(cx, &viewer);
|
|
cx.update(|_, app| view.update(app, |view, cx| {
|
|
view.zoom = Zoom::Scale(1.0);
|
|
cx.notify();
|
|
}));
|
|
settle(cx, |app| view.read(app).tiles.keys().any(|key| key.ty == 0));
|
|
cx.update(|_, app| view.update(app, |view, cx| {
|
|
view.go_to = Some((0.0, 4000.0));
|
|
cx.notify();
|
|
}));
|
|
settle(cx, |app| !view.read(app).tiles.is_empty() && view.read(app).tiles.keys().all(|key| key.ty > 0));
|
|
}
|
|
|
|
#[test]
|
|
fn no_worker_runs_before_a_file_opens() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[], false);
|
|
let started = |cx: &mut VisualTestContext| cx.update(|_, app| viewer.read(app).core.worker.lock().expect("the lock").started());
|
|
assert!(!started(cx));
|
|
let path = file(dir.path(), "plain.pdf", &[(612.0, 792.0, &["no marks"])]);
|
|
cx.update(|_, app| viewer.update(app, |viewer, cx| ely_office::Opening::open_file(viewer, path.clone(), cx)));
|
|
settle(cx, |app| viewer.read(app).active_tab().is_some());
|
|
assert!(started(cx));
|
|
}
|
|
|
|
#[test]
|
|
fn tiles_beside_the_view_are_neither_asked_nor_kept() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "wide.pdf", &[(612.0, 792.0, &["x"])])], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| view.read(app).room.size.width > px(100.0));
|
|
cx.update(|_, app| view.update(app, |view, cx| {
|
|
view.zoom = Zoom::Scale(4.0);
|
|
cx.notify();
|
|
}));
|
|
let columns = |app: &gpui::App| view.read(app).tiles.keys().map(|key| key.tx).collect::<HashSet<_>>();
|
|
let last = cx.update(|window, app| {
|
|
let laid = view.read(app).laid_out();
|
|
((laid.placed[0].w * window.scale_factor()).ceil() as i32 - 1) / crate::pages::TILE
|
|
});
|
|
settle(cx, |app| columns(app).contains(&0) && !view.read(app).painting);
|
|
assert!(!cx.update(|_, app| columns(app)).contains(&last), "the right edge is off screen");
|
|
cx.update(|_, app| view.update(app, |view, cx| {
|
|
let wide = view.laid_out().size.0 - f32::from(view.room.size.width);
|
|
let y = view.scroll.offset().y;
|
|
view.scroll.set_offset(point(px(-wide), y));
|
|
cx.notify();
|
|
}));
|
|
settle(cx, |app| columns(app).contains(&last) && !columns(app).contains(&0));
|
|
}
|
|
|
|
/// Flags any notify leaving a shown page with nothing drawn.
|
|
fn never_bare(cx: &mut VisualTestContext, view: &Entity<PdfView>) -> (gpui::Subscription, std::rc::Rc<std::cell::Cell<bool>>) {
|
|
let (sf, dark) = cx.update(|window, app| (window.scale_factor(), ely_gpui_component::theme::ActiveTheme::theme(app).is_dark()));
|
|
let bare = std::rc::Rc::new(std::cell::Cell::new(false));
|
|
let seen = bare.clone();
|
|
let watch = cx.update(|_, app| {
|
|
app.observe(view, move |view, app| {
|
|
let read = view.read(app);
|
|
if read.showing(sf, dark).iter().any(|page| read.pieces(page).is_empty()) {
|
|
seen.set(true);
|
|
}
|
|
})
|
|
});
|
|
(watch, bare)
|
|
}
|
|
|
|
/// Only new tiles drawn, and none on its way.
|
|
fn repainted(view: &PdfView) -> bool {
|
|
view.backdrop.is_empty() && !view.painting && !view.tiles.is_empty()
|
|
}
|
|
|
|
fn note() -> ely_pdf_engine::NewAnnot {
|
|
ely_pdf_engine::NewAnnot {
|
|
page: 0,
|
|
shape: ely_pdf_engine::Shape::Note((100.0, 500.0)),
|
|
rgb: None,
|
|
contents: "Look".into(),
|
|
author: String::new(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn an_edit_keeps_the_page_drawn_until_its_repaint_lands() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "one.pdf", &[(612.0, 792.0, &["Hello"])])], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| repainted(view.read(app)));
|
|
let before: Vec<_> = cx.update(|_, app| view.read(app).tiles.values().cloned().collect());
|
|
let (_watch, bare) = never_bare(cx, &view);
|
|
cx.update(|_, app| view.update(app, |view, cx| view.annotate("adding a note", vec![note()], cx)));
|
|
settle(cx, |app| view.read(app).edited == 1 && repainted(view.read(app)));
|
|
assert!(!bare.get(), "the page never goes blank");
|
|
let after = cx.update(|_, app| view.read(app).tiles.values().cloned().collect::<Vec<_>>());
|
|
assert!(
|
|
after.iter().all(|image| before.iter().all(|old| !std::sync::Arc::ptr_eq(old, image))),
|
|
"every tile was painted again"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_new_scale_keeps_the_old_tiles_until_new_ones_land() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "one.pdf", &[(612.0, 792.0, &["Hello"])])], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| repainted(view.read(app)));
|
|
let scale = cx.update(|_, app| view.read(app).laid_out().scale);
|
|
let (_watch, bare) = never_bare(cx, &view);
|
|
cx.simulate_resize(gpui::size(px(700.), px(800.)));
|
|
// The new size lays out before any new tile lands.
|
|
cx.run_until_parked();
|
|
let (sf, dark) = cx.update(|window, app| (window.scale_factor(), ely_gpui_component::theme::ActiveTheme::theme(app).is_dark()));
|
|
let now = cx.update(|_, app| {
|
|
let read = view.read(app);
|
|
read.showing(sf, dark).iter().map(|page| read.pieces(page).len()).collect::<Vec<_>>()
|
|
});
|
|
assert!(now.iter().all(|count| *count > 0), "drawn right after the resize: {now:?}");
|
|
settle(cx, |app| view.read(app).laid_out().scale != scale && repainted(view.read(app)));
|
|
assert!(!bare.get(), "the page never goes blank");
|
|
}
|
|
|
|
#[test]
|
|
fn an_edit_past_the_first_hundred_sizes_keeps_the_page_drawn() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut pages: Vec<(f32, f32, &[&str])> = vec![(612.0, 792.0, &["Page"]); 100];
|
|
pages.push((612.0, 900.0, &["Taller"]));
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "mixed.pdf", &pages)], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| view.read(app).sizes[100] == (612.0, 900.0) && repainted(view.read(app)));
|
|
let (_watch, bare) = never_bare(cx, &view);
|
|
cx.update(|_, app| view.update(app, |view, cx| view.annotate("adding a note", vec![note()], cx)));
|
|
settle(cx, |app| view.read(app).edited == 1 && repainted(view.read(app)));
|
|
assert!(!bare.get(), "the page never goes blank");
|
|
}
|
|
|
|
#[test]
|
|
fn an_edit_on_page_101_keeps_its_measured_size_and_its_tiles() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut pages: Vec<(f32, f32, &[&str])> = vec![(612.0, 792.0, &["Page"]); 100];
|
|
pages.push((612.0, 900.0, &["Taller"]));
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "mixed.pdf", &pages)], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| view.read(app).sizes[100] == (612.0, 900.0));
|
|
cx.update(|_, app| view.update(app, |view, cx| view.show(100, 0.0, cx)));
|
|
settle(cx, |app| view.read(app).current == 100 && repainted(view.read(app)));
|
|
let (_watch, bare) = never_bare(cx, &view);
|
|
let late = ely_pdf_engine::NewAnnot { page: 100, ..note() };
|
|
cx.update(|_, app| view.update(app, |view, cx| view.annotate("adding a note", vec![late], cx)));
|
|
settle(cx, |app| view.read(app).edited == 1 && repainted(view.read(app)));
|
|
assert!(!bare.get(), "page 101 never goes blank");
|
|
assert_eq!(cx.update(|_, app| view.read(app).sizes[100]), (612.0, 900.0), "its measured size holds");
|
|
}
|
|
|
|
#[test]
|
|
fn old_tiles_are_painted_and_freed_with_their_tab() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "one.pdf", &[(612.0, 792.0, &["Hello"])])], true);
|
|
let view = shown(cx, &viewer);
|
|
settle(cx, |app| repainted(view.read(app)));
|
|
// Nothing new is asked; only old tiles can paint.
|
|
let before = cx.update(|_, app| {
|
|
view.update(app, |view, cx| {
|
|
let keys: Vec<_> = view.tiles.keys().copied().collect();
|
|
view.failed.extend(keys);
|
|
view.keep_all();
|
|
cx.notify();
|
|
view.painted
|
|
})
|
|
});
|
|
cx.run_until_parked();
|
|
let (painted, kept) = cx.update(|_, app| (view.read(app).painted, view.read(app).backdrop.len()));
|
|
// Old tiles cover what shows of the page.
|
|
let shown = cx.update(|window, app| {
|
|
let read = view.read(app);
|
|
let room = read.room;
|
|
read.showing(window.scale_factor(), false).iter().map(|s| {
|
|
let (left, top) = (-f32::from(read.scroll.offset().x), -f32::from(read.scroll.offset().y));
|
|
let w = (s.place.x + s.place.w).min(left + f32::from(room.size.width)) - s.place.x.max(left);
|
|
let h = (s.place.y + s.place.h).min(top + f32::from(room.size.height)) - s.place.y.max(top);
|
|
f64::from(w.max(0.0) * h.max(0.0))
|
|
}).sum::<f64>()
|
|
});
|
|
assert!(kept > 0 && painted - before >= shown * 0.99, "{kept} old tiles painted {} of {shown}", painted - before);
|
|
cx.update(|_, app| view.update(app, |view, _| view.retire_all()));
|
|
assert!(cx.update(|_, app| view.read(app).backdrop.is_empty()), "closing hands every old tile over");
|
|
}
|
|
|
|
#[test]
|
|
fn an_edit_keeps_page_pictures_until_they_repaint() {
|
|
let dir = tempfile::tempdir().expect("a temp dir");
|
|
let mut cx = TestAppContext::single();
|
|
let (viewer, cx) = windowed(&mut cx, dir.path(), &[file(dir.path(), "one.pdf", &[(612.0, 792.0, &["Hello"])])], true);
|
|
let view = shown(cx, &viewer);
|
|
let dark = cx.update(|_, app| ely_gpui_component::theme::ActiveTheme::theme(app).is_dark());
|
|
settle(cx, |app| view.read(app).picture(0, dark).is_some() && repainted(view.read(app)));
|
|
let old = cx.update(|_, app| view.read(app).picture(0, dark).expect("a picture"));
|
|
// A picture on its way holds back the repaint.
|
|
cx.update(|_, app| view.update(app, |view, _| view.thumbing = true));
|
|
cx.update(|_, app| view.update(app, |view, cx| view.annotate("adding a note", vec![note()], cx)));
|
|
settle(cx, |app| view.read(app).edited == 1 && repainted(view.read(app)));
|
|
// Dropped from the atlas, it returns only if drawn.
|
|
cx.update(|window, _| window.drop_image(old.clone())).expect("drops");
|
|
super::frames(cx);
|
|
assert!(cx.update(|window, _| window.has_image_atlas_entry(&old)), "the old picture shows meanwhile");
|
|
cx.update(|_, app| view.update(app, |view, cx| {
|
|
view.thumbing = false;
|
|
cx.notify()
|
|
}));
|
|
settle(cx, |app| view.read(app).thumbs_stale.is_empty());
|
|
let new = cx.update(|_, app| view.read(app).picture(0, dark).expect("a picture"));
|
|
assert!(!std::sync::Arc::ptr_eq(&new, &old), "the new picture replaces it");
|
|
super::frames(cx);
|
|
assert!(cx.update(|window, _| window.has_image_atlas_entry(&new)), "and is drawn");
|
|
}
|