PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
refactor(ui-egui): move motion.rs's tests to motion/tests.rs
aiongg7d54ae2be302
diff --git a/crates/ui-egui/src/motion.rs b/crates/ui-egui/src/motion.rsindex d95d205b0..92ca469da 100644--- a/crates/ui-egui/src/motion.rs+++ b/crates/ui-egui/src/motion.rs@@ -282,390 +282,4 @@ impl WheelReader {}#[cfg(test)]-mod tests {- use super::*;- use std::cell::Cell;- use std::rc::Rc;-- fn wheel(unit: MouseWheelUnit, delta: Vec2, phase: TouchPhase, modifiers: Modifiers) -> Event {- Event::MouseWheel { unit, delta, phase, modifiers, source: egui::MouseWheelSource::Unknown }- }-- fn notch(dy: f32, modifiers: Modifiers) -> Event {- wheel(MouseWheelUnit::Line, vec2(0.0, dy), TouchPhase::Move, modifiers)- }-- fn read(events: &[Event]) -> WheelMotion {- WheelReader::default().read(events, 600.0, &egui::InputOptions::default())- }-- #[test]- fn a_step_is_read_whole_in_its_units() {- let line = egui::InputOptions::default().line_scroll_speed;- assert_eq!(read(&[notch(-1.0, Modifiers::NONE)]), WheelMotion { scroll: vec2(0.0, -line), zoom: 1.0 });- assert_eq!(read(&[notch(-1.0, Modifiers::NONE), notch(-2.0, Modifiers::NONE)]).scroll, vec2(0.0, -3.0 * line), "steps of one pass add up");- let points = wheel(MouseWheelUnit::Point, vec2(3.0, -250.0), TouchPhase::Move, Modifiers::NONE);- assert_eq!(read(&[points]).scroll, vec2(3.0, -250.0));- let page = wheel(MouseWheelUnit::Page, vec2(0.0, -1.0), TouchPhase::Move, Modifiers::NONE);- assert_eq!(read(&[page]).scroll, vec2(0.0, -600.0));- assert_eq!(read(&[]), WheelMotion { scroll: Vec2::ZERO, zoom: 1.0 }, "and nothing is left for a later pass");- }-- #[test]- fn modifiers_turn_the_wheel_sideways_or_into_zoom() {- let line = egui::InputOptions::default().line_scroll_speed;- assert_eq!(read(&[notch(-1.0, Modifiers::SHIFT)]).scroll, vec2(-line, 0.0));- let sideways = wheel(MouseWheelUnit::Point, vec2(-30.0, 0.0), TouchPhase::Move, Modifiers::ALT);- assert_eq!(read(&[sideways]).scroll, vec2(0.0, -30.0));- let zoomed = read(&[notch(1.0, Modifiers::COMMAND)]);- assert_eq!(zoomed.scroll, Vec2::ZERO, "a zooming wheel doesn't scroll");- let step = (egui::InputOptions::default().scroll_zoom_speed * line).exp();- assert!((zoomed.zoom - step).abs() < 1e-6, "{zoomed:?}");- assert!((read(&[notch(-1.0, Modifiers::COMMAND)]).zoom - 1.0 / step).abs() < 1e-6);- assert!((read(&[Event::Zoom(1.5), Event::Zoom(2.0)]).zoom - 3.0).abs() < 1e-6, "pinch events multiply");- }-- #[test]- fn a_touch_gesture_keeps_its_modifiers_and_ends_clean() {- let mut reader = WheelReader::default();- let options = egui::InputOptions::default();- let point = |dy: f32, phase, modifiers| wheel(MouseWheelUnit::Point, vec2(0.0, dy), phase, modifiers);- // ⌘ held as the fingers land, let go before the momentum: still zooming.- let began =- reader.read(&[point(0.0, TouchPhase::Start, Modifiers::COMMAND), point(20.0, TouchPhase::Move, Modifiers::COMMAND)], 600.0, &options);- assert!(began.zoom > 1.0 && began.scroll == Vec2::ZERO, "{began:?}");- let momentum = reader.read(&[point(20.0, TouchPhase::Move, Modifiers::NONE)], 600.0, &options);- assert!(momentum.zoom > 1.0 && momentum.scroll == Vec2::ZERO, "{momentum:?}");- // The pass it ends in moves nothing, and the next gesture starts without the modifier.- let ended = reader.read(&[point(20.0, TouchPhase::Move, Modifiers::NONE), point(0.0, TouchPhase::End, Modifiers::NONE)], 600.0, &options);- assert_eq!(ended, WheelMotion { scroll: Vec2::ZERO, zoom: 1.0 });- assert_eq!(reader.read(&[point(-20.0, TouchPhase::Move, Modifiers::NONE)], 600.0, &options).scroll, vec2(0.0, -20.0));- }-- #[test]- fn numbers_that_are_not_finite_move_nothing() {- for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {- let scrolled = read(&[notch(bad, Modifiers::NONE), notch(-1.0, Modifiers::NONE)]);- assert!(scrolled.scroll.x.is_finite() && scrolled.scroll.y.is_finite(), "{bad}: {scrolled:?}");- assert_eq!(read(&[notch(bad, Modifiers::COMMAND)]).zoom, 1.0, "{bad}");- assert_eq!(read(&[Event::Zoom(bad)]).zoom, 1.0, "{bad}");- }- assert_eq!(read(&[Event::Zoom(0.0)]).zoom, 1.0);- assert_eq!(read(&[Event::Zoom(-2.0)]).zoom, 1.0);- // Too far to be a factor at all.- assert_eq!(read(&[notch(1.0e9, Modifiers::COMMAND)]).zoom, 1.0);- }-- /// One pass of a bare egui context, a sixtieth of a second after the last.- fn pass(ctx: &egui::Context, time: &mut f64, events: Vec<Event>, mut seen: impl FnMut(&egui::Context)) {- *time += 1.0 / 60.0;- let raw = egui::RawInput { time: Some(*time), events, ..Default::default() };- // A bare context's first frame uploads the font atlas; nothing paints it here.- ctx.run_ui(raw, |ui| seen(ui.ctx())).textures_delta.clear();- }-- /// The reader must stay egui's own reading minus the easing: over the passes egui takes to- /// ease a step, it hands out as much scroll (and as much zoom) as the reader does at once.- #[test]- fn reading_at_once_goes_as_far_as_egui_eases() {- let options = egui::InputOptions::default();- for (modifiers, unit, step) in [- (Modifiers::NONE, MouseWheelUnit::Line, vec2(0.0, -3.0)),- (Modifiers::NONE, MouseWheelUnit::Point, vec2(40.0, -250.0)),- (Modifiers::SHIFT, MouseWheelUnit::Line, vec2(0.0, 2.0)),- (Modifiers::COMMAND, MouseWheelUnit::Line, vec2(0.0, 1.0)),- (Modifiers::COMMAND, MouseWheelUnit::Point, vec2(0.0, -90.0)),- ] {- let event = wheel(unit, step, TouchPhase::Move, modifiers);- let ctx = egui::Context::default();- let (mut time, mut scrolled, mut zoomed, mut first) = (0.0, Vec2::ZERO, 1.0_f32, None);- let mut events = vec![event.clone()];- for _ in 0..120 {- pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {- let (scroll, zoom) = ctx.input(|i| (i.smooth_scroll_delta, i.zoom_delta()));- first.get_or_insert((scroll, zoom));- scrolled += scroll;- zoomed *= zoom;- });- }- let page_height = ctx.input(|i| i.viewport_rect().height());- let at_once = WheelReader::default().read(&[event], page_height, &options);- assert!((scrolled - at_once.scroll).length() < 0.01, "{modifiers:?} {unit:?}: egui scrolled {scrolled:?}, read {:?}", at_once.scroll);- assert!((zoomed / at_once.zoom - 1.0).abs() < 1e-3, "{modifiers:?} {unit:?}: egui zoomed {zoomed}, read {}", at_once.zoom);- // What makes the reader necessary: egui's first pass holds part of the step back.- let first = first.expect("passes ran");- assert!(- first != (at_once.scroll, at_once.zoom),- "{modifiers:?} {unit:?}: egui no longer eases this step ({first:?}); the reader may not be needed"- );- }- }-- #[test]- fn reduced_motion_hands_egui_the_whole_step_and_stops_its_animations() {- let ctx = egui::Context::default();- let mut motion = Motion { reduced: true, ..Default::default() };- let line = egui::InputOptions::default().line_scroll_speed;- let mut time = 0.0;- let mut seen = Vec::new();- let mut events = vec![notch(-1.0, Modifiers::NONE)];- for _ in 0..30 {- pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {- motion.begin_pass(ctx, AnimationEffects::System);- seen.push(ctx.input(|i| i.smooth_scroll_delta));- });- }- assert_eq!(seen.first(), Some(&vec2(0.0, -line)), "the whole notch in the pass it arrives");- assert!(seen.iter().skip(1).all(|d| *d == Vec2::ZERO), "and none of egui's easing after it: {seen:?}");- let style = ctx.global_style();- assert_eq!((style.animation_time, style.scroll_animation), (0.0, egui::style::ScrollAnimation::none()));- for theme in [egui::Theme::Light, egui::Theme::Dark] {- assert_eq!(ctx.style_of(theme).animation_time, 0.0, "{theme:?}");- }-- // ⌘/Ctrl with the wheel: the whole zoom step at once, then nothing.- let step = (egui::InputOptions::default().scroll_zoom_speed * line).exp();- let mut zooms = Vec::new();- let mut events = vec![notch(1.0, Modifiers::COMMAND)];- for _ in 0..30 {- pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {- motion.begin_pass(ctx, AnimationEffects::System);- zooms.push(zoom_delta(ctx));- });- }- assert!((zooms[0] - step).abs() < 1e-6, "{zooms:?}");- assert!(zooms.iter().skip(1).all(|z| *z == 1.0), "{zooms:?}");-- // Animations allowed again: egui's own values and its own times.- motion.reduced = false;- let mut eased = Vec::new();- let mut events = vec![notch(1.0, Modifiers::COMMAND)];- for _ in 0..3 {- pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {- motion.begin_pass(ctx, AnimationEffects::System);- eased.push((zoom_delta(ctx), ctx.input(|i| i.zoom_delta())));- });- }- assert!(eased.iter().all(|(ours, eguis)| ours == eguis), "{eased:?}");- assert!(eased[0].0 > 1.0 && eased[0].0 < step, "egui eases the step: {eased:?}");- let (style, default) = (ctx.global_style(), egui::Style::default());- assert_eq!((style.animation_time, style.scroll_animation), (default.animation_time, default.scroll_animation));- }-- #[test]- fn the_preference_overrides_the_system_for_every_animation() {- use AnimationEffects::{Off, On, System};- assert_eq!(AnimationEffects::default(), System, "the system's setting is followed unless the user chooses");- for choice in AnimationEffects::ALL {- assert_eq!(AnimationEffects::parse(choice.name()), Some(choice));- }- assert_eq!((AnimationEffects::parse("OFF"), AnimationEffects::parse("smooth")), (Some(Off), None));- let (line, egui_default) = (egui::InputOptions::default().line_scroll_speed, egui::Style::default());- let egui_times = (egui_default.animation_time, egui_default.scroll_animation);- // The system's answer, the choice, and whether the window then animates.- for (reduced, effects, animates) in- [(false, System, true), (true, System, false), (false, On, true), (true, On, true), (false, Off, false), (true, Off, false)]- {- assert_eq!(effects.animates(reduced), animates, "{effects:?}, system reduced: {reduced}");- let ctx = egui::Context::default();- let mut motion = Motion { reduced, ..Default::default() };- let (mut time, mut first) = (0.0, None);- pass(&ctx, &mut time, vec![notch(-1.0, Modifiers::NONE)], |ctx| {- motion.begin_pass(ctx, effects);- first = Some((ctx.input(|i| i.smooth_scroll_delta), animated(ctx)));- });- // The wheel, egui's animations and the app's own fades all go the same way.- let whole_notch = first.map(|(scroll, _)| scroll) == Some(vec2(0.0, -line));- assert_eq!(- (whole_notch, first.map(|(_, animated)| animated)),- (!animates, Some(animates)),- "{effects:?}, system reduced: {reduced}: {first:?}"- );- let style = ctx.global_style();- let times = if animates { egui_times } else { (0.0, ScrollAnimation::none()) };- assert_eq!((style.animation_time, style.scroll_animation), times, "{effects:?}, system reduced: {reduced}");- }- // A choice made while running applies from the next pass, and choosing back undoes it.- let ctx = egui::Context::default();- let mut motion = Motion::default();- let mut time = 0.0;- for (effects, times) in [(Off, (0.0, ScrollAnimation::none())), (System, egui_times), (Off, (0.0, ScrollAnimation::none())), (On, egui_times)]- {- pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, effects));- let style = ctx.global_style();- assert_eq!((style.animation_time, style.scroll_animation), times, "{effects:?}");- }- }-- /// The chrome's hover wash has a duration of its own (`theme::Press`): it eases in with- /// animation effects on and is simply there with them off.- #[test]- fn the_hover_wash_eases_only_with_animation_effects_on() {- for (effects, eased) in [(AnimationEffects::On, true), (AnimationEffects::Off, false)] {- let ctx = egui::Context::default();- let mut motion = Motion::default();- let (mut time, mut hover) = (0.0, Vec::new());- for _ in 0..12 {- time += 1.0 / 60.0;- let raw = egui::RawInput { time: Some(time), events: vec![Event::PointerMoved(egui::pos2(20.0, 20.0))], ..Default::default() };- ctx.run_ui(raw, |ui| {- motion.begin_pass(ui.ctx(), effects);- let (_, response) = ui.allocate_exact_size(vec2(100.0, 40.0), egui::Sense::click());- hover.push(crate::theme::Press::track(ui, &response).hover);- })- .textures_delta- .clear();- }- // The first frame the pointer is found over the control.- let first = hover.iter().copied().find(|amount| *amount > 0.0).expect("the pointer is over the control");- assert_eq!(first < 1.0, eased, "{effects:?}: {hover:?}");- assert_eq!(hover.last(), Some(&1.0), "{effects:?}: the wash is whole in the end either way: {hover:?}");- }- }-- #[test]- fn a_zoom_read_in_an_earlier_pass_is_never_used_again() {- let ctx = egui::Context::default();- let mut motion = Motion { reduced: true, ..Default::default() };- let mut time = 0.0;- pass(&ctx, &mut time, vec![notch(1.0, Modifiers::COMMAND)], |ctx| {- motion.begin_pass(ctx, AnimationEffects::System);- assert!(zoom_delta(ctx) > 1.0);- });- // A pass that didn't begin here (a host that draws without `logic`): egui's own answer.- pass(&ctx, &mut time, Vec::new(), |ctx| {- let eguis = ctx.input(|i| i.zoom_delta());- assert_eq!(zoom_delta(ctx), eguis);- });- }-- /// With animation effects off, a real scroll area moves by one wheel step whether the frame- /// runs one pass or two (a `request_discard` from a sizing pass): the scroll area already- /// applied and stored the step in the first pass, so a later pass must not apply it again,- /// and must not replay the frame's raw wheel events either.- #[test]- fn two_pass_scroll_area_applies_one_wheel_step_like_a_single_pass() {- fn run(two_passes: bool) -> (Vec<Vec2>, Vec<usize>) {- let ctx = egui::Context::default();- let mut motion = Motion { reduced: true, ..Default::default() };- let mut offsets = Vec::new();- let mut wheel_events = Vec::new();- let raw = egui::RawInput {- time: Some(0.1),- screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(300.0, 300.0))),- events: vec![egui::Event::PointerMoved(egui::pos2(50.0, 50.0)), notch(-1.0, Modifiers::NONE)],- ..Default::default()- };- let output = ctx.run_ui(raw, |ui| {- motion.begin_pass(ui.ctx(), AnimationEffects::System);- wheel_events.push(ui.input(|i| i.events.iter().filter(|e| matches!(e, egui::Event::MouseWheel { .. })).count()));- // Taller than the 300-point viewport, so one step stays far from the scroll- // limit and a doubled step could not be hidden by clamping.- let out = egui::ScrollArea::vertical().id_salt("motion-two-pass-scroll").auto_shrink([false, false]).show(ui, |ui| {- ui.set_min_size(egui::vec2(100.0, 3000.0));- });- offsets.push(out.state.unclamped_offset());- if two_passes && ui.ctx().current_pass_index() == 0 {- ui.ctx().request_discard("motion two-pass scroll regression");- }- });- output.drop_without_applying_deltas();- (offsets, wheel_events)- }-- let (single, single_events) = run(false);- let (two, two_events) = run(true);-- assert_eq!(single.len(), 1, "one frame, one pass");- assert_eq!(two.len(), 2, "the frame really ran two passes");- assert_eq!(single_events, vec![1], "one wheel event reaches the first pass");- assert_eq!(two_events, vec![1, 0], "raw wheel events are not replayed in the later pass");-- let step = single[0].y;- assert!(step > 0.0, "the wheel step scrolled: {single:?}");- assert!((two[0].y - step).abs() < 0.01, "the first pass applies the whole step: single={step}, two-pass={two:?}");- assert!((two[1].y - step).abs() < 0.01, "the presented pass must not apply the same step again: single={step}, two-pass={two:?}");- }-- /// With animation effects off, ctrl/⌘-wheel and pinch zoom reach a view's persisted zoom- /// once, whether the frame runs one pass or two (a `request_discard` from a sizing pass):- /// multiplying an accumulator by each pass's factor gives the single step either way. A- /// later pass gets a unit factor explicitly, and a frame with no wheel input resets to it.- #[test]- fn two_pass_zoom_applies_one_step_like_a_single_pass() {- /// One frame's `zoom_delta` readings, one per pass.- fn frame(ctx: &egui::Context, motion: &mut Motion, time: f64, events: Vec<Event>, two_passes: bool) -> Vec<f32> {- let raw = egui::RawInput {- time: Some(time),- screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(300.0, 300.0))),- events,- ..Default::default()- };- let mut zooms = Vec::new();- let output = ctx.run_ui(raw, |ui| {- motion.begin_pass(ui.ctx(), AnimationEffects::System);- zooms.push(zoom_delta(ui.ctx()));- if two_passes && ui.ctx().current_pass_index() == 0 {- ui.ctx().request_discard("motion two-pass zoom regression");- }- });- output.drop_without_applying_deltas();- zooms- }-- let line = egui::InputOptions::default().line_scroll_speed;- let ctrl_step = (egui::InputOptions::default().scroll_zoom_speed * line).exp();- for (name, events, step) in [("ctrl-wheel", vec![notch(1.0, Modifiers::COMMAND)], ctrl_step), ("pinch", vec![Event::Zoom(1.5)], 1.5)] {- assert!((step - 1.0).abs() > 0.01, "{name}: the factor is nontrivial: {step}");- let single = {- let ctx = egui::Context::default();- let mut motion = Motion { reduced: true, ..Default::default() };- frame(&ctx, &mut motion, 0.1, events.clone(), false)- };- let ctx = egui::Context::default();- let mut motion = Motion { reduced: true, ..Default::default() };- let two = frame(&ctx, &mut motion, 0.1, events, true);- assert_eq!(single.len(), 1, "{name}: one frame, one pass: {single:?}");- assert_eq!(two.len(), 2, "{name}: the frame really ran two passes: {two:?}");- let product = |zooms: &[f32]| zooms.iter().product::<f32>();- assert!((product(&single) - step).abs() < 1e-5, "{name}: one pass applies the step: {single:?}");- assert!((product(&two) - step).abs() < 1e-5, "{name}: two passes apply it once: {two:?}");- assert!((two[1] - 1.0).abs() < 1e-6, "{name}: a later pass zooms by nothing: {two:?}");- // The next frame's wheel reading starts over; the two-pass frame's factor is gone.- let after = frame(&ctx, &mut motion, 0.1 + 1.0 / 60.0, Vec::new(), false);- assert_eq!(after, vec![1.0], "{name}: the cached factor does not survive the frame");- }- }-- #[test]- fn the_system_is_asked_now_and_then_and_no_answer_changes_nothing() {- let ctx = egui::Context::default();- let answer = Rc::new(Cell::new(Some(true)));- let asked = Rc::new(Cell::new(0_u32));- let (source_answer, source_asked) = (Rc::clone(&answer), Rc::clone(&asked));- let mut motion = Motion {- source: Some(Box::new(move || {- source_asked.set(source_asked.get() + 1);- source_answer.get()- })),- ..Default::default()- };- let mut time = 0.0;- pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));- assert!(motion.reduced, "asked in the first pass");- answer.set(Some(false));- for _ in 0..30 {- pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));- }- assert!(motion.reduced && asked.get() == 1, "not asked again within half a second ({} times)", asked.get());- // Back at the window later: the first pass asks.- time += ASK_EVERY;- pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));- assert!(!motion.reduced);- answer.set(None);- motion.reduced = true;- time += ASK_EVERY;- pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));- assert!(motion.reduced && asked.get() == 3, "no answer leaves the last one standing");- }-}+mod tests;diff --git a/crates/ui-egui/src/motion/tests.rs b/crates/ui-egui/src/motion/tests.rsnew file mode 100644index 000000000..c9c291252--- /dev/null+++ b/crates/ui-egui/src/motion/tests.rs@@ -0,0 +1,385 @@+use super::*;+use std::cell::Cell;+use std::rc::Rc;++fn wheel(unit: MouseWheelUnit, delta: Vec2, phase: TouchPhase, modifiers: Modifiers) -> Event {+ Event::MouseWheel { unit, delta, phase, modifiers, source: egui::MouseWheelSource::Unknown }+}++fn notch(dy: f32, modifiers: Modifiers) -> Event {+ wheel(MouseWheelUnit::Line, vec2(0.0, dy), TouchPhase::Move, modifiers)+}++fn read(events: &[Event]) -> WheelMotion {+ WheelReader::default().read(events, 600.0, &egui::InputOptions::default())+}++#[test]+fn a_step_is_read_whole_in_its_units() {+ let line = egui::InputOptions::default().line_scroll_speed;+ assert_eq!(read(&[notch(-1.0, Modifiers::NONE)]), WheelMotion { scroll: vec2(0.0, -line), zoom: 1.0 });+ assert_eq!(read(&[notch(-1.0, Modifiers::NONE), notch(-2.0, Modifiers::NONE)]).scroll, vec2(0.0, -3.0 * line), "steps of one pass add up");+ let points = wheel(MouseWheelUnit::Point, vec2(3.0, -250.0), TouchPhase::Move, Modifiers::NONE);+ assert_eq!(read(&[points]).scroll, vec2(3.0, -250.0));+ let page = wheel(MouseWheelUnit::Page, vec2(0.0, -1.0), TouchPhase::Move, Modifiers::NONE);+ assert_eq!(read(&[page]).scroll, vec2(0.0, -600.0));+ assert_eq!(read(&[]), WheelMotion { scroll: Vec2::ZERO, zoom: 1.0 }, "and nothing is left for a later pass");+}++#[test]+fn modifiers_turn_the_wheel_sideways_or_into_zoom() {+ let line = egui::InputOptions::default().line_scroll_speed;+ assert_eq!(read(&[notch(-1.0, Modifiers::SHIFT)]).scroll, vec2(-line, 0.0));+ let sideways = wheel(MouseWheelUnit::Point, vec2(-30.0, 0.0), TouchPhase::Move, Modifiers::ALT);+ assert_eq!(read(&[sideways]).scroll, vec2(0.0, -30.0));+ let zoomed = read(&[notch(1.0, Modifiers::COMMAND)]);+ assert_eq!(zoomed.scroll, Vec2::ZERO, "a zooming wheel doesn't scroll");+ let step = (egui::InputOptions::default().scroll_zoom_speed * line).exp();+ assert!((zoomed.zoom - step).abs() < 1e-6, "{zoomed:?}");+ assert!((read(&[notch(-1.0, Modifiers::COMMAND)]).zoom - 1.0 / step).abs() < 1e-6);+ assert!((read(&[Event::Zoom(1.5), Event::Zoom(2.0)]).zoom - 3.0).abs() < 1e-6, "pinch events multiply");+}++#[test]+fn a_touch_gesture_keeps_its_modifiers_and_ends_clean() {+ let mut reader = WheelReader::default();+ let options = egui::InputOptions::default();+ let point = |dy: f32, phase, modifiers| wheel(MouseWheelUnit::Point, vec2(0.0, dy), phase, modifiers);+ // ⌘ held as the fingers land, let go before the momentum: still zooming.+ let began =+ reader.read(&[point(0.0, TouchPhase::Start, Modifiers::COMMAND), point(20.0, TouchPhase::Move, Modifiers::COMMAND)], 600.0, &options);+ assert!(began.zoom > 1.0 && began.scroll == Vec2::ZERO, "{began:?}");+ let momentum = reader.read(&[point(20.0, TouchPhase::Move, Modifiers::NONE)], 600.0, &options);+ assert!(momentum.zoom > 1.0 && momentum.scroll == Vec2::ZERO, "{momentum:?}");+ // The pass it ends in moves nothing, and the next gesture starts without the modifier.+ let ended = reader.read(&[point(20.0, TouchPhase::Move, Modifiers::NONE), point(0.0, TouchPhase::End, Modifiers::NONE)], 600.0, &options);+ assert_eq!(ended, WheelMotion { scroll: Vec2::ZERO, zoom: 1.0 });+ assert_eq!(reader.read(&[point(-20.0, TouchPhase::Move, Modifiers::NONE)], 600.0, &options).scroll, vec2(0.0, -20.0));+}++#[test]+fn numbers_that_are_not_finite_move_nothing() {+ for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {+ let scrolled = read(&[notch(bad, Modifiers::NONE), notch(-1.0, Modifiers::NONE)]);+ assert!(scrolled.scroll.x.is_finite() && scrolled.scroll.y.is_finite(), "{bad}: {scrolled:?}");+ assert_eq!(read(&[notch(bad, Modifiers::COMMAND)]).zoom, 1.0, "{bad}");+ assert_eq!(read(&[Event::Zoom(bad)]).zoom, 1.0, "{bad}");+ }+ assert_eq!(read(&[Event::Zoom(0.0)]).zoom, 1.0);+ assert_eq!(read(&[Event::Zoom(-2.0)]).zoom, 1.0);+ // Too far to be a factor at all.+ assert_eq!(read(&[notch(1.0e9, Modifiers::COMMAND)]).zoom, 1.0);+}++/// One pass of a bare egui context, a sixtieth of a second after the last.+fn pass(ctx: &egui::Context, time: &mut f64, events: Vec<Event>, mut seen: impl FnMut(&egui::Context)) {+ *time += 1.0 / 60.0;+ let raw = egui::RawInput { time: Some(*time), events, ..Default::default() };+ // A bare context's first frame uploads the font atlas; nothing paints it here.+ ctx.run_ui(raw, |ui| seen(ui.ctx())).textures_delta.clear();+}++/// The reader must stay egui's own reading minus the easing: over the passes egui takes to+/// ease a step, it hands out as much scroll (and as much zoom) as the reader does at once.+#[test]+fn reading_at_once_goes_as_far_as_egui_eases() {+ let options = egui::InputOptions::default();+ for (modifiers, unit, step) in [+ (Modifiers::NONE, MouseWheelUnit::Line, vec2(0.0, -3.0)),+ (Modifiers::NONE, MouseWheelUnit::Point, vec2(40.0, -250.0)),+ (Modifiers::SHIFT, MouseWheelUnit::Line, vec2(0.0, 2.0)),+ (Modifiers::COMMAND, MouseWheelUnit::Line, vec2(0.0, 1.0)),+ (Modifiers::COMMAND, MouseWheelUnit::Point, vec2(0.0, -90.0)),+ ] {+ let event = wheel(unit, step, TouchPhase::Move, modifiers);+ let ctx = egui::Context::default();+ let (mut time, mut scrolled, mut zoomed, mut first) = (0.0, Vec2::ZERO, 1.0_f32, None);+ let mut events = vec![event.clone()];+ for _ in 0..120 {+ pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {+ let (scroll, zoom) = ctx.input(|i| (i.smooth_scroll_delta, i.zoom_delta()));+ first.get_or_insert((scroll, zoom));+ scrolled += scroll;+ zoomed *= zoom;+ });+ }+ let page_height = ctx.input(|i| i.viewport_rect().height());+ let at_once = WheelReader::default().read(&[event], page_height, &options);+ assert!((scrolled - at_once.scroll).length() < 0.01, "{modifiers:?} {unit:?}: egui scrolled {scrolled:?}, read {:?}", at_once.scroll);+ assert!((zoomed / at_once.zoom - 1.0).abs() < 1e-3, "{modifiers:?} {unit:?}: egui zoomed {zoomed}, read {}", at_once.zoom);+ // What makes the reader necessary: egui's first pass holds part of the step back.+ let first = first.expect("passes ran");+ assert!(+ first != (at_once.scroll, at_once.zoom),+ "{modifiers:?} {unit:?}: egui no longer eases this step ({first:?}); the reader may not be needed"+ );+ }+}++#[test]+fn reduced_motion_hands_egui_the_whole_step_and_stops_its_animations() {+ let ctx = egui::Context::default();+ let mut motion = Motion { reduced: true, ..Default::default() };+ let line = egui::InputOptions::default().line_scroll_speed;+ let mut time = 0.0;+ let mut seen = Vec::new();+ let mut events = vec![notch(-1.0, Modifiers::NONE)];+ for _ in 0..30 {+ pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {+ motion.begin_pass(ctx, AnimationEffects::System);+ seen.push(ctx.input(|i| i.smooth_scroll_delta));+ });+ }+ assert_eq!(seen.first(), Some(&vec2(0.0, -line)), "the whole notch in the pass it arrives");+ assert!(seen.iter().skip(1).all(|d| *d == Vec2::ZERO), "and none of egui's easing after it: {seen:?}");+ let style = ctx.global_style();+ assert_eq!((style.animation_time, style.scroll_animation), (0.0, egui::style::ScrollAnimation::none()));+ for theme in [egui::Theme::Light, egui::Theme::Dark] {+ assert_eq!(ctx.style_of(theme).animation_time, 0.0, "{theme:?}");+ }++ // ⌘/Ctrl with the wheel: the whole zoom step at once, then nothing.+ let step = (egui::InputOptions::default().scroll_zoom_speed * line).exp();+ let mut zooms = Vec::new();+ let mut events = vec![notch(1.0, Modifiers::COMMAND)];+ for _ in 0..30 {+ pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {+ motion.begin_pass(ctx, AnimationEffects::System);+ zooms.push(zoom_delta(ctx));+ });+ }+ assert!((zooms[0] - step).abs() < 1e-6, "{zooms:?}");+ assert!(zooms.iter().skip(1).all(|z| *z == 1.0), "{zooms:?}");++ // Animations allowed again: egui's own values and its own times.+ motion.reduced = false;+ let mut eased = Vec::new();+ let mut events = vec![notch(1.0, Modifiers::COMMAND)];+ for _ in 0..3 {+ pass(&ctx, &mut time, std::mem::take(&mut events), |ctx| {+ motion.begin_pass(ctx, AnimationEffects::System);+ eased.push((zoom_delta(ctx), ctx.input(|i| i.zoom_delta())));+ });+ }+ assert!(eased.iter().all(|(ours, eguis)| ours == eguis), "{eased:?}");+ assert!(eased[0].0 > 1.0 && eased[0].0 < step, "egui eases the step: {eased:?}");+ let (style, default) = (ctx.global_style(), egui::Style::default());+ assert_eq!((style.animation_time, style.scroll_animation), (default.animation_time, default.scroll_animation));+}++#[test]+fn the_preference_overrides_the_system_for_every_animation() {+ use AnimationEffects::{Off, On, System};+ assert_eq!(AnimationEffects::default(), System, "the system's setting is followed unless the user chooses");+ for choice in AnimationEffects::ALL {+ assert_eq!(AnimationEffects::parse(choice.name()), Some(choice));+ }+ assert_eq!((AnimationEffects::parse("OFF"), AnimationEffects::parse("smooth")), (Some(Off), None));+ let (line, egui_default) = (egui::InputOptions::default().line_scroll_speed, egui::Style::default());+ let egui_times = (egui_default.animation_time, egui_default.scroll_animation);+ // The system's answer, the choice, and whether the window then animates.+ for (reduced, effects, animates) in+ [(false, System, true), (true, System, false), (false, On, true), (true, On, true), (false, Off, false), (true, Off, false)]+ {+ assert_eq!(effects.animates(reduced), animates, "{effects:?}, system reduced: {reduced}");+ let ctx = egui::Context::default();+ let mut motion = Motion { reduced, ..Default::default() };+ let (mut time, mut first) = (0.0, None);+ pass(&ctx, &mut time, vec![notch(-1.0, Modifiers::NONE)], |ctx| {+ motion.begin_pass(ctx, effects);+ first = Some((ctx.input(|i| i.smooth_scroll_delta), animated(ctx)));+ });+ // The wheel, egui's animations and the app's own fades all go the same way.+ let whole_notch = first.map(|(scroll, _)| scroll) == Some(vec2(0.0, -line));+ assert_eq!(+ (whole_notch, first.map(|(_, animated)| animated)),+ (!animates, Some(animates)),+ "{effects:?}, system reduced: {reduced}: {first:?}"+ );+ let style = ctx.global_style();+ let times = if animates { egui_times } else { (0.0, ScrollAnimation::none()) };+ assert_eq!((style.animation_time, style.scroll_animation), times, "{effects:?}, system reduced: {reduced}");+ }+ // A choice made while running applies from the next pass, and choosing back undoes it.+ let ctx = egui::Context::default();+ let mut motion = Motion::default();+ let mut time = 0.0;+ for (effects, times) in [(Off, (0.0, ScrollAnimation::none())), (System, egui_times), (Off, (0.0, ScrollAnimation::none())), (On, egui_times)]+ {+ pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, effects));+ let style = ctx.global_style();+ assert_eq!((style.animation_time, style.scroll_animation), times, "{effects:?}");+ }+}++/// The chrome's hover wash has a duration of its own (`theme::Press`): it eases in with+/// animation effects on and is simply there with them off.+#[test]+fn the_hover_wash_eases_only_with_animation_effects_on() {+ for (effects, eased) in [(AnimationEffects::On, true), (AnimationEffects::Off, false)] {+ let ctx = egui::Context::default();+ let mut motion = Motion::default();+ let (mut time, mut hover) = (0.0, Vec::new());+ for _ in 0..12 {+ time += 1.0 / 60.0;+ let raw = egui::RawInput { time: Some(time), events: vec![Event::PointerMoved(egui::pos2(20.0, 20.0))], ..Default::default() };+ ctx.run_ui(raw, |ui| {+ motion.begin_pass(ui.ctx(), effects);+ let (_, response) = ui.allocate_exact_size(vec2(100.0, 40.0), egui::Sense::click());+ hover.push(crate::theme::Press::track(ui, &response).hover);+ })+ .textures_delta+ .clear();+ }+ // The first frame the pointer is found over the control.+ let first = hover.iter().copied().find(|amount| *amount > 0.0).expect("the pointer is over the control");+ assert_eq!(first < 1.0, eased, "{effects:?}: {hover:?}");+ assert_eq!(hover.last(), Some(&1.0), "{effects:?}: the wash is whole in the end either way: {hover:?}");+ }+}++#[test]+fn a_zoom_read_in_an_earlier_pass_is_never_used_again() {+ let ctx = egui::Context::default();+ let mut motion = Motion { reduced: true, ..Default::default() };+ let mut time = 0.0;+ pass(&ctx, &mut time, vec![notch(1.0, Modifiers::COMMAND)], |ctx| {+ motion.begin_pass(ctx, AnimationEffects::System);+ assert!(zoom_delta(ctx) > 1.0);+ });+ // A pass that didn't begin here (a host that draws without `logic`): egui's own answer.+ pass(&ctx, &mut time, Vec::new(), |ctx| {+ let eguis = ctx.input(|i| i.zoom_delta());+ assert_eq!(zoom_delta(ctx), eguis);+ });+}++/// With animation effects off, a real scroll area moves by one wheel step whether the frame+/// runs one pass or two (a `request_discard` from a sizing pass): the scroll area already+/// applied and stored the step in the first pass, so a later pass must not apply it again,+/// and must not replay the frame's raw wheel events either.+#[test]+fn two_pass_scroll_area_applies_one_wheel_step_like_a_single_pass() {+ fn run(two_passes: bool) -> (Vec<Vec2>, Vec<usize>) {+ let ctx = egui::Context::default();+ let mut motion = Motion { reduced: true, ..Default::default() };+ let mut offsets = Vec::new();+ let mut wheel_events = Vec::new();+ let raw = egui::RawInput {+ time: Some(0.1),+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(300.0, 300.0))),+ events: vec![egui::Event::PointerMoved(egui::pos2(50.0, 50.0)), notch(-1.0, Modifiers::NONE)],+ ..Default::default()+ };+ let output = ctx.run_ui(raw, |ui| {+ motion.begin_pass(ui.ctx(), AnimationEffects::System);+ wheel_events.push(ui.input(|i| i.events.iter().filter(|e| matches!(e, egui::Event::MouseWheel { .. })).count()));+ // Taller than the 300-point viewport, so one step stays far from the scroll+ // limit and a doubled step could not be hidden by clamping.+ let out = egui::ScrollArea::vertical().id_salt("motion-two-pass-scroll").auto_shrink([false, false]).show(ui, |ui| {+ ui.set_min_size(egui::vec2(100.0, 3000.0));+ });+ offsets.push(out.state.unclamped_offset());+ if two_passes && ui.ctx().current_pass_index() == 0 {+ ui.ctx().request_discard("motion two-pass scroll regression");+ }+ });+ output.drop_without_applying_deltas();+ (offsets, wheel_events)+ }++ let (single, single_events) = run(false);+ let (two, two_events) = run(true);++ assert_eq!(single.len(), 1, "one frame, one pass");+ assert_eq!(two.len(), 2, "the frame really ran two passes");+ assert_eq!(single_events, vec![1], "one wheel event reaches the first pass");+ assert_eq!(two_events, vec![1, 0], "raw wheel events are not replayed in the later pass");++ let step = single[0].y;+ assert!(step > 0.0, "the wheel step scrolled: {single:?}");+ assert!((two[0].y - step).abs() < 0.01, "the first pass applies the whole step: single={step}, two-pass={two:?}");+ assert!((two[1].y - step).abs() < 0.01, "the presented pass must not apply the same step again: single={step}, two-pass={two:?}");+}++/// With animation effects off, ctrl/⌘-wheel and pinch zoom reach a view's persisted zoom+/// once, whether the frame runs one pass or two (a `request_discard` from a sizing pass):+/// multiplying an accumulator by each pass's factor gives the single step either way. A+/// later pass gets a unit factor explicitly, and a frame with no wheel input resets to it.+#[test]+fn two_pass_zoom_applies_one_step_like_a_single_pass() {+ /// One frame's `zoom_delta` readings, one per pass.+ fn frame(ctx: &egui::Context, motion: &mut Motion, time: f64, events: Vec<Event>, two_passes: bool) -> Vec<f32> {+ let raw = egui::RawInput {+ time: Some(time),+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(300.0, 300.0))),+ events,+ ..Default::default()+ };+ let mut zooms = Vec::new();+ let output = ctx.run_ui(raw, |ui| {+ motion.begin_pass(ui.ctx(), AnimationEffects::System);+ zooms.push(zoom_delta(ui.ctx()));+ if two_passes && ui.ctx().current_pass_index() == 0 {+ ui.ctx().request_discard("motion two-pass zoom regression");+ }+ });+ output.drop_without_applying_deltas();+ zooms+ }++ let line = egui::InputOptions::default().line_scroll_speed;+ let ctrl_step = (egui::InputOptions::default().scroll_zoom_speed * line).exp();+ for (name, events, step) in [("ctrl-wheel", vec![notch(1.0, Modifiers::COMMAND)], ctrl_step), ("pinch", vec![Event::Zoom(1.5)], 1.5)] {+ assert!((step - 1.0).abs() > 0.01, "{name}: the factor is nontrivial: {step}");+ let single = {+ let ctx = egui::Context::default();+ let mut motion = Motion { reduced: true, ..Default::default() };+ frame(&ctx, &mut motion, 0.1, events.clone(), false)+ };+ let ctx = egui::Context::default();+ let mut motion = Motion { reduced: true, ..Default::default() };+ let two = frame(&ctx, &mut motion, 0.1, events, true);+ assert_eq!(single.len(), 1, "{name}: one frame, one pass: {single:?}");+ assert_eq!(two.len(), 2, "{name}: the frame really ran two passes: {two:?}");+ let product = |zooms: &[f32]| zooms.iter().product::<f32>();+ assert!((product(&single) - step).abs() < 1e-5, "{name}: one pass applies the step: {single:?}");+ assert!((product(&two) - step).abs() < 1e-5, "{name}: two passes apply it once: {two:?}");+ assert!((two[1] - 1.0).abs() < 1e-6, "{name}: a later pass zooms by nothing: {two:?}");+ // The next frame's wheel reading starts over; the two-pass frame's factor is gone.+ let after = frame(&ctx, &mut motion, 0.1 + 1.0 / 60.0, Vec::new(), false);+ assert_eq!(after, vec![1.0], "{name}: the cached factor does not survive the frame");+ }+}++#[test]+fn the_system_is_asked_now_and_then_and_no_answer_changes_nothing() {+ let ctx = egui::Context::default();+ let answer = Rc::new(Cell::new(Some(true)));+ let asked = Rc::new(Cell::new(0_u32));+ let (source_answer, source_asked) = (Rc::clone(&answer), Rc::clone(&asked));+ let mut motion = Motion {+ source: Some(Box::new(move || {+ source_asked.set(source_asked.get() + 1);+ source_answer.get()+ })),+ ..Default::default()+ };+ let mut time = 0.0;+ pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));+ assert!(motion.reduced, "asked in the first pass");+ answer.set(Some(false));+ for _ in 0..30 {+ pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));+ }+ assert!(motion.reduced && asked.get() == 1, "not asked again within half a second ({} times)", asked.get());+ // Back at the window later: the first pass asks.+ time += ASK_EVERY;+ pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));+ assert!(!motion.reduced);+ answer.set(None);+ motion.reduced = true;+ time += ASK_EVERY;+ pass(&ctx, &mut time, Vec::new(), |ctx| motion.begin_pass(ctx, AnimationEffects::System));+ assert!(motion.reduced && asked.get() == 3, "no answer leaves the last one standing");+}