These functions are provided to change which physical device is used as the X pointer or X keyboard. Using these functions may change the characteristics of the core devices. The new pointer device may have a different number of buttons than the old one did, 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 indicies into that array. Changing the core devices could cause such client programs to behave improperly or abnormally terminate, if they ignore the ChangeDeviceNotify event generated by these requests.

These functions change the X keyboard or X pointer device and generate an XChangeDeviceNotify event and a MappingNotify event. The specified device becomes the new X keyboard or X pointer device. The location of the core device does not change as a result of this request.

These requests fail and return AlreadyGrabbed if either the specified device or the core device it would replace are grabbed by some other client. They fail and return GrabFrozen if either device is frozen by the active grab of another client.

These requests fail with a BadDevice error if the specified device is invalid, has not previously been opened via XOpenDevice, or is not supported as a core device by the server implementation.

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 ChangeDevice request, or until the server terminates. The termination of the client that changed the device will not cause it to change back. Attempts to use the XCloseDevice request to close the new core device will fail with a BadDevice error.

To change which physical device is used as the X keyboard, use the XChangeKeyboardDevice function.

The specified device must support input class Keys (as reported in the ListInputDevices request) or the request will fail with a BadMatch error.

int
XChangeKeyboardDevice (display, device)
    Display *display;
    XDevice *device;

If no error occurs, this function returns Success. A ChangeDeviceNotify event with the request field set to NewKeyboard is sent to all clients selecting that event. A MappingNotify event with the request field set to MappingKeyboard is sent to all clients. The requested device becomes the X keyboard, and the old keyboard becomes available as an extension input device. The focus state of the new keyboard is the same as the focus state of the old X keyboard.

Errors returned by this function: BadDevice, BadMatch, AlreadyGrabbed, and GrabFrozen.

To change which physical device is used as the X pointer, use the XChangePointerDevice function. The specified device must support input class Valuators (as reported in the XListInputDevices request) and report at least two axes of motion, or the request will fail with a BadMatch error. If the specified device reports more than two axes, the two specified in the xaxis and yaxis arguments will be used. Data from other valuators on the device will be ignored.

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 BadDevice error.

int
XChangePointerDevice (display, device, xaxis, yaxis)
    Display *display;
    XDevice *device;
    int     xaxis;
    int     yaxis;

If no error occurs, this function returns Success. A ChangeDeviceNotify event with the request field set to NewPointer is sent to all clients selecting that event. A MappingNotify event with the request field set to MappingPointer is sent to all clients. The requested device becomes the X pointer, and the old pointer becomes available as an extension input device.

Errors returned by this function: BadDevice,BadMatch, AlreadyGrabbed, and GrabFrozen.

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 XGrabPointer and XGrabButton requests, pointer_mode controls synchronization of the pointer device, and keyboard_mode controls the synchronization of all other input devices. For the XGrabKeyboard and XGrabKey requests, pointer_mode controls the synchronization of all input devices except the X keyboard, while keyboard_mode controls the synchronization of the keyboard. When using one of the core grab requests, the synchronization of extension devices is controlled by the mode specified for the device not being grabbed.

Active grabs of extension devices are supported via the XGrabDevice function in the same way that core devices are grabbed using the core XGrabKeyboard function, except that a Device is passed as a function parameter. The XUngrabDevice function allows a previous active grab for an extension device to be released.

Passive grabs of buttons and keys on extension devices are supported via the XGrabDeviceButton and XGrabDeviceKey functions. These passive grabs are released via the XUngrabDeviceKey and XUngrabDeviceButton functions.

To grab an extension device, use the XGrabDevice function. The device must have previously been opened using the XOpenDevice function.

int
XGrabDevice (display, device, grab_window, owner_events, 
    event_count, event_list, this_device_mode, 
    other_device_mode, time)
        Display     *display;
        XDevice     *device;
        Window      grab_window;
        Bool        owner_events;
        int         event_count;
        XEventClass *event_list;
        int         this_device_mode;
        int         other_device_mode;
        Time        time;

The XGrabDevice function actively grabs an extension input device, and generates DeviceFocusIn and DeviceFocusOut events. Further input events from this device are reported only to the grabbing client. This function overrides any previous active grab by this client for this device.

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 False, input events from this device are reported with respect to grab_window and are only reported if specified in 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 specified in event_list.

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.

XGrabDevice fails and returns:

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.

Errors returned by this function: BadDevice, BadWindow, BadValue, BadClass.

To release a grab of an extension device, use XUngrabDevice.

int
XUngrabDevice (display, device, time)
        Display *display;
        XDevice *device;
        Time    time;

This function allows a client to release an extension input device and any queued events if this client has it grabbed from either XGrabDevice or XGrabDeviceKey. If any other devices are frozen by the grab, XUngrabDevice thaws them. The function does not release the device and any queued events if the specified time is earlier than the last-device-grab time or is later than the current X server time. It also generates DeviceFocusIn and DeviceFocusOut events. The X server automatically performs an XUngrabDevice if the event window for an active device grab becomes not viewable, or if the client terminates without releasing the grab.

Errors returned by this function: BadDevice.

To passively grab a single key on an extension device, use XGrabDeviceKey. That device must have previously been opened using the XOpenDevice function, or the request will fail with a BadDevice error. If the specified device does not support input class Keys, the request will fail with a BadMatch error.

