Destroys the wp_input_method_v3 object and any associated child objects, i.e. wp_input_popup_surface_v3

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 wp_input_method_v3 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 wp_input_method_v3 object.

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 wp_input_method_v3.commit event.

The initial value of text is an empty string. The initial value of cursor_begin, and cursor_end are both 0.

Send the 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 wp_text_input_v3.commit request.

The initial value of text is an empty string.

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 wp_input_method_v3.commit request.

The initial values of both before_length and after_length are 0.

Set the action to be performed on commit.

Values set with this event are double-buffered. They must be applied and reset to initial on the next wp_input_method_v3.commit request.

Notify the application of language used by the input method.

This event will be sent on creation if known and for all subsequent changes.

The language should be specified as an IETF BCP 47 tag. Setting an empty string will reset any known language back to the default unknown state.

Specify how the visible preedit should be handled when switching the focus widget or changing the cursor position, whether to commit the preedit text or clear the preedit text.

This is usually used together with the preedit_string event.

The commit behavior is the same for focus switch and cursor position change.

The parameter mode selects the desired behavior and its value is one from the commit mode enum.

Sets styling information on composing text. Event sent without preedit string sets a default style for all future preedit text.

The parameters begin and end are counted in bytes relative to the beginning of the text buffer submitted through wp_text_input_v3.preedit_string.

Multiple events may be submitted if the preedit string has different sections. Compositors/input method must not send multiple wp_text_input_v3.preedit_underline events with overlapping extents.

Clients should pick colors appropriate for their color scheme, underline colors follows text color. For parts of the preedit string that are not covered by any wp_text_input_v3.preedit_hint event, or if no events were sent, the text will be considered unstyled.

Values set with this event are double-buffered. They must be applied and reset on the next wp_text_input_v3.done event.

This tells the compositor to assign parents to an xdg_popup. This popup should have been created via xdg_surface::get_popup with the parent set to NULL, and this request must be invoked before committing the popup's initial state.

See the documentation of xdg_popup for more details about what an xdg_popup is and how it is used.

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 wp_input_method_v3 object as active.

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 wp_input_method_v3.done event, and stay valid until changed.

The app ID identifies the general class of applications to which the current input method context belongs. An input method framework can use this to manage individual state for different text input clients.

For D-Bus activatable applications, the app ID is used as the D-Bus service name.

The compositor shell will try to group application surfaces together by their app ID. As a best practice, it is suggested to select app ID's that match the basename of the application's .desktop file. For example, "org.freedesktop.FooViewer" where the .desktop file is "org.freedesktop.FooViewer.desktop".

See the desktop-entry specification [0] for more details on application identifiers and how they relate to well-known D-Bus names and .desktop files.

[0] http://standards.freedesktop.org/desktop-entry-spec/

Notification that no focused text input currently needs an active input method on this seat.

This event marks the wp_input_method_v3 object as inactive. The compositor must make all existing wp_input_popup_surface_v3 objects invisible until the next activate event.

State set with this event is double-buffered. It will get applied on the next wp_input_method_v3.done event, and stay valid until changed.

Notification that a text input focused on this seat has been destroyed.

This event serves the purpose of providing the input method with information of when and which text input has been destroyed.

This event removed all state associated with a text input.

The app ID identifies the general class of applications to which the current input method context belongs. An input method framework can use this to manage individual state for different text input clients.

For D-Bus activatable applications, the app ID is used as the D-Bus service name.

The compositor shell will try to group application surfaces together by their app ID. As a best practice, it is suggested to select app ID's that match the basename of the application's .desktop file. For example, "org.freedesktop.FooViewer" where the .desktop file is "org.freedesktop.FooViewer.desktop".

See the desktop-entry specification [0] for more details on application identifiers and how they relate to well-known D-Bus names and .desktop files.

[0] http://standards.freedesktop.org/desktop-entry-spec/

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 wp_input_method_v3.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.

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 wp_input_method_v3.done event.

The initial value of cause is input_method.

Indicates the content type and hint for the current wp_input_method_v3 instance.

