+ added unit xinput - a header translation of X11/extensions/XInput.h

git-svn-id: trunk@33620 -

.gitattributes

@@ -8054,6 +8054,7 @@ packages/x11/src/xft.pas svneol=native#text/pascal
 packages/x11/src/xi.pp svneol=native#text/plain
 packages/x11/src/xi2.pp svneol=native#text/plain
 packages/x11/src/xinerama.pp svneol=native#text/plain
+packages/x11/src/xinput.pp svneol=native#text/plain
 packages/x11/src/xkb.pp svneol=native#text/plain
 packages/x11/src/xkblib.pp svneol=native#text/plain
 packages/x11/src/xlib.pp svneol=native#text/plain
@@ -8064,6 +8065,7 @@ packages/x11/src/xshm.pp svneol=native#text/plain
 packages/x11/src/xutil.pp svneol=native#text/plain
 packages/x11/src/xv.pp svneol=native#text/plain
 packages/x11/src/xvlib.pp svneol=native#text/plain
+packages/x11/tests/xinput_linktest.pp svneol=native#text/plain
 packages/xforms/Makefile svneol=native#text/plain
 packages/xforms/Makefile.fpc svneol=native#text/plain
 packages/xforms/Makefile.fpc.fpcmake svneol=native#text/plain

packages/x11/fpmake.pp

@@ -51,6 +51,13 @@ begin
         end;
     T:=P.Targets.AddUnit('xi.pp');
     T:=P.Targets.AddUnit('xi2.pp');
+    T:=P.Targets.AddUnit('xinput.pp');
+      with T.Dependencies do
+        begin
+          AddUnit('x');
+          AddUnit('xlib');
+          AddUnit('xi');
+        end;
     T:=P.Targets.AddUnit('xkblib.pp');
       with T.Dependencies do
         begin

packages/x11/src/xinput.pp