int
XGrabDeviceKey (display, device, keycode, modifiers, modifier_device
    grab_window, owner_events, event_count, event_list, 
    this_device_mode, other_device_mode)
        Display     *display;
        XDevice     *device;
        int         keycode;
        unsigned    int modifiers;
        XDevice     *modifier_device;
        Window      grab_window;
        Bool        owner_events;
        int         event_count;
        XEventClass *event_list;
        int         this_device_mode;
        int         other_device_mode;

This function is analogous to the core XGrabKey function. It creates an explicit passive grab for a key on an extension device.

The XGrabDeviceKey function establishes a passive grab on a device. Consequently, in the future,

The interpretation of the remaining arguments is as for XGrabDevice. The active grab is terminated automatically when the logical state of the device has the specified key released (independent of the logical state of the modifier keys).

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 AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all modifiers specified have currently assigned keycodes. A key of AnyKey is equivalent to issuing the request for all possible keycodes. Otherwise, the key must be in the range specified by min_keycode and max_keycode in the information returned by the XListInputDevices function. If it is not within that range, XGrabDeviceKey generates a BadValue error.

A BadAccess error is generated if some other client has issued a XGrabDeviceKey with the same device and key combination on the same window. When using AnyModifier or AnyKey, the request fails completely and the X server generates a BadAccess error and no grabs are established if there is a conflicting grab for any combination.

XGrabDeviceKey can generate BadDevice, BadAccess, BadMatch, BadWindow, BadClass, and BadValue errors.

XGrabDeviceKey returns Success upon successful completion of the request.

To release a passive grab of a single key on an extension device, use XUngrabDeviceKey.

int
XUngrabDeviceKey (display, device, keycode, modifiers, 
    modifier_device, ungrab_window)
        Display  *display;
        XDevice  *device;
        int      keycode;
        unsigned int modifiers;
        XDevice  *modifier_device;
        Window   ungrab_window;

This function is analogous to the core XUngrabKey function. It releases an explicit passive grab for a key on an extension input device.

Errors returned by this function: BadDevice, BadWindow, BadValue, BadAlloc, and BadMatch.

To establish a passive grab for a single button on an extension device, use XGrabDeviceButton. The specified device must have previously been opened using the XOpenDevice function, or the request will fail with a BadDevice error. If the specified device does not support input class Buttons, the request will fail with a BadMatch error.

int
XGrabDeviceButton (display, device, button, modifiers, 
    modifier_device, grab_window, owner_events, event_count, 
    event_list, this_device_mode, other_device_mode)
        Display      *display;
        XDevice      *device;
        unsigned int button;
        unsigned int modifiers;
        XDevice      *modifier_device;
        Window       grab_window;
        Bool         owner_events;
        int          event_count;
        XEventClass  *event_list;
        int          this_device_mode;
        int          other_device_mode;

This function is analogous to the core XGrabButton function. It creates an explicit passive grab for a button on an extension input device. Since the server does not track extension devices, no cursor is specified with this request. For the same reason, there is no confine_to parameter. The device must have previously been opened using the XOpenDevice function.

The XGrabDeviceButton function establishes a passive grab on a device. Consequently, in the future,

The interpretation of the remaining arguments is as for XGrabDevice. The active grab is terminated automatically when logical state of the device has all buttons released (independent of the logical state of the modifier keys).

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 AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all modifiers specified have currently assigned keycodes. A button of AnyButton is equivalent to issuing the request for all possible buttons. Otherwise, it is not required that the specified button be assigned to a physical button.

A BadAccess error is generated if some other client has issued a XGrabDeviceButton with the same device and button combination on the same window. When using AnyModifier or AnyButton, the request fails completely and the X server generates a BadAccess error and no grabs are established if there is a conflicting grab for any combination.

XGrabDeviceButton can generate BadDevice, BadMatch, BadAccess, BadWindow, BadClass, and BadValue errors.

To release a passive grab of a button on an extension device, use XUngrabDeviceButton.

int
XUngrabDeviceButton (display, device, button, modifiers, 
    modifier_device, ungrab_window)
        Display  *display;
        XDevice  *device;
        unsigned int button;
        unsigned int modifiers;
        XDevice  *modifier_device;
        Window   ungrab_window;

This function is analogous to the core XUngrabButton function. It releases an explicit passive grab for a button on an extension device. That device must have previously been opened using the XOpenDevice function, or a BadDevice error will result.

A modifier of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers).

XUngrabDeviceButton can generate BadDevice, BadMatch, BadWindow, BadValue, and BadAlloc errors.

To allow further events to be processed when a device has been frozen, use XAllowDeviceEvents.

int
XAllowDeviceEvents (display, device, event_mode, time)
        Display *display;
        XDevice *device;
        int     event_mode;
        Time    time;

The XAllowDeviceEvents function releases some queued events if the client has caused a device to freeze. The function has no effect if the specified time is earlier than the last-grab time of the most recent active grab for the client and device, 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:

AsyncThisDevice, SyncThisDevice, and ReplayThisDevice have no effect on the processing of events from the remaining devices. AsyncOtherDevices has no effect on the processing of events from the specified device. When the event_mode is SyncAll or AsyncAll, the device parameter is ignored.

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.

Errors returned by this function: BadDevice, BadValue.

The current focus window for an extension input device can be determined using the XGetDeviceFocus function. Extension devices are focused using the XSetDeviceFocus function in the same way that the keyboard is focused using the core XSetInputFocus function, except that a device id is passed as a function parameter. One additional focus state, FollowKeyboard, is provided for extension devices.

