Struct EventPump 

pub struct EventPump {
    pub app: App,
    /* private fields */
}

Owns the app, its channel and the keys held while it was busy.

Fields

app: App

Implementations

impl EventPump

pub fn new(app: App, tx: Sender<AppEvent>, rx: Receiver<AppEvent>) -> Self

pub fn handle_first(&mut self, events: impl IntoIterator<Item = AppEvent>)

Handle events before the channel: they arrived first, or are the startup open those keys were typed at. Keys among them are offered after the other events, ahead of the channel.

pub fn send(&self, event: AppEvent) -> Result<()>

pub fn held_keys(&self) -> impl Iterator<Item = &KeyEvent>

The keys waiting for the app to go idle, oldest first.

pub fn terminal_key(&mut self, key: KeyEvent) -> Result<bool>

A key from the terminal, classified by classify: handled now, held behind earlier keys, held as another key, or dropped. Returns whether the app changed.

pub fn terminal_mouse(&mut self, mouse: MouseEvent) -> Result<bool>

A mouse event, meaning what it lands on in the last frame (App::pointer). Never held: aimed at the screen now, it would land elsewhere later. Each acts where the key it stands for would act at once, and is dropped where that key would wait: the wheel as arrows, a click as ↓, a chip or menu line or tool as its key, a dragged width as >, a dropped header as L. Returns whether the app changed.

pub fn replay_one(&mut self) -> Result<bool>

Replay the oldest held key if the app is idle. Returns whether one was replayed.

pub fn drain(&mut self) -> Result<Drained>

Handle everything waiting on the channel.

pub fn wait_and_drain(&mut self, timeout: Duration) -> Result<Drained>

Wait up to timeout for the next event, then handle it and everything behind it. The run loop’s only wait. Duration::MAX waits indefinitely.

pub fn run(&mut self, draw: impl FnMut(&mut App) -> Result<()>) -> Result<Ended>

The run loop: draw the first frame, then replay one held key, handle what has arrived, sleep until something arrives or a deadline passes, and redraw, until exit. Everything comes through one channel, so nothing waits out a poll interval; a queued continuation runs right after the frame showing its phase.