Struct wayland_client::Connection

pub struct Connection { /* private fields */ }

The Wayland connection

This is the main type representing your connection to the Wayland server.

Implementations

impl Connection

pub fn connect_to_env() -> Result<Self, ConnectError>

Try to connect to the Wayland server following the environment

This is the standard way to initialize a Wayland connection.

pub fn from_socket(stream: UnixStream) -> Result<Self, ConnectError>

Initialize a Wayland connection from an already existing Unix stream

pub fn from_backend(backend: Backend) -> Self

Wrap an existing Backend into a Connection

pub fn backend(&self) -> Backend

Get the Backend underlying this Connection

pub fn flush(&self) -> Result<(), WaylandError>

Flush pending outgoing events to the server

This needs to be done regularly to ensure the server receives all your requests.

pub fn prepare_read(&self) -> Result<ReadEventsGuard, WaylandError>

Start a synchronized read from the socket

This is needed if you plan to wait on readiness of the Wayland socket using an event loop. See ReadEventsGuard for details. Once the events are received, you’ll then need to dispatch them from the event queue using EventQueue::dispatch_pending().

If you don’t need to manage multiple event sources, see blocking_dispatch() for a simpler mechanism.

pub fn blocking_dispatch(&self) -> Result<usize, WaylandError>

Block until events are received from the server

This will flush the outgoing socket, and then block until events are received from the server and read them. You’ll then need to invoke EventQueue::dispatch_pending() to dispatch them on their respective event queues. Alternatively, EventQueue::blocking_dispatch() does both.

pub fn roundtrip(&self) -> Result<usize, WaylandError>

Do a roundtrip to the server

This method will block until the Wayland server has processed and answered all your preceding requests. This is notably useful during the initial setup of an app, to wait for the initial state from the server.

pub fn new_event_queue<D>(&self) -> EventQueue<D>

Create a new event queue

pub fn protocol_error(&self) -> Option<ProtocolError>

Retrive the protocol error that occured on the socket (if any)

impl Connection

pub fn display(&self) -> WlDisplay

Get the WlDisplay associated with this connection

pub fn send_request<I: Proxy>(
    &self,
    proxy: &I,
    request: I::Request,
    data: Option<Arc<dyn ObjectData>>
) -> Result<ObjectId, InvalidId>

Send a request associated with the provided object

This is a low-level interface for sending requests, you will likely instead use the methods of the types representing each interface.

pub fn null_id() -> ObjectId

Create a null id for request serialization

This is a low-level interface for sending requests, you don’t need to use it if you are using the methods of the types representing each interface.

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

Get the object data for a given object ID

This is a low-level interface, a higher-level interface for manipulating object data is given as Proxy::data().

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

Get the protocol information related to given object ID

Trait Implementations

impl Clone for Connection

fn clone(&self) -> Connection

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Connection

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

Formats the value using the given formatter.