To get the current focus state, revert state, and focus time of an extension device, use XGetDeviceFocus.

int
XGetDeviceFocus (display, device, focus_return, revert_to_return,
    focus_time_return)
        Display *display;
        XDevice *device;
        Window  *focus_return;
        int     *revert_to_return;
        Time    *focus_time_return;

This function returns the focus state, the revert-to state, and the last-focus-time for an extension input device.

Errors returned by this function: BadDevice, BadMatch.

To set the focus of an extension device, use XSetDeviceFocus.

int
XSetDeviceFocus (display, device, focus, revert_to, time)
        Display *display;
        XDevice *device;
        Window  focus;
        int     revert_to;
        Time    time;

This function changes the focus for an extension input device and the last-focus-change-time. The function has no effect if the specified time is earlier than the 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. This function causes the X server to generate DeviceFocusIn and DeviceFocusOut events.

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 XSetDeviceFocus is called. Otherwise, it generates a BadMatch error. If the focus window later becomes not viewable, the X server evaluates the revert_to argument to determine the new focus window.

When the focus reverts, the X server generates DeviceFocusIn and DeviceFocusOut events, but the last-focus-change time is not affected.

Errors returned by this function: BadDevice, BadMatch, BadValue, and BadWindow.

To determine the current feedback settings of an extension input device, use XGetFeedbackControl.

XFeedbackState
*XGetFeedbackControl (display, device, num_feedbacks_return)
        Display          *display;
        XDevice          *device;
        int              *num_feedbacks_return;

where class identifies the class of feedback. The class may be compared to constants defined in the file XI.h. Currently defined feedback constants include KbdFeedbackClass, PtrFeedbackClass, StringFeedbackClass, IntegerFeedbackClass, LedFeedbackClass, and BellFeedbackClass.

The length specifies the length of the FeedbackState structure and can be used by clients to traverse the list.

The id uniquely identifies a feedback for a given device and class. This allows a device to support more than one feedback of the same class. Other feedbacks of other classes or devices may have the same id.

The fields of the XKbdFeedbackState structure report the current state of the feedback:

Those feedbacks equivalent to those supported by the core pointer are reported in class PtrFeedback using he XPtrFeedbackState structure. The members of that structure are as follows:

typedef struct {
    XID     class;
    int     length;
    XID     id;
    int     accelNum;
    int     accelDenom;
    int     threshold;
} XPtrFeedbackState;

The fields of the XPtrFeedbackState structure report the current state of the feedback:

Integer feedbacks are those capable of displaying integer numbers. The minimum and maximum values that they can display are reported.

typedef struct {
    XID     class;
    int     length;
    XID     id;
    int     resolution;
    int     minVal;
    int     maxVal;
} XIntegerFeedbackState;

The fields of the XIntegerFeedbackState structure report the capabilities of the feedback:

The fields of the XStringFeedbackState structure report the capabilities of the feedback:

Led feedbacks are those that can generate a light. Up to 32 lights per feedback are supported. Each bit in led_mask corresponds to one supported light, and the corresponding bit in led_values indicates whether that light is currently on (1) or off (0). Some implementations may support leds as part of a KbdFeedback feedback. Class LedFeedback is provided for implementations that do not choose to do so, and for devices that support multiple led feedbacks.

typedef struct {
    XID     class;
    int     length;
    XID     id;
    Mask    led_values;
    Mask    led_mask;
} XLedFeedbackState;

Errors returned by this function: BadDevice, BadMatch.

To free the information returned by the XGetFeedbackControl function, use XFreeFeedbackList.

void
XFreeFeedbackList (list)
        XFeedbackState *list;

This function frees the list of feedback control information.

To change the settings of a feedback on an extension device, use XChangeFeedbackControl. This function modifies the current control values of the specified feedback using information passed in the appropriate XFeedbackControl structure for the feedback. Which values are modified depends on the valuemask passed.

int
XChangeFeedbackControl (display, device, valuemask, value)
        Display          *display;
        XDevice          *device;
        unsigned long    valuemask;
        XFeedbackControl *value;

This function controls the device characteristics described by the XFeedbackControl structure. There is an XFeedbackControl structure for each clase of feedback. These are of variable length, but the first two fields are common to all. The common fields are as follows:

typedef struct {
    XID    class;
    int    length;
    XID    id;
} XFeedbackControl;

Feedback class KbdFeedback controls feedbacks equivalent to those provided by the core keyboard using the KbdFeedbackControl structure. The members of that structure are:

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 XKbdFeedbackControl structure. These include the key_click_percent, global_auto_repeat and individual key auto-repeat. Valid modes are AutoRepeatModeOn, AutoRepeatModeOff, AutoRepeatModeDefault.

Valid masks are as follows:

#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)

Errors returned by this function: BadDevice, BadMatch, BadValue.

Feedback class PtrFeedback controls feedbacks equivalent to those provided by the core pointer using the PtrFeedbackControl structure. The members of that structure are:

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 the device moves three times as fast as normal. The fraction may be rounded arbitrarily by the X server. Acceleration only takes effect if the device moves more than threshold pixels at once and only applies 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 BadValue error, as does a zero value for the accelDenominator field.

This request fails with a BadMatch error if the specified device is not currently reporting relative motion. If a device that is capable of reporting both relative and absolute motion has its mode changed from Relative to Absolute by an XSetDeviceMode request, valuator control values will be ignored by the server while the device is in that mode.

