Struct LoopHandle

pub struct LoopHandle<'l, Data> { /* private fields */ }

Available on crate feature wayland and Linux only.

A handle to an event loop

This handle allows you to insert new sources and idles in this event loop, it can be cloned, and it is possible to insert new sources from within a source callback.

Implementations

impl<'l, Data> LoopHandle<'l, Data>

pub fn insert_source<S, F>( &self, source: S, callback: F, ) -> Result<RegistrationToken, InsertError<S>>

where S: EventSource + 'l, F: FnMut(<S as EventSource>::Event, &mut <S as EventSource>::Metadata, &mut Data) -> <S as EventSource>::Ret + 'l,

Inserts a new event source in the loop.

The provided callback will be called during the dispatching cycles whenever the associated source generates events, see EventLoop::dispatch(..) for details.

This function takes ownership of the event source. Use register_dispatcher if you need access to the event source after this call.

pub fn register_dispatcher<S>( &self, dispatcher: Dispatcher<'l, S, Data>, ) -> Result<RegistrationToken, Error>

where S: EventSource + 'l,

Registers a Dispatcher in the loop.

Use this function if you need access to the event source after its insertion in the loop.

See also insert_source.

pub fn insert_idle<'i, F>(&self, callback: F) -> Idle<'i>

where F: FnOnce(&mut Data) + 'l + 'i,

Inserts an idle callback.

This callback will be called during a dispatching cycle when the event loop has finished processing all pending events from the sources and becomes idle.

pub fn enable(&self, token: &RegistrationToken) -> Result<(), Error>

Enables this previously disabled event source.

This previously disabled source will start generating events again.

Note: this cannot be done from within the source callback.

pub fn update(&self, token: &RegistrationToken) -> Result<(), Error>

Makes this source update its registration.

If after accessing the source you changed its parameters in a way that requires updating its registration.

pub fn disable(&self, token: &RegistrationToken) -> Result<(), Error>

Disables this event source.

The source remains in the event loop, but it’ll no longer generate events

pub fn remove(&self, token: RegistrationToken)

Removes this source from the event loop.

pub fn adapt_io<F>(&self, fd: F) -> Result<Async<'l, F>, Error>

where F: AsFd,

Wrap an IO object into an async adapter

This adapter turns the IO object into an async-aware one that can be used in futures. The readiness of these futures will be driven by the event loop.

The produced futures can be polled in any executor, and notably the one provided by calloop.

pub fn downgrade(&self) -> WeakLoopHandle<'l, Data>

Create a weak reference to this loop data.

Examples

use calloop::timer::{TimeoutAction, Timer};
use calloop::EventLoop;

let event_loop: EventLoop<()> = EventLoop::try_new().unwrap();
let weak_handle = event_loop.handle().downgrade();

event_loop
   .handle()
   .insert_source(Timer::immediate(), move |_, _, _| {
       // Hold its weak handle in the event loop's callback to break the reference cycle.
       let handle = weak_handle.upgrade().unwrap();

       // Use the upgraded handle later...

       TimeoutAction::Drop
   })
   .unwrap();

Trait Implementations

impl<Data> Clone for LoopHandle<'_, Data>

Manually implemented Clone.

The derived implementation adds a Clone bound on the generic parameter Data.

fn clone(&self) -> LoopHandle<'_, Data>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Data> Debug for LoopHandle<'_, Data>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.