Struct AppHandler

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

Default implementation for winit::application::ApplicationHandler.

The new winit requires an implementation of that trait to be able to use an EventLoop, and everything, including the main window, will be done from that. This type implements this trait and does some basic tasks:

• Creates the MainWindowWithRenderer object.
• Forwards the events to your application object.

For that it requires that your application object implements UiBuilder and Application.

If you have special needs you can skip this and write your own implementation of winit::application::ApplicationHandler.

Implementations

impl<A: Application> AppHandler<A>

pub fn new(event_loop: &EventLoop<AppEvent<A>>, app_data: A::Data) -> Self

Creates a new AppHandler.

It creates an empty handler. It automatically creates an EventLoopProxy.

pub fn imgui_builder(&mut self) -> &mut ContextBuilder

Returns the ContextBuilder of this application.

With this you can change the ImGui options before the context is created.

pub fn set_attributes(&mut self, wattrs: WindowAttributes)

Sets the window attributes that will be used to create the main window.

pub fn attributes(&mut self) -> &mut WindowAttributes

Gets the current window attributes.

It returns a mutable reference, so you can modify it in-place, which is sometimes more convenient.

pub fn data(&self) -> &A::Data

Gets the custom data.

pub fn data_mut(&mut self) -> &mut A::Data

Gets a mutable reference to the custom data.

pub fn app(&self) -> Option<&A>

Gets the inner app object.

pub fn app_mut(&mut self) -> Option<&mut A>

Gets a mutable reference to the inner app object.

pub fn into_inner(self) -> (Option<A>, A::Data)

Extracts the inner values.

You may need this after the main loop has finished to get the result of your program execution.

pub fn event_proxy(&self) -> &EventLoopProxy<AppEvent<A>>

Gets the inner EventLoopProxy.

Trait Implementations

impl<A> ApplicationHandler<AppEvent<A>> for AppHandler<A>

where A: Application,

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

Emitted when the application has been suspended.

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 user_event(&mut self, event_loop: &ActiveEventLoop, event: AppEvent<A>)

Emitted when an event is sent from EventLoopProxy::send_event.

fn new_events(&mut self, _event_loop: &ActiveEventLoop, _cause: StartCause)

Emitted when new events arrive from the OS to be processed.

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

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

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

Emitted when the event loop is being shut down.

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

Emitted when the application has received a memory warning.