diff --git a/crates/ui-canvas/src/canvas/opacity_keys.rs b/crates/ui-canvas/src/canvas/opacity_keys.rs index 8596f4440..103d87fa9 100644 --- a/crates/ui-canvas/src/canvas/opacity_keys.rs +++ b/crates/ui-canvas/src/canvas/opacity_keys.rs @@ -102,13 +102,13 @@ impl OpacityDigit { } } - /// What `fired` sets, through the pair state `keys`, at `now` seconds (the pass time): `None` for another command, - /// a release, or a held key's repeat, which types no second digit. - pub fn entry(keys: &mut DigitKeys, fired: &Fired, now: f64) -> Option { + /// What `fired` sets, through the pair state `keys`, at the key's own time (`Fired::time`): `None` for another + /// command, a release, or a held key's repeat, which types no second digit. + pub fn entry(keys: &mut DigitKeys, fired: &Fired) -> Option { if fired.phase != FirePhase::Press { return None; } let (digit, second) = OpacityDigit::from_ref(&fired.command)?.digit(); - keys.press(digit, second, now) + keys.press(digit, second, fired.time) } } diff --git a/crates/ui-canvas/tests/it/canvas/opacity_keys.rs b/crates/ui-canvas/tests/it/canvas/opacity_keys.rs index 1c1cc25f0..7d33a10ba 100644 --- a/crates/ui-canvas/tests/it/canvas/opacity_keys.rs +++ b/crates/ui-canvas/tests/it/canvas/opacity_keys.rs @@ -16,8 +16,7 @@ fn a_digit_key_sets_the_opacity_and_shift_with_it_the_second_value() { let mut keys = DigitKeys::default(); let mut press = |frames: &mut Frames, key: Key, modifiers: Modifiers| { frames.frame(vec![key_press(key, modifiers)], &mut show); - let now = frames.ctx.input(|input| input.time); - let entries: Vec<_> = take_output(&frames.ctx).fired.iter().filter_map(|fired| OpacityDigit::entry(&mut keys, fired, now)).collect(); + let entries: Vec<_> = take_output(&frames.ctx).fired.iter().filter_map(|fired| OpacityDigit::entry(&mut keys, fired)).collect(); assert_eq!(entries.len(), 1, "{key:?} with {modifiers:?} makes one entry"); (entries[0].percent, entries[0].second) }; diff --git a/crates/ui-contract/src/runtime/commands/board.rs b/crates/ui-contract/src/runtime/commands/board.rs index 8dfa847d2..8f6672ed2 100644 --- a/crates/ui-contract/src/runtime/commands/board.rs +++ b/crates/ui-contract/src/runtime/commands/board.rs @@ -923,7 +923,7 @@ pub(crate) fn fall_through(ctx: &Context, command: craft_behavior::EditCommand) let Some(command) = EditCommands::of(command) else { return }; let command = CommandRef::from(command); let target = with(ctx, |board| board.resolve(ctx, &command, None, Reach::Focus, &board.here).0.instance); - let fired = Fired { target, ..Fired::new(command, FireSource::Key, FirePhase::Press) }; + let fired = Fired { target, ..Fired::new(command, FireSource::Key, FirePhase::Press, pass::now(ctx)) }; with(ctx, |board| if fired.target.is_some() { board.queue.push(fired) } else { board.out.push(fired) }); repaint::request_of(ctx, ViewportId::ROOT); } @@ -938,7 +938,7 @@ pub(crate) fn fire_resolved(ctx: &Context, command: &ResolvedCommand, source: Fi if !command.enabled || !crate::runtime::measure::effect(ctx, "board::fire_resolved") { return false; } - queue(ctx, Fired { target: command.instance, ..Fired::new(command.command.clone(), source, FirePhase::Press) }); + queue(ctx, Fired { target: command.instance, ..Fired::new(command.command.clone(), source, FirePhase::Press, pass::now(ctx)) }); true } @@ -964,7 +964,7 @@ fn fire_in(ctx: &Context, command: &CommandRef, source: FireSource, from: Option } // An app-scope command a modal layer's instance declares is delivered to that instance. let target = if app { resolved.instance } else { instance }; - queue(ctx, Fired { target, ..Fired::new(command.clone(), source, FirePhase::Press) }); + queue(ctx, Fired { target, ..Fired::new(command.clone(), source, FirePhase::Press, pass::now(ctx)) }); true } @@ -1186,6 +1186,8 @@ pub(crate) fn begin(ctx: &Context) { let Some((keys, mut matcher)) = taken else { return }; let mut fired = Vec::new(); for shortcut in &shortcuts.keys { + // When the key event arrived: a frame may run it later, and a double press and a hold read the key's own times. + let time = shortcut.at.unwrap_or(now); match shortcut.phase { FirePhase::Release => { let key = shortcut.input.physical.or(shortcut.input.typed); @@ -1198,11 +1200,12 @@ pub(crate) fn begin(ctx: &Context) { phase: FirePhase::Release, cycle: false, alt_variant: false, + time, }); } } _ => { - let Some(hit) = keys.press(&shortcuts.layout, &shortcut.input, shortcuts.typing && !shortcut.canvas, Some((&mut matcher, now))) else { + let Some(hit) = keys.press(&shortcuts.layout, &shortcut.input, shortcuts.typing && !shortcut.canvas, Some((&mut matcher, time))) else { continue; }; let (app, instance) = with(ctx, |board| board.target_of(ctx, &hit.command, &board.here)); @@ -1228,6 +1231,7 @@ pub(crate) fn begin(ctx: &Context) { phase: FirePhase::Press, cycle: hit.cycle.len() > 1, alt_variant: hit.alt_variant, + time, }); } } diff --git a/crates/ui-contract/src/runtime/commands/mod.rs b/crates/ui-contract/src/runtime/commands/mod.rs index feeb51a60..d9abd6201 100644 --- a/crates/ui-contract/src/runtime/commands/mod.rs +++ b/crates/ui-contract/src/runtime/commands/mod.rs @@ -123,12 +123,17 @@ pub struct Fired { pub cycle: bool, /// The chord pressed was a bound chord of the command with Alt added, and the command opted in. pub alt_variant: bool, + /// The input time, in seconds of egui's input clock, of the event that fired it: for a key, when its press or + /// release arrived, also when the runtime held the event back to a later frame; the pass time for the other + /// sources. A key's hold is the time between its press and its release, however late a frame runs them. + pub time: f64, } impl Fired { - /// `command` fired from `source` in `phase`, for the app scope (no target), without a group cycle or the Alt variant. - pub fn new(command: CommandRef, source: FireSource, phase: FirePhase) -> Fired { - Fired { command, target: None, source, phase, cycle: false, alt_variant: false } + /// `command` fired from `source` in `phase` at the input time `time`, for the app scope (no target), without a group + /// cycle or the Alt variant. + pub fn new(command: CommandRef, source: FireSource, phase: FirePhase, time: f64) -> Fired { + Fired { command, target: None, source, phase, cycle: false, alt_variant: false, time } } } diff --git a/crates/ui-contract/src/runtime/egui/input.rs b/crates/ui-contract/src/runtime/egui/input.rs index 8f81b5882..fde8dd314 100644 --- a/crates/ui-contract/src/runtime/egui/input.rs +++ b/crates/ui-contract/src/runtime/egui/input.rs @@ -12,21 +12,29 @@ use egui::{Context, Event, Id, ImeEvent, Key, MouseWheelSource, MouseWheelUnit, pub use egui::RawInput; /// The events that wait for the next frame, for one viewport: the one-press rule's and those the key stage cuts at a -/// focus move (`keys::input_hook`). +/// focus move (`keys::input_hook`). Each keeps the input time it arrived at, `None` until the begin hook of the frame +/// it arrived in reads the clock (`stamp`). #[derive(Default)] pub(crate) struct HeldInput { - events: Vec, + events: Vec<(Event, Option)>, frame: Option, } impl HeldInput { /// Holds `events`, which a later step of this pass's input hook cut, for the next frame, ahead of the events held /// already: they arrived before them. - pub(crate) fn hold_ahead(&mut self, mut events: Vec) { + pub(crate) fn hold_ahead(&mut self, mut events: Vec<(Event, Option)>) { events.append(&mut self.events); self.events = events; } + /// Gives the events this frame's input hook held the frame's input time `now`, which the begin hook reads. + pub(crate) fn stamp(&mut self, now: f64) { + for (_, arrived) in self.events.iter_mut().filter(|(_, arrived)| arrived.is_none()) { + *arrived = Some(now); + } + } + /// Whether events wait for the next frame. #[cfg(feature = "testing")] pub(crate) fn holds(&self) -> bool { @@ -34,21 +42,39 @@ impl HeldInput { } } +/// The events an earlier frame held that lead this frame's input, in order, each with the input time it arrived at. +#[derive(Default)] +pub(crate) struct Refed(Vec<(Event, f64)>); + +impl Refed { + /// The input time `event` arrived at when it is a held event, read in input order; `None` for an event of this + /// frame's own input, which arrived at the pass time. Held events lead the input and a stage may have removed some, + /// so the held events before a match are gone, and the first event that matches none ends them. + pub(crate) fn arrival(&mut self, event: &Event) -> Option { + let Some(at) = self.0.iter().position(|(held, _)| held == event) else { + self.0.clear(); + return None; + }; + self.0.drain(..=at).last().map(|(_, arrived)| arrived) + } +} + /// H0: this pass carries at most one pointer press, as its last pointer event. Events after the first press /// wait in `held` and lead the next frame's events. A repeated pass of the same frame, a discard pass, /// receives no input events, so it gets none of the held ones. Returns whether events were held, so the hook -/// asks for a repaint. -pub(crate) fn hold_back_presses(input: &mut RawInput, frame: u64, held: &mut HeldInput) -> bool { +/// asks for a repaint, and the held events this pass's input carries with their arrival times. +pub(crate) fn hold_back_presses(input: &mut RawInput, frame: u64, held: &mut HeldInput) -> (bool, Refed) { if held.frame == Some(frame) { - return false; + return (false, Refed::default()); } held.frame = Some(frame); let mut events = std::mem::take(&mut held.events); - events.append(&mut input.events); - let (now, later) = split_after_first_press(events, |event| matches!(event, Event::PointerButton { pressed: true, .. })); - input.events = now; + events.extend(input.events.drain(..).map(|event| (event, None))); + let (now, later) = split_after_first_press(events, |(event, _)| matches!(event, Event::PointerButton { pressed: true, .. })); + let refed = now.iter().filter_map(|(event, arrived)| arrived.map(|arrived| (event.clone(), arrived))).collect(); + input.events = now.into_iter().map(|(event, _)| event).collect(); held.events = later; - !held.events.is_empty() + (!held.events.is_empty(), Refed(refed)) } /// Takes key presses and texts out of the running pass's input. `places` and `texts` are the places the key stage diff --git a/crates/ui-contract/src/runtime/frame.rs b/crates/ui-contract/src/runtime/frame.rs index 5cf26e8c5..8f364937b 100644 --- a/crates/ui-contract/src/runtime/frame.rs +++ b/crates/ui-contract/src/runtime/frame.rs @@ -569,10 +569,10 @@ pub(crate) fn input_hook(ctx: &Context, input: &mut RawInput) { crate::runtime::env::system::input_hook(ctx, &input.events); // H0: one press per pass. let frame = pass::frame_nr(ctx, viewport); - let held_back = PerViewport::::with(ctx, viewport, |record| raw_input::hold_back_presses(input, frame, &mut record.held)); + let (held_back, refed) = PerViewport::::with(ctx, viewport, |record| raw_input::hold_back_presses(input, frame, &mut record.held)); // H3: the key stage strips what the runtime owns; egui decides on a repaint from the events left. ime::input_hook(ctx, &mut input.events, viewport); - let (stripped, later) = keys::input_hook(ctx, input); + let (stripped, later) = keys::input_hook(ctx, input, refed); if !later.is_empty() { PerViewport::::with(ctx, viewport, |record| record.held.hold_ahead(later)); } @@ -602,6 +602,8 @@ pub(crate) fn begin_pass(ui: &mut Ui) { let now = pass::now(&ctx); let (pass_nr, frame_nr) = (pass::pass_nr(&ctx, viewport), ctx.cumulative_frame_nr_for(viewport)); let (elapsed, cancelled) = PerViewport::::with(&ctx, viewport, |record| { + // The events this frame's input hook held arrived at the frame's input time. + record.held.stamp(now); let elapsed = record.now.replace(now).map_or(0.0, |previous| (now - previous).max(0.0)); (elapsed, std::mem::take(&mut record.press_cancelled)) }); diff --git a/crates/ui-contract/src/runtime/keys.rs b/crates/ui-contract/src/runtime/keys.rs index d3ba9f78d..ecf3c230a 100644 --- a/crates/ui-contract/src/runtime/keys.rs +++ b/crates/ui-contract/src/runtime/keys.rs @@ -91,6 +91,9 @@ pub(crate) struct Shortcut { press: Option, /// The press is the canvas's Space ([`Press::canvas`]): it fires its command whatever the focused stop types. pub(crate) canvas: bool, + /// The input time the event arrived at when an earlier frame held it back; `None` for the pass's own input, which + /// arrived at the pass time. + pub(crate) at: Option, } /// What the intent routing did with one press. diff --git a/crates/ui-contract/src/runtime/keys/input.rs b/crates/ui-contract/src/runtime/keys/input.rs index 92e006689..74c76f4f4 100644 --- a/crates/ui-contract/src/runtime/keys/input.rs +++ b/crates/ui-contract/src/runtime/keys/input.rs @@ -3,7 +3,7 @@ use super::route::layout_of; use super::{AltTrack, Batch, LastPress, MenuKey, NavKeys, Press, Shortcut, Stage, TabPress, Typed, current, with}; use crate::runtime::commands::{self, EditCommands, FirePhase, NavCommand, WindowShortcut}; -use crate::runtime::egui::input::{self as raw_input, KeyEvent, RawInput}; +use crate::runtime::egui::input::{self as raw_input, KeyEvent, RawInput, Refed}; use crate::runtime::env::Env; use crate::runtime::focus::{self, EndKey, KeyUse}; use crate::runtime::frame::{ChromeToggle, request_chrome_toggle}; @@ -53,8 +53,9 @@ impl Strip<'_> { /// Records `event` in `batch` and returns whether egui keeps it. /// /// `consumed` holds the keys whose press the strip took and whose release has not come yet: the release goes - /// with the press, in this pass or a later one. - fn event(&self, batch: &mut Batch, alt: &mut AltTrack, consumed: &mut Vec, event: KeyEvent) -> bool { + /// with the press, in this pass or a later one. `at` is the input time the event arrived at when an earlier frame + /// held it (`Refed`), `None` for this pass's own input. + fn event(&self, batch: &mut Batch, alt: &mut AltTrack, consumed: &mut Vec, event: KeyEvent, at: Option) -> bool { if matches!(event, KeyEvent::Clip { .. }) { // A clipboard event stands for its chord's press, which types nothing. batch.last_press = None; @@ -67,7 +68,7 @@ impl Strip<'_> { } let pushed = batch.presses.len(); let claims = batch.claimed.len(); - let kept = self.press(batch, key, &input, repeat); + let kept = self.press(batch, key, &input, repeat, at); // The canvas's Space keeps its text from every field, as a claim does. let canvas = batch.presses.get(pushed).is_some_and(|press| press.canvas); batch.last_press = Some(LastPress { @@ -105,7 +106,7 @@ impl Strip<'_> { if key == Some(Key::Enter) { batch.enter_down = Some(false); } - batch.shortcuts.push(Shortcut { input, phase: FirePhase::Release, press: None, canvas: false }); + batch.shortcuts.push(Shortcut { input, phase: FirePhase::Release, press: None, canvas: false, at }); true } KeyEvent::Text(text) => { @@ -150,9 +151,9 @@ impl Strip<'_> { .any(|shortcut| shortcut.phase == FirePhase::Press && shortcut.input.mods == Mods::CMD && shortcut.input.typed == Some(key)); if !sent && self.records { // A component that reads every chord gets the event as the chord's press, the way the key made it. - self.press(batch, key, &input, false); + self.press(batch, key, &input, false, at); } else if !sent { - batch.shortcuts.push(Shortcut { input, phase: FirePhase::Press, press: None, canvas: false }); + batch.shortcuts.push(Shortcut { input, phase: FirePhase::Press, press: None, canvas: false, at }); } // The event stands for the chord, so the shortcut path is its only reader: egui does not copy or paste // on top of the command. @@ -244,7 +245,7 @@ impl Strip<'_> { } } - fn press(&self, batch: &mut Batch, key: Key, input: &KeyInput, repeat: bool) -> bool { + fn press(&self, batch: &mut Batch, key: Key, input: &KeyInput, repeat: bool, at: Option) -> bool { let mods = input.mods; match self.use_of(key, input) { PressUse::Claimed(chord) => { @@ -261,7 +262,7 @@ impl Strip<'_> { // keeps its momentary command from firing (production pans under a dialog whatever has focus). batch.presses.push(Press { key, mods, repeat, in_egui: None, release: None, text: None, canvas: true }); if !repeat { - batch.shortcuts.push(Shortcut { input: *input, phase: FirePhase::Press, press: Some(batch.presses.len() - 1), canvas: true }); + batch.shortcuts.push(Shortcut { input: *input, phase: FirePhase::Press, press: Some(batch.presses.len() - 1), canvas: true, at }); } false } @@ -300,7 +301,7 @@ impl Strip<'_> { PressUse::Press => { batch.presses.push(Press { key, mods, repeat, in_egui: None, release: None, text: None, canvas: false }); if !repeat { - batch.shortcuts.push(Shortcut { input: *input, phase: FirePhase::Press, press: Some(batch.presses.len() - 1), canvas: false }); + batch.shortcuts.push(Shortcut { input: *input, phase: FirePhase::Press, press: Some(batch.presses.len() - 1), canvas: false, at }); } true } @@ -389,8 +390,9 @@ pub(super) fn chrome_toggle_of(ctx: &Context, input: &KeyInput) -> Option (bool, Vec) { +/// (`Strip::ends_pass`), in order, with the input time each arrived at when an earlier frame held it. `refed` is the +/// held events of earlier frames the input carries (H0). +pub(crate) fn input_hook(ctx: &Context, input: &mut RawInput, mut refed: Refed) -> (bool, Vec<(egui::Event, Option)>) { let viewport = input.viewport_id; // The canvas a modal layer keeps open takes the events its reach admits and nothing else (`runtime::sampler`). let (hole, trimmed) = sampler::hook(ctx, input); @@ -444,8 +446,9 @@ pub(crate) fn input_hook(ctx: &Context, input: &mut RawInput) -> (bool, Vec (bool, Vec Some(true), _ => visible, }; - strip.event(&mut batch, &mut stage.alt, &mut stage.consumed, read) + strip.event(&mut batch, &mut stage.alt, &mut stage.consumed, read, at) }); for (physical, mods, text) in std::mem::take(&mut batch.learned) { stage.layout.observe(physical, mods, &text); diff --git a/crates/ui-shell/tests/it/commands/app_catalog.rs b/crates/ui-shell/tests/it/commands/app_catalog.rs index 0b6cc8f0c..c726f77cc 100644 --- a/crates/ui-shell/tests/it/commands/app_catalog.rs +++ b/crates/ui-shell/tests/it/commands/app_catalog.rs @@ -98,6 +98,41 @@ fn an_app_catalog_command_fires_by_its_chord_and_a_focused_text_field_keeps_a_ty assert_eq!(*name.borrow(), "q", "the focused field types the letter"); } +/// A key's press and its release fire with the input times they arrived at, whichever frame runs them: a hold is +/// read from the key's own times. Keys behind a pointer press wait for the next frame (one press per pass) and keep +/// the time they arrived at. +#[trial] +fn a_keys_press_and_release_fire_with_the_times_they_arrived_at() { + let mut show = |ui: &mut Ui| { + AppShell::new(WindowKey::main()).show(ui, &mut ()); + }; + let mut frames = Frames::new(); + frames.commands(catalog(1)); + frames.idle(3, &mut show); + let times = |frames: &Frames| take_output(&frames.ctx).fired.into_iter().map(|fired| (fired.command.id, fired.phase, fired.time)).collect::>(); + let now = |frames: &Frames| frames.ctx.input(|input| input.time); + frames.frame(vec![key_press(Key::J, Modifiers::NONE)], &mut show); + let pressed = now(&frames); + frames.frame(vec![key_release(Key::J, Modifiers::NONE)], &mut show); + let released = now(&frames); + assert!(pressed < released); + assert_eq!(times(&frames), [(BRUSH.to_owned(), FirePhase::Press, pressed), (BRUSH.to_owned(), FirePhase::Release, released)]); + + let at = egui::pos2(400.0, 300.0); + frames.frame(vec![moved(at)], &mut show); + let _ = times(&frames); + frames.frame(vec![press(at), key_press(Key::J, Modifiers::NONE), key_release(Key::J, Modifiers::NONE)], &mut show); + let arrived = now(&frames); + assert!(times(&frames).is_empty(), "the keys after the pointer press wait for the next frame"); + frames.frame(vec![release(at)], &mut show); + assert!(now(&frames) > arrived); + assert_eq!( + times(&frames), + [(BRUSH.to_owned(), FirePhase::Press, arrived), (BRUSH.to_owned(), FirePhase::Release, arrived)], + "the held keys fire with the time they arrived at" + ); +} + /// Count relation: frames given a catalog of the generation already built, even as a new value, build no keymap; a new /// generation builds one, in its first frame, and its new command fires by its chord. #[trial]