Struct wayland_client::WaylandSource

pub struct WaylandSource<D> { /* private fields */ }

Available on crate feature calloop only.

An adapter to insert an EventQueue into a calloop EventLoop.

This type implements EventSource which generates an event whenever events on the event queue need to be dispatched. The event queue available in the callback calloop registers may be used to dispatch pending events using EventQueue::dispatch_pending.

WaylandSource::insert can be used to insert this source into an event loop and automatically dispatch pending events on the event queue.

Implementations

impl<D> WaylandSource<D>

pub fn new(queue: EventQueue<D>) -> Result<WaylandSource<D>, WaylandError>

Wrap an EventQueue as a WaylandSource.

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

Access the underlying event queue

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 interfere with the proper waking up of this event source in the event loop.

pub fn insert(
    self,
    handle: LoopHandle<'_, D>
) -> Result<RegistrationToken, InsertError<Self>>where
    D: 'static,

Insert this source into the given event loop.

This adapter will pass the event loop’s shared data as the D type for the event loop.

Trait Implementations

impl<D: Debug> Debug for WaylandSource<D>

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

Formats the value using the given formatter.

impl<D> EventSource for WaylandSource<D>

type Metadata = EventQueue<D>

The underlying event queue.

You should call EventQueue::dispatch_pending inside your callback using this queue.

type Event = ()

The type of events generated by your source.

type Ret = Result<usize, DispatchError>

The return type of the user callback

type Error = Error

The error type returned from process_events() (not the user callback!).

fn process_events<F>(
    &mut self,
    readiness: Readiness,
    token: Token,
    callback: F
) -> Result<PostAction, Self::Error>where
    F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,

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 Self::Metadata) -> Self::Ret,

Notification that a polling session is going to start

fn post_run<F>(&mut self, _: F) -> Result<()>where
    F: FnMut((), &mut Self::Metadata) -> Self::Ret,

Notification that the current polling session ended