Feedback class IntegerFeedback controls integer feedbacks displayed on input devices, using the IntegerFeedbackControl structure. The members of that structure are:

typedef struct {
    XID     class;
    int     length;
    XID     id;
    int     int_to_display;
} XIntegerFeedbackControl;

Valid masks are as follows:

#define DvInteger                    (1L << 0)

Feedback class StringFeedback controls string feedbacks displayed on input devices, using the StringFeedbackControl structure. The members of that structure are:

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 BellFeedback controls a bell on an input device, using the BellFeedbackControl structure. The members of that structure are:

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)

To ring a bell on an extension input device, use the XDeviceBell protocol request.

Feedback class LedFeedback controls lights on an input device, using the LedFeedbackControl structure. The members of that structure are:

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)

Errors returned by this function: BadDevice, BadMatch, BadFeedBack.

To ring a bell on a extension input device, use XDeviceBell.

int
XDeviceBell (display, device, feedbackclass, feedbackid, percent)
        Display *display;
        XDevice *device;
        XID     feedbackclass, feedbackid;
        int     percent;

This function is analogous to the core XBell function. It rings the specified bell on the specified input device feedback, using the specified volume. The specified volume is relative to the base volume for the feedback. If the value for the percent argument is not in the range -100 to 100 inclusive, a BadValue error results. The volume at which the bell rings when the percent argument is nonnegative is:

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

Errors returned by this function: BadDevice, BadValue.

To get the key mapping of an extension device that supports input class Keys, use XGetDeviceKeyMapping.

KeySym
*XGetDeviceKeyMapping (display, device, first_keycode_wanted, 
    keycode_count, keysyms_per_keycode_return)
        Display *display;
        XDevice *device;
        KeyCode first_keycode_wanted;
        int     keycode_count;
        int     *keysyms_per_keycode_return;

This function is analogous to the core XGetKeyboardMapping function. It returns the symbols for the specified number of keycodes for the specified extension device.

XGetDeviceKeyMapping returns the symbols for the specified number of keycodes for the specified extension device, starting with the specified keycode. The first_keycode_wanted must be greater than or equal to min-keycode as returned by the XListInputDevices request (else a BadValue error), and

first_keycode_wanted + keycode_count – 1

must be less than or equal to max-keycode as returned by the XListInputDevices request (else a BadValue error).

The number of elements in the keysyms list is

keycode_count * keysyms_per_keycode_return

and KEYSYM number N (counting from zero) for keycode K has an index (counting from zero) of

(K – first_keycode_wanted) * keysyms_per_keycode_return + N

in keysyms. 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 NoSymbol is used to fill in unused elements for individual keycodes.

You should use XFree to free the data returned by this function.

If the specified device has not first been opened by this client via XOpenDevice, this request will fail with a BadDevice error. If that device does not support input class Keys, this request will fail with a BadMatch error.

Errors returned by this function: BadDevice, BadMatch, BadValue.

To change the keyboard mapping of an extension device that supports input class Keys, use XChangeDeviceKeyMapping.

int
XChangeDeviceKeyMapping (display, device, first_keycode, 
    keysyms_per_keycode, keysyms, num_codes)
        Display *display;
        XDevice *device;
        int     first_keycode;
        int     keysyms_per_keycode;
        KeySym  *keysyms;
        int     num_codes;

This function is analogous to the core XChangeKeyboardMapping function. It defines the symbols for the specified number of keycodes for the specified extension keyboard device.

If the specified device has not first been opened by this client via XOpenDevice, this request will fail with a BadDevice error. If the specified device does not support input class Keys, this request will fail with a BadMatch error.

The number of elements in the keysyms list must be a multiple of keysyms_per_keycode. Otherwise, XChangeDeviceKeyMapping generates a BadLength error. The specified first_keycode must be greater than or equal to the min_keycode value returned by the ListInputDevices request, or this request will fail with a BadValue error. In addition, if the following expression is not less than the max_keycode value returned by the ListInputDevices request, the request will fail with a BadValue error:

first_keycode + (num_codes / keysyms_per_keycode) - 1

Errors returned by this function: BadDevice, BadMatch, BadValue, BadAlloc.

To obtain the keycodes that are used as modifiers on an extension device that supports input class Keys, use XGetDeviceModifierMapping.

XModifierKeymap 
*XGetDeviceModifierMapping (display, device)
        Display *display;
        XDevice *device;

This function is analogous to the core XGetModifierMapping function. The XGetDeviceModifierMapping function returns a newly created XModifierKeymap structure that contains the keys being used as modifiers for the specified device. The structure should be freed after use with XFreeModifierMapping. If only zero values appear in the set for any modifier, that modifier is disabled.

Errors returned by this function: BadDevice, BadMatch.

To set which keycodes that are to be used as modifiers for an extension device, use XSetDeviceModifierMapping.

int 
XSetDeviceModifierMapping (display, device, modmap)
        Display         *display;
        XDevice         *device;
        XModifierKeymap *modmap;

