Struct smithay_client_toolkit::WaylandSource

pub struct WaylandSource { /* fields omitted */ }

An adapter to insert a Wayland EventQueue into a calloop event loop

This is a struct that implements calloop::EventSource. It generates an event whenever events need to be dispatched. At this point your calloop callback will be given access to the EventQueue and you should call .dispatch_pending() and forward its return value, allowing you to handle orphan events as you prefer.

If you don’t use orphan events, the quick_insert method will directly insert the source into a provided LoopHandle with an adapter which will panic whenever an oprhan event is encountered.

Implementations

impl WaylandSource

pub fn new(queue: EventQueue) -> WaylandSource

Wrap an EventQueue as a WaylandSource.

pub fn quick_insert<Data: 'static>(
    self,
    handle: LoopHandle<'_, Data>
) -> Result<RegistrationToken, InsertError<WaylandSource>>

Insert this source into given event loop with an adapter that panics on orphan events

The adapter will pass the event loop’s global shared data as dispatch_data too all callbacks.

pub fn queue(&mut self) -> &mut EventQueue

Access the underlying event queue

This method can be used if you need to access the underlying EventQueue while this WaylandSource is currently inserted in an event loop.

Note that you should be careful when interacting with it if you invoke methods that interact with the wayland socket (such as dispatch() or prepare_read()). These may interefere with the proper waking up of this event source in the event loop.

Trait Implementations

impl Debug for WaylandSource

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

Formats the value using the given formatter.

impl EventSource for WaylandSource

type Event = ()

The type of events generated by your source.

type Metadata = EventQueue

Some metadata of your event source

type Ret = Result<u32>

The return type of the user callback

fn process_events<F>(
    &mut self,
    readiness: Readiness,
    token: Token,
    callback: F
) -> Result<PostAction> where
    F: FnMut((), &mut EventQueue) -> Result<u32>, 

Process any relevant events

fn register(
    &mut self,
    poll: &mut Poll,
    token_factory: &mut TokenFactory
) -> Result<()>

Register yourself to this poll instance

fn reregister(
    &mut self,
    poll: &mut Poll,
    token_factory: &mut TokenFactory
) -> Result<()>

Re-register your file descriptors

fn unregister(&mut self, poll: &mut Poll) -> Result<()>

Unregister your file descriptors

fn pre_run<F>(&mut self, callback: F) -> Result<()> where
    F: FnMut((), &mut EventQueue) -> Result<u32>, 

Notification that a polling session is going to start

fn post_run<F>(&mut self, _: F) -> Result<()> where
    F: FnMut((), &mut EventQueue) -> Result<u32>, 

Notification that the current polling session ended