Struct XxKeyboardFilterV1 

pub struct XxKeyboardFilterV1 { /* private fields */ }

keyboard event filtering functionality

Manages the filtering of key presses.

This interface has no events.

Implementations

impl XxKeyboardFilterV1

pub fn unbind(&self)

Stop intercepting

Unbind the keyboard and stop intercepting events.

Unbinds the bound keyboard and the input method. the compositor must stop redirecting keyboard events. Events that the keyboard_filter client has not yet responded to are treated as if they received the “passthrough” action.

This request takes effect immediately.

pub fn filter(&self, serial: u32, action: FilterAction)

decide the processing of a keyboard event

This request controls the filtering of keyboard input events before reaching the focused surface.

Usage:

While keyboard_filter is intercepting, the compositor must send every intercepted event to its bound wl_keyboard, and hold a copy of it in an internal queue. When the client responds with the .filter request, the compositor either removes the event from the queue (filter_action.consume), or sends the copy to the original wl_keyboard objects (filter_action.passthrough).

The compositor must process .filter the oldest event in the queue before processing more recent ones. For this reason, the client sets the argument “serial” to the serial of the corresponding event it received.

Exceptions:

If the event is other than wl_keyboard.key or contains no serial, it cannot be filtered. The keyboard_filter client must not respond to it with .filter request. When such an event is oldest in the queue, the compositor must proceed as if the event had received a “passthrough” reply.

As of wl_keyboard v10 and keyboard_filter_v1, the only event that can be filtered is the wl_keyboard.key event.

Sequence:

The wl_keyboard begins to receive events after input_method.activate is committed. The valid serial is the serial of the oldest wl_keyboard event which has been sent after input_method.activate but which hasn’t yet received a .filter confirmation. The compositor may raise the invalid_serial error in response to events with serials it had not issued. The compositor must ignore events with all other serials. (Particularly, this means events with repeating serials are accepted normally and are not ignored). Events must be filtered in order of arrival.

pub fn destroy(&self)

destroy the keyboard

Destroys the keyboard_filter object, stops event interception, and unbinds the wl_keyboard and input_method objects bound to it.

Trait Implementations

impl Borrow<ObjectId> for XxKeyboardFilterV1

fn borrow(&self) -> &ObjectId

Immutably borrows from an owned value.

impl Clone for XxKeyboardFilterV1

fn clone(&self) -> XxKeyboardFilterV1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for XxKeyboardFilterV1

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

Formats the value using the given formatter.

impl<D> Dispatch2<XxKeyboardFilterV1, D> for GlobalData

fn event( &self, _data: &mut D, _keyboard: &XxKeyboardFilterV1, _event: Event, _conn: &Connection, _qh: &QueueHandle<D>, )

fn event_created_child( opcode: u16, _qh: &QueueHandle<State>, ) -> Arc<dyn ObjectData>

impl Hash for XxKeyboardFilterV1

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Weak<XxKeyboardFilterV1>> for XxKeyboardFilterV1

fn eq(&self, other: &Weak<XxKeyboardFilterV1>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for XxKeyboardFilterV1

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Proxy for XxKeyboardFilterV1

type Request<'request> = Request<'request>

The request enum for this interface

type Event = Event

The event enum for this interface

fn interface() -> &'static Interface

The interface description

fn id(&self) -> ObjectId

The ID of this object

fn version(&self) -> u32

The version of this object

fn data<U>(&self) -> Option<&U>

where U: Send + Sync + 'static,

Access the user-data associated with this object

fn object_data(&self) -> Option<&Arc<dyn ObjectData>>

Access the raw data associated with this object.

fn backend(&self) -> &WeakBackend

Access the backend associated with this object

fn send_request( &self, req: <XxKeyboardFilterV1 as Proxy>::Request<'_>, ) -> Result<(), InvalidId>

Send a request for this object.

fn send_constructor<I>( &self, req: <XxKeyboardFilterV1 as Proxy>::Request<'_>, data: Arc<dyn ObjectData>, ) -> Result<I, InvalidId>

where I: Proxy,

Send a request for this object that creates another object.

fn from_id( conn: &Connection, id: ObjectId, ) -> Result<XxKeyboardFilterV1, InvalidId>

Create an object proxy from its ID

fn inert(backend: WeakBackend) -> XxKeyboardFilterV1

Create an inert object proxy

fn parse_event( conn: &Connection, msg: Message<ObjectId, OwnedFd>, ) -> Result<(XxKeyboardFilterV1, <XxKeyboardFilterV1 as Proxy>::Event), DispatchError>

Parse a event for this object

fn write_request<'a>( &self, conn: &Connection, msg: <XxKeyboardFilterV1 as Proxy>::Request<'a>, ) -> Result<(Message<ObjectId, BorrowedFd<'a>>, Option<(&'static Interface, u32)>), InvalidId>

Serialize a request for this object

fn is_alive(&self) -> bool

Checks if the Wayland object associated with this proxy is still alive

fn downgrade(&self) -> Weak<Self>

Creates a weak handle to this object

impl Eq for XxKeyboardFilterV1