Struct calloop_wayland_source::WaylandSource

pub struct WaylandSource<D> {
    pub(crate) queue: EventQueue<D>,
    pub(crate) connection_source: Generic<Connection>,
    pub(crate) read_guard: Option<ReadEventsGuard>,
    pub(crate) fake_token: Option<Token>,
    pub(crate) stored_error: Result<(), Error>,
}

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.

Fields

queue: EventQueue<D>

connection_source: Generic<Connection>

read_guard: Option<ReadEventsGuard>

fake_token: Option<Token>

Calloop’s before_will_sleep method allows skipping the sleeping by returning a Token. We cannot produce this on the fly, so store it here instead

stored_error: Result<(), Error>

Implementations

impl<D> WaylandSource<D>

pub fn new(connection: Connection, queue: EventQueue<D>) -> WaylandSource<D>

Wrap an EventQueue as a WaylandSource.

queue must be from the connection Connection. This is not a safety invariant, but not following this may cause freezes or hangs

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

Access the underlying event queue

Note that you should not replace this queue with a queue from a different Connection, as that may cause freezes or other hangs.

pub fn connection(&self) -> &Connection

Access the connection to the Wayland server

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.

impl<D> WaylandSource<D>

pub(crate) fn loop_callback_pending<F>( queue: &mut EventQueue<D>, callback: &mut F, ) -> Result<()>

where F: FnMut((), &mut EventQueue<D>) -> Result<usize, DispatchError>,

Loop over the callback until all pending messages have been dispatched.

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 Error = Error

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

type Event = ()

The type of events generated by your source.

type Ret = Result<usize, DispatchError>

The return type of the user callback

const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = true

Whether this source needs to be sent the EventSource::before_sleep and EventSource::before_handle_events notifications. These are opt-in because they require more expensive checks, and almost all sources will not need these notifications

fn process_events<F>( &mut self, _: Readiness, _: 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 before_sleep(&mut self) -> Result<Option<(Readiness, Token)>>

Notification that a single poll is about to begin

fn before_handle_events(&mut self, events: EventIterator<'_>)

Notification that polling is complete, and EventSource::process_events will be called with the given events for this source. The iterator may be empty, which indicates that no events were generated for this source