@@ -0,0 +1,1339 @@
+(************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
+
+			All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Hewlett-Packard not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+********************************************************)
+
+{ Definitions used by the library and client }
+
+unit xinput;
+
+interface
+
+{$PACKRECORDS C}
+{$MODE objfpc}
+
+uses
+  ctypes, x, xlib, xi;
+
+const
+  libXi = 'Xi';
+
+  _deviceKeyPress         = 0;
+  _deviceKeyRelease       = 1;
+
+  _deviceButtonPress      = 0;
+  _deviceButtonRelease    = 1;
+
+  _deviceMotionNotify     = 0;
+
+  _deviceFocusIn          = 0;
+  _deviceFocusOut         = 1;
+
+  _proximityIn            = 0;
+  _proximityOut           = 1;
+
+  _deviceStateNotify      = 0;
+  _deviceMappingNotify    = 1;
+  _changeDeviceNotify     = 2;
+(* Space of 3 between is necessary! Reserved for DeviceKeyStateNotify,
+   DeviceButtonStateNotify, DevicePresenceNotify (essentially unused). This
+   code has to be in sync with FixExtensionEvents() in xserver/Xi/extinit.c *)
+  _propertyNotify         = 6;
+
+{ We need the declaration for DevicePresence. }
+function _XiGetDevicePresenceNotifyEvent(dpy: PDisplay): cint; cdecl; external libXi;
+procedure _xibaddevice(dpy: PDisplay; error: Pcint); cdecl; external libXi;
+procedure _xibadclass(dpy: PDisplay; error: Pcint); cdecl; external libXi;
+procedure _xibadevent(dpy: PDisplay; error: Pcint); cdecl; external libXi;
+procedure _xibadmode(dpy: PDisplay; error: Pcint); cdecl; external libXi;
+procedure _xidevicebusy(dpy: PDisplay; error: Pcint); cdecl; external libXi;
+
+procedure DevicePresence(dpy: PDisplay; out event_type: cint; event_class: TXEventClass); inline;
+
+{ Errors }
+procedure BadDevice(dpy: PDisplay; out error: cint); inline;
+
+procedure BadClass(dpy: PDisplay; out error: cint); inline;
+
+procedure BadEvent(dpy: PDisplay; out error: cint); inline;
+
+procedure BadMode(dpy: PDisplay; out error: cint); inline;
+
+procedure DeviceBusy(dpy: PDisplay; out error: cint); inline;
+
+type
+
+(***************************************************************
+ *
+ * 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.
+ *
+ *)
+
+  PXDeviceKeyEvent = ^TXDeviceKeyEvent;
+  TXDeviceKeyEvent = record
+    _type: cint;                 { of event }
+    serial: culong;              { # of last request processed }
+    send_event: TBool;           { true if from SendEvent request }
+    display: PDisplay;           { Display the event was read from }
+    window: TWindow;             { "event" window reported relative to }
+    deviceid: TXID;
+    root: TWindow;               { root window event occured on }
+    subwindow: TWindow;          { child window }
+    time: TTime;                 { milliseconds }
+    x, y: cint;                  { x, y coordinates in event window }
+    x_root: cint;                { coordinates relative to root }
+    y_root: cint;                { coordinates relative to root }
+    state: cuint;                { key or button mask }
+    keycode: cuint;              { detail }
+    same_screen: TBool;          { same screen flag }
+    device_state: cuint;         { device key or button mask }
+    axes_count: cuchar;
+    first_axis: cuchar;
+    axis_data: array [0..5] of cint;
+  end;
+
+  PXDeviceKeyPressedEvent = ^TXDeviceKeyPressedEvent;
+  TXDeviceKeyPressedEvent = TXDeviceKeyEvent;
+  PXDeviceKeyReleasedEvent = ^TXDeviceKeyReleasedEvent;
+  TXDeviceKeyReleasedEvent = TXDeviceKeyEvent;
+
+(*******************************************************************
+ *
+ * DeviceButton events.  These events are sent by extension devices
+ * that support input class Buttons.
+ *
+ *)
+
+  PXDeviceButtonEvent = ^TXDeviceButtonEvent;
+  TXDeviceButtonEvent = record
+    _type: cint;                { of event }
+    serial: culong;             { # of last request processed by server }
+    send_event: TBool;          { true if from a SendEvent request }
+    display: PDisplay;          { Display the event was read from }
+    window: TWindow;            { "event" window reported relative to }
+    deviceid: TXID;
+    root: TWindow;              { root window that the event occured on }
+    subwindow: TWindow;         { child window }
+    time: TTime;                { milliseconds }
+    x, y: cint;                 { x, y coordinates in event window }
+    x_root: cint;               { coordinates relative to root }
+    y_root: cint;               { coordinates relative to root }
+    state: cuint;               { key or button mask }
+    button: cuint;              { detail }
+    same_screen: TBool;         { same screen flag }
+    device_state: cuint;        { device key or button mask }
+    axes_count: cuchar;
+    first_axis: cuchar;
+    axis_data: array [0..5] of cint;
+  end;
+
+  PXDeviceButtonPressedEvent = ^TXDeviceButtonPressedEvent;
+  TXDeviceButtonPressedEvent = TXDeviceButtonEvent;
+  PXDeviceButtonReleasedEvent = ^TXDeviceButtonReleasedEvent;
+  TXDeviceButtonReleasedEvent = TXDeviceButtonEvent;
+
+(*******************************************************************
+ *
+ * DeviceMotionNotify event.  These events are sent by extension devices
+ * that support input class Valuators.
+ *
+ *)
+
+  PXDeviceMotionEvent = ^TXDeviceMotionEvent;
+  TXDeviceMotionEvent = record
+    _type: cint;               { of event }
+    serial: culong;            { # of last request processed by server }
+    send_event: TBool;         { true if from a SendEvent request }
+    display: PDisplay;         { Display the event was read from }
+    window: TWindow;           { "event" window reported relative to }
+    deviceid: TXID;
+    root: TWindow;             { root window that the event occured on }
+    subwindow: TWindow;        { child window }
+    time: TTime;               { milliseconds }
+    x, y: cint;                { x, y coordinates in event window }
+    x_root: cint;              { coordinates relative to root }
+    y_root: cint;              { coordinates relative to root }
+    state: cuint;              { key or button mask }
+    is_hint: char;             { detail }
+    same_screen: TBool;        { same screen flag }
+    device_state: cuint;       { device key or button mask }
+    axes_count: cuchar;
+    first_axis: cuchar;
+    axis_data: array [0..5] of cint;
+  end;
+
+(*******************************************************************
+ *
+ * DeviceFocusChange events.  These events are sent when the focus
+ * of an extension device that can be focused is changed.
+ *
+ *)
+
+  PXDeviceFocusChangeEvent = ^TXDeviceFocusChangeEvent;
+  TXDeviceFocusChangeEvent = record
+    _type: cint;              { of event }
+    serial: culong;           { # of last request processed by server }
+    send_event: TBool;        { true if from a SendEvent request }
+    display: PDisplay;        { Display the event was read from }
+    window: TWindow;          { "event" window reported relative to }
+    deviceid: TXID;
+    mode: cint;               { NotifyNormal, NotifyGrab, NotifyUngrab }
+    detail: cint;
+        (*
+         * NotifyAncestor, NotifyVirtual, NotifyInferior,
+         * NotifyNonLinear,NotifyNonLinearVirtual, NotifyPointer,
+         * NotifyPointerRoot, NotifyDetailNone
+         *)
+    time: TTime;
+  end;
+
+  PXDeviceFocusInEvent = ^TXDeviceFocusInEvent;
+  TXDeviceFocusInEvent = TXDeviceFocusChangeEvent;
+  PXDeviceFocusOutEvent = ^TXDeviceFocusOutEvent;
+  TXDeviceFocusOutEvent = TXDeviceFocusChangeEvent;
+
+(*******************************************************************
+ *
+ * ProximityNotify events.  These events are sent by those absolute
+ * positioning devices that are capable of generating proximity information.
+ *
+ *)
+
+  PXProximityNotifyEvent = ^TXProximityNotifyEvent;
+  TXProximityNotifyEvent = record
+    _type: cint;               { ProximityIn or ProximityOut }
+    serial: culong;            { # of last request processed by server }
+    send_event: TBool;         { true if this came from a SendEvent request }
+    display: PDisplay;         { Display the event was read from }
+    window: TWindow;
+    deviceid: TXID;
+    root: TWindow;
+    subwindow: TWindow;
+    time: TTime;
+    x, y: cint;
+    x_root, y_root: cint;
+    state: cuint;
+    same_screen: TBool;
+    device_state: cuint;       { device key or button mask }
+    axes_count: cuchar;
+    first_axis: cuchar;
+    axis_data: array [0..5] of cint;
+  end;
+  PXProximityInEvent = ^TXProximityInEvent;
+  TXProximityInEvent = TXProximityNotifyEvent;
+  PXProximityOutEvent = ^TXProximityOutEvent;
+  TXProximityOutEvent = TXProximityNotifyEvent;
+
+(*******************************************************************
+ *
+ * DeviceStateNotify events are generated on EnterWindow and FocusIn 
+ * for those clients who have selected DeviceState.
+ *
+ *)
+
+  PXInputClass = ^TXInputClass;
+  TXInputClass = record
+    c_class: cuchar;
+    length: cuchar;
+  end;
+
+  PXDeviceStateNotifyEvent = ^TXDeviceStateNotifyEvent;
+  TXDeviceStateNotifyEvent = record
+     _type: cint;
+     serial: culong;             { # of last request processed by server }
+     send_event: TBool;          { true if this came from a SendEvent request }
+     display: PDisplay;          { Display the event was read from }
+     window: TWindow;
+     deviceid: TXID;
+     time: TTime;
+     num_classes: cint;
+     data: array [0..63] of cchar;
+  end;
+
+  PXValuatorStatus = ^TXValuatorStatus;
+  TXValuatorStatus = record
+    c_class: cuchar;
+    length: cuchar;
+    num_valuators: cuchar;
+    mode: cuchar;
+    valuators: array [0..5] of cint;
+  end;
+
+  PXKeyStatus = ^TXKeyStatus;
+  TXKeyStatus = record
+    c_class: cuchar;
+    length: cuchar;
+    num_keys: cshort;
+    keys: array [0..31] of cchar;
+  end;
+
+  PXButtonStatus = ^TXButtonStatus;
+  TXButtonStatus = record
+    c_class: cuchar;
+    length: cuchar;
+    num_buttons: cshort	;
+    buttons: array [0..31] of cchar;
+  end;
+
+(*******************************************************************
+ *
+ * DeviceMappingNotify event.  This event is sent when the key mapping,
+ * modifier mapping, or button mapping of an extension device is changed.
+ *
+ *)
+
+  PXDeviceMappingEvent = ^TXDeviceMappingEvent;
+  TXDeviceMappingEvent = record
+    _type: cint;
+    serial: culong;             { # of last request processed by server }
+    send_event: TBool;          { true if this came from a SendEvent request }
+    display: PDisplay;          { Display the event was read from }
+    window: TWindow;            { unused }
+    deviceid: TXID;
+    time: TTime;
+    request: cint;              { one of MappingModifier, MappingKeyboard,
+                                   MappingPointer }
+    first_keycode: cint;        { first keycode }
+    count: cint;                { defines range of change w. first_keycode }
+  end;
+
+(*******************************************************************
+ *
+ * ChangeDeviceNotify event.  This event is sent when an 
+ * XChangeKeyboard or XChangePointer request is made.
+ *
+ *)
+
+  PXChangeDeviceNotifyEvent = ^TXChangeDeviceNotifyEvent;
+  TXChangeDeviceNotifyEvent = record
+    _type: cint;
+    serial: culong;             { # of last request processed by server }
+    send_event: TBool;          { true if this came from a SendEvent request }
+    display: PDisplay;          { Display the event was read from }
+    window: TWindow;            { unused }
+    deviceid: TXID;
+    time: TTime;
+    request: cint;              { NewPointer or NewKeyboard }
+  end;
+
+(*******************************************************************
+ *
+ * DevicePresenceNotify event.  This event is sent when the list of
+ * input devices changes, in which case devchange will be false, and
+ * no information about the change will be contained in the event;
+ * the client should use XListInputDevices() to learn what has changed.
+ *
+ * If devchange is true, an attribute that the server believes is
+ * important has changed on a device, and the client should use
+ * XGetDeviceControl to examine the device.  If control is non-zero,
+ * then that control has changed meaningfully.
+ *)
+
+  PXDevicePresenceNotifyEvent = ^TXDevicePresenceNotifyEvent;
+  TXDevicePresenceNotifyEvent = record
+    _type: cint;
+    serial: culong;             { # of last request processed by server }
+    send_event: TBool;          { true if this came from a SendEvent request }
+    display: PDisplay;          { Display the event was read from }
+    window: TWindow;            { unused }
+    time: TTime;
+    devchange: TBool;
+    deviceid: TXID;
+    control: TXID;
+  end;
+
+(*
+ * Notifies the client that a property on a device has changed value. The
+ * client is expected to query the server for updated value of the property.
+ *)
+  PXDevicePropertyNotifyEvent = ^TXDevicePropertyNotifyEvent;
+  TXDevicePropertyNotifyEvent = record
+    _type: cint;
+    serial: culong;             { # of last request processed by server }
+    send_event: TBool;          { true if this came from a SendEvent request }
+    display: PDisplay;          { Display the event was read from }
+    window: TWindow;            { unused }
+    time: TTime;
+    deviceid: TXID;             { id of the device that changed }
+    atom: TAtom;                { the property that changed }
+    state: cint;                { PropertyNewValue or PropertyDeleted }
+  end;
+
+
+(*******************************************************************
+ *
+ * Control structures for input devices that support input class
+ * Feedback.  These are used by the XGetFeedbackControl and 
+ * XChangeFeedbackControl functions.
+ *
+ *)
+
+  PXFeedbackState = ^TXFeedbackState;
+  TXFeedbackState = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+  end;
+
+  PXKbdFeedbackState = ^TXKbdFeedbackState;
+  TXKbdFeedbackState = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    click: cint;
+    percent: cint;
+    pitch: cint;
+    duration: cint;
+    led_mask: cint;
+    global_auto_repeat: cint;
+    auto_repeats: array [0..31] of cchar;
+  end;
+
+  PXPtrFeedbackState = ^TXPtrFeedbackState;
+  TXPtrFeedbackState = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    accelNum: cint;
+    accelDenom: cint;
+    threshold: cint;
+  end;
+
+  PXIntegerFeedbackState = ^TXIntegerFeedbackState;
+  TXIntegerFeedbackState = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    resolution: cint;
+    minVal: cint;
+    maxVal: cint;
+  end;
+
+  PXStringFeedbackState = ^TXStringFeedbackState;
+  TXStringFeedbackState = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    max_symbols: cint;
+    num_syms_supported: cint;
+    syms_supported: PKeySym;
+  end;
+
+  PXBellFeedbackState = ^TXBellFeedbackState;
+  TXBellFeedbackState = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    percent: cint;
+    pitch: cint;
+    duration: cint;
+  end;
+
+  PXLedFeedbackState = ^TXLedFeedbackState;
+  TXLedFeedbackState = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    led_values: cint;
+    led_mask: cint;
+  end;
+
+  PXFeedbackControl = ^TXFeedbackControl;
+  TXFeedbackControl = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+  end;
+
+  PXPtrFeedbackControl = ^TXPtrFeedbackControl;
+  TXPtrFeedbackControl = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    accelNum: cint;
+    accelDenom: cint;
+    threshold: cint;
+  end;
+
+  PXKbdFeedbackControl = ^TXKbdFeedbackControl;
+  TXKbdFeedbackControl = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    click: cint;
+    percent: cint;
+    pitch: cint;
+    duration: cint;
+    led_mask: cint;
+    led_value: cint;
+    key: cint;
+    auto_repeat_mode: cint;
+  end;
+
+  PXStringFeedbackControl = ^TXStringFeedbackControl;
+  TXStringFeedbackControl = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    num_keysyms: cint;
+    syms_to_display: PKeySym;
+  end;
+
+  PXIntegerFeedbackControl = ^TXIntegerFeedbackControl;
+  TXIntegerFeedbackControl = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    int_to_display: cint;
+  end;
+
+  PXBellFeedbackControl = ^TXBellFeedbackControl;
+  TXBellFeedbackControl = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    percent: cint;
+    pitch: cint;
+    duration: cint;
+  end;
+
+  PXLedFeedbackControl = ^TXLedFeedbackControl;
+  TXLedFeedbackControl = record
+    c_class: TXID;
+    length: cint;
+    id: TXID;
+    led_mask: cint;
+    led_values: cint;
+  end;
+
+(*******************************************************************
+ *
+ * Device control structures.
+ *
+ *)
+
+  PXDeviceControl = ^TXDeviceControl;
+  TXDeviceControl = record
+    control: TXID;
+    length: cint;
+  end;
+
+  PXDeviceResolutionControl = ^TXDeviceResolutionControl;
+  TXDeviceResolutionControl = record
+    control: TXID;
+    length: cint;
+    first_valuator: cint;
+    num_valuators: cint;
+    resolutions: Pcint;
+  end;
+
+  PXDeviceResolutionState = ^TXDeviceResolutionState;
+  TXDeviceResolutionState = record
+    control: TXID;
+    length: cint;
+    num_valuators: cint;
+    resolutions: Pcint;
+    min_resolutions: Pcint;
+    max_resolutions: Pcint;
+  end;
+
+  PXDeviceAbsCalibControl = ^TXDeviceAbsCalibControl;
+  TXDeviceAbsCalibControl = record
+    control: TXID;
+    length: cint;
+    min_x: cint;
+    max_x: cint;
+    min_y: cint;
+    max_y: cint;
+    flip_x: cint;
+    flip_y: cint;
+    rotation: cint;
+    button_threshold: cint;
+  end;
+  PXDeviceAbsCalibState = ^TXDeviceAbsCalibState;
+  TXDeviceAbsCalibState = TXDeviceAbsCalibControl;
+
+  PXDeviceAbsAreaControl = ^TXDeviceAbsAreaControl;
+  TXDeviceAbsAreaControl = record
+    control: TXID;
+    length: cint;
+    offset_x: cint;
+    offset_y: cint;
+    width: cint;
+    height: cint;
+    screen: cint;
+    following: TXID;
+  end;
+  PXDeviceAbsAreaState = ^TXDeviceAbsAreaState;
+  TXDeviceAbsAreaState = TXDeviceAbsAreaControl;
+
+  PXDeviceCoreControl = ^TXDeviceCoreControl;
+  TXDeviceCoreControl = record
+    control: TXID;
+    length: cint;
+    status: cint;
+  end;
+
+  PXDeviceCoreState = ^TXDeviceCoreState;
+  TXDeviceCoreState = record
+    control: TXID;
+    length: cint;
+    status: cint;
+    iscore: cint;
+  end;
+
+  PXDeviceEnableControl = ^TXDeviceEnableControl;
+  TXDeviceEnableControl = record
+    control: TXID;
+    length: cint;
+    enable: cint;
+  end;
+  PXDeviceEnableState = ^TXDeviceEnableState;
+  TXDeviceEnableState = TXDeviceEnableControl;
+
+(*******************************************************************
+ *
+ * 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.
+ *
+ *)
+
+  PXAnyClassInfo = ^TXAnyClassInfo;
+  TXAnyClassPtr = PXAnyClassInfo;
+  TXAnyClassInfo = record
+    c_classs: TXID;
+    length: cint;
+  end;
+
+  PXDeviceInfo = ^TXDeviceInfo;
+  TXDeviceInfoPtr = PXDeviceInfo;
+  TXDeviceInfo = record
+    id: TXID;
+    _type: TAtom;
+    name: PChar;
+    num_classes: cint;
+    use: cint;
+    inputclassinfo: TXAnyClassPtr;
+  end;
+
+  PXKeyInfo = ^TXKeyInfo;
+  TXKeyInfoPtr = PXKeyInfo;
+  TXKeyInfo = record
+    c_class: TXID;
+    length: cint;
+    min_keycode: cushort;
+    max_keycode: cushort;
+    num_keys: cushort;
+  end;
+
+  PXButtonInfo = ^TXButtonInfo;
+  TXButtonInfoPtr = PXButtonInfo;
+  TXButtonInfo = record
+    c_class: TXID;
+    length: cint;
+    num_buttons: cshort;
+  end;
+
+  PXAxisInfo = ^TXAxisInfo;
+  TXAxisInfoPtr = PXAxisInfo;
+  TXAxisInfo = record
+    resolution: cint;
+    min_value: cint;
+    max_value: cint;
+  end;
+
+  PXValuatorInfo = ^TXValuatorInfo;
+  TXValuatorInfoPtr = PXValuatorInfo;
+  TXValuatorInfo = record
+    c_class: TXID;
+    length: cint;
+    num_axes: cuchar;
+    mode: cuchar;
+    motion_buffer: culong;
+    axes: TXAxisInfoPtr;
+  end;
+
+(*******************************************************************
+ *
+ * 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.
+ *
+ *)
+
+
+  PXInputClassInfo = ^TXInputClassInfo;
+  TXInputClassInfo = record
+    input_class: cuchar;
+    event_type_base: cuchar;
+  end;
+
+  PXDevice = ^TXDevice;
+  TXDevice = record
+    device_id: TXID;
+    num_classes: cint;
+    classes: PXInputClassInfo;
+  end;
+
+
+(*******************************************************************
+ *
+ * The following structure is used to return information for the 
+ * XGetSelectedExtensionEvents function.
+ *
+ *)
+
+  PXEventList = ^TXEventList;
+  TXEventList = record
+    event_type: TXEventClass;
+    device: TXID;
+  end;
+
+(*******************************************************************
+ *
+ * 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.
+ *
+ *)
+
+  PXDeviceTimeCoord = ^TXDeviceTimeCoord;
+  TXDeviceTimeCoord = record
+    time: TTime;
+    data: Pcint;
+  end;
+
+
+(*******************************************************************
+ *
+ * Device state structure.
+ * This is returned by the XQueryDeviceState request.
+ *
+ *)
+
+  PXDeviceState = ^TXDeviceState;
+  TXDeviceState = record
+    device_id: TXID;
+    num_classes: cint;
+    data: PXInputClass;
+  end;
+
+(*******************************************************************
+ *
+ * Note that the mode field is a bitfield that reports the Proximity
+ * status of the device as well as the mode.  The mode field should
+ * be OR'd with the mask DeviceMode and compared with the values
+ * Absolute and Relative to determine the mode, and should be OR'd
+ * with the mask ProximityState and compared with the values InProximity
+ * and OutOfProximity to determine the proximity state.
+ *
+ *)
+
+  PXValuatorState = ^TXValuatorState;
+  TXValuatorState = record
+    c_class: cuchar;
+    length: cuchar;
+    num_valuators: cuchar;
+    mode: cuchar;
+    valuators: Pcint;
+  end;
+
+  PXKeyState = ^TXKeyState;
+  TXKeyState = record
+    c_class: cuchar;
+    length: cuchar;
+    num_keys: cshort;
+    keys: array [0..31] of cchar;
+  end;
+
+  PXButtonState = ^TXButtonState;
+  TXButtonState = record
+    c_class: cuchar;
+    length: cuchar;
+    num_buttons: cshort;
+    buttons: array [0..31] of cchar;
+  end;
+
+procedure FindTypeAndClass(d: PXDevice; out event_type: cint; out event_class: TXEventClass; classid: cuchar; offset: cint); inline;
+procedure DeviceKeyPress(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceKeyRelease(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButtonPress(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButtonRelease(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceMotionNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceFocusIn(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceFocusOut(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure ProximityIn(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure ProximityOut(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceStateNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceMappingNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure ChangeDeviceNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DevicePropertyNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+procedure DevicePointerMotionHint(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButton1Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButton2Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButton3Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButton4Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButton5Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButtonMotion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceOwnerGrabButton(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure DeviceButtonPressGrab(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+procedure NoExtensionEvent(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+
+
+
+
+(*******************************************************************
+ *
+ * Function definitions.
+ *
+ *)
+
+//_XFUNCPROTOBEGIN
+
+function XChangeKeyboardDevice(
+    display: PDisplay;
+    device: PXDevice
+): cint; cdecl; external libXi;
+
+function XChangePointerDevice(
+    display: PDisplay;
+    device: PXDevice;
+    xaxis: cint;
+    yaxis: cint
+): cint; cdecl; external libXi;
+
+function XGrabDevice(
+    display: PDisplay;
+    device: PXDevice;
+    grab_window: TWindow;
+    ownerEvents: TBool;
+    event_count: cint;
+    event_list: PXEventClass;
+    this_device_mode: cint;
+    other_devices_mode: cint;
+    time: TTime
+): cint; cdecl; external libXi;
+
+function XUngrabDevice(
+    display: PDisplay;
+    device: PXDevice;
+    time: TTime
+): cint; cdecl; external libXi;
+
+function XGrabDeviceKey(
+    display: PDisplay;
+    device: PXDevice;
+    key: cuint;
+    modifiers: cuint;
+    modifier_device: PXDevice;
+    grab_window: TWindow;
+    owner_events: TBool;
+    event_count: cuint;
+    event_list: PXEventClass;
+    this_device_mode: cint;
+    other_devices_mode: cint
+): cint; cdecl; external libXi;
+
+function XUngrabDeviceKey(
+    display: PDisplay;
+    device: PXDevice;
+    key: cuint;
+    modifiers: cuint;
+    modifier_dev: PXDevice;
+    grab_window: TWindow
+): cint; cdecl; external libXi;
+
+function XGrabDeviceButton(
+    display: PDisplay;
+    device: PXDevice;
+    button: cuint;
+    modifiers: cuint;
+    modifier_device: PXDevice;
+    grab_window: TWindow;
+    owner_events: TBool;
+    event_count: cuint;
+    event_list: PXEventClass;
+    this_device_mode: cint;
+    other_devices_mode: cint
+): cint; cdecl; external libXi;
+
+function XUngrabDeviceButton(
+    display: PDisplay;
+    device: PXDevice;
+    button: cuint;
+    modifiers: cuint;
+    modifier_dev: PXDevice;
+    grab_window: TWindow
+): cint; cdecl; external libXi;
+
+function XAllowDeviceEvents(
+    display: PDisplay;
+    device: PXDevice;
+    event_mode: cint;
+    time: TTime
+): cint; cdecl; external libXi;
+
+function XGetDeviceFocus(
+    display: PDisplay;
+    device: PXDevice;
+    focus: PWindow;
+    revert_to: Pcint;
+    time: PTime
+): cint; cdecl; external libXi;
+
+function XSetDeviceFocus(
+    display: PDisplay;
+    device: PXDevice;
+    focus: TWindow;
+    revert_to: cint;
+    time: TTime
+): cint; cdecl; external libXi;
+
+function XGetFeedbackControl(
+    display: PDisplay;
+    device: PXDevice;
+    num_feedbacks: Pcint
+): PXFeedbackState; cdecl; external libXi;
+
+procedure XFreeFeedbackList(
+    list: PXFeedbackState
+); cdecl; external libXi;
+
+function XChangeFeedbackControl(
+    display: PDisplay;
+    device: PXDevice;
+    mask: culong;
+    f: PXFeedbackControl
+): cint; cdecl; external libXi;
+
+function XDeviceBell(
+    display: PDisplay;
+    device: PXDevice;
+    feedbackclass: TXID;
+    feedbackid: TXID;
+    percent: cint
+): cint; cdecl; external libXi;
+
+function XGetDeviceKeyMapping(
+    display: PDisplay;
+    device: PXDevice;
+{$ifdef NeedWidePrototypes}
+    first: cuint;
+{$else}
+    first: TKeyCode;
+{$endif}
+    keycount: cint;
+    syms_per_code: Pcint
+): PKeySym; cdecl; external libXi;
+
+function XChangeDeviceKeyMapping(
+    display: PDisplay;
+    device: PXDevice;
+    first: cint;
+    syms_per_code: cint;
+    keysyms: PKeySym;
+    count: cint
+): cint; cdecl; external libXi;
+
+function XGetDeviceModifierMapping(
+    display: PDisplay;
+    device: PXDevice
+): PXModifierKeymap; cdecl; external libXi;
+
+function XSetDeviceModifierMapping(
+    display: PDisplay;
+    device: PXDevice;
+    modmap: PXModifierKeymap
+): cint; cdecl; external libXi;
+
+function XSetDeviceButtonMapping(
+    display: PDisplay;
+    device: PXDevice;
+    map: Pcuchar;
+    nmap: cint
+): cint; cdecl; external libXi;
+
+function XGetDeviceButtonMapping(
+    display: PDisplay;
+    device: PXDevice;
+    map: Pcuchar;
+    nmap: cuint
+): cint; cdecl; external libXi;
+
+function XQueryDeviceState(
+    display: PDisplay;
+    device: PXDevice
+): PXDeviceState; cdecl; external libXi;
+
+procedure XFreeDeviceState(
+    list: PXDeviceState
+); cdecl; external libXi;
+
+function XGetExtensionVersion(
+    display: PDisplay;
+    name: {_Xconst} Pchar
+): PXExtensionVersion; cdecl; external libXi;
+
+function XListInputDevices(
+    display: PDisplay;
+    ndevices: Pcint
+): PXDeviceInfo; cdecl; external libXi;
+
+procedure XFreeDeviceList(
+    list: PXDeviceInfo
+); cdecl; external libXi;
+
+function XOpenDevice(
+    display: PDisplay;
+    id: TXID
+): PXDevice; cdecl; external libXi;
+
+function XCloseDevice(
+    display: PDisplay;
+    device: PXDevice
+): cint; cdecl; external libXi;
+
+function XSetDeviceMode(
+    display: PDisplay;
+    device: PXDevice;
+    mode: cint
+): cint; cdecl; external libXi;
+
+function XSetDeviceValuators(
+    display: PDisplay;
+    device: PXDevice;
+    valuators: Pcint;
+    first_valuator: cint;
+    num_valuators: cint
+): cint; cdecl; external libXi;
+
+function XGetDeviceControl(
+    display: PDisplay;
+    device: PXDevice;
+    control: cint
+): PXDeviceControl; cdecl; external libXi;
+
+function XChangeDeviceControl(
+    display: PDisplay;
+    device: PXDevice;
+    control: cint;
+    d: PXDeviceControl
+): cint; cdecl; external libXi;
+
+function XSelectExtensionEvent(
+    display: PDisplay;
+    w: TWindow;
+    event_list: PXEventClass;
+    count: cint
+): cint; cdecl; external libXi;
+
+function XGetSelectedExtensionEvents(
+    display: PDisplay;
+    w: TWindow;
+    this_client_count: Pcint;
+    this_client_list: PPXEventClass;
+    all_clients_count: Pcint;
+    all_clients_list: PPXEventClass
+): cint; cdecl; external libXi;
+
+function XChangeDeviceDontPropagateList(
+    display: PDisplay;
+    window: TWindow;
+    count: cint;
+    events: PXEventClass;
+    mode: cint
+): cint; cdecl; external libXi;
+
+function XGetDeviceDontPropagateList(
+    display: PDisplay;
+    window: TWindow;
+    count: Pcint
+): PXEventClass; cdecl; external libXi;
+
+function XSendExtensionEvent(
+    display: PDisplay;
+    device: PXDevice;
+    dest: TWindow;
+    prop: TBool;
+    count: cint;
+    list: PXEventClass;
+    event: PXEvent
+): TStatus; cdecl; external libXi;
+
+function XGetDeviceMotionEvents(
+    display: PDisplay;
+    device: PXDevice;
+    start: TTime;
+    stop: TTime;
+    nEvents: Pcint;
+    mode: Pcint;
+    axis_count: Pcint
+): PXDeviceTimeCoord; cdecl; external libXi;
+
+procedure XFreeDeviceMotionEvents(
+    events: PXDeviceTimeCoord
+); cdecl; external libXi;
+
+procedure XFreeDeviceControl(
+    control: PXDeviceControl
+); cdecl; external libXi;
+
+function XListDeviceProperties(
+    dpy: PDisplay;
+    dev: PXDevice;
+    nprops_return: Pcint
+): PAtom; cdecl; external libXi;
+
+procedure XChangeDeviceProperty(
+    dpy: PDisplay;
+    dev: PXDevice;
+    _property: TAtom;
+    _type: TAtom;
+    format: cint;
+    mode: cint;
+    data: {_Xconst} Pcuchar;
+    nelements: cint
+); cdecl; external libXi;
+
+procedure XDeleteDeviceProperty(
+    dpy: PDisplay;
+    dev: PXDevice;
+    _property: TAtom
+); cdecl; external libXi;
+
+function XGetDeviceProperty(
+     dpy: PDisplay;
+     dev: PXDevice;
+     _property: TAtom;
+     offset: clong;
+     length: clong;
+     delete: TBool;
+     req_type: TAtom;
+     actual_type: PAtom;
+     actual_format: Pcint;
+     nitems: Pculong;
+     bytes_after: Pculong;
+     prop: PPcuchar
+): TStatus; cdecl; external libXi;
+
+//_XFUNCPROTOEND
+
+implementation
+
+procedure DevicePresence(dpy: PDisplay; out event_type: cint; event_class: TXEventClass); inline;
+begin
+  event_type := _XiGetDevicePresenceNotifyEvent(dpy);
+  event_class := $10000 or _devicePresence;
+end;
+
+procedure BadDevice(dpy: PDisplay; out error: cint); inline;
+begin
+  _xibaddevice(dpy, @error);
+end;
+
+procedure BadClass(dpy: PDisplay; out error: cint); inline;
+begin
+  _xibadclass(dpy, @error);
+end;
+
+procedure BadEvent(dpy: PDisplay; out error: cint); inline;
+begin
+  _xibadevent(dpy, @error);
+end;
+
+procedure BadMode(dpy: PDisplay; out error: cint); inline;
+begin
+  _xibadmode(dpy, @error);
+end;
+
+procedure DeviceBusy(dpy: PDisplay; out error: cint); inline;
+begin
+  _xidevicebusy(dpy, @error);
+end;
+
+procedure FindTypeAndClass(d: PXDevice; out event_type: cint; out event_class: TXEventClass; classid: cuchar; offset: cint); inline;
+var
+  _i : cint = 0;
+  _ip: PXInputClassInfo;
+begin
+  event_type := 0;
+  event_class := 0;
+
+  _ip := d^.classes;
+  for _i := 0 to d^.num_classes - 1 do
+  begin
+    if _ip^.input_class = classid then
+    begin
+      event_type := _ip^.event_type_base + offset;
+      event_class := (d^.device_id shl 8) or event_type;
+    end;
+    Inc(_ip);
+  end;
+end;
+
+procedure DeviceKeyPress(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, KeyClass, _deviceKeyPress);
+end;
+
+procedure DeviceKeyRelease(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, KeyClass, _deviceKeyRelease);
+end;
+
+procedure DeviceButtonPress(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, ButtonClass, _deviceButtonPress);
+end;
+
+procedure DeviceButtonRelease(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, ButtonClass, _deviceButtonRelease);
+end;
+
+procedure DeviceMotionNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, ValuatorClass, _deviceMotionNotify);
+end;
+
+procedure DeviceFocusIn(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, FocusClass, _deviceFocusIn);
+end;
+
+procedure DeviceFocusOut(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, FocusClass, _deviceFocusOut);
+end;
+
+procedure ProximityIn(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, ProximityClass, _proximityIn);
+end;
+
+procedure ProximityOut(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, ProximityClass, _proximityOut);
+end;
+
+procedure DeviceStateNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, OtherClass, _deviceStateNotify);
+end;
+
+procedure DeviceMappingNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, OtherClass, _deviceMappingNotify);
+end;
+
+procedure ChangeDeviceNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, OtherClass, _changeDeviceNotify);
+end;
+
+procedure DevicePropertyNotify(d: PXDevice; out event_type: cint; out event_class: TXEventClass); inline;
+begin
+  FindTypeAndClass(d, event_type, event_class, OtherClass, _propertyNotify);
+end;
+
+procedure DevicePointerMotionHint(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _devicePointerMotionHint;
+end;
+
+procedure DeviceButton1Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceButton1Motion;
+end;
+
+procedure DeviceButton2Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceButton2Motion;
+end;
+
+procedure DeviceButton3Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceButton3Motion;
+end;
+
+procedure DeviceButton4Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceButton4Motion;
+end;
+
+procedure DeviceButton5Motion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceButton5Motion;
+end;
+
+procedure DeviceButtonMotion(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceButtonMotion;
+end;
+
+procedure DeviceOwnerGrabButton(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceOwnerGrabButton;
+end;
+
+procedure DeviceButtonPressGrab(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _deviceButtonGrab;
+end;
+
+procedure NoExtensionEvent(d: PXDevice; event_type: cint; out event_class: TXEventClass); inline;
+begin
+  event_class := (d^.device_id shl 8) or _noExtensionEvent;
+end;
+
+end.
+

packages/x11/tests/xinput_linktest.pp

@@ -0,0 +1,57 @@
+{ this program just links all externals, declared in the xinput unit }
+program xinput_linktest;
+uses
+  xinput;
+begin
+  halt(0);
+  _XiGetDevicePresenceNotifyEvent(nil);
+  _xibaddevice(nil, nil);
+  _xibadclass(nil, nil);
+  _xibadevent(nil, nil);
+  _xibadmode(nil, nil);
+  _xidevicebusy(nil, nil);
+  XChangeKeyboardDevice(nil, nil);
+  XChangePointerDevice(nil, nil, 0, 0);
+  XGrabDevice(nil, nil, 0, 0, 0, nil, 0, 0, 0);
+  XUngrabDevice(nil, nil, 0);
+  XGrabDeviceKey(nil, nil, 0, 0, nil, 0, 0, 0, nil, 0, 0);
+  XUngrabDeviceKey(nil, nil, 0, 0, nil, 0);
+  XGrabDeviceButton(nil, nil, 0, 0, nil, 0, 0, 0, nil, 0, 0);
+  XUngrabDeviceButton(nil, nil, 0, 0, nil, 0);
+  XAllowDeviceEvents(nil, nil, 0, 0);
+  XGetDeviceFocus(nil, nil, nil, nil, nil);
+  XSetDeviceFocus(nil, nil, 0, 0, 0);
+  XGetFeedbackControl(nil, nil, nil);
+  XFreeFeedbackList(nil);
+  XChangeFeedbackControl(nil, nil, 0, nil);
+  XDeviceBell(nil, nil, 0, 0, 0);
+  XGetDeviceKeyMapping(nil, nil, 0, 0, nil);
+  XChangeDeviceKeyMapping(nil, nil, 0, 0, nil, 0);
+  XGetDeviceModifierMapping(nil, nil);
+  XSetDeviceModifierMapping(nil, nil, nil);
+  XSetDeviceButtonMapping(nil, nil, nil, 0);
+  XGetDeviceButtonMapping(nil, nil, nil, 0);
+  XQueryDeviceState(nil, nil);
+  XFreeDeviceState(nil);
+  XGetExtensionVersion(nil, nil);
+  XListInputDevices(nil, nil);
+  XFreeDeviceList(nil);
+  XOpenDevice(nil, 0);
+  XCloseDevice(nil, nil);
+  XSetDeviceMode(nil, nil, 0);
+  XSetDeviceValuators(nil, nil, nil, 0, 0);
+  XGetDeviceControl(nil, nil, 0);
+  XChangeDeviceControl(nil, nil, 0, nil);
+  XSelectExtensionEvent(nil, 0, nil, 0);
+  XGetSelectedExtensionEvents(nil, 0, nil, nil, nil, nil);
+  XChangeDeviceDontPropagateList(nil, 0, 0, nil, 0);
+  XGetDeviceDontPropagateList(nil, 0, nil);
+  XSendExtensionEvent(nil, nil, 0, 0, 0, nil, nil);
+  XGetDeviceMotionEvents(nil, nil, 0, 0, nil, nil, nil);
+  XFreeDeviceMotionEvents(nil);
+  XFreeDeviceControl(nil);
+  XListDeviceProperties(nil, nil, nil);
+  XChangeDeviceProperty(nil, nil, 0, 0, 0, 0, nil, 0);
+  XDeleteDeviceProperty(nil, nil, 0);
+  XGetDeviceProperty(nil, nil, 0, 0, 0, 0, 0, nil, nil, nil, nil, nil);
+end.