input_method_unstable_v2

• # zwp_input_method_v2

  An input method object allows for clients to compose text. The objects connects the client to a text input in an application, and lets the client to serve as an input method for a seat. The zwp_input_method_v2 object can occupy two distinct states: active and inactive. In the active state, the object is associated to and communicates with a text input. In the inactive state, there is no associated text input, and the only communication is with the compositor. Initially, the input method is in the inactive state. Requests issued in the inactive state must be accepted by the compositor. Because of the serial mechanism, and the state reset on activate event, they will not have any effect on the state of the next text input. There must be no more than one input method object per seat.

  Requests

  • #

    commit_string

    commit string
    void zwp_input_method_v2_commit_string(

    struct zwp_input_method_v2* zwp_input_method_v2,

    const char* text

    )
    Send the commit string text for insertion to the application. Inserts a string at current cursor position (see commit event sequence). The string to commit could be either just a single character after a key press or the result of some composing. The argument text is a buffer containing the string to insert. There is a maximum length of wayland messages, so text can not be longer than 4000 bytes. Values set with this event are double-buffered. They must be applied and reset to initial on the next zwp_text_input_v3.commit request. The initial value of text is an empty string.
  • #

    set_preedit_string

    pre-edit string
    void zwp_input_method_v2_set_preedit_string(

    struct zwp_input_method_v2* zwp_input_method_v2,

    const char* text,

    int32_t cursor_begin,

    int32_t cursor_end

    )
    Send the pre-edit string text to the application text input. Place a new composing text (pre-edit) at the current cursor position. Any previously set composing text must be removed. Any previously existing selected text must be removed. The cursor is moved to a new position within the preedit string. The argument text is a buffer containing the preedit string. There is a maximum length of wayland messages, so text can not be longer than 4000 bytes. The arguments cursor_begin and cursor_end are counted in bytes relative to the beginning of the submitted string buffer. Cursor should be hidden by the text input when both are equal to -1. cursor_begin indicates the beginning of the cursor. cursor_end indicates the end of the cursor. It may be equal or different than cursor_begin. Values set with this event are double-buffered. They must be applied on the next zwp_input_method_v2.commit event. The initial value of text is an empty string. The initial value of cursor_begin, and cursor_end are both 0.
  • #

    delete_surrounding_text

    delete text
    void zwp_input_method_v2_delete_surrounding_text(

    struct zwp_input_method_v2* zwp_input_method_v2,

    uint32_t before_length,

    uint32_t after_length

    )
    Remove the surrounding text. before_length and after_length are the number of bytes before and after the current cursor index (excluding the preedit text) to delete. If any preedit text is present, it is replaced with the cursor for the purpose of this event. In effect before_length is counted from the beginning of preedit text, and after_length from its end (see commit event sequence). Values set with this event are double-buffered. They must be applied and reset to initial on the next zwp_input_method_v2.commit request. The initial values of both before_length and after_length are 0.
  • #

    commit

    apply state
    void zwp_input_method_v2_commit(

    struct zwp_input_method_v2* zwp_input_method_v2,

    uint32_t serial

    )
    Apply state changes from commit_string, set_preedit_string and delete_surrounding_text requests. The state relating to these events is double-buffered, and each one modifies the pending state. This request replaces the current state with the pending state. The connected text input is expected to proceed by evaluating the changes in the following order: 1. Replace existing preedit string with the cursor. 2. Delete requested surrounding text. 3. Insert commit string with the cursor at its end. 4. Calculate surrounding text to send. 5. Insert new preedit text in cursor position. 6. Place cursor inside preedit text. The serial number reflects the last state of the zwp_input_method_v2 object known to the client. The value of the serial argument must be equal to the number of done events already issued by that object. When the compositor receives a commit request with a serial different than the number of past done events, it must proceed as normal, except it should not change the current state of the zwp_input_method_v2 object.
  • #

    get_input_popup_surface

    create popup surface
    struct zwp_input_popup_surface_v2* zwp_input_method_v2_get_input_popup_surface(

    struct zwp_input_method_v2* zwp_input_method_v2,

    struct wl_surface* surface

    )
    Creates a new zwp_input_popup_surface_v2 object wrapping a given surface. The surface gets assigned the "input_popup" role. If the surface already has an assigned role, the compositor must issue a protocol error.
  • #

    grab_keyboard

    grab hardware keyboard
    struct zwp_input_method_keyboard_grab_v2* zwp_input_method_v2_grab_keyboard(

    struct zwp_input_method_v2* zwp_input_method_v2

    )
    Allow an input method to receive hardware keyboard input and process key events to generate text events (with pre-edit) over the wire. This allows input methods which compose multiple key events for inputting text like it is done for CJK languages. The compositor should send all keyboard events on the seat to the grab holder via the returned wl_keyboard object. Nevertheless, the compositor may decide not to forward any particular event. The compositor must not further process any event after it has been forwarded to the grab holder. Releasing the resulting wl_keyboard object releases the grab.
  • #

    destroy

    destroy the text input
    void zwp_input_method_v2_destroy(

    struct zwp_input_method_v2* zwp_input_method_v2

    )
    Destroys the zwp_text_input_v2 object and any associated child objects, i.e. zwp_input_popup_surface_v2 and zwp_input_method_keyboard_grab_v2.

  Events

  • #

    activate

    input method has been requested
    Notification that a text input focused on this seat requested the input method to be activated. This event serves the purpose of providing the compositor with an active input method. This event resets all state associated with previous enable, disable, surrounding_text, text_change_cause, and content_type events, as well as the state associated with set_preedit_string, commit_string, and delete_surrounding_text requests. In addition, it marks the zwp_input_method_v2 object as active, and makes any existing zwp_input_popup_surface_v2 objects visible. The surrounding_text, and content_type events must follow before the next done event if the text input supports the respective functionality. State set with this event is double-buffered. It will get applied on the next zwp_input_method_v2.done event, and stay valid until changed.
  • #

    deactivate

    deactivate event
    Notification that no focused text input currently needs an active input method on this seat. This event marks the zwp_input_method_v2 object as inactive. The compositor must make all existing zwp_input_popup_surface_v2 objects invisible until the next activate event. State set with this event is double-buffered. It will get applied on the next zwp_input_method_v2.done event, and stay valid until changed.
  • #

    surrounding_text

    surrounding text event
    const char* text
    uint32_t cursor
    uint32_t anchor
    Updates the surrounding plain text around the cursor, excluding the preedit text. If any preedit text is present, it is replaced with the cursor for the purpose of this event. The argument text is a buffer containing the preedit string, and must include the cursor position, and the complete selection. It should contain additional characters before and after these. There is a maximum length of wayland messages, so text can not be longer than 4000 bytes. cursor is the byte offset of the cursor within the text buffer. anchor is the byte offset of the selection anchor within the text buffer. If there is no selected text, anchor must be the same as cursor. If this event does not arrive before the first done event, the input method may assume that the text input does not support this functionality and ignore following surrounding_text events. Values set with this event are double-buffered. They will get applied and set to initial values on the next zwp_input_method_v2.done event. The initial state for affected fields is empty, meaning that the text input does not support sending surrounding text. If the empty values get applied, subsequent attempts to change them may have no effect.
  • #

    text_change_cause

    indicates the cause of surrounding text change
    uint32_t cause
    Tells the input method why the text surrounding the cursor changed. Whenever the client detects an external change in text, cursor, or anchor position, it must issue this request to the compositor. This request is intended to give the input method a chance to update the preedit text in an appropriate way, e.g. by removing it when the user starts typing with a keyboard. cause describes the source of the change. The value set with this event is double-buffered. It will get applied and set to its initial value on the next zwp_input_method_v2.done event. The initial value of cause is input_method.
  • #

    content_type

    content purpose and hint
    uint32_t hint
    uint32_t purpose
    Indicates the content type and hint for the current zwp_input_method_v2 instance. Values set with this event are double-buffered. They will get applied on the next zwp_input_method_v2.done event. The initial value for hint is none, and the initial value for purpose is normal.
  • #

    done

    apply state
    Atomically applies state changes recently sent to the client. The done event establishes and updates the state of the client, and must be issued after any changes to apply them. Text input state (content purpose, content hint, surrounding text, and change cause) is conceptually double-buffered within an input method context. Events modify the pending state, as opposed to the current state in use by the input method. A done event atomically applies all pending state, replacing the current state. After done, the new pending state is as documented for each related request. Events must be applied in the order of arrival. Neither current nor pending state are modified unless noted otherwise.
  • #

    unavailable

    input method unavailable
    The input method ceased to be available. The compositor must issue this event as the only event on the object if there was another input_method object associated with the same seat at the time of its creation. The compositor must issue this request when the object is no longer usable, e.g. due to seat removal. The input method context becomes inert and should be destroyed after deactivation is handled. Any further requests and events except for the destroy request must be ignored.

  Enums

  • #

    error
    ZWP_INPUT_METHOD_V2_ERROR_ROLE /* wl_surface has another role */

