Struct EventLoopBuilder

pub struct EventLoopBuilder<T: 'static> { /* private fields */ }

Object that allows building the event loop.

This is used to make specifying options that affect the whole application easier. But note that constructing multiple event loops is not supported.

This can be created using EventLoop::new or EventLoop::with_user_event.

Implementations

impl EventLoopBuilder<()>

pub fn new() -> Self

👎Deprecated: use EventLoop::builder instead

Start building a new event loop.

impl<T> EventLoopBuilder<T>

pub fn build(&mut self) -> Result<EventLoop<T>, EventLoopError>

Builds a new event loop.

For cross-platform compatibility, the EventLoop must be created on the main thread, and only once per application.

Calling this function will result in display backend initialisation.

Panics

Attempting to create the event loop off the main thread will panic. This restriction isn’t strictly necessary on all platforms, but is imposed to eliminate any nasty surprises when porting to platforms that require it. EventLoopBuilderExt::any_thread functions are exposed in the relevant platform module if the target platform supports creating an event loop on any thread.

Platform-specific

• Wayland/X11: to prevent running under Wayland or X11 unset WAYLAND_DISPLAY or DISPLAY respectively when building the event loop.
• Android: must be configured with an AndroidApp from android_main() by calling .with_android_app(app) before calling .build(), otherwise it’ll panic.

Examples found in repository

examples/window.rs (line 52)

fn main() -> Result<(), Box<dyn Error>> {
    #[cfg(web_platform)]
    console_error_panic_hook::set_once();

    tracing::init();

    let event_loop = EventLoop::<UserEvent>::with_user_event().build()?;
    let _event_loop_proxy = event_loop.create_proxy();

    // Wire the user event from another thread.
    #[cfg(not(web_platform))]
    std::thread::spawn(move || {
        // Wake up the `event_loop` once every second and dispatch a custom event
        // from a different thread.
        info!("Starting to send user event every second");
        loop {
            let _ = _event_loop_proxy.send_event(UserEvent::WakeUp);
            std::thread::sleep(std::time::Duration::from_secs(1));
        }
    });

    let mut state = Application::new(&event_loop);

    event_loop.run_app(&mut state).map_err(Into::into)
}

Trait Implementations

impl<T: Default + 'static> Default for EventLoopBuilder<T>

fn default() -> EventLoopBuilder<T>

Returns the “default value” for a type.

impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T>

fn with_activation_policy( &mut self, activation_policy: ActivationPolicy, ) -> &mut Self

Sets the activation policy for the application.

fn with_default_menu(&mut self, enable: bool) -> &mut Self

Used to control whether a default menubar menu is created.

fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self

Used to prevent the application from automatically activating when launched if another application is already active.

impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T>

fn with_wayland(&mut self) -> &mut Self

Force using Wayland.

fn with_any_thread(&mut self, any_thread: bool) -> &mut Self

Whether to allow the event loop to be created off of the main thread.

impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T>

fn with_any_thread(&mut self, any_thread: bool) -> &mut Self

Whether to allow the event loop to be created off of the main thread.

fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self

Whether to enable process-wide DPI awareness.

fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self

where F: FnMut(*const c_void) -> bool + 'static,

A callback to be executed before dispatching a win32 message to the window procedure. Return true to disable winit’s internal message dispatching.

impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T>

fn with_x11(&mut self) -> &mut Self

Force using X11.

fn with_any_thread(&mut self, any_thread: bool) -> &mut Self

Whether to allow the event loop to be created off of the main thread.