Struct wayland_backend::rs::server::Handle

pub struct Handle<D> { /* fields omitted */ }

Main handle of a backend to the Wayland protocol

This type hosts most of the protocol-related functionality of the backend, and is the main entry point for manipulating Wayland objects. It can be retrieved both from the backend via Backend::handle(), and is given to you as argument in most event callbacks.

Implementations

impl<D> Handle<D>

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

Returns information about some object.

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

Returns the id of the client which owns the object.

pub fn get_client_data(
    &self,
    id: ClientId
) -> Result<Arc<dyn ClientData<D>>, InvalidId>

Returns the data associated with a client.

pub fn get_client_credentials(
    &self,
    id: ClientId
) -> Result<Credentials, InvalidId>

Retrive the Credentials of a client

pub fn all_clients<'a>(&'a self) -> Box<dyn Iterator<Item = ClientId> + 'a>

Returns an iterator over all clients connected to the server.

pub fn all_objects_for<'a>(
    &'a self,
    client_id: ClientId
) -> Result<Box<dyn Iterator<Item = ObjectId> + 'a>, InvalidId>

Returns an iterator over all objects owned by a client.

pub fn object_for_protocol_id(
    &self,
    client_id: ClientId,
    interface: &'static Interface,
    protocol_id: u32
) -> Result<ObjectId, InvalidId>

Retrieve the ObjectId for a wayland object given its protocol numerical ID

pub fn create_object(
    &mut self,
    client_id: ClientId,
    interface: &'static Interface,
    version: u32,
    data: Arc<dyn ObjectData<D>>
) -> Result<ObjectId, InvalidId>

Create a new object for given client

To ensure state coherence of the protocol, the created object should be immediately sent as a “New ID” argument in an event to the client.

pub fn null_id(&mut self) -> ObjectId

Returns an object id that represents a null object.

pub fn send_event(&mut self, msg: Message<ObjectId>) -> Result<(), InvalidId>

Send an event to the client

Returns an error if the sender ID of the provided message is no longer valid.

Panic:

Checks against the protocol specification are done, and this method will panic if they do not pass:

• the message opcode must be valid for the sender interface
• the argument list must match the prototype for the message associated with this opcode

pub fn get_object_data(
    &self,
    id: ObjectId
) -> Result<Arc<dyn ObjectData<D>>, InvalidId>

Returns the data associated with an object.

pub fn set_object_data(
    &mut self,
    id: ObjectId,
    data: Arc<dyn ObjectData<D>>
) -> Result<(), InvalidId>

Sets the data associated with some object.

pub fn post_error(
    &mut self,
    object_id: ObjectId,
    error_code: u32,
    message: CString
)

Posts an error on an object. This will also disconnect the client which created the object.

pub fn kill_client(&mut self, client_id: ClientId, reason: DisconnectReason)

Kills the connection to a client.

The disconnection reason determines the error message that is sent to the client (if any).

pub fn create_global(
    &mut self,
    interface: &'static Interface,
    version: u32,
    handler: Arc<dyn GlobalHandler<D>>
) -> GlobalId

Creates a global of the specified interface and version and then advertises it to clients.

The clients which the global is advertised to is determined by the implementation of the GlobalHandler.

pub fn disable_global(&mut self, id: GlobalId)

Disables a global object that is currently active.

The global removal will be signaled to all currently connected clients. New clients will not know of the global, but the associated state and callbacks will not be freed. As such, clients that still try to bind the global afterwards (because they have not yet realized it was removed) will succeed.

pub fn remove_global(&mut self, id: GlobalId)

Removes a global object and free its ressources.

The global object will no longer be considered valid by the server, clients trying to bind it will be killed, and the global ID is freed for re-use.

It is advised to first disable a global and wait some amount of time before removing it, to ensure all clients are correctly aware of its removal. Note that clients will generally not expect globals that represent a capability of the server to be removed, as opposed to globals representing peripherals (like wl_output or wl_seat).

pub fn global_info(&self, id: GlobalId) -> Result<GlobalInfo, InvalidId>

Returns information about a global.

pub fn get_global_handler(
    &self,
    id: GlobalId
) -> Result<Arc<dyn GlobalHandler<D>>, InvalidId>

Returns the handler which manages the visibility and notifies when a client has bound the global.

Trait Implementations

impl<D: Debug> Debug for Handle<D>

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

Formats the value using the given formatter.