Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 uid=33(www-data) gid=33(www-data) groups=33(www-data) Safe-mode: OFF (not secure) /usr/share/doc/libxi-dev/ drwxr-xr-x | |
| Viewing file: Select action/file-type: X Version 11, Release 7.7 Version 1.0 Copyright © 1989, 1990, 1991 Hewlett-Packard Company, Ardent Computer Permission to use, copy, modify, and distribute this documentation for any purpose and without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. Ardent and Hewlett-Packard make no representations about the suitability for any purpose of the information in this document. It is provided "as is" without express or implied warranty. Copyright © 1989, 1990, 1991, 1992 X Consortium Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘‘Software’’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of the X Consortium shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from the X Consortium. X Window System is a trademark of The Open Group. Table of Contents Table of Contents This document describes an extension to the X11 server. The purpose of this extension is to support the use of additional input devices beyond the pointer and keyboard devices defined by the core X protocol. This first section gives an overview of the input extension. The following sections correspond to chapters 9, 10, and 11, ``Window and Session Manager Functions'', ``Events'', and ``Event Handling Functions'' of the ``Xlib - C Language Interface'' manual and describe how to use the input device extension. The design approach of the extension is to define functions and events analogous to the core functions and events. This allows extension input devices and events to be individually distinguishable from each other and from the core input devices and events. These functions and events make use of a device identifier and support the reporting of n-dimensional motion data as well as other data that is not currently reportable via the core input events. The X server core protocol supports two input devices: a pointer and a keyboard. The pointer device has two major functions. First, it may be used to generate motion information that client programs can detect. Second, it may also be used to indicate the current location and focus of the X keyboard. To accomplish this, the server echoes a cursor at the current position of the X pointer. Unless the X keyboard has been explicitly focused, this cursor also shows the current location and focus of the X keyboard. The X keyboard is used to generate input that client programs can detect.
The X keyboard and X pointer are referred to in this document as
the core devices, and the input
events they generate
Selection of the physical devices to be initially used by the server as the core devices is left implementation dependent. Functions are defined that allow client programs to change which physical devices are used as the core devices.
The input extension controls access to input devices other than the X keyboard
and X pointer. It allows client programs to select input from these devices
independently
from each other and independently from the core devices. Input events from
these devices are of extension types
Extension input events are not limited in size by the size of the server 32-byte wire events. Extension input events may be constructed by the server sending as many wire-sized events as necessary to return the information required for that event. The library event reformatting routines are responsible for combining these into one or more client XEvents. Any input device that generates key, button, or motion data may be used as an extension input device. Extension input devices may have zero or more keys, zero or more buttons, and may report zero or more axes of motion. Motion may be reported as relative movements from a previous position or as an absolute position. All valuators reporting motion information for a given extension input device must report the same kind of motion information (absolute or relative). This extension is designed to accommodate new types of input devices that may be added in the future. The protocol requests that refer to specific characteristics of input devices organize that information by input device classes. Server implementors may add new classes of input devices without changing the protocol requests. All extension input devices are treated like the core X keyboard in determining their location and focus. The server does not track the location of these devices on an individual basis and, therefore, does not echo a cursor to indicate their current location. Instead, their location is determined by the location of the core X pointer. Like the core X keyboard, some may be explicitly focused. If they are not explicitly focused, their focus is determined by the location of the core X pointer. Some of the input extension requests divide input devices into classes based on their functionality. This is intended to allow new classes of input devices to be defined at a later time without changing the semantics of these functions. The following input device classes are currently defined:
Additional classes may be added in the future.
Functions that support multiple input classes, such as the
A client that wishes to access an input device does so through the library functions defined in the following sections. A typical sequence of requests that a client would make is as follows:
Other requests are defined to grab and focus extension devices, to change their key, button, or modifier mappings, to control the propagation of input extension events, to get motion history from an extension device, and to send input extension events to another client. These functions are described in the following sections.
Extension input devices are accessed by client programs through the
use of new protocol requests.
The following requests are provided as extensions to Xlib. Constants
and structures referenced by these functions may be found in the
files
The library will return Input extension requests cannot be used to access the X keyboard and X pointer devices. This section discusses the following X Input Extension Window Manager topics:
These functions are provided to change which physical device is used as the X pointer or X keyboard. Note
Using these functions may change the characteristics of the core devices.
The new pointer device may have a different number of buttons from the
old one, or the new keyboard device may have a different number of
keys or report a different range of keycodes. Client programs may be
running that depend on those characteristics. For example, a client
program could allocate an array based on the number of buttons on the
pointer device and then use the button numbers received in button events
as indices into that array. Changing the core devices could cause
such client programs to behave improperly or to terminate abnormally
if they ignore the
These functions change the X keyboard or X pointer device and generate an
These requests fail and return
These requests fail with a
Once the device has successfully replaced one of the core devices, it
is treated as a core device until it is in turn replaced by another
To change which physical device is used as the X keyboard, use the
If no error occurs,
To change which physical device is used as the X pointer,
use the
If the specified device reports absolute positional information, and the
server implementation does not allow such a device to be used as the
X pointer, the request will fail with a
If no error occurs,
Implementation of the input extension requires an extension of the meaning of event synchronization for the core grab requests. This is necessary in order to allow window managers to freeze all input devices with a single request.
The core grab requests require a pointer_mode and keyboard_mode
argument. The meaning of these modes is changed by the input extension.
For the
Active grabs of
extension devices are supported via the
Passive grabs of buttons and keys on extension devices are supported
via the
To grab an extension device, use the
The event_list parameter is a pointer to a list of event classes. This list
indicates which events the client wishes to receive while the grab is active.
If owner_events is
The this_device_mode argument controls the further processing of events from this device, and the other_device_mode argument controls the further processing of input events from all other devices.
If a grabbed device is closed by a client while an active grab by that client is in effect, that active grab will be released. Any passive grabs established by that client will be released. If the device is frozen only by an active grab of the requesting client, it is thawed.
To release a grab of an extension device, use the
To passively grab a single key on an extension device, use
The interpretation of the remaining arguments is as for
Note that the logical state of a device (as seen by means of the X protocol) may lag the physical state if device event processing is frozen.
A modifier of
To release a passive grab of a single key on an extension device, use
To establish a passive grab for a single button on an extension device, use
The
The interpretation of the remaining arguments is as for
Note that the logical state of a device (as seen by means of the X protocol) may lag the physical state if device event processing is frozen.
A modifier of
To release a passive grab of a button on an extension device, use
A modifier of
To allow further events to be processed when a device has been frozen, use
It is possible for several grabs of different devices (by the same or different clients) to be active simultaneously. If a device is frozen on behalf of any grab, no event processing is performed for the device. It is possible for a single device to be frozen because of several grabs. In this case, the freeze must be released on behalf of each grab before events can again be processed.
The current focus window for an extension input device can be
determined using the
To get the current focus state, revert state,
and focus time of an extension device, use
To set the focus of an extension device, use
The action taken by the server when this function is requested depends on the value of the focus argument:
The specified focus window must be viewable at the time
When the focus reverts,
the X server generates
To determine the current feedback settings of an extension input device, use
typedef struct {
XID class;
int length;
XID id;
} XFeedbackState;
The common members are as follows:
Those feedbacks equivalent to those
supported by the core keyboard are reported in class
typedef struct {
XID class;
int length;
XID id;
int click;
int percent;
int pitch;
int duration;
int led_mask;
int global_auto_repeat;
char auto_repeats[32];
} XKbdFeedbackState;
The additional members of the
Those feedbacks equivalent to those
supported by the core pointer are reported in class
typedef struct {
XID class;
int length;
XID id;
int accelNum;
int accelDenom;
int threshold;
} XPtrFeedbackState;
The additional members of the
Integer feedbacks are those capable of displaying integer numbers
and reported via the
typedef struct {
XID class;
int length;
XID id;
int resolution;
int minVal;
int maxVal;
} XIntegerFeedbackState;
The additional members of the
String feedbacks are those that can display character information
and are reported via the
typedef struct {
XID class;
int length;
XID id;
int max_symbols;
int num_syms_supported;
KeySym *syms_supported;
} XStringFeedbackState;
The additional members of the
Bell feedbacks are those that can generate a sound
and are reported via the
typedef struct {
XID class;
int length;
XID id;
int percent;
int pitch;
int duration;
} XBellFeedbackState;
Led feedbacks are those that can generate a light and are reported via the
typedef struct {
XID class;
int length;
XID id;
Mask led_values;
Mask led_mask;
} XLedFeedbackState;
To free the information returned by the
To change the settings of a feedback on an extension device, use
typedef struct {
XID class;
int length;
XID id;
} XFeedbackControl;
Feedback class
typedef struct {
XID class;
int length;
XID id;
int click;
int percent;
int pitch;
int duration;
int led_mask;
int led_value;
int key;
int auto_repeat_mode;
} XKbdFeedbackControl;
This class controls the device characteristics described by the
Valid masks are as follows: #define DvKeyClickPercent (1><<0) #define DvPercent (1><<0) #define DvPitch (1><<0) #define DvDuration (1><<0) #define DvLed (1><<0) #define DvLedMode (1><<0) #define DvKey (1><<0) #define DvAutoRepeatMode (1><<0)
Feedback class
typedef struct {
XID class;
int length;
XID id;
int accelNum;
int accelDenom;
int threshold;
} XPtrFeedbackControl;
Which values are modified depends on the valuemask passed. Valid masks are as follows: #define DvAccelnum (1L<<0) #define DvAccelDenom (1L<<1) #define DvThreshold (1L<<2)
The acceleration, expressed as a fraction, is a multiplier for movement.
For example,
specifying 3/1 means that the device moves three times as fast as normal.
The fraction may be rounded arbitrarily by the X server.
Acceleration takes effect only if the device moves more than threshold pixels at
once and applies only to the amount beyond the value in the threshold argument.
Setting a value to -1 restores the default.
The values of the accelNumerator and threshold fields must be nonzero for
the pointer values to be set.
Otherwise, the parameters will be unchanged.
Negative values generate a
This request fails with a
Feedback class
typedef struct {
XID class;
int length;
XID id;
int int_to_display;
} XIntegerFeedbackControl;
Valid masks are as follows: #define DvInteger (1L<<0)
Feedback class
typedef struct {
XID class;
int length;
XID id;
int num_keysyms;
KeySym *syms_to_display;
} XStringFeedbackControl;
Valid masks are as follows: #define DvString (1L<<0)
Feedback class
typedef struct {
XID class;
int length;
XID id;
int percent;
int pitch;
int duration;
} XBellFeedbackControl;
Valid masks are as follows: #define DvPercent (1L<<1) #define DvPitch (1L<<2) #define DvDuration (1L<<3)
Feedback class
typedef struct {
XID class;
int length;
XID id;
int led_mask;
int led_values;
} XLedFeedbackControl;
Valid masks are as follows: #define DvLed (1L<<4) #define DvLedMode (1L<<5)
To ring a bell on an extension input device, use
base - [(base * percent) / 100] + percent
The volume at which the bell rings when the percent argument is negative is:
base + [(base * percent) / 100]
To change the base volume of the bell, use
To get the key mapping of an extension device that supports input class
first_keycode_wanted + keycode_count - 1
must be less than or equal to max-keycode as returned
by the
The number of elements in the keysyms list is as follows: keycode_count * keysyms_per_keycode_return And KEYSYM number N (counting from zero) for keycode K has an index (counting from zero), in keysyms, of the following: (K - first_keycode_wanted) * keysyms_per_keycode_return + N
The keysyms_per_keycode_return value is chosen arbitrarily by the server
to be large enough to report all requested symbols.
A special KEYSYM value of
To free the data returned by this function, use
If the specified device has not first been opened by this client via
To change the keyboard mapping of an extension device that supports input class
If the specified device has not first been opened by this client via
The number of elements in the keysyms list must be a multiple of
keysyms_per_keycode. Otherwise,
first_keycode + (num_codes / keysyms_per_keycode) - 1
To obtain the keycodes that are used as modifiers on an
extension device that supports input class
To set which keycodes are to be used as modifiers for an extension device, use
A X server can impose restrictions on how modifiers can be changed,
for example,
if certain keys do not generate up transitions in hardware or if multiple
modifier keys are not supported.
If some such restriction is violated,
the status reply is
To set the mapping of the buttons on an extension device, use
To get the button mapping, use
To obtain information that describes the state of the keys, buttons, and
valuators of an extension device, use
typedef struct {
XID device_id;
int num_classes;
XInputClass *data;
} XDeviceState;
The structures are of variable length, but the first two members are common to all and are as follows:
typedef struct {
unsigned char class;
unsigned char length;
} XInputClass;
The class member contains a class identifier. This identifier can be
compared with constants defined in the file
The length member contains the length of the structure and can be used by clients to traverse the list.
The
DeviceMode 1 << 0 Relative = 0, Absolute = 1
ProximityState 1 << 1 InProximity = 0, OutOfProximity = 1
The valuators member contains a pointer to an array of integers that
describe the current value of the valuators.
If the mode is
typedef struct {
unsigned char class;
unsigned char length;
unsigned char num_valuators;
unsigned char mode;
int *valuators;
} XValuatorState;
The
typedef struct {
unsigned char class;
unsigned char length;
short num_keys;
char keys[32];
} XKeyState;
The
typedef struct {
unsigned char class;
unsigned char length;
short num_buttons;
char buttons[32];
} XButtonState;
To free the data returned by this function, use
The input extension creates input events analogous to the core input events. These extension input events are generated by manipulating one of the extension input devices. The remainder of this section discusses the following X Input Extension event topics:
Event types are integer numbers that a client can use to determine what kind of event it has received. The client compares the type field of the event structure with known event types to make this determination.
The core input event types are constants and are defined in the header file
The client program determines the event type for an extension event by using
the information returned by the
Extension events propagate up the window hierarchy in the same manner as core events. If a window is not interested in an extension event, it usually propagates to the closest ancestor that is interested, unless the dont_propagate list prohibits it. Grabs of extension devices may alter the set of windows that receive a particular extension event. The following table lists the event category and its associated event type or types.
Event classes are integer numbers that are used in the same way as the core event masks. They are used by a client program to indicate to the server which events that client program wishes to receive.
The core input event masks are constants and are defined in the header file
The event class for an extension event and device is obtained from
information returned by the
For
If any client has specified the
If only the
The client may also select
Each extension event type has a corresponding structure declared in
Extension event structures report the current position of the X pointer. In addition, if the device reports motion data and is reporting absolute data, the current value of any valuators the device contains is also reported.
Key events from extension devices contain all the information that is
contained in a key event from the X keyboard. In addition, they contain
a device ID and report the current value of any valuators on the device,
if that device is reporting absolute data.
If data for more than six valuators is being reported, more than one
key event will be sent.
The axes_count member contains the number of axes that are being
reported. The server sends as many of these events as are
needed to report the device data. Each event contains the total number
of axes reported in the axes_count member and the first axis reported
in the current event in the first_axis member.
If the device supports input class
The location reported in the x, y and x_root, y_root members is the location of the core X pointer.
The
typedef struct {
int type; /* of event */
unsigned long serial; /* # of last request processed */
Bool send_event; /* true if from SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window reported relative to */
XID deviceid;
Window root; /* root window event occurred on */
Window subwindow; /* child window */
Time time; /* milliseconds */
int x, y; /* x, y coordinates in event window */
int x_root; /* coordinates relative to root */
int y_root; /* coordinates relative to root */
unsigned int state; /* key or button mask */
unsigned int keycode; /* detail */
Bool same_screen; /* same screen flag */
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XDeviceKeyEvent;
typedef XDeviceKeyEvent XDeviceKeyPressedEvent;
typedef XDeviceKeyEvent XDeviceKeyReleasedEvent;
Button events from extension devices contain all the information that is
contained in a button event from the X pointer. In addition, they contain
a device ID and report the current value of any valuators on the device
if that device is reporting absolute data.
If data for more than six valuators is being reported, more than one
button event may be sent.
The axes_count member contains the number of axes that are being
reported. The server sends as many of these events as are
needed to report the device data. Each event contains the total number
of axes reported in the axes_count member and the first axis reported
in the current event in the first_axis member.
If the device supports input class
The location reported in the x, y and x_root, y_root members is the location of the core X pointer.
typedef struct {
int type; /* of event */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window reported relative to */
XID deviceid;
Window root; /* root window that the event occurred on */
Window subwindow; /* child window */
Time time; /* milliseconds */
int x, y; /* x, y coordinates in event window */
int x_root; /* coordinates relative to root */
int y_root; /* coordinates relative to root */
unsigned int state; /* key or button mask */
unsigned int button; /* detail */
Bool same_screen; /* same screen flag */
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XDeviceButtonEvent;
typedef XDeviceButtonEvent XDeviceButtonPressedEvent;
typedef XDeviceButtonEvent XDeviceButtonReleasedEvent;
Motion events from extension devices contain all the information that is contained in a motion event from the X pointer. In addition, they contain a device ID and report the current value of any valuators on the device. The location reported in the x, y and x_root, y_root members is the location of the core X pointer, and so is 2-dimensional. Extension motion devices may report motion data for a variable number of axes. The axes_count member contains the number of axes that are being reported. The server sends as many of these events as are needed to report the device data. Each event contains the total number of axes reported in the axes_count member and the first axis reported in the current event in the first_axis member.
typedef struct {
int type; /* of event */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window reported relative to */
XID deviceid;
Window root; /* root window that the event occurred on */
Window subwindow; /* child window */
Time time; /* milliseconds */
int x, y; /* x, y coordinates in event window */
int x_root; /* coordinates relative to root */
int y_root; /* coordinates relative to root */
unsigned int state; /* key or button mask */
char is_hint; /* detail */
Bool same_screen; /* same screen flag */
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XDeviceMotionEvent;
These events are equivalent to the core focus events. They contain the same information, with the addition of a device ID to identify which device has had a focus change, and a timestamp.
typedef struct {
int type; /* of event */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if this came from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window it is reported relative to */
XID deviceid;
int mode; /* NotifyNormal, NotifyGrab, NotifyUngrab */
int detail;
/*
* NotifyAncestor, NotifyVirtual, NotifyInferior,
* NotifyNonLinear,NotifyNonLinearVirtual, NotifyPointer,
* NotifyPointerRoot, NotifyDetailNone
*/
Time time;
} XDeviceFocusChangeEvent;
typedef XDeviceFocusChangeEvent XDeviceFocusInEvent;
typedef XDeviceFocusChangeEvent XDeviceFocusOutEvent;
This event is analogous to the core keymap event but
reports the current state of the device for each
input class that it supports.
It is generated after every
If the device supports input class
0x01 Relative = 0, Absolute = 1
0x02 InProximity = 0, OutOfProximity = 1
If the device supports more valuators than can be reported in a single
typedef struct {
unsigned char class;
unsigned char length;
} XInputClass;
typedef struct {
int type;
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if this came from a SendEvent request */
Display *display; /* Display the event was read from */
Window window;
XID deviceid;
Time time;
int num_classes;
char data[64];
} XDeviceStateNotifyEvent;
typedef struct {
unsigned char class;
unsigned char length;
unsigned char num_valuators;
unsigned char mode;
int valuators[6];
} XValuatorStatus;
typedef struct {
unsigned char class;
unsigned char length;
short num_keys;
char keys[32];
} XKeyStatus;
typedef struct {
unsigned char class;
unsigned char length;
short num_buttons;
char buttons[32];
} XButtonStatus;
This event is equivalent to the core
typedef struct {
int type;
unsigned long serial;
Bool send_event;
Display *display;
Window window;
XID deviceid;
Time time;
int request;
int first_keycode;
int count;
} XDeviceMappingEvent;
This event has no equivalent in the core protocol. It notifies client programs when one of the core devices has been changed.
typedef struct {
int type;
unsigned long serial;
Bool send_event;
Display *display;
Window window;
XID deviceid;
Time time;
int request;
} XChangeDeviceNotifyEvent;
These events have no equivalent in the core protocol. Some input devices such as graphics tablets or touchscreens may send these events to indicate that a stylus has moved into or out of contact with a positional sensing surface.
The event contains the current value of any valuators on the device
if that device is reporting absolute data.
If data for more than six valuators is being reported, more than one
proximity event may be sent.
The axes_count member contains the number of axes that are being
reported. The server sends as many of these events as are
needed to report the device data. Each event contains the total number
of axes reported in the axes_count member and the first axis reported
in the current event in the first_axis member.
If the device supports input class
typedef struct {
int type; /* ProximityIn or ProximityOut */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if this came from a SendEvent request */
Display *display; /* Display the event was read from */
Window window;
XID deviceid;
Window root;
Window subwindow;
Time time;
int x, y;
int x_root, y_root;
unsigned int state;
Bool same_screen;
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XProximityNotifyEvent;
typedef XProximityNotifyEvent XProximityInEvent;
typedef XProximityNotifyEvent XProximityOutEvent;
This section discusses the X Input Extension event handling functions that allow you to:
The
typedef struct {
Bool present;
short major_version;
short minor_version;
} XExtensionVersion;
The major and minor versions can be compared with constants defined in
the header file
You should use
A client program that wishes to access a specific device
must first determine whether that device is connected to the X server. This
is done through the
The X pointer device and X keyboard device are reported, as well as
all available extension input devices. The use member of the
Each
If the device supports input class
The
typedef struct _XDeviceInfo {
XID id;
Atom type;
char *name;
int num_classes;
int use;
XAnyClassPtr inputclassinfo;
} XDeviceInfo;
The structures pointed to by the
typedef struct _XKeyInfo {
XID class;
int length;
unsigned short min_keycode;
unsigned short max_keycode;
unsigned short num_keys;
} XKeyInfo;
typedef struct _XButtonInfo {
XID class;
int length;
short num_buttons;
} XButtonInfo;
typedef struct _XValuatorInfo {
XID class;
int length;
unsigned char num_axes;
unsigned char mode;
unsigned long motion_buffer;
XAxisInfoPtr axes;
} XValuatorInfo;
The
typedef struct _XAxisInfo {
int resolution;
int min_value;
int max_value;
} XAxisInfo;
The following atom names are defined in the
MOUSE QUADRATURE TABLET SPACEBALL KEYBOARD DATAGLOVE TOUCHSCREEN EYETRACKER TOUCHPAD CURSORKEYS BUTTONBOX FOOTMOUSE BARCODE ID_MODULE KNOB_BOX ONE_KNOB TRACKBALL NINE_KNOB\s+1
These names can be used in an
To free the data returned by
Each client program that wishes to access an extension device must request
that the server open that device by calling the
typedef struct {
XID device_id;
int num_classes;
XInputClassInfo *classes;
} XDevice;
The
The
typedef struct {
unsigned char input_class;
unsigned char event_type_base;
} XInputClassInfo;
A client program can determine the event type and event class for a given event by using macros defined by the input extension. The name of the macro corresponds to the desired event, and the macro is passed the structure that describes the device from which input is desired, for example:
DeviceKeyPress(XDevice *device, event_type, event_class)
The macro will fill in the values of the event class to be used in an
Before terminating, the client program should request that the server close
the device by calling the
A client may open the same extension device more than once. Requests
after the first successful one return an additional
Closing a device releases any active or passive grabs the requesting client has established. If the device is frozen only by an active grab of the requesting client, any queued events are released. If a client program terminates without closing a device, the server will automatically close that device on behalf of the client. This does not affect any other clients that may be accessing that device.
Some devices are capable of reporting either relative or absolute motion
data.
To change the mode of a device from relative to absolute, use
This request will fail and return
Some devices that report absolute positional data can be initialized to a
starting value. Devices that are capable of reporting relative motion or
absolute positional data may require that their valuators be initialized
to a starting value after the mode of the device is changed to
To initialize the valuators on such a device, use
first_valuator + num_valuators
If the request succeeds,
Some input devices support various configuration controls that can be queried or changed by clients. The set of supported controls will vary from one input device to another. Requests to manipulate these controls will fail if either the target X server or the target input device does not support the requested device control. Each device control has a unique identifier. Information passed with each device control varies in length and is mapped by data structures unique to that device control.
To query a device control, use
If the request is successful, a pointer to a generic
typedef struct {
XID control;
int length;
} XDeviceState;
\fP
The control may be compared to constants defined in the file
The information returned for the DEVICE_RESOLUTION control is
defined in the
typedef struct {
XID control;
int length;
int num_valuators;
int *resolutions;
int *min_resolutions;
int *max_resolutions;
} XDeviceResolutionState;
This device control returns a list of valuators and the range of valid resolutions allowed for each. Valuators are numbered beginning with zero (0). Resolutions for all valuators on the device are returned. For each valuator i on the device, resolutions[i] returns the current setting of the resolution, min_resolutions[i] returns the minimum valid setting, and max_resolutions[i] returns the maximum valid setting.
When this control is specified,
Some input devices support various configuration controls that can be changed by clients. Typically, this would be done to initialize the device to a known state or configuration. The set of supported controls will vary from one input device to another. Requests to manipulate these controls will fail if either the target X server or the target input device does not support the requested device control. Setting the device control will also fail if the target input device is grabbed by another client or is open by another client and has been set to a conflicting state. Each device control has a unique identifier. Information passed with each device control varies in length and is mapped by data structures unique to that device control.
To change a device control, use
If the request is successful, the device control will be changed
and a status of
typedef struct {
XID control;
int length;
} XDeviceControl;
The control may be set using constants defined in the
The information that can be changed by the DEVICE_RESOLUTION
control is defined in the
typedef struct {
XID control;
int length;
int first_valuator;
int num_valuators;
int *resolutions;
} XDeviceResolutionControl;
This device control changes the resolution of the specified valuators on the specified extension input device. Valuators are numbered beginning with zero. Only the valuators in the range specified by first_valuator and num_valuators are set. A value of -1 in the resolutions list indicates that the resolution for this valuator is not to be changed. The num_valuators member specifies the number of valuators in the resolutions list.
When this control is specified,
first_valuator + num_valuators,
To select device input events, use
DeviceKeyPress (XDevice *device, event_type, event_class)
Macros are defined for the following event classes:
To get the next available event from within a client program, use the core
Succeeding
To determine which extension events are currently selected from a given
window, use
Extension events propagate up the window hierarchy in the same manner as core events. If a window is not interested in an extension event, it usually propagates to the closest ancestor that is interested, unless the dont_propagate list prohibits it. Grabs of extension devices may alter the set of windows that receive a particular extension event.
Client programs may control event propagation through the use
of the following two functions:
Suppression of event propagation is not allowed for all events. If a
specified
To send an extension event to another client, use
To determine which clients should receive the specified events,
The event in the
The return type for this function is an
typedef struct {
Time time;
unsigned int *data;
} XDeviceTimeCoord;
The data member is a pointer to an array of data items. Each item is of type int, and there is one data item per axis of motion reported by the device. The number of axes reported by the device is returned in the axis_count variable.
The value of the data items depends on the mode of the device.
The mode is returned in the mode variable. If the
mode is
If the mode is
Consecutive calls to
To free the data returned by
The following information is contained in the
/* Definitions used by the library and client */
#ifndef _XINPUT_H_
#define _XINPUT_H_
#ifndef _XLIB_H_
#include <X11/Xlib.h>
#endif
#ifndef _XI_H_
#include "XI.h"
#endif
#define _deviceKeyPress 0
#define _deviceKeyRelease 1
#define _deviceButtonPress 0
#define _deviceButtonRelease 1
#define _deviceMotionNotify 0
#define _deviceFocusIn 0
#define _deviceFocusOut 1
#define _proximityIn 0
#define _proximityOut 1
#define _deviceStateNotify 0
#define _deviceMappingNotify 1
#define _changeDeviceNotify 2
#define FindTypeAndClass(d, type, class, classid, offset) \
{ int i; XInputClassInfo *ip; \
type = 0; class = 0; \
for (i=0, ip= ((XDevice *) d)->classes; \
i< ((XDevice *) d)->num_classes; \
i++, ip++) \
if (ip->input_class == classid) \
{type = ip->event_type_base + offset; \
class = ((XDevice *) d)->device_id << 8 | type;}}
#define DeviceKeyPress(d, type, class) \
FindTypeAndClass(d, type, class, KeyClass, _deviceKeyPress)
#define DeviceKeyRelease(d, type, class) \
FindTypeAndClass(d, type, class, KeyClass, _deviceKeyRelease)
#define DeviceButtonPress(d, type, class) \
FindTypeAndClass(d, type, class, ButtonClass, _deviceButtonPress)
#define DeviceButtonRelease(d, type, class) \
FindTypeAndClass(d, type, class, ButtonClass, _deviceButtonRelease)
#define DeviceMotionNotify(d, type, class) \
FindTypeAndClass(d, type, class, ValuatorClass, _deviceMotionNotify)
#define DeviceFocusIn(d, type, class) \
FindTypeAndClass(d, type, class, FocusClass, _deviceFocusIn)
#define DeviceFocusOut(d, type, class) \
FindTypeAndClass(d, type, class, FocusClass, _deviceFocusOut)
#define ProximityIn(d, type, class) \
FindTypeAndClass(d, type, class, ProximityClass, _proximityIn)
#define ProximityOut(d, type, class) \
FindTypeAndClass(d, type, class, ProximityClass, _proximityOut)
#define DeviceStateNotify(d, type, class) \
FindTypeAndClass(d, type, class, OtherClass, _deviceStateNotify)
#define DeviceMappingNotify(d, type, class) \
FindTypeAndClass(d, type, class, OtherClass, _deviceMappingNotify)
#define ChangeDeviceNotify(d, type, class) \
FindTypeAndClass(d, type, class, OtherClass, _changeDeviceNotify)
#define DevicePointerMotionHint(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _devicePointerMotionHint;}
#define DeviceButton1Motion(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceButton1Motion;}
#define DeviceButton2Motion(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceButton2Motion;}
#define DeviceButton3Motion(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceButton3Motion;}
#define DeviceButton4Motion(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceButton4Motion;}
#define DeviceButton5Motion(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceButton5Motion;}
#define DeviceButtonMotion(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceButtonMotion;}
#define DeviceOwnerGrabButton(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceOwnerGrabButton;}
#define DeviceButtonPressGrab(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _deviceButtonGrab;}
#define NoExtensionEvent(d, type, class) \
{ class = ((XDevice *) d)->device_id << 8 | _noExtensionEvent;}
#define BadDevice(dpy, error) _xibaddevice(dpy, &error)
#define BadClass(dpy, error) _xibadclass(dpy, &error)
#define BadEvent(dpy, error) _xibadevent(dpy, &error)
#define BadMode(dpy, error) _xibadmode(dpy, &error)
#define DeviceBusy(dpy, error) _xidevicebusy(dpy, &error)
/***************************************************************
*
* DeviceKey events. These events are sent by input devices that
* support input class Keys.
* The location of the X pointer is reported in the coordinate
* fields of the x,y and x_root,y_root fields.
*
*/
typedef struct
{
int type; /* of event */
unsigned long serial; /* # of last request processed */
Bool send_event; /* true if from SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window reported relative to */
XID deviceid;
Window root; /* root window event occured on */
Window subwindow; /* child window */
Time time; /* milliseconds */
int x, y; /* x, y coordinates in event window */
int x_root; /* coordinates relative to root */
int y_root; /* coordinates relative to root */
unsigned int state; /* key or button mask */
unsigned int keycode; /* detail */
Bool same_screen; /* same screen flag */
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XDeviceKeyEvent;
typedef XDeviceKeyEvent XDeviceKeyPressedEvent;
typedef XDeviceKeyEvent XDeviceKeyReleasedEvent;
/*******************************************************************
*
* DeviceButton events. These events are sent by extension devices
* that support input class Buttons.
*
*/
typedef struct {
int type; /* of event */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window reported relative to */
XID deviceid;
Window root; /* root window that the event occured on */
Window subwindow; /* child window */
Time time; /* milliseconds */
int x, y; /* x, y coordinates in event window */
int x_root; /* coordinates relative to root */
int y_root; /* coordinates relative to root */
unsigned int state; /* key or button mask */
unsigned int button; /* detail */
Bool same_screen; /* same screen flag */
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XDeviceButtonEvent;
typedef XDeviceButtonEvent XDeviceButtonPressedEvent;
typedef XDeviceButtonEvent XDeviceButtonReleasedEvent;
/*******************************************************************
*
* DeviceMotionNotify event. These events are sent by extension devices
* that support input class Valuators.
*
*/
typedef struct
{
int type; /* of event */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window reported relative to */
XID deviceid;
Window root; /* root window that the event occured on */
Window subwindow; /* child window */
Time time; /* milliseconds */
int x, y; /* x, y coordinates in event window */
int x_root; /* coordinates relative to root */
int y_root; /* coordinates relative to root */
unsigned int state; /* key or button mask */
char is_hint; /* detail */
Bool same_screen; /* same screen flag */
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XDeviceMotionEvent;
/*******************************************************************
*
* DeviceFocusChange events. These events are sent when the focus
* of an extension device that can be focused is changed.
*
*/
typedef struct
{
int type; /* of event */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* "event" window reported relative to */
XID deviceid;
int mode; /* NotifyNormal, NotifyGrab, NotifyUngrab */
int detail;
/*
* NotifyAncestor, NotifyVirtual, NotifyInferior,
* NotifyNonLinear,NotifyNonLinearVirtual, NotifyPointer,
* NotifyPointerRoot, NotifyDetailNone
*/
Time time;
} XDeviceFocusChangeEvent;
typedef XDeviceFocusChangeEvent XDeviceFocusInEvent;
typedef XDeviceFocusChangeEvent XDeviceFocusOutEvent;
/*******************************************************************
*
* ProximityNotify events. These events are sent by those absolute
* positioning devices that are capable of generating proximity information.
*
*/
typedef struct
{
int type; /* ProximityIn or ProximityOut */
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if this came from a SendEvent request */
Display *display; /* Display the event was read from */
Window window;
XID deviceid;
Window root;
Window subwindow;
Time time;
int x, y;
int x_root, y_root;
unsigned int state;
Bool same_screen;
unsigned int device_state; /* device key or button mask */
unsigned char axes_count;
unsigned char first_axis;
int axis_data[6];
} XProximityNotifyEvent;
typedef XProximityNotifyEvent XProximityInEvent;
typedef XProximityNotifyEvent XProximityOutEvent;
/*******************************************************************
*
* DeviceStateNotify events are generated on EnterWindow and FocusIn
* for those clients who have selected DeviceState.
*
*/
typedef struct
{
unsigned char class;
unsigned char length;
} XInputClass;
typedef struct {
int type;
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if this came from a SendEvent request */
Display *display; /* Display the event was read from */
Window window;
XID deviceid;
Time time;
int num_classes;
char data[64];
} XDeviceStateNotifyEvent;
typedef struct {
unsigned char class;
unsigned char length;
unsigned char num_valuators;
unsigned char mode;
int valuators[6];
} XValuatorStatus;
typedef struct {
unsigned char class;
unsigned char length;
short num_keys;
char keys[32];
} XKeyStatus;
typedef struct {
unsigned char class;
unsigned char length;
short num_buttons;
char buttons[32];
} XButtonStatus;
/*******************************************************************
*
* DeviceMappingNotify event. This event is sent when the key mapping,
* modifier mapping, or button mapping of an extension device is changed.
*
*/
typedef struct {
int type;
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if this came from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* unused */
XID deviceid;
Time time;
int request; /* one of MappingModifier, MappingKeyboard,
MappingPointer */
int first_keycode;/* first keycode */
int count; /* defines range of change w. first_keycode*/
} XDeviceMappingEvent;
/*******************************************************************
*
* ChangeDeviceNotify event. This event is sent when an
* XChangeKeyboard or XChangePointer request is made.
*
*/
typedef struct {
int type;
unsigned long serial; /* # of last request processed by server */
Bool send_event; /* true if this came from a SendEvent request */
Display *display; /* Display the event was read from */
Window window; /* unused */
XID deviceid;
Time time;
int request; /* NewPointer or NewKeyboard */
} XChangeDeviceNotifyEvent;
/*******************************************************************
*
* Control structures for input devices that support input class
* Feedback. These are used by the XGetFeedbackControl and
* XChangeFeedbackControl functions.
*
*/
typedef struct {
XID class;
int length;
XID id;
} XFeedbackState;
typedef struct {
XID class;
int length;
XID id;
int click;
int percent;
int pitch;
int duration;
int led_mask;
int global_auto_repeat;
char auto_repeats[32];
} XKbdFeedbackState;
typedef struct {
XID class;
int length;
XID id;
int accelNum;
int accelDenom;
int threshold;
} XPtrFeedbackState;
typedef struct {
XID class;
int length;
XID id;
int resolution;
int minVal;
int maxVal;
} XIntegerFeedbackState;
typedef struct {
XID class;
int length;
XID id;
int max_symbols;
int num_syms_supported;
KeySym *syms_supported;
} XStringFeedbackState;
typedef struct {
XID class;
int length;
XID id;
int percent;
int pitch;
int duration;
} XBellFeedbackState;
typedef struct {
XID class;
int length;
XID id;
int led_values;
int led_mask;
} XLedFeedbackState;
typedef struct {
XID class;
int length;
XID id;
} XFeedbackControl;
typedef struct {
XID class;
int length;
XID id;
int accelNum;
int accelDenom;
int threshold;
} XPtrFeedbackControl;
typedef struct {
XID class;
int length;
XID id;
int click;
int percent;
int pitch;
int duration;
int led_mask;
int led_value;
int key;
int auto_repeat_mode;
} XKbdFeedbackControl;
typedef struct {
XID class;
int length;
XID id;
int num_keysyms;
KeySym *syms_to_display;
} XStringFeedbackControl;
typedef struct {
XID class;
int length;
XID id;
int int_to_display;
} XIntegerFeedbackControl;
typedef struct {
XID class;
int length;
XID id;
int percent;
int pitch;
int duration;
} XBellFeedbackControl;
typedef struct {
XID class;
int length;
XID id;
int led_mask;
int led_values;
} XLedFeedbackControl;
/*******************************************************************
*
* Device control structures.
*
*/
typedef struct {
XID control;
int length;
} XDeviceControl;
typedef struct {
XID control;
int length;
int first_valuator;
int num_valuators;
int *resolutions;
} XDeviceResolutionControl;
typedef struct {
XID control;
int length;
int num_valuators;
int *resolutions;
int *min_resolutions;
int *max_resolutions;
} XDeviceResolutionState;
/*******************************************************************
*
* An array of XDeviceList structures is returned by the
* XListInputDevices function. Each entry contains information
* about one input device. Among that information is an array of
* pointers to structures that describe the characteristics of
* the input device.
*
*/
typedef struct _XAnyClassinfo *XAnyClassPtr;
typedef struct _XAnyClassinfo {
XID class;
int length;
} XAnyClassInfo;
typedef struct _XDeviceInfo *XDeviceInfoPtr;
typedef struct _XDeviceInfo
{
XID id;
Atom type;
char *name;
int num_classes;
int use;
XAnyClassPtr inputclassinfo;
} XDeviceInfo;
typedef struct _XKeyInfo *XKeyInfoPtr;
typedef struct _XKeyInfo
{
XID class;
int length;
unsigned short min_keycode;
unsigned short max_keycode;
unsigned short num_keys;
} XKeyInfo;
typedef struct _XButtonInfo *XButtonInfoPtr;
typedef struct _XButtonInfo {
XID class;
int length;
short num_buttons;
} XButtonInfo;
typedef struct _XAxisInfo *XAxisInfoPtr;
typedef struct _XAxisInfo {
int resolution;
int min_value;
int max_value;
} XAxisInfo;
typedef struct _XValuatorInfo *XValuatorInfoPtr;
typedef struct _XValuatorInfo
{
XID class;
int length;
unsigned char num_axes;
unsigned char mode;
unsigned long motion_buffer;
XAxisInfoPtr axes;
} XValuatorInfo;
/*******************************************************************
*
* An XDevice structure is returned by the XOpenDevice function.
* It contains an array of pointers to XInputClassInfo structures.
* Each contains information about a class of input supported by the
* device, including a pointer to an array of data for each type of event
* the device reports.
*
*/
typedef struct {
unsigned char input_class;
unsigned char event_type_base;
} XInputClassInfo;
typedef struct {
XID device_id;
int num_classes;
XInputClassInfo *classes;
} XDevice;
/*******************************************************************
*
* The following structure is used to return information for the
* XGetSelectedExtensionEvents function.
*
*/
typedef struct {
XEventClass event_type;
XID device;
} XEventList;
/*******************************************************************
*
* The following structure is used to return motion history data from
* an input device that supports the input class Valuators.
* This information is returned by the XGetDeviceMotionEvents function.
*
*/
typedef struct {
Time time;
int *data;
} XDeviceTimeCoord;
/*******************************************************************
*
* Device state structure.
* This is returned by the XQueryDeviceState request.
*
*/
typedef struct {
XID device_id;
int num_classes;
XInputClass *data;
} XDeviceState;
/*******************************************************************
*
* Note that the mode field is a bitfield that reports the Proximity
* status of the device as well as the mode. The mode field should
* be OR'd with the mask DeviceMode and compared with the values
* Absolute and Relative to determine the mode, and should be OR'd
* with the mask ProximityState and compared with the values InProximity
* and OutOfProximity to determine the proximity state.
*
*/
typedef struct {
unsigned char class;
unsigned char length;
unsigned char num_valuators;
unsigned char mode;
int *valuators;
} XValuatorState;
typedef struct {
unsigned char class;
unsigned char length;
short num_keys;
char keys[32];
} XKeyState;
typedef struct {
unsigned char class;
unsigned char length;
short num_buttons;
char buttons[32];
} XButtonState;
/*******************************************************************
*
* Function definitions.
*
*/
_XFUNCPROTOBEGIN
extern int XChangeKeyboardDevice(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */
#endif
);
extern int XChangePointerDevice(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int /* xaxis */,
int /* yaxis */
#endif
);
extern int XGrabDevice(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
Window /* grab_window */,
Bool /* ownerEvents */,
int /* event count */,
XEventClass* /* event_list */,
int /* this_device_mode */,
int /* other_devices_mode */,
Time /* time */
#endif
);
extern int XUngrabDevice(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
Time /* time */
#endif
);
extern int XGrabDeviceKey(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
unsigned int /* key */,
unsigned int /* modifiers */,
XDevice* /* modifier_device */,
Window /* grab_window */,
Bool /* owner_events */,
unsigned int /* event_count */,
XEventClass* /* event_list */,
int /* this_device_mode */,
int /* other_devices_mode */
#endif
);
extern int XUngrabDeviceKey(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
unsigned int /* key */,
unsigned int /* modifiers */,
XDevice* /* modifier_dev */,
Window /* grab_window */
#endif
);
extern int XGrabDeviceButton(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
unsigned int /* button */,
unsigned int /* modifiers */,
XDevice* /* modifier_device */,
Window /* grab_window */,
Bool /* owner_events */,
unsigned int /* event_count */,
XEventClass* /* event_list */,
int /* this_device_mode */,
int /* other_devices_mode */
#endif
);
extern int XUngrabDeviceButton(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
unsigned int /* button */,
unsigned int /* modifiers */,
XDevice* /* modifier_dev */,
Window /* grab_window */
#endif
);
extern int XAllowDeviceEvents(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int /* event_mode */,
Time /* time */
#endif
);
extern int XGetDeviceFocus(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
Window* /* focus */,
int* /* revert_to */,
Time* /* time */
#endif
);
extern int XSetDeviceFocus(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
Window /* focus */,
int /* revert_to */,
Time /* time */
#endif
);
extern XFeedbackState *XGetFeedbackControl(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int* /* num_feedbacks */
#endif
);
extern int XFreeFeedbackList(
#if NeedFunctionPrototypes
XFeedbackState* /* list */
#endif
);
extern int XChangeFeedbackControl(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
unsigned long /* mask */,
XFeedbackControl* /* f */
#endif
);
extern int XDeviceBell(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
XID /* feedbackclass */,
XID /* feedbackid */,
int /* percent */
#endif
);
extern KeySym *XGetDeviceKeyMapping(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
#if NeedWidePrototypes
unsigned int /* first */,
#else
KeyCode /* first */,
#endif
int /* keycount */,
int* /* syms_per_code */
#endif
);
extern int XChangeDeviceKeyMapping(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int /* first */,
int /* syms_per_code */,
KeySym* /* keysyms */,
int /* count */
#endif
);
extern XModifierKeymap *XGetDeviceModifierMapping(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */
#endif
);
extern int XSetDeviceModifierMapping(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
XModifierKeymap* /* modmap */
#endif
);
extern int XSetDeviceButtonMapping(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
unsigned char* /* map[] */,
int /* nmap */
#endif
);
extern int XGetDeviceButtonMapping(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
unsigned char* /* map[] */,
unsigned int /* nmap */
#endif
);
extern XDeviceState *XQueryDeviceState(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */
#endif
);
extern int XFreeDeviceState(
#if NeedFunctionPrototypes
XDeviceState* /* list */
#endif
);
extern XExtensionVersion *XGetExtensionVersion(
#if NeedFunctionPrototypes
Display* /* display */,
_Xconst char* /* name */
#endif
);
extern XDeviceInfo *XListInputDevices(
#if NeedFunctionPrototypes
Display* /* display */,
int* /* ndevices */
#endif
);
extern int XFreeDeviceList(
#if NeedFunctionPrototypes
XDeviceInfo* /* list */
#endif
);
extern XDevice *XOpenDevice(
#if NeedFunctionPrototypes
Display* /* display */,
XID /* id */
#endif
);
extern int XCloseDevice(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */
#endif
);
extern int XSetDeviceMode(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int /* mode */
#endif
);
extern int XSetDeviceValuators(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int* /* valuators */,
int /* first_valuator */,
int /* num_valuators */
#endif
);
extern XDeviceControl *XGetDeviceControl(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int /* control */
#endif
);
extern int XChangeDeviceControl(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
int /* control */,
XDeviceControl* /* d */
#endif
);
extern int XSelectExtensionEvent(
#if NeedFunctionPrototypes
Display* /* display */,
Window /* w */,
XEventClass* /* event_list */,
int /* count */
#endif
);
extern int XGetSelectedExtensionEvents(
#if NeedFunctionPrototypes
Display* /* display */,
Window /* w */,
int* /* this_client_count */,
XEventClass** /* this_client_list */,
int* /* all_clients_count */,
XEventClass** /* all_clients_list */
#endif
);
extern int XChangeDeviceDontPropagateList(
#if NeedFunctionPrototypes
Display* /* display */,
Window /* window */,
int /* count */,
XEventClass* /* events */,
int /* mode */
#endif
);
extern XEventClass *XGetDeviceDontPropagateList(
#if NeedFunctionPrototypes
Display* /* display */,
Window /* window */,
int* /* count */
#endif
);
extern Status XSendExtensionEvent(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
Window /* dest */,
Bool /* prop */,
int /* count */,
XEventClass* /* list */,
XEvent* /* event */
#endif
);
extern XDeviceTimeCoord *XGetDeviceMotionEvents(
#if NeedFunctionPrototypes
Display* /* display */,
XDevice* /* device */,
Time /* start */,
Time /* stop */,
int* /* nEvents */,
int* /* mode */,
int* /* axis_count */
#endif
);
extern int XFreeDeviceMotionEvents(
#if NeedFunctionPrototypes
XDeviceTimeCoord* /* events */
#endif
);
extern int XFreeDeviceControl(
#if NeedFunctionPrototypes
XDeviceControl* /* control */
#endif
);
_XFUNCPROTOEND
#endif /* _XINPUT_H_ */
/* Definitions used by the server, library and client */
#ifndef _XI_H_
#define _XI_H_
#define sz_xGetExtensionVersionReq 8
#define sz_xGetExtensionVersionReply 32
#define sz_xListInputDevicesReq 4
#define sz_xListInputDevicesReply 32
#define sz_xOpenDeviceReq 8
#define sz_xOpenDeviceReply 32
#define sz_xCloseDeviceReq 8
#define sz_xSetDeviceModeReq 8
#define sz_xSetDeviceModeReply 32
#define sz_xSelectExtensionEventReq 12
#define sz_xGetSelectedExtensionEventsReq 8
#define sz_xGetSelectedExtensionEventsReply 32
#define sz_xChangeDeviceDontPropagateListReq 12
#define sz_xGetDeviceDontPropagateListReq 8
#define sz_xGetDeviceDontPropagateListReply 32
#define sz_xGetDeviceMotionEventsReq 16
#define sz_xGetDeviceMotionEventsReply 32
#define sz_xChangeKeyboardDeviceReq 8
#define sz_xChangeKeyboardDeviceReply 32
#define sz_xChangePointerDeviceReq 8
#define sz_xChangePointerDeviceReply 32
#define sz_xGrabDeviceReq 20
#define sz_xGrabDeviceReply 32
#define sz_xUngrabDeviceReq 12
#define sz_xGrabDeviceKeyReq 20
#define sz_xGrabDeviceKeyReply 32
#define sz_xUngrabDeviceKeyReq 16
#define sz_xGrabDeviceButtonReq 20
#define sz_xGrabDeviceButtonReply 32
#define sz_xUngrabDeviceButtonReq 16
#define sz_xAllowDeviceEventsReq 12
#define sz_xGetDeviceFocusReq 8
#define sz_xGetDeviceFocusReply 32
#define sz_xSetDeviceFocusReq 16
#define sz_xGetFeedbackControlReq 8
#define sz_xGetFeedbackControlReply 32
#define sz_xChangeFeedbackControlReq 12
#define sz_xGetDeviceKeyMappingReq 8
#define sz_xGetDeviceKeyMappingReply 32
#define sz_xChangeDeviceKeyMappingReq 8
#define sz_xGetDeviceModifierMappingReq 8
#define sz_xSetDeviceModifierMappingReq 8
#define sz_xSetDeviceModifierMappingReply 32
#define sz_xGetDeviceButtonMappingReq 8
#define sz_xGetDeviceButtonMappingReply 32
#define sz_xSetDeviceButtonMappingReq 8
#define sz_xSetDeviceButtonMappingReply 32
#define sz_xQueryDeviceStateReq 8
#define sz_xQueryDeviceStateReply 32
#define sz_xSendExtensionEventReq 16
#define sz_xDeviceBellReq 8
#define sz_xSetDeviceValuatorsReq 8
#define sz_xSetDeviceValuatorsReply 32
#define sz_xGetDeviceControlReq 8
#define sz_xGetDeviceControlReply 32
#define sz_xChangeDeviceControlReq 8
#define sz_xChangeDeviceControlReply 32
#define INAME "XInputExtension"
#define XI_KEYBOARD "KEYBOARD"
#define XI_MOUSE "MOUSE"
#define XI_TABLET "TABLET"
#define XI_TOUCHSCREEN "TOUCHSCREEN"
#define XI_TOUCHPAD "TOUCHPAD"
#define XI_BARCODE "BARCODE"
#define XI_BUTTONBOX "BUTTONBOX"
#define XI_KNOB_BOX "KNOB_BOX"
#define XI_ONE_KNOB "ONE_KNOB"
#define XI_NINE_KNOB "NINE_KNOB"
#define XI_TRACKBALL "TRACKBALL"
#define XI_QUADRATURE "QUADRATURE"
#define XI_ID_MODULE "ID_MODULE"
#define XI_SPACEBALL "SPACEBALL"
#define XI_DATAGLOVE "DATAGLOVE"
#define XI_EYETRACKER "EYETRACKER"
#define XI_CURSORKEYS "CURSORKEYS"
#define XI_FOOTMOUSE "FOOTMOUSE"
#define Dont_Check 0
#define XInput_Initial_Release 1
#define XInput_Add_XDeviceBell 2
#define XInput_Add_XSetDeviceValuators 3
#define XInput_Add_XChangeDeviceControl 4
#define XI_Absent 0
#define XI_Present 1
#define XI_Initial_Release_Major 1
#define XI_Initial_Release_Minor 0
#define XI_Add_XDeviceBell_Major 1
#define XI_Add_XDeviceBell_Minor 1
#define XI_Add_XSetDeviceValuators_Major 1
#define XI_Add_XSetDeviceValuators_Minor 2
#define XI_Add_XChangeDeviceControl_Major 1
#define XI_Add_XChangeDeviceControl_Minor 3
#define DEVICE_RESOLUTION 1
#define NoSuchExtension 1
#define COUNT 0
#define CREATE 1
#define NewPointer 0
#define NewKeyboard 1
#define XPOINTER 0
#define XKEYBOARD 1
#define UseXKeyboard 0xFF
#define IsXPointer 0
#define IsXKeyboard 1
#define IsXExtensionDevice 2
#define AsyncThisDevice 0
#define SyncThisDevice 1
#define ReplayThisDevice 2
#define AsyncOtherDevices 3
#define AsyncAll 4
#define SyncAll 5
#define FollowKeyboard 3
#define RevertToFollowKeyboard 3
#define DvAccelNum (1L << 0)
#define DvAccelDenom (1L << 1)
#define DvThreshold (1L << 2)
#define DvKeyClickPercent (1L<<0)
#define DvPercent (1L<<1)
#define DvPitch (1L<<2)
#define DvDuration (1L<<3)
#define DvLed (1L<<4)
#define DvLedMode (1L<<5)
#define DvKey (1L<<6)
#define DvAutoRepeatMode (1L<<7)
#define DvString (1L << 0)
#define DvInteger (1L << 0)
#define DeviceMode (1L << 0)
#define Relative 0
#define Absolute 1
#define ProximityState (1L << 1)
#define InProximity (0L << 1)
#define OutOfProximity (1L << 1)
#define AddToList 0
#define DeleteFromList 1
#define KeyClass 0
#define ButtonClass 1
#define ValuatorClass 2
#define FeedbackClass 3
#define ProximityClass 4
#define FocusClass 5
#define OtherClass 6
#define KbdFeedbackClass 0
#define PtrFeedbackClass 1
#define StringFeedbackClass 2
#define IntegerFeedbackClass 3
#define LedFeedbackClass 4
#define BellFeedbackClass 5
#define _devicePointerMotionHint 0
#define _deviceButton1Motion 1
#define _deviceButton2Motion 2
#define _deviceButton3Motion 3
#define _deviceButton4Motion 4
#define _deviceButton5Motion 5
#define _deviceButtonMotion 6
#define _deviceButtonGrab 7
#define _deviceOwnerGrabButton 8
#define _noExtensionEvent 9
#define XI_BadDevice 0
#define XI_BadEvent 1
#define XI_BadMode 2
#define XI_DeviceBusy 3
#define XI_BadClass 4
typedef unsigned long XEventClass;
/*******************************************************************
*
* Extension version structure.
*
*/
typedef struct {
int present;
short major_version;
short minor_version;
} XExtensionVersion;
#endif /* _XI_H_ */
All numbers are in decimal, unless prefixed with #x, in which case they are in hexadecimal (base 16). The general syntax used to describe requests, replies, errors, events, and compound types is:
Each encode-form describes a single component. For components described in the protocol as:
name: TYPE the encode-form is:
N TYPE name N is the number of bytes occupied in the data stream, and TYPE is the interpretation of those bytes. For example,
depth: CARD8 becomes:
1 CARD8 depth For components with a static numeric value the encode-form is:
N value name The value is always interpreted as an N-byte unsigned integer. For example, the first two bytes of a Window error are always zero (indicating an error in general) and three (indicating the Window error in particular):
1 0 Error 1 3 code For components described in the protocol as:
name:
the encode-form is:
N name value1 Name1 ... valueI NameI The value is always interpreted as an N-byte unsigned integer. Note that the size of N is sometimes larger than that strictly required to encode the values. For example:
class:
becomes:
2 class 0 CopyFromParent 1 InputOutput 2 InputOnly For components described in the protocol as:
NAME: TYPE or
the encode-form is:
N TYPE NAME value1 Alternative1 ... valueI AlternativeI The alternative values are guaranteed not to conflict with the encoding of TYPE. For example:
destination: WINDOW or
becomes:
4 WINDOW destination 0 PointerWindow 1 InputFocus For components described in the protocol as:
value-mask: BITMASK the encode-form is:
N BITMASK value-mask mask1 mask-name1 ... maskI mask-nameI The individual bits in the mask are specified and named, and N is 2 or 4. The most-significant bit in a BITMASK is reserved for use in defining chained (multiword) bitmasks, as extensions augment existing core requests. The precise interpretation of this bit is not yet defined here, although a probable mechanism is that a 1-bit indicates that another N bytes of bitmask follows, with bits within the overall mask still interpreted from least-significant to most-significant with an N-byte unit, with N-byte units interpreted in stream order, and with the overall mask being byte-swapped in individual N-byte units. For LISTofVALUE encodings, the request is followed by a section of the form:
VALUEs encode-form ... encode-form listing an encode-form for each VALUE. The NAME in each encode-form keys to the corresponding BITMASK bit. The encoding of a VALUE always occupies four bytes, but the number of bytes specified in the encoding-form indicates how many of the least-significant bytes are actually used; the remaining bytes are unused and their values do not matter. In various cases, the number of bytes occupied by a component will be specified by a lowercase single-letter variable name instead of a specific numeric value, and often some other component will have its value specified as a simple numeric expression involving these variables. Components specified with such expressions are always interpreted as unsigned integers. The scope of such variables is always just the enclosing request, reply, error, event, or compound type structure. For example:
2 3+n request length 4n LISTofPOINT points For unused bytes (the values of the bytes are undefined and do not matter), the encode-form is:
N unused If the number of unused bytes is variable, the encode-form typically is:
p unused, p=pad(E) where E is some expression, and pad(E) is the number of bytes needed to round E up to a multiple of four.
pad(E) = (4 - (E mod 4)) mod 4
LISTofFOO
SETofFOO
BITMASK: CARD32 WINDOW: CARD32 BYTE: 8-bit value INT8: 8-bit signed integer INT16: 16-bit signed integer INT32: 32-bit signed integer CARD8: 8-bit unsigned integer CARD16: 16-bit unsigned integer CARD32: 32-bit unsigned integer TIMESTAMP: CARD32 EVENTCLASS: CARD32
INPUTCLASS 0 KeyClass 1 ButtonClass 2 ValuatorClass 3 FeedbackClass 4 ProximityClass 5 FocusClass 6 OtherClass
INPUTCLASS 0 KbdFeedbackClass 1 PtrFeedbackClass 2 StringFeedbackClass 3 IntegerFeedbackClass 4 LedFeedbackClass 5 BellFeedbackClass
INPUTINFO 0 KEYINFO 1 BUTTONINFO 2 VALUATORINFO
DEVICEMODE 0 Relative 1 Absolute
PROXIMITYSTATE 0 InProximity 1 OutOfProximity
BOOL 0 False 1 True
KEYSYM: CARD32 KEYCODE: CARD8 BUTTON: CARD8
SETofKEYBUTMASK #x0001 Shift #x0002 Lock #x0004 Control #x0008 Mod1 #x0010 Mod2 #x0020 Mod3 #x0040 Mod4 #x0080 Mod5 #x0100 Button1 #x0200 Button2 #x0400 Button3 #x0800 Button4 #x1000 Button5 #xe000 unused but must be zero
SETofKEYMASK encodings are the same as for SETofKEYBUTMASK, except with #xff00 unused but must be zero
STRING8: LISTofCARD8
STR 1 n length of name in bytes n STRING8 name
Request 1 0 Error 1 1 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Value 1 0 Error 1 2 code 2 CARD16 sequence number 4 <32-bits> bad value 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Window 1 0 Error 1 3 code 2 CARD16 sequence number 4 CARD32 bad resource id 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Match 1 0 Error 1 8 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Access 1 0 Error 1 10 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Alloc 1 0 Error 1 11 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Name 1 0 Error 1 15 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Device 1 0 Error 1 CARD8 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Event 1 0 Error 1 CARD8 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Mode 1 0 Error 1 CARD8 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused
Class 1 0 Error 1 CARD8 code 2 CARD16 sequence number 4 unused 2 CARD16 minor opcode 1 CARD8 major opcode 21 unused Keyboards KEYCODE values are always greater than 7 (and less than 256). KEYSYM values with the bit #x10000000 set are reserved as vendor-specific. The names and encodings of the standard KEYSYM values are contained in appendix F. Pointers BUTTON values are numbered starting with one. Requests
GetExtensionVersion 1 CARD8 input extension opcode 1 1 GetExtensionVersion opcode 2 2+(n+p)/4 request length 2 n length of name 2 unused n STRING8 name p unused, p=pad(n)
=> 1 1 Reply 1 1 GetExtensionVersion opcode 2 CARD16 sequence number 4 0 reply length 2 CARD16 major version 2 CARD16 minor version 1 BOOL present 19 unused
ListInputDevices 1 CARD8 input extension opcode 1 2 ListInputDevices opcode 2 1 request length
=> 1 1 Reply 1 2 ListInputDevices opcode 2 CARD16 sequence number 4 (n+p)/4 reply length 1 CARD8 number of input devices 23 unused n LISTofDEVICEINFO info for each input device p unused, p=pad(n)
DEVICEINFO 4 CARD32 device type 1 CARD8 device id 1 CARD8 number of input classes this device reports 1 CARD8 device use 0 IsXPointer 1 IsXKeyboard 2 IsXExtensionDevice 1 unused n LISTofINPUTINFO input info for each input class m STR name p unused, p=pad(m)
INPUTINFO KEYINFO or BUTTONINFO or VALUATORINFO
KEYINFO 1 0 class id 1 8 length 1 KEYCODE minimum keycode 1 KEYCODE maximum keycode 2 CARD16 number of keys 2 unused
BUTTONINFO 1 1 class id 1 4 length 2 CARD16 number of buttons
VALUATORINFO 1 2 class id 1 8+12n length 1 n number of axes 1 SETofDEVICEMODE mode 4 CARD32 size of motion buffer 12n LISTofAXISINFO valuator limits
AXISINFO 4 CARD32 resolution 4 CARD32 minimum value 4 CARD32 maximum value
OpenDevice 1 CARD8 input extension opcode 1 3 OpenDevice opcode 2 2 request length 1 CARD8 device id 3 unused
=> 1 1 Reply 1 3 OpenDevice opcode 2 CARD16 sequence number 4 (n+p)/4 reply length 1 CARD8 number of input classes 23 unused n LISTofINPUTCLASSINFO input class information p unused, p=pad(n)
INPUTCLASSINFO 1 CARD8 input class id 0 KEY 1 BUTTON 2 VALUATOR 3 FEEDBACK 4 PROXIMITY 5 FOCUS 6 OTHER 1 CARD8 event type base code for this class
CloseDevice 1 CARD8 input extension opcode 1 4 CloseDevice opcode 2 2 request length 1 CARD8 device id 3 unused
SetDeviceMode 1 CARD8 input extension opcode 1 5 SetDeviceMode opcode 2 2 request length 1 CARD8 device id 1 CARD8 mode 2 unused
=> 1 1 Reply 1 5 SetDeviceMode opcode 2 CARD16 sequence number 4 0 reply length 1 CARD8 status 0 Success 1 AlreadyGrabbed 3 + first_error DeviceBusy 23 unused
SelectExtensionEvent 1 CARD8 input extension opcode 1 6 SelectExtensionEvent opcode 2 3+n request length 4 Window event window 2 CARD16 count 2 unused 4n LISTofEVENTCLASS desired events
GetSelectedExtensionEvents 1 CARD8 input extension opcode 1 7 GetSelectedExtensionEvents opcode 2 2 request length 4 Window event window
=> 1 1 Reply 1 7 GetSelecteExtensionEvents opcode 2 CARD16 sequence number 4 n + m reply length 2 n this client count 2 m all clients count 20 unused 4n LISTofEVENTCLASS this client list 4m LISTofEVENTCLASS all clients list
ChangeDeviceDontPropagateList 1 CARD8 input extension opcode 1 8 ChangeDeviceDontPropagateList opcode 2 3+n request length 4 Window event window 2 n count of events 1 mode 0 AddToList 1 DeleteFromList 1 unused 4n LISTofEVENTCLASS desired events
GetDeviceDontPropagateList 1 CARD8 input extension opcode 1 9 GetDeviceDontPropagateList opcode 2 2 request length 4 Window event window
=> 1 1 Reply 1 9 GetDeviceDontPropagateList opcode 2 CARD16 sequence number 4 n reply length 2 n count of events 22 unused 4n LISTofEVENTCLASS don't propagate list
GetDeviceMotionEvents 1 CARD8 input extension opcode 1 10 GetDeviceMotionEvents opcode 2 4 request length 4 TIMESTAMP start 0 CurrentTime 4 TIMESTAMP stop 0 CurrentTime 1 CARD8 device id 3 unused
=> 1 1 Reply 1 10 GetDeviceMotionEvents opcode 2 CARD16 sequence number 4 (m+1)n reply length 4 n number of DEVICETIMECOORDs in events 1 m number of valuators per event 1 CARD8 mode of the device 0 Absolute 1 Relative 18 unused (4m+4)n LISTofDEVICETIMECOORD events
DEVICETIMECOORD 4 TIMESTAMP time 4m LISTofINT32 valuators
ChangeKeyboardDevice 1 CARD8 input extension opcode 1 11 ChangeKeyboardDevice opcode 2 2 request length 1 CARD8 device id 3 unused
=> 1 1 Reply 1 11 ChangeKeyboardDevice opcode 2 CARD16 sequence number 4 0 reply length 1 status 0 Success 1 AlreadyGrabbed 2 DeviceFrozen 23 unused
ChangePointerDevice 1 CARD8 input extension opcode 1 12 ChangePointerDevice opcode 2 2 request length 1 CARD8 x-axis 1 CARD8 y-axis 1 CARD8 device id 1 unused
=> 1 1 Reply 1 12 ChangePointerDevice opcode 2 CARD16 sequence number 4 0 reply length 1 status 0 Success 1 AlreadyGrabbed 2 DeviceFrozen 23 unused
GrabDevice 1 CARD8 input extension opcode 1 13 GrabDevice opcode 2 5+n request length 4 WINDOW grab-window 4 TIMESTAMP time 0 CurrentTime 2 n count of events 1 this-device-mode 0 Synchronous 1 Asynchronous 1 other-devices-mode 0 Synchronous 1 Asynchronous 1 BOOL owner-events 1 CARD8 device id 2 unused 4n LISTofEVENTCLASS event list
=> 1 1 Reply 1 13 GrabDevice opcode 2 CARD16 sequence number 4 0 reply length 1 status 0 Success 1 AlreadyGrabbed 2 InvalidTime 3 NotViewable 4 Frozen 23 unused
UngrabDevice 1 CARD8 input extension opcode 1 14 UngrabDevice opcode 2 3 request length 4 TIMESTAMP time 0 CurrentTime 1 CARD8 device id 3 unused
GrabDeviceKey 1 CARD8 input extension opcode 1 15 GrabDeviceKey opcode 2 5+n request length 4 WINDOW grab-window 2 n count of events 2 SETofKEYMASK modifiers #x8000 AnyModifier 1 CARD8 modifier device #x0FF UseXKeyboard 1 CARD8 grabbed device 1 KEYCODE key 0 AnyKey 1 this-device-mode 0 Synchronous 1 Asynchronous 1 other-devices-mode 0 Synchronous 1 Asynchronous 1 BOOL owner-events 2 unused 4n LISTofEVENTCLASS event list
UngrabDeviceKey 1 CARD8 input extension opcode 1 16 UngrabDeviceKey opcode 2 4 request length 4 WINDOW grab-window 2 SETofKEYMASK modifiers #x8000 AnyModifier 1 CARD8 modifier device #x0FF UseXKeyboard 1 KEYCODE key 0 AnyKey 1 CARD8 grabbed device 3 unused
GrabDeviceButton 1 CARD8 input extension opcode 1 17 GrabDeviceButton opcode 2 5+n request length 4 WINDOW grab-window 1 CARD8 grabbed device 1 CARD8 modifier device #x0FF UseXKeyboard 2 n count of desired events 2 SETofKEYMASK modifiers 1 this-device-mode 0 Synchronous 1 Asynchronous 1 other-device-mode 0 Synchronous 1 Asynchronous 1 BUTTON button 0 AnyButton 1 BOOL owner-events #x8000 AnyModifier 2 unused 4n LISTofEVENTCLASS event list
UngrabDeviceButton 1 CARD8 input extension opcode 1 18 UngrabDeviceButton opcode 2 4 request length 4 WINDOW grab-window 2 SETofKEYMASK modifiers #x8000 AnyModifier 1 CARD8 modifier device #x0FF UseXKeyboard 1 BUTTON button 0 AnyButton 1 CARD8 grabbed device 3 unused
AllowDeviceEvents 1 CARD8 input extension opcode 1 19 AllowDeviceEvents opcode 2 3 request length 4 TIMESTAMP time 0 CurrentTime 1 mode 0 AsyncThisDevice 1 SyncThisDevice 2 ReplayThisDevice 3 AsyncOtherDevices 4 AsyncAll 5 SyncAll 1 CARD8 device id 2 unused
GetDeviceFocus 1 CARD8 input extension opcode 1 20 GetDeviceFocus opcode 2 2 request length 1 CARD8 device 3 unused
=> 1 1 Reply 1 20 GetDeviceFocus opcode 2 CARD16 sequence number 4 0 reply length 4 WINDOW focus 0 None 1 PointerRoot 3 FollowKeyboard 4 TIMESTAMP focus time 1 revert-to 0 None 1 PointerRoot 2 Parent 3 FollowKeyboard 15 unused
SetDeviceFocus 1 CARD8 input extension opcode 1 21 SetDeviceFocus opcode 2 4 request length 4 WINDOW focus 0 None 1 PointerRoot 3 FollowKeyboard 4 TIMESTAMP time 0 CurrentTime 1 revert-to 0 None 1 PointerRoot 2 Parent 3 FollowKeyboard 1 CARD8 device 2 unused
GetFeedbackControl 1 CARD8 input extension opcode 1 22 GetFeedbackControl opcode 2 2 request length 1 CARD8 device id 3 unused
=> 1 1 Reply 1 22 GetFeedbackControl opcode 2 CARD16 sequence number 4 m/4 reply length 2 n number of feedbacks supported 22 unused m LISTofFEEDBACKSTATE feedbacks
FEEDBACKSTATE KBDFEEDBACKSTATE, PTRFEEDBACKSTATE, INTEGERFEEDBACKSTATE, STRINGFEEDBACKSTATE, BELLFEEDBACKSTATE, or LEDFEEDBACKSTATE
KBDFEEDBACKSTATE 1 0 feedback class id 1 CARD8 id of this feedback 2 20 length 2 CARD16 pitch 2 CARD16 duration 4 CARD32 led_mask 4 CARD32 led_values 1 global_auto_repeat 0 Off 1 On 1 CARD8 click 1 CARD8 percent 1 unused 32 LISTofCARD8 auto_repeats
PTRFEEDBACKSTATE 1 0 feedback class id 1 CARD8 id of this feedback 2 12 length 2 unused 2 CARD16 acceleration-numerator 2 CARD16 acceleration-denominator 2 CARD16 threshold
INTEGERFEEDBACKSTATE 1 0 feedback class id 1 CARD8 id of this feedback 2 16 length 4 CARD32 resolution 4 INT32 minimum value 4 INT32 maximum value
STRINGFEEDBACKSTATE 1 1 feedback class id 1 CARD8 id of this feedback 2 4n+8 length 2 CARD16 max_symbols 2 n number of keysyms supported 4n LISTofKEYSYM key symbols supported
BELLFEEDBACKSTATE 1 1 feedback class id 1 CARD8 id of this feedback 2 12 length 1 CARD8 percent 3 unused 2 CARD16 pitch 2 CARD16 duration
LEDFEEDBACKSTATE 1 1 feedback class id 1 CARD8 id of this feedback 2 12 length 4 CARD32 led_mask 4 BITMASK led_values #x0001 On #x0002 Off
ChangeFeedbackControl 1 CARD8 input extension opcode 1 23 ChangeFeedbackControl opcode 2 3+n/4 request length 4 BITMASK value-mask (has n bits set to 1) #x0001 keyclick-percent #x0002 bell-percent #x0004 bell-pitch #x0008 bell-duration #x0010 led #x0020 led-mode #x0040 key #x0080 auto-repeat-mode #x0001 string #x0001 integer #x0001 acceleration-numerator #x0002 acceleration-denominator #x0004 acceleration-threshold 1 CARD8 device id 1 CARD8 feedback class id 2 unused n FEEDBACKCLASS
FEEDBACKCLASS KBDFEEDBACKCTL, PTRFEEDBACKCTL, INTEGERFEEDBACKCTL, STRINGFEEDBACKCTL, BELLFEEDBACKCTL, or LEDFEEDBACKCTL
KBDFEEDBACKCTL 1 0 feedback class id 1 CARD8 id of this feedback 2 20 length 1 KEYCODE key 1 auto-repeat-mode 0 Off 1 On 2 Default 1 INT8 key-click-percent 1 INT8 bell-percent 2 INT16 bell-pitch 2 INT16 bell-duration 4 CARD32 led_mask 4 CARD32 led_values
PTRFEEDBACKCTL 1 1 feedback class id 1 CARD8 id of this feedback 2 12 length 2 unused 2 INT16 numerator 2 INT16 denominator 2 INT16 threshold
STRINGCTL 1 2 feedback class id 1 CARD8 id of this feedback 2 4n+8 length 2 unused 2 n number of keysyms to display 4n LISTofKEYSYM list of key symbols to display
INTEGERCTL 1 3 feedback class id 1 CARD8 id of this feedback 2 8 length 4 INT32 integer to display
LEDCTL 1 4 feedback class id 1 CARD8 id of this feedback 2 12 length 4 CARD32 led_mask 4 BITMASK led_values #x0001 On #x0002 Off
BELLCTL 1 5 feedback class id 1 CARD8 id of this feedback 2 8 length 1 INT8 percent 3 unused 2 INT16 pitch 2 INT16 duration
GetDeviceKeyMapping 1 CARD8 input extension opcode 1 24 GetDeviceKeyMapping opcode 2 2 request length 1 CARD8 device 1 KEYCODE first-keycode 1 CARD8 count 1 unused
=> 1 1 Reply 1 24 GetDeviceKeyMapping opcode 2 CARD16 sequence number 4 nm reply length (m = count field from the request) 1 n keysyms-per-keycode 23 unused 4nm LISTofKEYSYM keysyms
ChangeDeviceKeyMapping 1 CARD8 input extension opcode 1 25 ChangeDeviceKeyMapping opcode 2 2+nm request length 1 CARD8 device 1 KEYCODE first-keycode 1 m keysyms-per-keycode 1 n keycode-count 4nm LISTofKEYSYM keysyms
GetDeviceModifierMapping 1 CARD8 input extension opcode 1 26 GetDeviceModifierMapping opcode 2 2 request length 1 CARD8 device 3 unused
=> 1 1 Reply 1 26 GetDeviceModifierMapping opcode 2 CARD16 sequence number 4 2n reply length 1 n keycodes-per-modifier 23 unused 8n LISTofKEYCODE keycodes
SetDeviceModifierMapping 1 CARD8 input extension opcode 1 27 SetDeviceModifier opcode 2 2+2n request length 1 CARD8 device 1 n keycodes-per-modifier 2 unused 8n LISTofKEYCODE keycodes
=> 1 1 Reply 1 27 SetDeviceModifierMapping opcode 2 CARD16 sequence number 4 0 reply length 1 status 0 Success 1 Busy 2 Failed 23 unused
GetDeviceButtonMapping 1 CARD8 input extension opcode 1 28 GetDeviceButtonMapping opcode 2 2 request length 1 CARD8 device 3 unused
=> 1 1 Reply 1 28 GetDeviceButtonMapping opcode 2 CARD16 sequence number 4 (n+p)/4 reply length 1 n number of elements in map list 23 unused n LISTofCARD8 map p unused, p=pad(n)
SetDeviceButtonMapping 1 CARD8 input extension opcode 1 29 SetDeviceButtonMapping opcode 2 2+(n+p)/4 request length 1 CARD8 device 1 n length of map 2 unused n LISTofCARD8 map p unused, p=pad(n)
=> 1 1 Reply 1 29 SetDeviceButtonMapping opcode 2 CARD16 sequence number 4 0 reply length 1 status 0 Success 1 Busy 23 unused
QueryDeviceState 1 CARD8 input extension opcode 1 30 QueryDeviceState opcode 2 2 request length 1 CARD8 device 3 unused
=> 1 1 Reply 1 30 QueryDeviceState opcode 2 CARD16 sequence number 4 m/4 reply length 1 n number of input classes 23 unused m LISTofINPUTSTATE
INPUTSTATE KEYSTATE or BUTTONSTATE or VALUATORSTATE
KEYSTATE 1 CARD8 key input class id 1 36 length 1 CARD8 num_keys 1 unused 32 LISTofCARD8 status of keys
BUTTONSTATE 1 CARD8 button input class id 1 36 length 1 CARD8 num_buttons 1 unused 32 LISTofCARD8 status of buttons
VALUATORSTATE 1 CARD8 valuator input class id 1 4n + 4 length 1 n number of valuators 1 mode #x01 DeviceMode (0 = Relative, 1 = Absolute) #x02 ProximityState (0 = InProximity, 1 = OutOfProximity) 4n LISTofCARD32 status of valuators
SendExtensionEvent 1 CARD8 input extension opcode 1 31 SendExtensionEvent opcode 2 4 + 8n + m request length 4 WINDOW destination 1 CARD8 device 1 BOOL propagate 2 CARD16 eventclass count 1 CARD8 num_events 3 unused 32n LISTofEVENTS events to send 4m LISTofEVENTCLASS desired events
DeviceBell 1 CARD8 input extension opcode 1 32 DeviceBell opcode 2 2 request length 1 CARD8 device id 1 CARD8 feedback id 1 CARD8 feedback class 1 INT8 percent
SetDeviceValuators 1 CARD8 input extension opcode 1 33 SetDeviceValuators opcode 2 2 + n request length 1 CARD8 device id 1 CARD8 first valuator 1 n number of valuators 1 unused 4n LISTofINT32 valuator values to set
=> 1 1 Reply 1 33 SetDeviceValuators opcode 2 CARD16 sequence number 4 0 reply length 1 CARD8 status 0 Success 1 AlreadyGrabbed 23 unused
GetDeviceControl 1 CARD8 input extension opcode 1 34 GetDeviceControl opcode 2 2 request length 2 CARD16 device control type 1 CARD8 device id 1 unused
=> 1 1 Reply 1 34 GetDeviceControl opcode 2 CARD16 sequence number 4 n/4 reply length 1 CARD8 status 0 Success 1 AlreadyGrabbed 3 + first_error DeviceBusy 23 unused n DEVICESTATE
DEVICESTATE DEVICERESOLUTIONSTATE
DEVICERESOLUTIONSTATE 2 0 control type 2 8 + 12n length 4 n num_valuators 4n LISTOfCARD32 resolution values 4n LISTOfCARD32 resolution min_values 4n LISTOfCARD32 resolution max_values
ChangeDeviceControl 1 CARD8 input extension opcode 1 35 ChangeDeviceControl opcode 2 2+n/4 request length 2 CARD16 control type 1 CARD8 device id 1 unused n DEVICECONTROL
DEVICECONTROL DEVICERESOLUTIONCTL
DEVICERESOLUTIONCTL 2 1 control type 2 8 + 4n length 1 CARD8 first_valuator 1 n num_valuators 2 unused 4n LISTOfCARD32 resolution values
=> 1 1 Reply 1 35 ChangeDeviceControl opcode 2 CARD16 sequence number 4 0 reply length 1 CARD8 status 0 Success 1 AlreadyGrabbed 3 + first_error DeviceBusy 23 unused Events DeviceKeyPress, DeviceKeyRelease, DeviceButtonPress, DeviceButtonRelease, ProximityIn, ProximityOut, and DeviceStateNotify events may be followed by zero or more DeviceValuator events. DeviceMotionNotify events will be followed by one or more DeviceValuator events.
DeviceValuator 1 CARD8 code 1 CARD8 device id 2 CARD16 sequence number 2 SETofKEYBUTMASK state 1 n number of valuators this device reports 1 m number of first valuator in this event 24 LISTofINT32 valuators
DeviceKeyPress 1 CARD8 code 1 KEYCODE detail 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW root 4 WINDOW event 4 WINDOW child 0 None 2 INT16 root-x 2 INT16 root-y 2 INT16 event-x 2 INT16 event-y 2 SETofKEYBUTMASK state 1 BOOL same-screen 1 CARD8 device id #x80 MORE_EVENTS follow
DeviceKeyRelease 1 CARD8 code 1 KEYCODE detail 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW root 4 WINDOW event 4 WINDOW child 0 None 2 INT16 root-x 2 INT16 root-y 2 INT16 event-x 2 INT16 event-y 2 SETofKEYBUTMASK state 1 BOOL same-screen 1 CARD8 device id #x80 MORE_EVENTS follow
DeviceButtonPress 1 CARD8 code 1 BUTTON detail 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW root 4 WINDOW event 4 WINDOW child 0 None 2 INT16 root-x 2 INT16 root-y 2 INT16 event-x 2 INT16 event-y 2 SETofKEYBUTMASK state 1 BOOL same-screen 1 CARD8 device id #x80 MORE_EVENTS follow
DeviceButtonRelease 1 CARD8 code 1 BUTTON detail 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW root 4 WINDOW event 4 WINDOW child 0 None 2 INT16 root-x 2 INT16 root-y 2 INT16 event-x 2 INT16 event-y 2 SETofKEYBUTMASK state 1 BOOL same-screen 1 CARD8 device id #x80 MORE_EVENTS follow
DeviceMotionNotify 1 CARD8 code 1 detail 0 Normal 1 Hint 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW root 4 WINDOW event 4 WINDOW child 0 None 2 INT16 root-x 2 INT16 root-y 2 INT16 event-x 2 INT16 event-y 2 SETofKEYBUTMASK state 1 BOOL same-screen 1 CARD8 device id #x80 MORE_EVENTS follow
DeviceFocusIn 1 CARD8 code 1 detail 0 Ancestor 1 Virtual 2 Inferior 3 Nonlinear 4 NonlinearVirtual 5 Pointer 6 PointerRoot 7 None 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW event 1 mode 0 Normal 1 Grab 2 Ungrab 3 WhileGrabbed 1 CARD8 device id 18 unused
DeviceFocusOut 1 CARD8 code 1 detail 0 Ancestor 1 Virtual 2 Inferior 3 Nonlinear 4 NonlinearVirtual 5 Pointer 6 PointerRoot 7 None 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW event 1 mode 0 Normal 1 Grab 2 Ungrab 3 WhileGrabbed 1 CARD8 device id 18 unused
ProximityIn 1 CARD8 code 1 unused 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW root 4 WINDOW event 4 WINDOW child 0 None 2 INT16 root-x 2 INT16 root-y 2 INT16 event-x 2 INT16 event-y 2 SETofKEYBUTMASK state 1 BOOL same-screen 1 CARD8 device id #x80 MORE_EVENTS follow
ProximityOut 1 CARD8 code 1 unused 2 CARD16 sequence number 4 TIMESTAMP time 4 WINDOW root 4 WINDOW event 4 WINDOW child 0 None 2 INT16 root-x 2 INT16 root-y 2 INT16 event-x 2 INT16 event-y 2 SETofKEYBUTMASK state 1 BOOL same-screen 1 CARD8 device id #x80 MORE_EVENTS follow
DeviceStateNotify events may be immediately followed by zero or one DeviceKeyStateNotify and/ or zero or more DeviceValuator events.
DeviceStateNotify 1 CARD8 code 1 CARD8 device id #x80 MORE_EVENTS follow 2 CARD16 sequence number 4 TIMESTAMP time 1 CARD8 num_keys 1 CARD8 num_buttons 1 CARD8 num_valuators 1 CARD8 valuator mode and input classes reported #x01 reporting keys #x02 reporting buttons #x04 reporting valuators #x40 device mode (0 = Relative, 1 = Absolute) #x80 proximity state (0 = InProximity, 1 = OutOfProximity) 4 LISTofCARD8 first 32 keys (if reported) 4 LISTofCARD8 first 32 buttons (if reported) 12 LISTofCARD32 first 3 valuators (if reported)
DeviceKeyStateNotify 1 CARD8 code 1 CARD8 device id #x80 MORE_EVENTS follow 2 CARD16 sequence number 28 LISTofCARD8 state of keys 33-255
DeviceButtonStateNotify 1 CARD8 code 1 CARD8 device id #x80 MORE_EVENTS follow 2 CARD16 sequence number 28 LISTofCARD8 state of buttons 33-255
DeviceValuator 1 CARD8 code 1 CARD8 device id 2 CARD16 sequence number 2 SETofKEYBUTMASK state 1 n number of valuators this device reports 1 n number of first valuator in this event 24 LISTofINT32 valuators
DeviceMappingNotify 1 CARD8 code 1 CARD8 device id 2 CARD16 sequence number 1 request 0 MappingModifier 1 MappingKeyboard 2 MappingPointer 1 KEYCODE first-keycode 1 CARD8 count 1 unused 4 TIMESTAMP time 20 unused
ChangeDeviceNotify 1 CARD8 code 1 CARD8 id of device specified on change request 2 CARD16 sequence number 4 TIMESTAMP time 1 request 0 NewPointer 1 NewKeyboard 23 unused |
:: Command execute :: | |
--[ c99shell v. 2.5 [PHP 8 Update] [24.05.2025] | Generation time: 0.0168 ]-- |