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 anything on the channel: they arrived first, or are the startup open those keys were typed at. Keys among them are offered, in order, after the other events and 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 replaying(&self) -> bool

True while held keys are waiting on an idle app: the loop should not wait on the terminal, since each iteration replays one.

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

A key read from the terminal. Handled now if it is a hard escape, or the app is idle with nothing queued ahead of it, or it is one of the view keys that act at a busy table; Enter with nothing to drill into waits as Space; a bare Enter/Esc at a busy table is dropped; otherwise it waits behind whatever was typed before it. Returns whether the app changed.

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

A mouse event read from the terminal, which means what it lands on in the last frame (App::pointer). It is never held: aimed at what is on screen now, it would land on something else later. The wheel’s arrows and a chip’s key act where a typed key would act at once and are dropped where it would wait, so the wheel across moves the column cursor at a busy table, as ←→ do, and the wheel down waits for nothing. A click moves the cursor where ↓ would act at once: at an idle table with nothing held, and on the home screen, which keeps its keys. Returns whether the app changed.

The rest stand for keys and act where those keys would: focusing a form’s field where ↓ would, a dragged width where > would, a dropped header where L would, opening the context menu where ↓ would at the table, and a menu line or a tool pressing its key as typed.

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: keys, worker results and continuations all arrive here, so whichever comes first ends it. Duration::MAX waits as long as it takes.

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

The run loop, given a way to draw a frame: draw the first one, then replay one held key, handle what has arrived, sleep until something arrives or a deadline passes, and redraw, until the app exits.

Keys (AppEvent::Terminal), worker results and the app’s own news all come through the one channel, so whichever is first ends the sleep; nothing waits out a poll interval. Whatever was handled is drawn before the loop sleeps, and a continuation queued by it runs right after that frame.