Struct App 

pub struct App<A: Application> { /* private fields */ }

The event handler that drives an Application: it owns the window, the renderer, the last interface built and the runtime, and turns each event of the loop into messages, frames and effects. run and the other entry points build one; it is exported for a platform layer that supplies its own loop, not for an application to construct.

Implementations

impl<A: Application> App<A>

pub fn new(app: A, proxy: EventLoopProxy<A::Message>) -> Self

Creates the driver around an application and its message channel.

Trait Implementations

impl<A: Application> ApplicationHandler<<A as Application>::Message> for App<A>

fn suspended(&mut self, _event_loop: &ActiveEventLoop)

Going to the background, on Android: the native surface is destroyed. We release the renderer and the window, and resumed recreates them on the way back, without replaying init — see started. Harmless on desktop, where the event never fires.

fn exiting(&mut self, _event_loop: &ActiveEventLoop)

The event loop is ending, on close: a final Detached notification, where the app can persist its state before the process disappears.

fn user_event(&mut self, _event_loop: &ActiveEventLoop, message: A::Message)

A message produced by an effect, on a background thread: we apply it and ask for another frame.

fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause)

The loop woke up: if the long-press deadline has been reached the recogniser accepts eagerly — the message is emitted and the release to come will be swallowed, the long press having evicted the tap.

fn resumed(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has been resumed.

fn window_event( &mut self, event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent, )

Emitted when the OS sends an event to a winit window.

fn device_event( &mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent, )

Emitted when the OS sends an event to a device.

fn about_to_wait(&mut self, event_loop: &ActiveEventLoop)

Emitted when the event loop is about to block and wait for new events.

fn memory_warning(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has received a memory warning.