This function is analogous to the core XSetModifierMapping function. The XSetDeviceModifierMapping function specifies the keycodes of the keys, if any, that are to be used as modifiers. A zero value means that no key should be used. No two arguments can have the same nonzero keycode value. Otherwise, XSetDeviceModifierMapping generates a BadValue error. There are eight modifiers, and the modifiermap member of the XModifierKeymap structure contains eight sets of max_keypermod keycodes, one for each modifier in the order Shift, Lock, Control, Mod1, Mod2, Mod3, Mod4, and Mod5. Only nonzero keycodes have meaning in each set, and zero keycodes are ignored. In addition, all of the nonzero keycodes must be in the range specified by min_keycode and max_keycode reported by the XListInputDevices function. Otherwise, XSetModifierMapping generates a BadValue error. No keycode may appear twice in the entire map. Otherwise, it generates a BadValue error.

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 MappingFailed, and none of the modifiers are changed. If the new keycodes specified for a modifier differ from those currently defined and any (current or new) keys for that modifier are in the logically down state, the status reply is MappingBusy, and none of the modifiers are changed. XSetModifierMapping generates a DeviceMappingNotify event on a MappingSuccess status.

XSetDeviceModifierMapping can generate BadDevice, BadMatch, BadAlloc, and BadValue errors.

To set the mapping of the buttons on an extension device, use XSetDeviceButtonMapping.

int
XSetDeviceButtonMapping (display, device, map, nmap)
        Display          *display;
        XDevice          *device;
        unsigned char    map[];
        int              nmap;

The XSetDeviceButtonMapping function sets the mapping of the buttons on an extension device. If it succeeds, the X server generates a DeviceMappingNotify event, and XSetDeviceButtonMapping returns MappingSuccess. Elements of the list are indexed starting from one. The length of the list must be the same as XGetDeviceButtonMapping would return, or a BadValue error results. The index is a button number, and the element of the list defines the effective number. A zero element disables a button, and elements are not restricted in value by the number of physical buttons. However, no two elements can have the same nonzero value, or a BadValue error results. If any of the buttons to be altered are logically in the down state, XSetDeviceButtonMapping returns MappingBusy, and the mapping is not changed.

XSetDeviceButtonMapping can generate BadDevice, BadMatch, and BadValue errors.

To get the button mapping, use XGetDeviceButtonMapping.

int
XGetDeviceButtonMapping (display, device, map_return, nmap)
        Display          *display;
        XDevice          *device;
        unsigned char    map_return[];
        int              nmap;

The XGetDeviceButtonMapping function returns the current mapping of the specified extension device. Elements of the list are indexed starting from one. XGetDeviceButtonMapping returns the number of physical buttons actually on the pointer. The nominal mapping for the buttons is the identity mapping: map[i]=i. The nmap argument specifies the length of the array where the button mapping is returned, and only the first nmap elements are returned in map_return.

Errors returned by this function: BadDevice, BadMatch.

To obtain information that describes the state of the keys, buttons and valuators of an extension device, use XQueryDeviceState.

XDeviceState 
*XQueryDeviceState (display, device)
        Display *display;
        XDevice *device;

The XQueryDeviceState function returns a pointer to an XDeviceState structure. This structure points to a list of structures that describe the state of the keys, buttons, and valuators on the device.

typedef struct {
        XID            device_id;
        int            num_classes;
        XInputClass    *data;
} XDeviceState;

The class field contains a class identifier. This identifier can be compared with constants defined in the file XI.h. Currently defined constants are: KeyClass, ButtonClass, and ValuatorClass.

The length field contains the length of the structure and can be used by clients to traverse the list.

The valuators field contains a pointer to an array of integers that describe the current value of the valuators. If the mode is Relative, these values are undefined.

typedef struct {
    unsigned char    class;
    unsigned char    length;
    unsigned char    num_valuators;
    unsigned char    mode;
    int              *valuators;
} XValuatorState;

You should use XFreeDeviceState to free the data returned by this function.

Errors returned by this function: BadDevice.

void
XFreeDeviceState (state)
        XDeviceState *state;

This function frees the device state data.

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 <X11/X.h>. Extension event types are not constants. Instead, they are dynamically allocated by the extension's request to the X server when the extension is initialized. Because of this, extension event types must be obtained by the client from the server.

The client program determines the event type for an extension event by using the information returned by the XOpenDevice request. This type can then be used for comparison with the type field of events received by the client.

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 <X11/X.h>. Extension event classes are not constants. Instead, they are dynamically allocated by the extension's request to the X server when the extension is initialized. Because of this, extension event classes must be obtained by the client from the server.

The event class for an extension event and device is obtained from information returned by the XOpenDevice function. This class can then be used in an XSelectExtensionEvent request to ask that events of that type from that device be sent to the client program.

For DeviceButtonPress events, the client may specify whether or not an implicit passive grab should be done when the button is pressed. If the client wants to guarantee that it will receive a DeviceButtonRelease event for each DeviceButtonPress event it receives, it should specify the DeviceButtonPressGrab class in addition to the DeviceButtonPress class. This restricts the client in that only one client at a time may request DeviceButtonPress events from the same device and window if any client specifies this class.

If any client has specified the DeviceButtonPressGrab class, any requests by any other client that specify the same device and window and specify either DeviceButtonPress or DeviceButtonPressGrab will cause an Access error to be generated.

If only the DeviceButtonPress class is specified, no implicit passive grab will be done when a button is pressed on the device. Multiple clients may use this class to specify the same device and window combination.

The client may also select DeviceMotion events only when a button is down. It does this by specifying the event classes DeviceButton1Motion through DeviceButton5Motion. An input device will only support as many button motion classes as it has buttons.

Each extension event type has a corresponding structure declared in <X11/extensions/XInput.h>. All event structures have the following members:

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.

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 char  axes_count;
    unsigned char  first_axis;
    unsigned int   device_state; /* device key or button
                                    mask */
    int            axis_data[6];
    } XDeviceKeyEvent;