Values set with this event are double-buffered. They will get applied on the next wp_input_method_v3.done event.

The initial value for hint is none, and the initial value for purpose is normal.

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.

This event provides a file descriptor to the client which can be memory-mapped to provide a keyboard mapping description.

Informs the client about the keyboard's repeat rate and delay.

This event is sent as soon as the wp_input_method_v3 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 wp_input_method_v3.

A key was pressed or released, forwarded from text input client. The time argument is a timestamp with millisecond granularity, with an undefined base.

Notifies input method that the modifier and/or group state has changed, and it should update its local state. Forwarded from text-input.

This event indicates which actions are supported by the text input.

Values set with this event are double-buffered. They will get applied on the next wp_input_method_v3.done event.

Initially, no actions are available.

Marks an area around the cursor as a x, y, width, height rectangle in surface local coordinates.

Allows the compositor to put a window with word suggestions near the cursor, without obstructing the text being input.

If the client is unaware of the position of edited text, it should not issue this request, to signify lack of support to the compositor.

Values set with this request are double-buffered. They will get applied on the next wp_text_input_v3.commit request, and stay valid until the next committed enable or disable request.

The initial values describing a cursor rectangle are empty. That means the text input does not support describing the cursor area. If the empty values get applied, subsequent attempts to change them may have no effect.

As of version 2, the values sent with this request are not used immediately after they are applied to the text-input state.

After the pending state is applied with the wp_text_input_v3.commit request, the following wl_surface.commit request on the surface with text-input focus will cause the values to become active.

If the surface with text-input focus changes before a wl_surface.commit request is sent, the values are discarded.

Indicates if the forwarded key is repeating or not

Request a new input wp_input_method_v3 object associated with a given seat.

Destroys the wp_input_method_manager_v3 object.

The wp_input_method_v3 objects originating from it remain valid.

Destroy the wp_text_input object. Also disables all surfaces enabled through this wp_text_input object.

Requests text input on the surface previously obtained from the enter event.

This request must be issued every time the active text input changes to a new one, including within the current surface. Use wp_text_input_v3.disable when there is no longer any input focus on the current surface.

Clients must not enable more than one text input on the single seat and should disable the current text input before enabling the new one. At most one instance of text input may be in enabled state per instance, Requests to enable the another text input when some text input is active must be ignored by compositor.

This request resets all state associated with previous enable, disable, set_surrounding_text, set_text_change_cause, set_content_type, and set_cursor_rectangle requests, as well as the state associated with preedit_string, commit_string, and delete_surrounding_text events.

The set_surrounding_text, set_content_type and set_cursor_rectangle requests must follow if the text input supports the necessary functionality.

State set with this request is double-buffered. It will get applied on the next wp_text_input_v3.commit request, and stay valid until the next committed enable or disable request.

The changes must be applied by the compositor after issuing a wp_text_input_v3.commit request.

Some clients need to reset the input method state. To reset the input method state, the client needs to send the disable request, the enable request, and the commit request sequence. The compositing manager will reset the input method.

Explicitly disable text input on the current surface (typically when there is no focus on any text entry inside the surface).

State set with this request is double-buffered. It will get applied on the next wp_text_input_v3.commit request.

Some clients need to reset the input method state. To reset the input method state, the client needs to send the disable request, the enable request, and the commit request sequence. The compositing manager will reset the input method.

Sets the surrounding plain text around the input, excluding the preedit text.

The client should notify the compositor of any changes in any of the values carried with this request, including changes caused by handling incoming text-input events as well as changes caused by other mechanisms like keyboard typing.

If the client is unaware of the text around the cursor, it should not issue this request, to signify lack of support to the compositor.

Text is UTF-8 encoded, and should include the cursor position, the complete selection and additional characters before and after them. 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 text buffer.

Anchor is the byte offset of the selection anchor within text buffer. If there is no selected text, anchor is the same as cursor.

If any preedit text is present, it is replaced with a cursor for the purpose of this event.

Values set with this request are double-buffered. They will get applied on the next wp_text_input_v3.commit request, and stay valid until the next committed enable or disable request.

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.

