Struct wayland_backend::sys::server::Handle

pub struct Handle { /* private fields */ }

Available on (test or crate feature client_system or crate feature server_system) and crate feature server_system only.

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(), cloned, and is given to you as argument in most event callbacks.

Implementations

impl Handle

pub fn downgrade(&self) -> WeakHandle

Get a WeakHandle from this handle

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

Returns information about some object.

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

Initializes a connection to a client.

The data parameter contains data that will be associated with the client.

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>, 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 with_all_clients(&self, f: impl FnMut(ClientId))

Invokes a closure for all clients connected to this server

Note that while this method is running, an internal lock of the backend is held, as a result invoking other methods of the Handle within the closure will deadlock. You should thus store the relevant ClientId in a container of your choice and process them after this method has returned.

pub fn with_all_objects_for(
    &self,
    client_id: ClientId,
    f: impl FnMut(ObjectId)
) -> Result<(), InvalidId>

Invokes a closure for all objects owned by a client.

Note that while this method is running, an internal lock of the backend is held, as a result invoking other methods of the Handle within the closure will deadlock. You should thus store the relevant ObjectId in a container of your choice and process them after this method has returned.

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<D: 'static>(
    &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() -> ObjectId

Returns an object id that represents a null object.

pub fn send_event(&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<D: 'static>(
    &self,
    id: ObjectId
) -> Result<Arc<dyn ObjectData<D>>, InvalidId>

Returns the data associated with an object.

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

Returns the data associated with an object as dyn Any

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

Sets the data associated with some object.

pub fn post_error(&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(&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<D: 'static>(
    &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(&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(&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<D: 'static>(
    &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.

impl Handle

pub fn display_ptr(&self) -> *mut wl_display

Access the underlying *mut wl_display pointer

Trait Implementations

impl Clone for Handle

fn clone(&self) -> Handle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Handle

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

Formats the value using the given formatter.