Struct devices::virtio::gpu::EventDevice

pub struct EventDevice {
    kind: EventDeviceKind,
    event_buffer: VecDeque<u8>,
    event_socket: StreamChannel,
}

Encapsulates a virtual event device, such as a mouse or keyboard

Fields

kind: EventDeviceKind

event_buffer: VecDeque<u8>

event_socket: StreamChannel

Implementations

impl EventDevice

pub fn new(kind: EventDeviceKind, event_socket: StreamChannel) -> EventDevice

pub fn mouse(event_socket: StreamChannel) -> EventDevice

pub fn touchscreen(event_socket: StreamChannel) -> EventDevice

pub fn keyboard(event_socket: StreamChannel) -> EventDevice

pub fn kind(&self) -> EventDeviceKind

pub fn flush_buffered_events(&mut self) -> Result<bool, Error>

Flushes the buffered events that did not fit into the underlying transport, if any.

Returns Ok(true) if, after this function returns, there all the buffer of events is empty.

pub fn is_buffered_events_empty(&self) -> bool

pub fn send_report<E>(&mut self, events: E) -> Result<bool, Error>

where E: IntoIterator<Item = virtio_input_event>, <E as IntoIterator>::IntoIter: ExactSizeIterator,

pub fn send_event_encoded( &mut self, event: virtio_input_event ) -> Result<bool, Error>

Sends the given event, returning Ok(true) if, after this function returns, there are no buffered events remaining.

pub fn recv_event_encoded(&self) -> Result<virtio_input_event, Error>

Trait Implementations

impl AsRawDescriptor for EventDevice

fn as_raw_descriptor(&self) -> i32

Returns the underlying raw descriptor.

impl Debug for EventDevice

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventDevice

fn deserialize<__D>( __deserializer: __D ) -> Result<EventDevice, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ReadNotifier for EventDevice

fn get_read_notifier(&self) -> &dyn AsRawDescriptor

Gets a descriptor that can be used in EventContext to wait for events to be available (e.g. to avoid receive_events blocking).

impl Serialize for EventDevice

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.