typedef XDeviceKeyEvent XDeviceKeyPressedEvent;
typedef XDeviceKeyEvent XDeviceKeyReleasedEvent;

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 char axes_count;
    unsigned char first_axis;
    unsigned int  device_state; /* device key or 
                                   button mask*/
    int           axis_data[6];
    } XDeviceButtonEvent;

typedef XDeviceButtonEvent XDeviceButtonPressedEvent;
typedef XDeviceButtonEvent XDeviceButtonReleasedEvent;

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;

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;

    0x01        Relative = 0, Absolute = 1
    0x02        InProximity = 0, OutOfProximity = 1

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;

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;

typedef struct {
    int            type;
    unsigned long  serial;
    Bool           send_event;
    Display        *display;
    Window         window;
    XID            deviceid;
    Time           time;
    int            request;
} XChangeDeviceNotifyEvent;

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 char   axes_count;
    unsigned char   first_axis;
    unsigned int    device_state; /* device key or button
                                     mask */
    int             axis_data[6];
    } XProximityNotifyEvent;
typedef XProximityNotifyEvent XProximityInEvent;
typedef XProximityNotifyEvent XProximityOutEvent;

XExtensionVersion
*XGetExtensionVersion (display, name)
        Display *display;
        char    *name;

typedef struct
    {
    Bool  present;   
    short major_version;
    short minor_version;
    } XExtensionVersion;

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 XListInputDevices function, which will return a list of all devices that can be opened by the X server. The client program can use one of the names defined in the XI.h header file in an XInternAtom request, to determine the device type of the desired device. This type can then be compared with the device types returned by the XListInputDevices request.

XDeviceInfo 
*XListInputDevices (display, ndevices)
        Display *display;
        int     *ndevices;            /* RETURN */

This function allows a client to determine which devices are available for X input and information about those devices. An array of XDeviceInfo structures is returned, with one element in the array for each device. The number of devices is returned in the ndevices argument.

The X pointer device and X keyboard device are reported, as well as all available extension input devices. The use field of the XDeviceInfo structure specifies the current use of the device. If the value of this field is IsXPointer, the device is the X pointer device. If the value is IsXKeyboard, the device is the X keyboard device. If the value is IsXExtensionDevice, the device is available for use as an extension input device.

Each XDeviceInfo entry contains a pointer to a list of structures that describe the characteristics of each class of input supported by that device. The num_classes field contains the number of entries in that list.

If the device supports input class Valuators, one of the structures pointed to by the XDeviceInfo structure will be an XValuatorInfo structure. The axes field of that structure contains the address of an array of XAxisInfo structures. There is one element in this array for each axis of motion reported by the device. The number of elements in this array is contained in the num_axes element of the XValuatorInfo structure. The size of the motion buffer for the device is reported in the motion_buffer field of the XValuatorInfo structure.

The XDeviceInfo structure contains the following information:

typedef struct _XDeviceInfo
    {
    XID                 id;        
    Atom                type;
    char                *name;
    int                 num_classes;
    int                 use;
    XAnyClassPtr        inputclassinfo;
    } XDeviceInfo;

The structures pointed to by the XDeviceInfo structure contain the following information:

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 XAxisInfo structure pointed to by the XValuatorInfo structure contains the following information.

typedef struct _XAxisInfo {
    int     resolution;
    int     min_value;
    int     max_value;
    } XAxisInfo;

The following atom names are defined in the file XI.h:

MOUSE
TABLET
KEYBOARD
TOUCHSCREEN
TOUCHPAD
BUTTONBOX
BARCODE
KNOB_BOX
TRACKBALL
QUADRATURE
SPACEBALL
DATAGLOVE
EYETRACKER
CURSORKEYS
FOOTMOUSE
ID_MODULE
ONE_KNOB
NINE_KNOB

These names can be used in an XInternAtom request to return an atom that can be used for comparison with the type field of the XDeviceInfo structure.

This function returns NULL if there are no input devices to list. You should use XFreeDeviceList to free the data returned by XListInputDevices.

void
XFreeDeviceList (list) 
    XDeviceInfo *list;

This function frees the list of input device information.

Each client program that wishes to access an extension device must request that the server open that device. This is done via the XOpenDevice request. That request is defined as follows:

XDevice 
*XOpenDevice(display, device_id)
        Display *display;
        XID     device_id;

This function opens the device for the requesting client and returns an XDevice structure on success. That structure is defined as follows:

typedef struct {
        XID                    device_id;
        int                    num_classes;
        XInputClassInfo        *classes;
} XDevice;

The XDevice structure contains a pointer to an array of XInputClassInfo structures. Each element in that array contains information about events of a particular input class supported by the input device.

The XInputClassInfo structure is defined as follows:

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, i.e.

DeviceKeyPress (XDevice *device, event_type, event_class)

The macro will fill in the values of the event class to be used in an XSelectExtensionEvent request to select the event, and the event type to be used in comparing with the event types of events received via XNextEvent.

Errors returned by this function: BadDevice.

Before terminating, the client program should request that the server close the device. This is done via the XCloseDevice request.

A client may open the same extension device more than once. Requests after the first successful one return an additional XDevice structure with the same information as the first, but otherwise have no effect. A single XCloseDevice request will terminate that client's access to the device.

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.

int
XCloseDevice(display, device)
        Display *display;
        XDevice *device;

This function closes the device for the requesting client, and frees the XDevice structure.