• # zwp_input_popup_surface_v2

  This interface marks a surface as a popup for interacting with an input method. The compositor should place it near the active text input area. It must be visible if and only if the input method is in the active state. The client must not destroy the underlying wl_surface while the zwp_input_popup_surface_v2 object exists.

  Requests

  • #

    destroy
    void zwp_input_popup_surface_v2_destroy(

    struct zwp_input_popup_surface_v2* zwp_input_popup_surface_v2

    )

  Events

  • #

    text_input_rectangle

    set text input area position
    int32_t x
    int32_t y
    int32_t width
    int32_t height
    Notify about the position of the area of the text input expressed as a rectangle in surface local coordinates. This is a hint to the input method telling it the relative position of the text being entered.

• # zwp_input_method_keyboard_grab_v2

  The zwp_input_method_keyboard_grab_v2 interface represents an exclusive grab of the wl_keyboard interface associated with the seat.

  Requests

  • #

    release

    release the grab object
    void zwp_input_method_keyboard_grab_v2_release(

    struct zwp_input_method_keyboard_grab_v2* zwp_input_method_keyboard_grab_v2

    )

  Events

  • #

    keymap

    keyboard mapping
    uint32_t format /* keymap format */
    int32_t fd /* keymap file descriptor */
    uint32_t size /* keymap size, in bytes */
    This event provides a file descriptor to the client which can be memory-mapped to provide a keyboard mapping description.
  • #

    key

    key event
    uint32_t serial /* serial number of the key event */
    uint32_t time /* timestamp with millisecond granularity */
    uint32_t key /* key that produced the event */
    uint32_t state /* physical state of the key */
    A key was pressed or released. The time argument is a timestamp with millisecond granularity, with an undefined base.
  • #

    modifiers

    modifier and group state
    uint32_t serial /* serial number of the modifiers event */
    uint32_t mods_depressed /* depressed modifiers */
    uint32_t mods_latched /* latched modifiers */
    uint32_t mods_locked /* locked modifiers */
    uint32_t group /* keyboard layout */
    Notifies clients that the modifier and/or group state has changed, and it should update its local state.
  • #

    repeat_info

    repeat rate and delay
    int32_t rate /* the rate of repeating keys in characters per second */
    int32_t delay /* delay in milliseconds since key down until repeating starts */
    Informs the client about the keyboard's repeat rate and delay. This event is sent as soon as the zwp_input_method_keyboard_grab_v2 object has been created, and is guaranteed to be received by the client before any key press event. Negative values for either rate or delay are illegal. A rate of zero will disable any repeating (regardless of the value of delay). This event can be sent later on as well with a new value if necessary, so clients should continue listening for the event past the creation of zwp_input_method_keyboard_grab_v2.

• # zwp_input_method_manager_v2

  The input method manager allows the client to become the input method on a chosen seat. No more than one input method must be associated with any seat at any given time.

  Requests

  • #

    get_input_method

    request an input method object
    struct zwp_input_method_v2* zwp_input_method_manager_v2_get_input_method(

    struct zwp_input_method_manager_v2* zwp_input_method_manager_v2,

    struct wl_seat* seat

    )
    Request a new input zwp_input_method_v2 object associated with a given seat.
  • #

    destroy

    destroy the input method manager
    void zwp_input_method_manager_v2_destroy(

    struct zwp_input_method_manager_v2* zwp_input_method_manager_v2

    )
    Destroys the zwp_input_method_manager_v2 object. The zwp_input_method_v2 objects originating from it remain valid.

Copyright Info