Struct wayland_server::DisplayHandle

pub struct DisplayHandle { /* private fields */ }

A handle to the Wayland display

A display handle may be constructed from a Handle using it’s From implementation.

Implementations

impl DisplayHandle

pub fn backend_handle(&self) -> Handle

Returns the underlying Handle from wayland-backend.

pub fn insert_client(
    &mut self,
    stream: UnixStream,
    data: Arc<dyn ClientData>
) -> Result<Client>

Insert a new client in your Display

This client will be associated with the provided ClientData, that you can then retrieve from it via Client::get_data(), and its requests will be processed by the Display and your callbacks.

pub fn get_client(&self, id: ObjectId) -> Result<Client, InvalidId>

Retrieve the Client which owns the object represented by the given ID

pub fn create_global<State, I: Resource + 'static, U: Send + Sync + 'static>(
    &self,
    version: u32,
    data: U
) -> GlobalIdwhere
    State: GlobalDispatch<I, U> + 'static,

Create a new protocol global

This global will be advertized to clients through the wl_registry according to the rules defined by your GlobalDispatch implementation for the given interface. Whenever a client binds this global, the associated GlobalDispatch::bind() method will be invoked on your State.

pub fn disable_global<State: 'static>(&self, id: GlobalId)

Disable this global

Clients will be notified of the global removal, and it will not be advertized to new clients. However the state associated with this global is not freed, so clients which already know about it can still bind it.

pub fn remove_global<State: 'static>(&self, id: GlobalId)

Remove this global

Clients will be notified of the global removal if it was not already disabled. The state associated with this global is freed, meaning clients trying to bind it will receive a protocol error.

When removing a global, it is recommended to first disable it using disable_global() to allow some time for clients to register that the global is getting removed, to avoid a race where a client would be killed because it bound a global at the same as the server decided to remove it. After the global has been disabled for some time (like a few seconds) it should be safe to actually remove it.

pub fn object_info(&self, id: ObjectId) -> Result<ObjectInfo, InvalidId>

Access the protocol information for a Wayland object

Returns an error if the object is no longer valid.

pub fn send_event<I: Resource>(
    &self,
    resource: &I,
    event: I::Event
) -> Result<(), InvalidId>

Send an event to given Wayland object

This is intended to be a low-level method. You can alternatively use the methods on the type representing your object, or Resource::send_event(), which may be more convenient.

pub fn post_error<I: Resource>(&self, resource: &I, code: u32, error: String)

Trigger a protocol error on this object

This is intended to be a low-level method. See Resource::post_error(), for a more convenient method.

pub fn get_object_data(
    &self,
    id: ObjectId
) -> Result<Arc<dyn Any + Send + Sync + 'static>, InvalidId>

Access the object data associated with this object

This is intended to be a low-level method. See Resource::object_data(), for a more convenient method.

Trait Implementations

impl Clone for DisplayHandle

fn clone(&self) -> DisplayHandle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DisplayHandle

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

Formats the value using the given formatter.

impl From<Handle> for DisplayHandle

fn from(handle: Handle) -> Self

Creates a DisplayHandle using a Handle from wayland-backend.