Struct Handler

pub struct Handler<T: Event, TS: ThreadSafety> { /* private fields */ }

An event handler.

This type is used to receive events from the GUI system. Whenever an event occurs, it is sent to all of the listeners of the corresponding event type. The listeners can then process the event asynchronously.

There are four ways to listen to events:

• Using the wait_once() function, which waits for a single instance of the event. However, there is a race condition where it can miss events in multithreaded environments where the event occurs between the time the event is received and the time the listener is registered. To avoid this, use one of the other methods. However, this method is the most efficient.
• Using the wait_many() stream, which asynchronously iterates over events.
• Using the wait_direct[_async]() function, which runs a closure in the event handler. This is good for use cases like drawing.
• Using the wait_guard() function, which forces the event handler to stop until the event has been completely processed. This is good for use cases like handling suspends.

This type does not allocate unless you use any waiting functions; therefore, you only pay overhead for events that you use.

Implementations

impl<T: Event, TS: ThreadSafety> Handler<T, TS>

pub fn wait(&self) -> Waiter<'_, T, TS>

Wait for the next event.

pub fn wait_direct_async<Fut: Future<Output = bool> + Send + 'static, F: FnMut(&mut T::Unique<'_>) -> Fut + Send + 'static>( &self, f: F, )

Register an async closure be called when the event is received.

pub fn wait_direct( &self, f: impl FnMut(&mut T::Unique<'_>) -> bool + Send + 'static, )

Register a closure be called when the event is received.

Trait Implementations

impl<'a, T: Event, TS: ThreadSafety> IntoFuture for &'a Handler<T, TS>

type IntoFuture = Waiter<'a, T, TS>

Which kind of future are we turning this into?

type Output = <T as Event>::Clonable

The output that the future will produce on completion.

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<T: Event, TS: ThreadSafety> Unpin for Handler<T, TS>