Errors returned by this function: BadDevice.

Some devices are capable of reporting either relative or absolute motion data. To change the mode of a device from relative to absolute, use the XSetDeviceMode function. The valid values are Absolute or Relative.

int
XSetDeviceMode (display, device, mode)
        Display *display;
        XDevice *device;
        int     mode;

This function allows a client to request the server to change the mode of a device that is capable of reporting either absolute positional data or relative motion data. If the device is invalid, or the client has not previously requested that the server open the device via an XOpenDevice request, this request will fail with a BadDevice error. If the device does not support input class Valuators, or if it is not capable of reporting the specified mode, the request will fail with a BadMatch error.

This request will fail and return DeviceBusy if another client has already opened the device and requested a different mode.

Errors returned by this function: BadDevice, BadMatch, BadMode, DeviceBusy.

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 Absolute. To initialize the valuators on such a device, use the XSetDeviceValuators function.

Status
XSetDeviceValuators (display, device, valuators, first_valuator, 
        num_valuators)
        Display *display;
        XDevice *device;
        int     *valuators, first_valuator, num_valuators;

This function initializes 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. If the number of valuators supported by the device is less than the expression

      first_valuator + num_valuators, 

a BadValue error will result.

If the request succeeds, Success is returned. If the specifed device is grabbed by some other client, the request will fail and a status of AlreadyGrabbed will be returned.

This request can fail with BadLength, BadDevice, BadMatch, and BadValue errors.

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

XDeviceControl
*XGetDeviceControl (display, device, control)
    Display *display;
    XDevice *device;
    int control;

This request returns the current state of the specified device control. If the target X server does not support that device control, a BadValue error will be returned. If the specified device does not support that device control, a BadMatch error will be returned.

If the request is successful, a pointer to a generic XDeviceState structure is returned. The information returned varies according to the specified control and is mapped by a structure appropriate for that control. The first two fields are common to all device controls:

typedef struct {
      XID     control;
      int     length;
} XDeviceState;

The control may be compared to constants defined in the file XI.h. Currently defined device controls include DEVICE_RESOLUTION.

The information returned for the DEVICE_RESOLUTION control is defined in the following structure: include:

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 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, XGetDeviceControl will fail with a BadMatch error if the specified device has no valuators.

Other errors returned by this request: BadValue.

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

Status
XChangeDeviceControl (display, device, control, value)
    Display *display;
    XDevice *device;
    int control;
    XDeviceControl *value;

This request changes the current state of the specified device control. If the target X server does not support that device control, a BadValue error will be returned. If the specified device does not support that device control, a BadMatch error will be returned. If another client has the target device grabbed, a status of AlreadyGrabbed will be returned. If another client has the device open and has set it to a conflicting state, a status of DeviceBusy will be returned.

If the request fails for any reason, the device control will not be changed.

If the request is successful, the device control will be changed and a status of Success will be returned. The information passed varies according to the specified control and is mapped by a structure appropriate for that control. The first two fields are common to all device controls:

typedef struct {
      XID     control;
      int     length;
} XDeviceControl;

The control may be set using constants defined in the file XI.h. Currently defined device controls include DEVICE_RESOLUTION.

The information that can be changed by the DEVICE_RESOLUTION control is defined in the following structure:

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. num_valuators specifies the number of valuators in the resolutions list.

When this control is specified, XChangeDeviceControl will fail with a BadMatch error if the specified device has no valuators. If a resolution is specified that is not within the range of valid values (as returned by XGetDeviceControl) the request will fail with a BadValue error. If the number of valuators supported by the device is less than the expression

      first_valuator + num_valuators, 

a BadValue error will result.

Device input events are selected using the XSelectExtensionEvent function. The parameters passed are a pointer to a list of classes that define the desired event types and devices, a count of the number of elements in the list, and the id of the window from which events are desired.

int
XSelectExtensionEvent (display, window, event_list, event_count)
        Display     *display;
        Window      window;
        XEventClass *event_list;
        int         event_count;

This function requests the server to send events that match the events and devices described by the event list and that come from the requested window. The elements of the XEventClass array are the event_class values returned obtained by invoking a macro with the pointer to a Device structure returned by the XOpenDevice request. For example, the DeviceKeyPress macro, invoked in the form:

DeviceKeyPress (XDevice *device, event_type, event_class)

returns the XEventClass for DeviceKeyPress events from the specified device.

Macros are defined for the following event classes: DeviceKeyPress, DeviceKeyRelease, DeviceButtonPress, DeviceButtonRelease, DeviceMotionNotify, DeviceFocusIn, DeviceFocusOut, ProximityIn, ProximityOut, DeviceStateNotify, DeviceMappingNotify, ChangeDeviceNotify, DevicePointerMotionHint, DeviceButton1Motion, DeviceButton2Motion, DeviceButton3Motion, DeviceButton4Motion, DeviceButton5Motion, DeviceButtonMotion, DeviceOwnerGrabButton, and DeviceButtonPressGrab. To get the next available event from within a client program, use the core XNextEvent function. This returns the next event whether it came from a core device or an extension device.

Succeeding XSelectExtensionEvent requests using XEventClasses for the same device as was specified on a previous request will replace the previous set of selected events from that device with the new set.

Errors returned by this function: BadWindow, BadAccess, BadClass, BadLength.

To determine which extension events are currently selected from a given window, use XGetSelectedExtensionEvents.

