Struct XxKeyboardFilterManagerV1 

pub struct XxKeyboardFilterManagerV1 { /* private fields */ }

xx_keyboard_filter_manager_v1

This interface has no events.

Implementations

impl XxKeyboardFilterManagerV1

pub fn bind_to_input_method<U, D>( &self, keyboard: &WlKeyboard, input_method: &XxInputMethodV1, surface: &WlSurface, qh: &QueueHandle<D>, udata: U, ) -> XxKeyboardFilterV1

where U: Send + Sync + 'static, D: Dispatch<XxKeyboardFilterV1, U> + 'static,

Bind a keyboard to an input method

Bind a keyboard to an input method for the purpose of capturing key presses before they reach the text input client.

When a wl_keyboard is bound, the compositor must redirect to it the input events intended for the focused surface with text input enabled. The wl_keyboard instance receives no other events from then on. See keyboard_filter.filter.

For the bound wl_keyboard instance to intercept events, the following conditions must be fulfilled:

• there’s a focused surface,
• the surface has an enabled text input object,
• the bound input method is active (for the meaning of “active”, see input_method.activate, input_method.deactivate).

When those conditions are fulfilled, the compositor must start redirecting input events intended for the text input surface to the wl_keyboard bound with this request. Otherwise, the text input surface receives events without intercepting them.

Be aware that the text input client might use a wl_keyboard object(s) of different version(s) than the one used by the input method. The compositor should issue events as it would normally do for the versions in question. This protocol assumes that events to multiple keyboards of different protocol versions are equivalent.

Background:

Whenever the input method is activated, the compositor must start sending it keyboard events intended for the text-input client, so that the input method can be controlled using a keyboard. Traditionally, from the user perspective, input methods receive keys as if they were an overlay: keys which are interesting to the input method gain a special input method meaning, all others work as usual. The binding and the keyboard_filter.filter request together make this possible by letting the input method indicate which events it is interested in.

Conceptually, when a wl_keyboard is bound to an input_method, the compositor prevents all keyboard events directed to the text input client from reaching it. They are delayed until the input method decides how to filter them using the keyboard_filter.filter request.

Arguments:

The wl_keyboard must not be already bound to another interface. The wl_keyboard must only receive events between committed .activate and .deactivate.

The surface argument represents an arbitrary wl_surface. When issuing wl_keyboard.enter and wl_keyboard.leave on the bound wl_keyboard, the compositor must replace the original surface argument with the one provided by the input method in this request.

Because the wl_keyboard.enter and wl_keyboard.leave events require a surface as the target, one must be provided even if the input method doesn’t display one. A dummy one is sufficient. The provided wl_surface will not be used for any other purpose than explained above.

The surface must outlive the input method.

NOTE: This feature works much better with compositor-side key repeat introduced in wl_seat version 10. This protocol doesn’t provide controls for filtering repeat key events generated client-side. A compositor implementing this protocol should implement compositor-side key repeat.

This request takes effect immediately.

Attempting to bind a keyboard to an input method which is already bound must cause the already_bound error. Attempting to bind a keyboard object which was already bound must cause the already_bound error. Attempting to bind a keyboard object to an input method acting on a different seat must cause the wrong_seat error.

When the input method gets destroyed, the compositor must stop issuing events to the keyboard and ignore any further requests to keyboard_filter, except keyboard_filter.destroy.

pub fn destroy(&self)

destroy the input method manager

Destroys the xx_keyboard_filter_manager_v1 object.

The xx_keyboard_filter_v1 objects originating from it remain unaffected.

Trait Implementations

impl Borrow<ObjectId> for XxKeyboardFilterManagerV1

fn borrow(&self) -> &ObjectId

Immutably borrows from an owned value.

impl Clone for XxKeyboardFilterManagerV1

fn clone(&self) -> XxKeyboardFilterManagerV1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for XxKeyboardFilterManagerV1

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

Formats the value using the given formatter.

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

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

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

impl Hash for XxKeyboardFilterManagerV1

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<XxKeyboardFilterManagerV1>> for XxKeyboardFilterManagerV1

fn eq(&self, other: &Weak<XxKeyboardFilterManagerV1>) -> 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 XxKeyboardFilterManagerV1

fn eq(&self, other: &XxKeyboardFilterManagerV1) -> 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 XxKeyboardFilterManagerV1

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: <XxKeyboardFilterManagerV1 as Proxy>::Request<'_>, ) -> Result<(), InvalidId>

Send a request for this object.

fn send_constructor<I>( &self, req: <XxKeyboardFilterManagerV1 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<XxKeyboardFilterManagerV1, InvalidId>

Create an object proxy from its ID

fn inert(backend: WeakBackend) -> XxKeyboardFilterManagerV1

Create an inert object proxy

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

Parse a event for this object

fn write_request<'a>( &self, conn: &Connection, msg: <XxKeyboardFilterManagerV1 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 XxKeyboardFilterManagerV1