Tells the compositor why the text surrounding the cursor changed.

Whenever the client detects an external change in text, cursor, or anchor posision, 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 request is double-buffered. It must be applied and reset to initial at the next wp_text_input_v3.commit request.

The initial value of cause is input_method.

Sets the content purpose and content hint. While the purpose is the basic purpose of an input field, the hint flags allow to modify some of the behavior.

Values set with this request are double-buffered. They will get applied on the next wp_text_input_v3.commit request. Subsequent attempts to update them may have no effect. The values remain valid until the next committed enable or disable request.

The initial value for hint is none, and the initial value for purpose is normal.

Marks an area around the cursor as a x, y, width, height rectangle in surface local coordinates.

Allows the compositor to put a window with word suggestions near the cursor, without obstructing the text being input.

If the client is unaware of the position of edited text, it should not issue this request, to signify lack of support to the compositor.

Values set with this request are double-buffered. They will get applied on the next wp_text_input_v3.commit request, and stay valid until the next committed enable or disable request.

The initial values describing a cursor rectangle are empty. That means the text input does not support describing the cursor area. If the empty values get applied, subsequent attempts to change them may have no effect.

As of version 2, the values sent with this request are not used immediately after they are applied to the text-input state.

After the pending state is applied with the wp_text_input_v3.commit request, the following wl_surface.commit request on the surface with text-input focus will cause the values to become active.

If the surface with text-input focus changes before a wl_surface.commit request is sent, the values are discarded.

Atomically applies state changes recently sent to the compositor.

The commit request establishes and updates the state of the client, and must be issued after any changes to apply them.

Text input state (enabled status, content purpose, content hint, surrounding text and change cause, cursor rectangle) is conceptually double-buffered within the context of a text input, i.e. between a committed enable request and the following committed enable or disable request.

Protocol requests modify the pending state, as opposed to the current state in use by the input method. A commit request atomically applies all pending state, replacing the current state. After commit, the new pending state is as documented for each related request.

Requests are applied in the order of arrival.

Neither current nor pending state are modified unless noted otherwise.

The compositor must count the number of commit requests coming from each wp_text_input_v3 object and use the count as the serial in done events.

Instruct the compositor to re-process through the input method a series of recent wl_keyboard.key events, starting from the given serial until the wp_text_input_v3 is enabled. This request should only be honored in the commit that does the wp_text_input_v3.enable request enabling input method treatment.

This request is useful for cases where wl_keyboard.key events result in wp_text_input_v3.enable happening on the client. A typical case is type-to-search UIs where the first characters introduced will trigger both change focus to an input search and re-route the key event being handled to it. In those situations it is desirable to have the already sent key events be processed through the input method instead of being handled without input method involvement.

Compositors should keep a small buffer of the last key events, if the requested serial is too old or does not exist in the buffer, compositors are free to either ignore the request or reprocess the full buffer. Compositors must replay full key press/release sequences to the input method.

Clients using this request must ignore the local effects of wl_keyboard.key events after this request is issued, until the first wp_text_input_v3.done event is received. The compositor may choose to replay the wl_keyboard.key events after sending the done event.

State set with this request is double-buffered. It will get applied on the next wp_text_input_v3.commit request.

Set the actions available for this text input.

Values set with this request are double-buffered. They will get applied on the next wp_text_input_v3.commit request.

If the available_actions array contains the none action, or contains the same action multiple times, the compositor must raise the invalid_action protocol error.

Initially, no actions are available.

Instruct the application to apply changes to state requested by the preedit_string, commit_string, delete_surrounding_text and action events.

The state relating to these events is double-buffered, and each one modifies the pending state. This event replaces the current state with the pending state.

The application must 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. 7. Perform the requested action.

The serial number reflects the last state of the wp_text_input_v3 object known to the compositor. The value of the serial argument must be equal to the number of commit requests already issued on that object.