int
XGetSelectedExtensionEvents (display, window, this_client_count, 
        this_client, all_clients_count, all_clients)
        Display     *display;
        Window      window;
        int         *this_client_count;  /* RETURN */
        XEventClass **this_client;       /* RETURN */
        int         *all_clients_count;  /* RETURN */
        XEventClass **all_clients;       /* RETURN */

This function returns pointers to two event class arrays. One lists the extension events selected by this client from the specified window. The other lists the extension events selected by all clients from the specified window. This information is analogous to that returned in the fields your_event_mask and all_event_masks of the XWindowAttributes structure when an XGetWindowAttributes request is made.

You should use XFree to free the two arrays returned by this function.

Errors returned by this function: BadWindow.

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.

XChangeDeviceDontPropagateList adds an event to or deletes an event from the do_not_propagate list of extension events for the specified window. There is one list per window, and the list remains for the life of the window. The list is not altered if a client that changed the list terminates.

Suppression of event propagation is not allowed for all events. If a specified XEventClass is invalid because suppression of that event is not allowed, a BadClass error will result.

int
XChangeDeviceDontPropagateList (display, window, event_count, 
        events, mode)
    Display     *display;
    Window      window;
    int         event_count;
    XEventClass *events;
    int         mode;

This function can return BadWindow, BadClass, and BadMode errors.

XGetDeviceDontPropagateList allows a client to determine the do_not_propagate list of extension events for the specified window.

XEventClass
*XGetDeviceDontPropagateList (display, window, event_count)
    Display *display;
    Window  window;
    int     *event_count;	/*RETURN */

An array of XEventClasses is returned by this function. Each XEventClass represents a device/ event type pair.

This function can return a BadWindow error.

You should use XFree to free the data returned by this function.

XSendExtensionEvent allows a client to send an extension event to another client.

int
XSendExtensionEvent (display, device, window, propagate, 
        event_count, event_list, event)
    Display     *display;
    XDevice     *device;
    Window      window;
    Bool        propagate;
    int         event_count;
    XEventClass *event_list;
    XEvent      *event;

The XSendExtensionEvent function identifies the destination window, determines which clients should receive the specified event, and ignores any active grabs. This function requires a list of XEventClasses to be specified. These are obtained by opening an input device with the XOpenDevice request.

This function uses the window argument to identify the destination window as follows:

To determine which clients should receive the specified events, XSendExtensionEvent uses the propagate argument as follows:

The event in the XEvent structure must be one of the events defined by the input extension, so that the X server can correctly byte swap the contents as necessary. The contents of the event are otherwise unaltered and unchecked by the X server except to force send_event to True in the forwarded event and to set the sequence number in the event correctly.

XSendExtensionEvent returns zero if the conversion-to-wire protocol failed, otherwise it returns nonzero.

This function can generate BadDevice, BadValue, BadWindow, or BadClass errors.

XDeviceTimeCoord 
*XGetDeviceMotionEvents (display, device, start, stop, 
        nevents_return, mode_return, axis_count_return);
        Display *display;
        XDevice *device;
        Time    start, stop;
        int     *nevents_return;
        int     *mode_return;
        int     *axis_count_return;

This function returns all positions in the device's motion history buffer that fall between the specified start and stop times inclusive. If the start time is in the future, or is later than the stop time, no positions are returned.

The return type for this function is a structure defined as follows:

typedef struct {
        Time time;
        unsigned int *data;
} XDeviceTimeCoord;

The data field of the XDeviceTimeCoord structure 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 Absolute, the data items are the raw values generated by the device. These may be scaled by the client program using the maximum values that the device can generate for each axis of motion that it reports. The maximum value for each axis is reported in the max_val field of the XAxisInfo structure. This structure is part of the information returned by the XListInputDevices request.

If the mode is Relative, the data items are the relative values generated by the device. The client program must choose an initial position for the device and maintain a current position by accumulating these relative values.

Consecutive calls to this function may return data of different modes, if some client program has changed the mode of the device via an XSetDeviceMode request.

You should use XFreeDeviceMotionEvents to free the data returned by this function.

Errors returned by this function: BadDevice, BadMatch.

void
XFreeDeviceMotionEvents (events)
        XDeviceTimeCoord *events;

This function frees the array of motion information.

The following information is contained in the <X11/extensions/XInput.h> and <X11/extensions/XI.h> header files:

/* 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;

/*******************************************************************
 *
 * 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.
 *
 */

typedef struct {
        XID            device_id;
        int            num_classes;
        XInputClass    *data;
} XDeviceState;

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_bons;
    char             buttons[32];
} XButtonState;

/*******************************************************************
 *
 * Function definitions.
 *
 */

XDevice                *XOpenDevice();
XDeviceInfo            *XListInputDevices();
XDeviceTimeCoord       *XGetDeviceMotionEvents();
KeySym                 *XGetDeviceKeyMapping();
XModifierKeymap        *XGetDeviceModifierMapping();
XFeedbackState         *XGetFeedbackControl();
XExtensionVersion      *XGetExtensionVersion();
XDeviceState           *XQueryDeviceState();
XEventClass            *XGetDeviceDontPropagateList();
#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 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 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 NoSuchExtension                              1

#define COUNT                                        0
#define CREATE                                       1

#define NewPointer                                   0
#define NewKeyboard                                  1

#define XPOINTER                                     0
#define XKEYBOARD                                    1

#define UseXKeyboard                                 0

#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 Relative                                    0
#define Absolute                                    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_ */