aboutsummaryrefslogtreecommitdiff
path: root/X11/extensions/XI2proto.txt
diff options
context:
space:
mode:
authormarha <marha@users.sourceforge.net>2009-07-25 18:12:25 +0000
committermarha <marha@users.sourceforge.net>2009-07-25 18:12:25 +0000
commitcd50a4bbac9375d3cd460bbdf88395f802609daf (patch)
tree158a3d7a416df4f8b36a040c1145d615256ac9d3 /X11/extensions/XI2proto.txt
parent4f6f74a5aa4bb99b8f2ad71e0ae590f82a0d6444 (diff)
downloadvcxsrv-cd50a4bbac9375d3cd460bbdf88395f802609daf.tar.gz
vcxsrv-cd50a4bbac9375d3cd460bbdf88395f802609daf.tar.bz2
vcxsrv-cd50a4bbac9375d3cd460bbdf88395f802609daf.zip
Added:
fixesproto-4.1.tar.gz glproto-1.4.10.tar.gz inputproto-1.9.99.15.tar.gz randrproto-1.3.0.tar.gz renderproto-0.11.tar.gz xextproto-7.0.99.3.tar.gz xproto-7.0.15.tar.gz
Diffstat (limited to 'X11/extensions/XI2proto.txt')
-rw-r--r--X11/extensions/XI2proto.txt1605
1 files changed, 1605 insertions, 0 deletions
diff --git a/X11/extensions/XI2proto.txt b/X11/extensions/XI2proto.txt
new file mode 100644
index 000000000..7c41debc8
--- /dev/null
+++ b/X11/extensions/XI2proto.txt
@@ -0,0 +1,1605 @@
+
+ The X Input Extension
+ Version 2.0
+
+ Peter Hutterer
+ peter.hutterer@redhat.com
+ Red Hat, Inc.
+
+
+
+1. Introduction
+
+The X Input Extension version 2.0 (XI2) is the second major release of the X
+Input Extension.
+
+XI2 provides a number of enhancements over version 1.5, including:
+- use of XGE and GenericEvents. GenericEvents are of flexible length with a
+ minimum length of 32 bytes.
+- explicit device hierarchy of master and slave devices. See Section 4.
+- use of multiple independent master devices (Multi-Poiner X or MPX).
+- the ability for devices to change capabilities at runtime.
+- raw device events
+
+XI2's intent is to replace both core input processing and prior versions of
+the X Input Extension. Historically, the majority of applications employed the
+core protocol requests and events to handle user input. The core protocol does
+not provide information about which device generated the event. The X Input
+Extension version up to 1.5 requires the differentiation between core and
+extended devices. Extended devices may not be core devices and thus cannot be
+used on applications employing the core protocol. XI2 addresses both of these
+issues by enabling devices to be both extended and core devices and providing
+device information in each event (with the exception of core events).
+
+ ❧❧❧❧❧❧❧❧❧❧❧
+
+2. Notations used in this document
+
+Notation for requests:
+┌───
+ Name of request
+ name of request field: type of request field
+ name of request field: type of request field
+ ▶
+ name of reply field: type of reply field
+└───
+
+Notation for events:
+┌───
+ Name of event
+ name of field: type of field
+ name of field: type of field
+└───
+
+Complex fields are specified in the following notation:
+ name of field: COMPLEXFIELDTYPE
+or, if multiple of these fields exist:
+ name of field: LISTofCOMPLEXFIELDTYPE
+
+COMPLEXFIELDTYPE: { name of subfield: type of subfield,
+ name of subfield: type of subfield }
+
+ ❧❧❧❧❧❧❧❧❧❧❧
+
+3. Interoperability between version 1.x and 2.0
+
+FIXME
+
+ ❧❧❧❧❧❧❧❧❧❧❧
+
+4. The Master/Slave device hierarchy
+
+XI2 introduces a device hierarchy split up into so-called Master Devices (MD)
+and Slave Devices (SD).
+
+4.1 Master devices
+An MD is a virtual device created and managed by the server. MDs may send core
+events and XI events. However, an MD does not represent a physical device and
+relies on SDs for event generation. MDs come in two forms: as master pointers
+or as master keyboards. A master pointer is represented by a visible cursor on
+the screen. A master keyboard is represented by a keyboard focus.
+
+Each master pointer is paired with the respective master keyboard and vice
+versa, and this pairing is constant for the lifetime of both input devices.
+Clients can use this pairing behaviour to implement input paradigms that
+require pointer and keyboard interation (e.g. SHIFT + Click).
+
+4.2 Slave devices
+An SD is usually a physical device configured in the server. SDs are not
+represented by a cursor or keyboard focus and may be attached to a master
+pointer or master keyboard. SDs can only be attached to any master of the same
+type (e.g. a physical pointer device can be attached to any master pointer).
+
+If an event is generated by an SD
+- if the SD is attached to a master pointer, it changes the position and/or
+ button state of the master pointer.
+- if the SD is attached to a master keyboard, it sends events to this
+ keyboard's focus window (if applicable) and/or changes the modifier state of
+ this keyboard.
+- if the SD is not attached to an MD ("floating"), it does not change
+ any master device. The SD has its own (invisible) sprite and its own focus.
+ Both the sprite and the focus must be managed explicitly by the client
+ program.
+
+4.3 Event processing for attached slave devices
+
+Whenever an SD changes its logical state,
+- the event is delivered as an XI event to any interested clients. If the
+ device is floating, event processing stops.
+ Otherwise, if the device is attached,
+- the master device changes its classes to reflect the SD's capabilities. All
+ interested clients are notified of this device change.
+- then, the event is delivered as an XI event from the MD to any interested
+ clients. If the event has been delivered, event processing stops.
+ Otherwise,
+- the event is delivered as a core event to any interested clients.
+
+Given that W is the event window, and P the parent window of W, event delivery
+to P is only attempted if neither the XI event, nor the core event has been
+delivered on W. Once an event has been delivered as either XI or core event,
+event processing stops.
+
+ ❧❧❧❧❧❧❧❧❧❧❧
+5. Data types
+
+BUTTONMASK
+ A binary mask defined as (1 << button number).
+ A SETofBUTTONMASK is a binary OR of zero or more BUTTONMASK.
+
+DEVICE { DEVICEID, AllDevices, AllMasterDevices }
+ A DEVICE specifies either a DEVICEID or AllDevices or
+ AllMasterDevices.
+
+DEVICEID { CARD16 }
+ A DEVICEID is a numerical ID for a device currently available in the
+ server. The server may re-use a device ID after a device's removal.
+ The device IDs 0 and 1 are reserved.
+ AllDevices ........ 0
+ AllMasterDevices .. 1
+
+DEVICEUSE { MasterPointer, MasterKeyboard, SlavePointer,
+ SlaveKeyboard, FloatingSlave }
+ A DEVICEUSE field specifies the current use of a device in the MD/SD
+ device hierarchy. See Section 4 for more information.
+
+EVENTMASK
+ An EVENTMASK is a binary mask defined as (1 << event type).
+ A SETofEVENTMASK is a binary OR of zero or more EVENTMASK.
+
+FP1616
+ Fixed point decimal in 16.16 format as one INT16 and one CARD16.
+ The INT16 contains the integral part, the CARD32 the decimal fraction
+ shifted by 16.
+
+FP3232
+ Fixed point decimal in 32.32 format as one INT32 and one CARD32.
+ The INT32 contains the integral part, the CARD32 the decimal fraction
+ shifted by 32.
+
+VALUATORMASK
+ A binary mask defined as (1 << valuator number).
+ A SETofVALUATORMASK is a binary OR of zero or more VALUATORMASK.
+
+ ❧❧❧❧❧❧❧❧❧❧❧
+6. Errors
+
+Errors are sent using core X error reports.
+
+Device
+ A value for a DEVICE argument does not specify a valid DEVICE.
+
+ ❧❧❧❧❧❧❧❧❧❧❧
+7. Requests:
+
+The server does not guarantee that the length of a reply remains constant in
+future revisions of XI2. A client must always retrieve the exact length of the
+protocol reply from the connection, even if the reply is longer than defined
+for the XI2 version supported by the client.
+Additional bytes in a request may include data supported in later versions of
+XI2. Clients should ignore this data.
+
+7.1 Requests introduced in version 2.0
+
+ ┌───
+ XIQueryVersion
+ major_version: CARD16
+ minor_version: CARD16
+ ▶
+ major_version: CARD16
+ minor_version: CARD16
+ └───
+
+ The client sends the highest supported version to the server and the
+ server sends the highest version it supports, but no higher than the
+ requested version. Major versions changes can introduce incompatibilities
+ in existing functionality, minor version changes introduce only backward
+ compatible changes. It is the clients responsibility to ensure that the
+ server supports a version which is compatible with its expectations.
+
+ major_version
+ Major XI2 version.
+ minor_version
+ Minor XI2 version.
+
+ If major_version is less than 2, a BadValue error occurs.
+
+ ┌───
+ XIQueryDevice
+ DEVICE deviceid
+ ▶
+ num_devices: CARD16
+ deviceinfo: LISTofDEVICEINFO
+ └───
+
+ DEVICEINFO { deviceid: DEVICEID
+ use: DEVICEUSE
+ attachment: DEVICEID
+ enabled: BOOL
+ num_classes: CARD16
+ name_len: CARD16
+ name: LISTofCHAR8
+ classes: LISTofCLASS }
+
+ CLASS { BUTTONCLASS KEYCLASS, AXISCLASS }
+
+ BUTTONCLASS { type: ButtonClass
+ length: CARD16
+ sourceid: CARD16
+ buttons_len: CARD16
+ state: SETofBUTTONMASK
+ labels: LISTofATOM }
+
+ KEYCLASS { type: KeyClass
+ length: CARD16
+ sourceid: CARD16
+ num_keys: CARD16
+ keys: LISTofCARD32 }
+
+ AXISCLASS { type: AxisClass
+ length: CARD16
+ sourceid: CARD16
+ axisnumber: CARD16
+ label: ATOM
+ min: FP3232
+ max: FP3232
+ value: FP3232
+ resolution: CARD32 }
+
+ XIQueryDevices details information about the requested input devices.
+
+ devices
+ The device to list. If 'devices' is AllDevices, all enabled and
+ disabled devices are listed. If 'devices' is AllMasterDevices, all
+ enabled and disabled master devices are listed. If 'devices' is a
+ valid DEVICE, only this DEVICE is listed and 'num_devices' is 1.
+ num_devices
+ The number of 'deviceinfos' returned.
+
+ Each 'deviceinfo' is detailed as follows:
+ deviceid
+ The unique ID of the device. Device IDs may get re-used when a device
+ is removed.
+ use
+ If the device is a master pointer, 'use' is MasterPointer.
+ If the device is a master keyboard, 'use' is MasterKeyboard.
+ If the device is a slave pointer, 'use' is SlavePointer.
+ If the device is a slave keyboard, 'use' is SlaveKeyboard.
+ If the device is a floating slave, 'use' is FloatingSlave.
+
+ attachment
+ If the device is a master pointer or a master keyboard, 'attachment'
+ specifies the paired master keyboard, or the paired master pointer,
+ respectively. If the device is a non-floating slave device
+ 'attachment' specifies the master device this device is attached to.
+ If the device is a floating slave, 'attachment' is undefined.
+
+ enabled
+ Zero if the device is disabled, non-zero otherwise.
+ num_classes
+ Number of 'classes' provided.
+ name_len
+ Length of the name in bytes.
+ classes
+ Details the available classes provided by the device in an undefined
+ order.
+ name
+ The device's name, padded to a multiple of 4 bytes.
+
+ For all classes, 'type' specifies the device class. Clients are required
+ to ignore unknown device classes. The 'length' field specifies the length
+ of the class in 4 byte units.
+ The following classes may occur only once: ButtonClass, KeyClass
+
+ ButtonClass:
+ type
+ Always ButtonClass.
+ length
+ Length in 4 byte units.
+ sourceid
+ The device this class originates from.
+ num_buttons
+ Number of buttons provided by the device.
+ labels
+ List of Atoms specifying the label for each button. An atom of None
+ specifies an unlabeled button. Buttons are listed in the device-native
+ order and potential button mappings are ignored.
+ state
+ The current button mask for this device. Each bit representing a
+ button is 1 if this button is logically down, or 0 otherwise. State a
+ multiple of 4-byte units and always contains at least num_buttons
+ bits.
+
+ KeyClass:
+ type
+ Always KeyClass.
+ length
+ Length in 4 byte units.
+ sourceid
+ The device this class originates from.
+ num_keys
+ Number of keycodes provided by the device.
+ keys
+ List of keycodes provided.
+
+ AxisClass:
+ type
+ Always AxisClass.
+ length
+ Length in 4 byte units.
+ sourceid
+ The device this class originates from.
+ axisnumber
+ Axis number of this axis. The axis number is in device-native
+ order and potential axis mappings are ignored.
+ label
+ Atom specifying the axis name. An Atom of None specifies an unlabeled
+ axis.
+ min
+ Minimum value.
+ max
+ Minimum value.
+ resolution
+ Resolution in counts/meter.
+ mode
+ Relative or Absolute.
+ value
+ Last published axis value (if mode is absolute).
+
+ An axis in Relative mode may specify 'min' and 'max' as a hint to the
+ client. If no 'min' and 'max' information is available, both must be 0.
+
+ ┌───
+ XISelectEvents
+ window: Window
+ num_masks: CARD16
+ masks: LISTofEVENTMASK
+
+ └───
+
+ EVENTMASK { deviceid: DEVICE,
+ mask_len: CARD16,
+ mask: SETofEVENTMASK
+
+ window
+ The window to select the events on.
+ num_masks
+ Number of items in mask.
+ deviceid
+ Numerical deviceid, or AllDevices, or AllMasterDevices.
+ mask_len
+ Length of mask in 4 byte units.
+ mask
+ Event mask. An event mask for an event type T is defined as (1 << T).
+
+ XISelectEvents selects for XI2 events on 'window'.
+
+ If 'num_masks' is 0, a BadValue error occurs.
+
+ Each 'mask' sets the (and overwrites a previous) event mask for the DEVICE
+ specified through 'deviceid'. The device 'AllDevices' or
+ 'AllMasterDevices' is treated as a separate device by server. A client's
+ event mask is the union of 'AllDevices', 'AllMasterDevices' and the
+ per-device event mask.
+ The removal of device from the server unsets the event masks for the
+ device. If an event mask is set for AllDevices or AllMasterDevices, the
+ event mask is not cleared on device removal and affects all future
+ devices.
+
+ If 'mask_len' is 0, the event mask for the given device is cleared.
+
+ The mask for XIHierarchyEvents may only be selected for XIAllDevices.
+ Setting it for any other device results in a BadValue error.
+
+ ┌───
+ XIGetSelectedEvents
+ window: Window
+ ▶
+ num_masks: CARD16
+ masks: LISTofEVENTMASK
+ └───
+
+
+ window
+ The window to select the events on.
+ num_masks
+ Number of items in mask.
+ masks
+ Selected event masks by this client.
+
+ Masks are returned on a per-device basis, with masks for 'AllDevices' and
+ 'AllMasterDevices' returned separately.
+
+ If 'num_masks' is 0, no events have been selected by this client on the
+ given window.
+
+ ┌───
+ XIQueryPointer
+ window: Window
+ deviceid: DEVICEID
+ ▶
+ root: Window
+ child: Window
+ root_x: FP1616
+ root_y: FP1616
+ win_x: FP1616
+ win_y: FP1616
+ same_screen: BOOL
+ mods: MODIFIERINFO
+ group: GROUPINFO
+ buttons_len: CARD16
+ buttons: SETofBUTTONMASK
+ └───
+
+ Query a master pointer device for its current position.
+
+ root
+ The root window the pointer is logically on.
+ child
+ The child window of 'window' that contains the pointer or None.
+ root_x
+ root_y
+ Pointer position relative to the root window's origin.
+ win_x
+ win_y
+ Pointer position relative to 'window' or 0 if 'same_screen' is false.
+ same_screen
+ TRUE if 'window' is on the same screen as the pointer.
+ mods
+ XKB modifier state on the paired device.
+ group
+ XKB group state on the paired device.
+ buttons_len
+ The length of 'buttons' in 4 byte units.
+ buttons
+ Button state.
+
+ ┌───
+ XIWarpPointer
+ src_win: Window
+ dst_win: Window
+ src_x: FP1616
+ src_y: FP1616
+ src_width: INT16
+ src_height: INT16
+ dst_x: FP1616
+ dst_y: FP1616
+ deviceid: DEVICEID
+ └───
+
+ WarpPointer moves the pointer of 'deviceid' as if the user had moved
+ the pointer. WarpPointer can only be called for MasterPointer and
+ FloatingSlave devices.
+
+ src_win
+ If src_window is not None, the move only takes place if src_window
+ contains the pointer and the pointer is contained in the specified
+ rectangle of src_window.
+ dst_win
+ If dst_win is None, this request moves the pointer by offsets
+ 'dst_x'/'dst_y' relative to the current position of the pointer. If
+ dst_window is a window, this request moves the pointer to
+ 'dst_x'/'dst_y' relative to dst_win's origin.
+ src_x
+ src_y
+ src_width
+ src_height
+ Specifies the source window rectangle.
+ dst_x
+ dst_y
+ The relative coordinates to move the pointer if 'dst_win' is None, or
+ the absolute coordinates if 'dst_win' is a window.
+ deviceid
+ The device to warp.
+
+ This request cannot be used to move the pointer outside the confine-to
+ window of an active pointer grab. An attempt will only move the pointer as
+ far as the closest edge of the confine-to window.
+
+ This request will generate events just as if the user had instantaneously
+ moved the pointer.
+
+ ┌───
+ XIChangeCursor
+ win: Window
+ cursor: Cursor
+ deviceid: DEVICEID
+ └───
+
+ Change a master pointer's cursor on the specified window.
+
+ window
+ The window.
+ cursor
+ The new cursor or None.
+ deviceid
+ The master pointer device.
+
+ Whenever 'device' enters a window W, the cursor shape is selected in the
+ following order:
+ - if the current window has a device cursor C(d) defined for 'device',
+ display this cursor C(d).
+ - otherwise, if the current window has a cursor C(w) defined in the core
+ protocol's window attributes, display cursor C(w).
+ - repeat on parent window until a cursor has been found.
+
+ ┌───
+ XIChangeHierarchy
+ num_changes: CARD8
+ changes: LISTofHIERARCHYCHANGES
+ └───
+
+ HIERARCHYCHANGE { ADDMASTER, REMOVEMASTER, ATTACHSLAVE, DETACHSLAVE }
+
+ HIERARCHYCHANGETYPE { AddMaster, RemoveMaster, AttachSlave, DetachSlave }
+
+ CHANGEMODE { Float, Attach }
+
+ ADDMASTER { type: HIERARCHYCHANGETYPE
+ length: CARD16
+ name_len: CARD16
+ send_core: BOOL
+ enable: BOOL
+ name: LISTofCHAR8 }
+
+ REMOVEMASTER { type: HIERARCHYCHANGETYPE
+ length: CARD16
+ deviceid: DEVICEID
+ return_mode: CHANGEMODE
+ return_pointer: DEVICEID
+ return_keyboard: DEVICEID }
+
+ ATTACHSLAVE { type: HIERARCHYCHANGETYPE
+ length: CARD16
+ deviceid: DEVICEID
+ master: DEVICEID }
+
+ DETACHSLAVE { type: HIERARCHYCHANGETYPE
+ length: CARD16
+ deviceid: DEVICEID }
+
+ XIChangeHierarchy allows a client to modify the MD/SD device
+ hierarchy (see Section 4).
+
+ num_changes
+ The number of changes to apply to the current hierarchy.
+ changes
+ The list of changes.
+
+ The server processes the changes one by one and applies changes
+ immediately. If an error occurs, processing stops at the current change
+ and returns the number of successfully applied changes in the error.
+
+ ADDMASTER creates a pair of master devices.
+ type
+ Always AddMaster.
+ length
+ Length in 4 byte units.
+ name_len
+ Length of 'name' in bytes.
+ send_core
+ TRUE if the device should send core events.
+ enable
+ TRUE if the device is to be enabled immediately.
+ name
+ The name for the new master devices. The master pointer's name is
+ automatically appended with " pointer", the master keyboard's name is
+ automatically appended with " keyboard".
+
+ REMOVEMASTER removes an existing master device.
+ type
+ Always RemoveMaster.
+ length
+ Length in 4 byte units.
+ deviceid
+ The device to remove.
+ return_mode
+ Return mode for attached slave devices.
+ If 'return_mode' is Float, all slave devices are set to floating.
+ If 'return_mode' is Attach, slave pointers are attached to
+ 'return_pointer' and slave keyboards are attached to
+ 'return_keyboard'.
+ return_pointer
+ return_keyboard
+ The master pointer and master keyboard to attach slave devices to, if
+ 'return_mode' is Attach.
+
+ Removing a master pointer removes the paired master keyboard and vice
+ versa.
+
+ ATTACHSLAVE attaches a slave device to a given master device.
+ type
+ Always ChangeAttachment.
+ length
+ Length in 4 byte units.
+ deviceid
+ Deviceid of the slave device.
+ master
+ The new master device to attach this slave device to.
+
+ DETACHSLAVE detaches a slave device from its current master device.
+ type
+ Always ChangeAttachment.
+ length
+ Length in 4 byte units.
+ deviceid
+ Deviceid of the slave device.
+
+ ┌───
+ XISetClientPointer
+ win: Window
+ deviceid: DEVICEID
+ └───
+
+ Set the ClientPointer for the client owning 'win' to the given device.
+
+ win
+ Window or client ID.
+ deviceid
+ The master pointer or master keyboard that acts as ClientPointer.
+
+ Some protocol requests are ambiguous and the server has to choose a device
+ to provide data for a request or a reply. By default, the server will
+ choose a client's ClientPointer device to provide the data, unless the
+ client currently has a grab on another device.
+
+ If win is None, the ClientPointer for this client is set to the given
+ device. Otherwise, if win is a valid window, the ClientPointer for the
+ client owning this window is set to the given device. Otherwise, if win is
+ not a valid window but a client with the client mask equal to win exists,
+ this client's ClientPointer is set to the given device.
+
+ If deviceid does not specify a master pointer or master keyboard, a
+ BadDevice error returned.
+
+ If window does not specify a valid window or client ID and is not None, a
+ BadWindow error is returned.
+
+ ┌───
+ XIGetClientPointer
+ win: Window
+ ▶
+ set: BOOL
+ deviceid: DEVICEID
+ └───
+
+ Query the ClientPointer for the client owning 'win'.
+
+ win
+ The window or client ID.
+ set
+ TRUE if the client has an explicitly set ClientPointer.
+ deviceid
+ The master pointer that acts as a ClientPointer if 'set' is TRUE.
+
+ ┌───
+ XISetFocus
+ focus: Window
+ deviceid: DEVICEID
+ time: Time
+ └───
+
+ Set the focus for the given device to the given window. Future key events
+ from this device are sent to this window.
+ This request generates FocusIn and FocusOut events.
+
+ focus
+ A viewable window or None.
+ deviceid
+ The device to modify the focus window for.
+ time
+ Specifies the time to change the focus or CurrentTime.
+
+ If focus is None, key events from this device are discarded until a new
+ focus window is set. If focus is a viewable window, key events from this
+ device are sent to this window. If the window becomes unviewable, the
+ window's first viewable ancestor automatically becomes the focus window
+ and FocusIn and FocusOut events are sent as if a client had changed the
+ focus window.
+ This is equivalent to RevertToParent in the core XSetInputFocus window.
+
+ This request has no effect if the specified time is earlier than the
+ current last-focus-change time or is later than the current X server time.
+ Otherwise, the last-focus-change time is set to the specified time.
+
+ ┌───
+ XIGetFocus
+ deviceid: DEVICEID
+ ▶
+ focus: Window
+ └───
+
+ Return the current focus window for the given device.
+
+ ┌───
+ XIGrabDevice
+ deviceid: DEVICEID
+ grab_window: Window
+ owner_events: BOOL
+ grab_mode: { Synchronous, Asynchronous }
+ paired_device_mode: { Synchronous, Asynchronous }
+ time: TIMESTAMP or CurrentTime
+ cursor: Cursor
+ mask_len: CARD16
+ masks: SETofEVENTMASK
+ ▶
+ status: Success, AlreadyGrabbed, Frozen, InvalidTime, NotViewable
+ └───
+
+ This request actively grabs control of the specified input device. Further
+ input events from this device are reported only to the grabbing client.
+ This request overides any previous active grab by this client for this
+ device.
+
+ deviceid
+ The device to grab.
+ grab_window
+ Events are reported relative to the grab window.
+ owner_events
+ Specifies whether event will be reported normally or relative to the
+ grab window.
+ grab_mode
+ Specifies if this device will be frozen as a result of the grab.
+ paired_device_mode
+ Specifies if the master device paired with this device will be frozen
+ as a result of the grab.
+ time
+ A valid server time or CurrentTime.
+ cursor
+ The cursor to display for the duration of the grab or None.
+ mask_len
+ Length of mask in 4 byte units.
+ mask
+ Event mask. An event mask for an event type T is defined as (1 << T).
+ status
+ Success or the reason why the grab could not be established.
+
+
+ The masks parameter specifies which events the client wishes to receive
+ while the device is grabbed.
+
+ If owner-events is False, input events generated from this device are
+ reported with respect to grab-window, and are only reported if selected by
+ being included in the event-list. If owner-events is True, then if a
+ generated event would normally be reported to this client, it is reported
+ normally, otherwise the event is reported with respect to the grab-window,
+ and is only reported if selected by being included in the event-list. For
+ either value of owner-events, unreported events are discarded.
+
+ If grab-mode is Asynchronous, device event processing continues normally.
+ If the device is currently frozen by this client, then processing of
+ device events is resumed. If grab-mode is Synchronous, the state of the
+ grabbed device (as seen by means of the protocol) appears to freeze,
+ and no further device events are generated by the server until the
+ grabbing client issues a releasing XIAllowEvents request or until the
+ device grab is released. Actual device input events are not lost while the
+ device is frozen; they are simply queued for later processing.
+
+ If the device is a slave device, the paired-device-mode is ignored.
+ Otherwise, if this device is a master device and paired-device-mode is
+ Asynchronous, event processing is unaffected by activation of the grab. If
+ this device is a master device and paired-device-mode is Synchronous, the
+ state of the master device paired with this device (as seen by means of the
+ protocol) appears to freeze, and no further events are generated by the
+ server until the grabbing client issues a releasing XIAllowEvents request
+ or until the device grab is released. Actual events are not lost while the
+ devices are frozen; they are simply queued for later processing.
+
+ If the cursor is not None and the device is a master pointer device, the
+ cursor will be displayed until the device is ungrabbed.
+
+ This request fails and returns:
+ AlreadyGrabbed: If the device is actively grabbed by some other client.
+ NotViewable: If grab-window is not viewable.
+ InvalidTime: If the specified time is earlier than the last-grab-time for
+ the specified device or later than the current X server time.
+ Otherwise, the last-grab-time for the specified device is set
+ to the specified time and CurrentTime is replaced by the
+ current X server time.
+ Frozen: If the device is frozen by an active grab of another client.
+
+ To release a grab of a device, use XIUngrabDevice.
+
+ ┌───
+ XIUngrabDevice
+ deviceid: DEVICEID
+ time: TIMESTAMP or CurrentTime
+ └───
+
+ This request releases the device if this client has it actively grabbed
+ (from either XIGrabDevice, XIGrabDeviceKey or XIGrabDeviceButton) and
+ releases any queued events. If any devices were frozen by the grab,
+ XIUngrabDevice thaws them.
+
+ deviceid
+ The device to grab.
+ time
+ A valid server time or CurrentTime.
+
+ The request has no effect if the specified time is earlier
+ than the last-device-grab time or is later than the current server time.
+ This request generates FocusIn and FocusOut events.
+ An XIUngrabDevice is performed automatically if the event window for an
+ active device grab becomes not viewable.
+
+ ┌───
+ XIAllowEvents:
+ deviceid: DEVICEID
+ time: TIMESTAMP or CurrentTime
+ event_mode: { AsyncDevice, SyncDevice,
+ AsyncPairedDevice, SyncPairedDevice,
+ ReplayDevice, AsyncPair, SyncPair }
+ └───
+
+ The XIAllowEvents request releases some queued events if the client
+ has caused a device to freeze.
+
+ deviceid
+ The device to grab.
+ time
+ A valid server time or CurrentTime.
+ event_mode
+ Specifies whether a device is to be thawed and events are to be
+ replayed.
+
+ The request has no effect if the specified time is earlier than the
+ last-grab time of the most recent active grab for the client, or if the
+ specified time is later than the current X server time.
+
+ The following describes the processing that occurs depending on what constant
+ you pass to the event-mode argument:
+ AsyncDevice:
+ If the specified device is frozen by the client, event processing for that
+ device continues as usual. If the device is frozen multiple times by the
+ client on behalf of multiple separate grabs, AsyncDevice thaws for
+ all.
+ AsyncDevice has no effect if the specified device is not frozen by the
+ client, but the device need not be grabbed by the client.
+ SyncDevice:
+ If the specified device is frozen and actively grabbed by the client,
+ event processing for that device continues normally until the next
+ event is reported to the client. At this time, the specified device
+ again appears to freeze. However, if the reported event causes the
+ grab to be released, the specified device does not freeze.
+ SyncDevice has no effect if the specified device is not frozen by the
+ client or is not grabbed by the client.
+ ReplayDevice:
+ If the specified device is actively grabbed by the client and is frozen
+ as the result of an event having been sent to the client (either from
+ the activation of a XIGrabButton or from a previous XIAllowEvents with
+ mode SyncDevice, but not from a Grab), the grab is released and
+ that event is completely reprocessed. This time, however, the request
+ ignores any passive grabs at or above (towards the root) the
+ grab-window of the grab just released.
+ The request has no effect if the specified device is not grabbed by
+ the client or if it is not frozen as the result of an event.
+ AsyncPairedDevice
+ If the paired master device is frozen by the client, event processing
+ for it continues as usual. If the paired device is frozen multiple
+ times by the client on behalf of multiple separate grabs,
+ AsyncPairedDevice thaws for all.
+ AsyncPairedDevice has no effect if the device is not frozen by the
+ client, but those devices need not be grabbed by the client.
+ AsyncPairedDevice has no effect if deviceid specifies a slave device.
+ SyncPairedDevice
+ If the paired master device is frozen by the client, event processing (for
+ the paired master device) continues normally until the next button or key
+ event is reported to the client for the grabbed device (button event for
+ the grabbed device, key or motion event for the device), at which time
+ the device again appears to freeze. However, if the reported event causes
+ the grab to be released, then the device does not freeze.
+ SyncPairedDevice has no effect if the specified device is not grabbed
+ by the client or if it is no frozen as the result of an event.
+ SyncPairedDevice has no effect if deviceid specifies a slave device.
+ SyncPair
+ If both the device and the paired master device are frozen by the
+ client, event processing (for both devices) continues normally until
+ the next XIButtonPress, XIButtonRelease, XIKeyPress, or XIKeyRelease
+ event is reported to the client for a grabbed device (button event for
+ a pointer, key event for a keyboard), at which time the devices again
+ appear to freeze. However, if the reported event causes the grab to be
+ released, then the devices do not freeze (but if the other device is
+ still grabbed, then a subsequent event for it will still cause both
+ devices to freeze).
+ SyncPair has no effect unless both the device and the paired master
+ device are frozen by the client. If the device or paired master device
+ is frozen twice by the client on behalf of two separate grabs,
+ SyncPair thaws for both (but a subsequent freeze for SyncPair will
+ only freeze each device once).
+ SyncPair has no effect if deviceid specifies a slave device.
+ AsyncPair
+ If the device and the paired master device are frozen by the client,
+ event processing for both devices continues normally. If a device is
+ frozen twice by the client on behalf of two separate grabs, AsyncBoth
+ thaws for both. AsyncPair has no effect unless both the device and the
+ paired master device frozen by the client.
+ AsyncPair has no effect if deviceid specifies a slave device.
+
+ ┌───
+ XIPassiveGrabDevice
+ deviceid: DEVICEID
+ detail: CARD32
+ grab_type: GRABTYPE
+ grab_window: Window
+ cursor: Cursor
+ owner_events: Bool
+ grab_mode: { Synchronous, Asynchronous }
+ paired_device_mode: { Synchronous, Asynchronous }
+ num_modifiers: INT16
+ mask_len: CARD16
+ masks: SETofEVENTMASK
+ modifiers: CARD32 or GrabAnyModifier
+ ▶
+ num_modifiers_return: INT16
+ modifiers_return: GRABMODIFIERINFO
+ └───
+
+ GRABTYPE { GrabtypeButton, GrabtypeKeycode, GrabtypeEnter,
+ GrabTypeFocusIn}
+
+ GRABMODIFIERINFO { status: Access
+ modifiers: CARD32 }
+
+ Establish an explicit passive grab for a button or keycode
+ on the specified input device.
+
+ cursor
+ The cursor to display for the duration of the grab. If grab_type
+ is not GrabtypeButton, this argument is ignored.
+ deviceid
+ The device to establish the passive grab on.
+ detail
+ The button number, or key symbol to grab for.
+ Must be 0 for GrabtypeEnter and GrabtypeFocusIn.
+ grab_type
+ The type of grab to establish.
+ grab_window
+ Events are reported relative to the grab window.
+ grab_mode
+ If grab-mode is Asynchronous, device event processing continues
+ normally. If the device is currently frozen by this client, then
+ processing of device events is resumed. If grab-mode is
+ Synchronous, the state of the grabbed device (as seen by means of
+ the protocol) appears to freeze, and no further device events are
+ generated by the server until the grabbing client issues a
+ releasing XIAllowEvents request or until the device grab is
+ released. Actual device input events are not lost while the device
+ is frozen; they are simply queued for later processing.
+ mask_len
+ Length of mask in 4 byte units.
+ mask
+ Event mask. An event mask for an event type T is defined as (1 << T).
+ modifiers
+ XKB modifier state to activate this passive grab.
+ num_modifiers
+ Number of elements in modifiers.
+ owner_events
+ Specifies whether event will be reported normally or relative to the
+ grab window.
+ num_modifiers_return
+ Number of elements in modifiers_return
+ modifiers_return
+ XKB modifier state that could not be grabbed.
+
+ If owner-events is False, input events generated from this device are
+ reported with respect to grab-window, and are only reported if
+ selected by being included in the event-list. If owner-events is
+ True, then if a generated event would normally be reported to this
+ client, it is reported normally, otherwise the event is reported
+ with respect to the grab-window, and is only reported if selected
+ by being included in the event-list. For either value of
+ owner-events, unreported events are discarded.
+
+ If deviceid specifies a master pointer, the modifiers of the paired
+ master keyboard are used. If deviceid specifies a slave pointer
+ the modifiers of the master keyboard paired with the attached master
+ pointers are used. If deviceid specifies a slave keyboard, the
+ modifiers of the attached master keyboard are used. Note that
+ activating a grab on a slave device detaches the device from its
+ master. In this case, the modifiers after activation of the grab are
+ from the slave device only and may be different to the modifier state
+ when the grab was triggered.
+
+ In the future, if grab_type is GrabtypeButton or GrabtypeKeyboard, the
+ device is actively grabbed if:
+ - the device is not grabbed, and
+ - the specified modifier keys are down, and
+ - the grab_type is GrabtypeButton and the button specified in detail
+ is logically pressed or the grab_type is GrabtypeKeycode and the
+ keycode specified in detail is logically pressed, and
+ - the grab_window contains the pointer, and
+ - a passive grab on the same button/keycode + modifier
+ combination does not exist on an ancestor of grab_window.
+
+ Otherwise, if grab_type is GrabtypeEnter or GrabtypeFocusIn, the
+ device is actively grabbed if:
+ - the device is not actively grabbed, and
+ - the specified modifier keys are down, and
+ - the grab_type is GrabtypeEnter and the device's pointer has moved
+ into grab_window or a descendant of grab_window, or the grab_type is
+ GrabtypeFocusIn and the device's focus has been set to the
+ grab_window or a descendant of grab_window,
+ - a passive grab of the same grab_type + modifier combination does not
+ does not exist on an ancestor of grab_window.
+
+ A modifier of GrabAnyModifier is equivalent to issuing the request for
+ all possible modifier combinations (including no modifiers). A client
+ may request a grab for GrabAnyModifier and explicit modifier
+ combinations in the same request.
+
+ A GrabtypeButton or GrabtypeKeyboard grab is released when all buttons
+ or keycode are released, independent of the state of modifier keys.
+ A GrabtypeEnter or GrabtypeFocusIn grab is released when the
+ pointer or focus leaves the window and all of its descendants,
+ independent of the state of modifier keys.
+ Note that the logical state of a device (as seen by means of the
+ protocol) may lag the physical state if device event processing is
+ frozen.
+
+ This request overrides all previous passive grabs by the same
+ client on the same button/key/enter/focus in + modifier combinations
+ on the same window.
+
+ If some other client already has issued a XIPassiveGrabDevice request
+ with the same button or keycode and modifier combination, the
+ failed modifier combinations is returned in modifiers_return. If some
+ other client already has issued an XIPassiveGrabDevice request of
+ grab_type XIGrabtypeEnter or XIGrabtypeFocusIn with the same
+ grab_window and the same modifier combination, the failed modifier
+ combinations are returned in modifiers_return. If num_modifiers_return
+ is zero, all passive grabs have been successful.
+
+ If a button grab or enter grab activates, EnterNotify and LeaveNotify
+ events with mode Grab are generated as if the pointer were to suddenly
+ warp from its current position some position in the grab_window.
+ However, the pointer does not warp, and the pointer position is used
+ as both the initial and final positions for the events.
+
+ If a keycode grab or focus grab activates, FocusIn and FocusOut events
+ with mode Grab are generated as if the focus were to change from the
+ current window to the grab_window.
+
+ If an enter or focus in grab activates, additional EnterNotify events
+ with mode XIPassiveGrabNotify are generated as if the pointer or focus
+ were to suddenly warp from its current position to some position in
+ the grab window. These events are sent to the grabbing client only
+ and only if the grab event mask has selected for it. If such a passive
+ grab deactivates, addional LeaveNotify events with mode
+ XIPassiveUngrabNotify are generated and sent to the grabbing client
+ before the grab deactivates.
+
+ ┌───
+ XIPassiveUngrabDevice
+ deviceid: DEVICEID
+ detail: CARD32
+ grab_type: GRABTYPE
+ grab_window: Window
+ num_modifiers: INT16
+ modifiers: MODIFIERINFO
+ └───
+
+ Release an explicit passive grab on the specified input device.
+
+ deviceid
+ The device to establish the passive grab on.
+ detail
+ The button number or key symbol to ungrab.
+ Must be 0 for GrabtypeEnter and GrabtypeFocusIn.
+ grab_type
+ The type of grab to establish.
+ grab_window
+ Events are reported relative to the grab window.
+ modifiers
+ XKB modifier state to activate this passive grab.
+ num_modifiers
+ Number of elements in modifiers.
+
+ This request has no effect if the client does not have a passive grab
+ of the same type, same button or keycode (if applicable) and modifier
+ combination on the grab_window.
+
+ ┌───
+ XIListProperties
+ deviceid: DEVICEID
+ ▶
+ num_properties: INT16
+ properties: LISTofATOM
+ └───
+
+ List the properties associated with the given device.
+
+ deviceid
+ The device to list the properties for.
+ num_atoms
+ Number of atoms in the reply
+ atoms
+ All properties on the device.
+
+ ┌───
+ XIChangeProperty
+ deviceid: DEVICEID
+ property: ATOM
+ type: ATOM
+ format: { 8, 16, 32 }
+ mode: { Append, Prepend, Replace }
+ num_items: CARD32
+ data: LISTofINT8, or LISTofINT16, or LISTofINT32
+ └───
+
+ Change the given property on the given device.
+
+ deviceid
+ The device to change the property on.
+ property
+ The property to modify.
+ type
+ The property's type.
+ mode
+ One of Append, Prepend, or Replace
+ num_items
+ Number of items following this request.
+ data
+ Property data (nitems * format/8 bytes)
+
+ The type is uninterpreted by the server. The format specifies whether
+ the data should be viewed as a list of 8-bit, 16-bit, or 32-bit
+ quantities so that the server can correctly byte-swap as necessary.
+
+ If the mode is Replace, the previous propert y value is discarded. If
+ the mode is Prepend or Append, then the type and format must match the
+ existing property value (or a Match error results). If the property is
+ undefined, it is treated as defined with the correct type and format
+ with zero-length data. For Prepend, the data is tacked on to the
+ beginning of the existing data, and for Append, it is tacked on to the
+ end of the existing data.
+
+ The lifetime of a property is not tied to the storing client. Properties
+ remain until explicitly deleted, until the device is removed, or
+ until server reset.
+
+ A property cannot be deleted by setting nitems to zero. To delete a
+ property, use XIDeleteDeviceProperty.
+
+ This request generates an XIPropertyEvent.
+
+ ┌───
+ XIDeleteProperty
+ deviceid: DEVICEID
+ property: ATOM
+ └───
+
+ Deletes the given property on the given device.
+
+ deviceid
+ The device to delete the property on.
+ property
+ The property to delete.
+
+ If the property is deleted, an XIPropertyEvent is generated on the device.
+ If the property does not exist, this request does nothing.
+
+ ┌───
+ XIGetProperty
+ deviceid: DEVICEID
+ property: ATOM
+ type: Atom or AnyPropertyType
+ offset: CARD32
+ len: CARD32
+ delete: BOOL
+ ▶
+ type: Atom
+ bytes_after: CARD32
+ num_items: CARD32
+ format: { 8, 16, 32 }
+ data: LISTofINT8, or LISTofINT16, or LISTofINT32
+ └───
+
+ Get the data for the given property on the given device.
+
+ deviceid
+ The device to retrieve the property data from.
+ property
+ The property to retrieve the data from..
+ type
+ The property type to retrieve or AnyPropertyType
+ offset
+ The offset in 4-byte units.
+ len
+ Number of bytes to receive in 4-byte units.
+ delete
+ Delete the property after retrieving the data.
+ bytes_after
+ Number of unread bytes in the stored property
+ num_items
+ Number of items in data
+ format
+ 8, 16, or 32
+ data
+ Property data (nitems * format/8 bytes)
+
+ If the specified property does not exist for the specified device, then
+ the return type is None, the format and bytes-after are zero, and the value is
+ empty. The delete argument is ignored in this case. If the specified property
+ exists but its type does not match the specified type, then the return
+ type is the actual type of the property, the format is the actual format of the
+ property (never zero), the bytes-after is the length of the property in bytes
+ (even if the format is 16 or 32), and the value is empty. The delete
+ argument is ignored in this case. If the specified property exists and
+ either AnyPropertyType is specified or the specified type matches the actual
+ type of the property, then the return type is the actual type of the property,
+ the format is the actual format of the property
+ (never zero), and the bytes-after and value are as follows, given:
+ N = actual length of the stored property in bytes
+ (even if the format is 16 or 32)
+ I = 4 * long-offset
+ T = N−I
+ L = MINIMUM(T, 4 * long-length)
+ A = N − (I + L)
+ The returned value starts at byte index I in the property (indexing
+ from 0), and its length in bytes is L. However, it is a Value error if
+ offset is given such that L is negative. The value of bytes_after is A,
+ giving the number of trailing unread bytes in the stored property. If
+ delete is True and the bytes_after is zero, the property is also
+ deleted from the device, and a XIPropertyNotify event is generated on
+ the device.
+
+
+8. Events:
+
+An event specifies its length in 4-byte units after the initial 32 bytes.
+Future versions of the protocol may provide additional information
+in the same event, thus increasing the event size. Clients are required to
+always read the number of bytes specified by the event, not the size of the
+event they may have been compiled against.
+
+
+The following event types are available in XI2.
+
+Version 2.0:
+ HierarchyChanged
+ DeviceChanged
+ KeyPress
+ KeyRelease
+ ButtonPress
+ ButtonRelease
+ Motion
+ RawEvent
+ Enter
+ Leave
+
+All events have a set of common fields specified as EVENTHEADER.
+
+
+EVENTHEADER { type: BYTE
+ extension: BYTE
+ sequenceNumber: CARD16
+ length: CARD32
+ evtype: CARD16
+ deviceid: DEVICEID
+ time: Time }
+
+ type
+ Always GenericEvent.
+ extension
+ Always the X Input extension offset.
+ sequenceNumber
+ Sequence number of last request processed by the server.
+ length
+ Length in 4-byte units after the initial 32 bytes.
+ evtype
+ XI-specific event type.
+ deviceid
+ Numerical device id for a device.
+ time
+ Time in ms.
+
+
+ ┌───
+ HierarchyEvent:
+ EVENTHEADER
+ flags: SETofHIERARCHYMASK
+ num_info: CARD16
+ info: LISTofHIERARCHYINFO
+ └───
+
+
+ HIERARCHYMASK { MasterAdded, MasterRemoved, SlaveAttached, SlaveDetached,
+ SlaveAdded, SlaveRemoved, DeviceEnabled, DeviceDisabled }
+
+ HIERARCHYINFO { deviceid: DEVICEID,
+ attachment: DEVICEID,
+ type: DEVICEUSE
+ enabled: BOOL
+ flags: SETofHIERARCHYMASK}
+
+ flags
+ Set of the changes that have occured, causing this event.
+ num_info
+ The number of device info structs following the request.
+ info:
+ The current hierarchy information.
+
+ An XIHierarchyEvent is sent whenever the device hierarchy been
+ changed. The 'flags' specify all types of hierarchy modifiations that have
+ occured.
+ For all devices, 'info' details the hierarchy information after the
+ modification of the hierarchy has occured. For each device specified with
+ 'deviceid':
+ - if 'type' is MasterPointer or MasterKeyboard, 'attachment' decribes the
+ pairing of this device.
+ - if 'type' is SlavePointer or SlaveKeyboard, 'attachment' describes the
+ master device this device is attached to.
+ - if 'type' is FloatingSlave device, 'attachment' is undefined.
+
+ enabled
+ TRUE if the device is enabled and can send events. A disabled master
+ device will not forward events from an attached, enabled slave
+ device.
+
+ Note: Multiple devices may be affected in one hierarchy change,
+ 'deviceid' in an XIHierarchyEvent is always the first affected
+ device. Clients should ignore deviceid and instead use the 'devices' list.
+
+ ┌───
+ DeviceChangedEvent:
+ EVENTHEADER
+ reason: CHANGEREASON
+ source: DEVICEID
+ num_classes: CARD16
+ classes: LISTofCLASS
+ └───
+
+ CHANGEREASON { SlaveSwitch, DeviceChange }
+
+ A DeviceChangeEvent is sent whenever a device changes it's capabilities.
+ This can happen either by a new slave device sending events through a
+ master device, or by a physical device changing capabilities at runtime.
+
+ reason
+ The reason for generating this event.
+ If 'reason' is SlaveSwitch, the slave device sending events through
+ this device has changed and 'source' specifies the new slave device.
+ A SlaveSwitch 'reason' can only occur on a master device.
+ If 'reason' is DeviceChange, the device itself has changed through
+ other means (e.g. a physical device change) and 'source' is
+ undefined.
+ source
+ The source of the new classes. Only defined in 'reason' is
+ SlaveSwitch.
+ num_classes
+ Number of 'classes' provided.
+ classes
+ Details the available classes provided by the device. The order the
+ classes are provided in is undefined.
+
+ For a detailed description of 'classes', see the XQueryInputDevice
+ request.
+
+ ┌───
+ DeviceEvent:
+ EVENTHEADER
+ detail: CARD32
+ root: Window
+ event: Window
+ child: Window
+ root_x: FP1616
+ root_y: FP1616
+ event_x: FP1616
+ event_y: FP1616
+ buttons_len: CARD16
+ valuators_len: CARD16
+ sourceid: DEVICEID
+ mods: MODIFIERINFO
+ group: GROUPINFO
+ flags: DEVICEEEVENTFLAGS
+ buttons: SETofBUTTONMASK
+ valuators: SETofVALUATORMASK
+ axisvalues: LISTofFP3232
+ └───
+
+ BUTTONBIT { (1 << Button1), (1 << Button2), ... , (1 << ButtonN) }
+ VALUATORBIT { (1 << 1), ( 1 << 2), ... ( 1 << n) }
+
+ MODIFIERINFO { base_mods: CARD32,
+ latched_mods: CARD32,
+ locked_mods: CARD32,
+ effective_mods: CARD32}
+ GROUPINFO { base_group: CARD8,
+ latched_group: CARD8,
+ locked_group: CARD8,
+ effective_group: CARD8}
+
+ DEVICEEVENTFLAGS (all events): none
+ DEVICEEVENTFLAGS (key events only): { KeyRepeat }
+ DEVICEEVENTFLAGS (pointer events only): none
+
+ An XIDeviceEvent is generated whenever the logical state of a device
+ changes in response to a button press, a button release, a motion, a key
+ press or a key release.
+
+ detail
+ The button number or key code, or 0.
+ root
+ event
+ child
+ The root window, event window or subwindow, respectively. See core
+ protocol specification for more detail.
+ root_x
+ root_y
+ The position of the pointer in screen coordinates (16.16 fixed point).
+ event_x
+ event_y
+ The position of the pointer in screen coordinates relative to the
+ event window (16.16 fixed point).
+
+ buttons_len
+ The length of 'buttons' in 4 byte units.
+ valuators_len
+ The length of 'valuators' in 4 byte units.
+ sourceid
+ The source device that originally generated the event.
+ mods
+ XKB modifier state before the event occured.
+ group
+ XKB group state before the event.
+ buttons
+ Button state before the event.
+ valuators
+ Bitmask of valuators provided in 'axisvalues'.
+ axisvalues
+ Valuator data in device-native resolution.
+ flags
+ Miscellaneous information about this event; the union of the
+ common flag set and either the key or pointer flag set,
+ depending on the event type.
+ KeyRepeat means that this event is for repeating purposes, and
+ the physical state of the key has not changed. This is only
+ valid for KeyPress events.
+
+ Modifier state in 'mods' is detailed as follows:
+ base_mods
+ XKB base modifier state.
+ latched_mods
+ XKB latched modifier state.
+ locked_mods
+ XKB locked modifier state.
+
+ Group state in 'group' is detailed as follows:
+ base_group
+ XKB base group state.
+ latched_group
+ XKB latched group state.
+ locked_group
+ XKB locked group state.
+
+ ┌───
+ RawEvent
+ EVENTHEADER
+ detail: CARD32
+ flags: DEVICEEVENTFLAGS
+ valuators_len: CARD16
+ valuators: SETofVALUATORMASK
+ axisvalues: LISTofFP3232
+ axisvalues_raw: LISTofFP3232
+ └───
+
+ A RawDevice event provides the information provided by the driver to the
+ client. RawDevice provide both the raw data as supplied by the driver and
+ transformed data as used in the server. Transformations include, but are
+ not limited to, axis clipping and acceleration.
+ Transformed valuator data may be equivalent to raw data. In this case,
+ both raw and transformed valuator data is provided.
+ RawEvents are sent exclusively to all root windows or to the client
+ that grabbed the device only.
+
+ eventtype
+ The type of event that occured on the device.
+ detail
+ The button number or keycode.
+ flags
+ Flags as described in DeviceEvent::flags.
+ valuators_len
+ The length of 'valuators' in 4 byte units.
+ valuators
+ Bitmask of valuators provided in 'axisvalues' and 'axisvalues_raw'.
+ axisvalues
+ Valuator data in device-native resolution.
+ axisvalues_raw
+ Untransformed valuator data in device-native resolution.
+
+ ┌───
+ Enter or Leave or FocusIn or FocusOut
+ EVENTHEADER
+ root: Window
+ event: Window
+ child: Window
+ sourceid: DEVICEID
+ root_x: FP1616
+ root_y: FP1616
+ event_x FP1616
+ event_y: FP1616
+ mode: NOTIFYMODE
+ detail: NOTIFYDETAIL
+ same_screen: BOOL
+ focus: BOOL
+ mods: MODIFIERINFO
+ group: GROUPINFO
+ buttons_len: CARD16
+ buttons: SETofBUTTONMASK
+ └───
+
+ NOTIFYMODE { Normal, Grab, Ungrab }
+ NOTIFYDETAIL { Ancestor, Virtual, Inferior, Nonlinear, NonlinearVirtual,
+ Pointer, PointerRoot, None }
+
+ Enter or Leave events are sent whenever a device's pointer enters or
+ leaves a window.
+ FocusIn or FocusOut events are sent whenever a device's focus is set to or
+ away from a window.
+ The enter/leave and focus in/out model is described in the core protocol
+ specification, Section 11. (EnterNotify, LeaveNotify events).
+
+ For enter and leave events, the modifier and group state is the state of
+ the paired master device if the device is a master device, or the state of
+ the attached master keyboard if the device is an attached slave device, or
+ zero if the device is a floating slave device.
+
+ For focus in and out events, the button state is the state of the paired
+ master device if the device is a master device, or the state of the
+ attached master keyboard if the device is an attached slave device, or
+ zero if the device is a floating slave device.
+
+ root
+ event
+ child
+ The root window, event window, and child window, respectively. See the
+ core protocol specification for more detail.
+ sourceid
+ The device that caused the pointer to move.
+ root_x
+ root_y
+ The pointer coordinates relative to the root window.
+ event_x
+ event_y
+ The pointer coordinates relative to the event window.
+ mode
+ Normal pointer motion events have mode Normal. Pseudo-motion events
+ when a grab activates have mode Grab, and pseudo-motion events when a
+ grab deactivates have mode Ungrab. Pseudo-motion events caused by the
+ activation or deactivation of a passive enter or focus in grab have mode
+ XIPassiveGrabNotify or XIPassiveUngrabNotify.
+ detail
+ Specifies the relation of the event window to the window the pointer
+ entered or left. See the core protocol spec for details.
+ same_screen
+ TRUE if the event window is on the same screen as the pointer's root
+ window.
+ focus
+ If the event window is the focus window or an inferior of the focus
+ window, then focus is True. Otherwise, focus is False. This field is
+ unspecified for focus in/out events.
+ mods
+ XKB modifier state before the event occured.
+ group
+ XKB group state before the event.
+ buttons_len
+ The length of 'buttons' in 4 byte units.
+ buttons
+ Button state before the event.
+
+ ┌───
+ XIPropertyEvent
+ EVENTHEADER
+ property: ATOM
+ what: { PropertyCreated, PropertyDeleted, PropertyModified }
+ └───
+
+ XIPropertyEvents are sent whenever a device property is created, deleted or
+ modified by a client.
+
+ property
+ The property that has been created, deleted, or modified
+ what
+ Specifies what has been changed.
+
+
+ ❧❧❧❧❧❧❧❧❧❧❧