When the client receives a done event with a serial different than the number of past commit requests, it must proceed with evaluating and applying the changes as normal, except it should not change the current state of the wp_text_input_v3 object. All pending state requests (set_surrounding_text, set_content_type and set_cursor_rectangle) on the wp_text_input_v3 object should be sent and committed after receiving a wp_text_input_v3.done event with a matching serial.

Notify when a new composing text (pre-edit) should be set at the current cursor position. Any previously set composing text must be removed. Any previously existing selected text must be removed.

The argument text contains the pre-edit string buffer.

The parameters cursor_begin and cursor_end are counted in bytes relative to the beginning of the submitted text buffer. Cursor should be hidden when both are equal to -1.

They could be represented by the client as a line if both values are the same, or as a text highlight otherwise.

Values set with this event are double-buffered. They must be applied and reset to initial on the next wp_text_input_v3.done event.

The initial value of text is an empty string, and cursor_begin, cursor_end and cursor_hidden are all 0.

Notify when text should be inserted into the editor widget. The text to commit could be either just a single character after a key press or the result of some composing (pre-edit).

Values set with this event are double-buffered. They must be applied and reset to initial on the next wp_text_input_v3.done event.

The initial value of text is an empty string.

Notify when the text around the current cursor position should be deleted.

Before_length and after_length are the number of bytes before and after the current cursor index (excluding the selection) to delete.

If a preedit text is present, in effect before_length is counted from the beginning of it, and after_length from its end (see done event sequence).

Values set with this event are double-buffered. They must be applied and reset to initial on the next wp_text_input_v3.done event.

The initial values of both before_length and after_length are 0.

Notification that this seat's text-input focus is on a certain surface.

If client has created multiple text input objects, compositor must send this event to all of them.

When the seat has the keyboard capability the text-input focus follows the keyboard focus. This event sets the current surface for the text-input object.

Notification that this seat's text-input focus is no longer on a certain surface. The client should reset any preedit string previously set.

The leave notification clears the current surface. It is sent before the enter notification for the new focus. After leave event, compositor must ignore requests from any text input instances until next enter event.

When the seat has the keyboard capability the text-input focus follows the keyboard focus.

An action was performed on this text input.

Values set with this event are double-buffered. They must be applied and reset to initial on the next wp_text_input_v3.done event.

The initial value of action is none.

Notify the application of language used by the input method.

This event will be sent on creation if known and for all subsequent changes.

The language should be specified as an IETF BCP 47 tag. Setting an empty string will reset any known language back to the default unknown state.

Specify how the visible preedit should be handled when switching the focus widget or changing the cursor position, whether to commit the preedit text or clear the preedit text.

This is usually used together with the preedit_string event.

The commit behavior is the same for focus switch and cursor position change.

The parameter mode selects the desired behavior and its value is one from the commit mode enum.

Sets styling information on composing text. Event sent without preedit string sets a default style for all future preedit text.

The parameters begin and end are counted in bytes relative to the beginning of the text buffer submitted through wp_text_input_v3.preedit_string.

Multiple events may be submitted if the preedit string has different sections. Compositors/input method must not send multiple wp_text_input_v3.preedit_underline events with overlapping extents.

Clients should pick colors appropriate for their color scheme, underline colors follows text color. For parts of the preedit string that are not covered by any wp_text_input_v3.preedit_hint event, or if no events were sent, the text will be considered unstyled.

Values set with this event are double-buffered. They must be applied and reset on the next wp_text_input_v3.done event.

Reason for the change of surrounding text or cursor posision.

Content hint is a bitmask to allow to modify the behavior of the text input.

The content purpose allows to specify the primary purpose of a text input.

This allows an input method to show special purpose input panels with extra characters or to disallow some characters.

A possible action to perform on a text input.

The backspace and delete actions should be handled in a similar manner to backpace and delete keys being pressed on a keyboard.

Pre-edit commit mode when the focus widget or the cursor position is changed.

Style to apply to sections of the preedit string.

Underline style to apply to sections of the preedit string.

Color hints to identify sections of the preedit string. They should be in accordance with the current color scheme.

Destroy the wp_text_input_manager object.

Creates a new text-input object for a given seat.