Struct evdi::handle::Handle

pub struct Handle {
    pub events: HandleEvents,
    // some fields omitted
}

Represents an evdi handle that is connected and ready.

Fields

events: HandleEvents

Holds ::tokio::sync::mpsc::Receivers for events.

// Initially events will be None
let mode = handle.events.current_mode();
assert!(mode.is_none());

// Wait for a mode
let mode: Mode = handle.events.await_mode(timeout).await?;

Implementations

impl Handle

pub fn new_buffer(&mut self, mode: &Mode) -> BufferId

Allocate and register a buffer to store the screen of a device with a specific mode.

You are responsible for re-creating buffers if the mode changes.

pub fn unregister_buffer(&mut self, id: BufferId)

De-allocate and unregister a buffer.

pub fn get_buffer(&self, id: BufferId) -> Option<&Buffer>

Get buffer data if the BufferId provided is associated with this handle.

pub async fn request_update(
    &mut self,
    buffer_id: BufferId,
    timeout: Duration
) -> Result<(), RequestUpdateError>

Ask the kernel module to update a buffer with the current display pixels.

Blocks until the update is complete.

let buf_id = handle.new_buffer(&mode);
handle.request_update(buf_id, timeout).await?;
let buf_data = handle.get_buffer(buf_id).expect("Buffer exists");

Note: Handle::request_update happens to be implemented in such a way that it causes events available at the time it is called to be dispatched. Users should not rely on this.

pub fn enable_cursor_events(&self, enable: bool)

pub fn disconnect(self) -> UnconnectedHandle

Disconnect the handle.

A handle is automatically disconnected and closed on drop, you only need this if you want to keep the UnconnectedHandle around to potentially connect to later.

Trait Implementations

impl Debug for Handle

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

Formats the value using the given formatter.

impl Drop for Handle

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<Handle> for Handle

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for Handle