[][src]Struct winit::EventsLoop

pub struct EventsLoop {
    events_loop: EventsLoop,
    _marker: PhantomData<*mut ()>,
}

Provides a way to retrieve events from the system and from the windows that were registered to the events loop.

An EventsLoop can be seen more or less as a "context". Calling EventsLoop::new() initializes everything that will be required to create windows. For example on Linux creating an events loop opens a connection to the X or Wayland server.

To wake up an EventsLoop from a another thread, see the EventsLoopProxy docs.

Note that the EventsLoop cannot be shared accross threads (due to platform-dependant logic forbiding it), as such it is neither Send nor Sync. If you need cross-thread access, the Window created from this EventsLoop can be sent to an other thread, and the EventsLoopProxy allows you to wakeup an EventsLoop from an other thread.

Fields

events_loop: EventsLoop_marker: PhantomData<*mut ()>

Implementations

impl EventsLoop[src]

pub fn new() -> EventsLoop[src]

Builds a new events loop.

Usage will result in display backend initialisation, this can be controlled on linux using an environment variable WINIT_UNIX_BACKEND. Legal values are x11 and wayland. If it is not set, winit will try to connect to a wayland connection, and if it fails will fallback on x11. If this variable is set with any other value, winit will panic.

pub fn get_available_monitors(&self) -> AvailableMonitorsIter[src]

Returns the list of all the monitors available on the system.

pub fn get_primary_monitor(&self) -> MonitorId[src]

Returns the primary monitor of the system.

pub fn poll_events<F>(&mut self, callback: F) where
    F: FnMut(Event), 
[src]

Fetches all the events that are pending, calls the callback function for each of them, and returns.

pub fn run_forever<F>(&mut self, callback: F) where
    F: FnMut(Event) -> ControlFlow
[src]

Calls callback every time an event is received. If no event is available, sleeps the current thread and waits for an event. If the callback returns ControlFlow::Break then run_forever will immediately return.

Danger!

The callback is run after every event, so if its execution time is non-trivial the event queue may not empty at a sufficient rate. Rendering in the callback with vsync enabled will cause significant lag.

pub fn create_proxy(&self) -> EventsLoopProxy[src]

Creates an EventsLoopProxy that can be used to wake up the EventsLoop from another thread.

Trait Implementations

impl Debug for EventsLoop[src]

impl EventsLoopExt for EventsLoop[src]

Auto Trait Implementations

impl !RefUnwindSafe for EventsLoop

impl !Send for EventsLoop

impl !Sync for EventsLoop

impl Unpin for EventsLoop

impl !UnwindSafe for EventsLoop

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.