(************************************************************

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 occurred 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 occurred 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 occurred 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;

{ boolean overload for the TBool parameter }
function XGrabDevice(
    display: PDisplay;
    device: PXDevice;
    grab_window: TWindow;
    ownerEvents: Boolean;
    event_count: cint;
    event_list: PXEventClass;
    this_device_mode: cint;
    other_devices_mode: cint;
    time: TTime
): cint; inline;

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;

{ boolean overload for the TBool parameter }
function XGrabDeviceKey(
    display: PDisplay;
    device: PXDevice;
    key: cuint;
    modifiers: cuint;
    modifier_device: PXDevice;
    grab_window: TWindow;
    owner_events: Boolean;
    event_count: cuint;
    event_list: PXEventClass;
    this_device_mode: cint;
    other_devices_mode: cint
): cint; inline;

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;

{ boolean overload for the TBool parameter }
function XGrabDeviceButton(
    display: PDisplay;
    device: PXDevice;
    button: cuint;
    modifiers: cuint;
    modifier_device: PXDevice;
    grab_window: TWindow;
    owner_events: Boolean;
    event_count: cuint;
    event_list: PXEventClass;
    this_device_mode: cint;
    other_devices_mode: cint
): cint; inline;

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;

{ boolean overload for the TBool parameter }
function XSendExtensionEvent(
    display: PDisplay;
    device: PXDevice;
    dest: TWindow;
    prop: Boolean;
    count: cint;
    list: PXEventClass;
    event: PXEvent
): TStatus; inline;

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;

{ boolean overload for the TBool parameter }
function XGetDeviceProperty(
     dpy: PDisplay;
     dev: PXDevice;
     _property: TAtom;
     offset: clong;
     length: clong;
     delete: Boolean;
     req_type: TAtom;
     actual_type: PAtom;
     actual_format: Pcint;
     nitems: Pculong;
     bytes_after: Pculong;
     prop: PPcuchar
): TStatus; inline;

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

function XGrabDevice(display: PDisplay; device: PXDevice; grab_window: TWindow;
  ownerEvents: Boolean; event_count: cint; event_list: PXEventClass;
  this_device_mode: cint; other_devices_mode: cint; time: TTime): cint; inline;
begin
  XGrabDevice := XGrabDevice(display, device, grab_window, Ord(ownerEvents), event_count, event_list, this_device_mode,
    other_devices_mode, time);
end;

function XGrabDeviceKey(display: PDisplay; device: PXDevice; key: cuint;
  modifiers: cuint; modifier_device: PXDevice; grab_window: TWindow;
  owner_events: Boolean; event_count: cuint; event_list: PXEventClass;
  this_device_mode: cint; other_devices_mode: cint): cint; inline;
begin
  XGrabDeviceKey := XGrabDeviceKey(display, device, key, modifiers, modifier_device, grab_window,
    Ord(owner_events), event_count, event_list, this_device_mode, other_devices_mode);
end;

function XGrabDeviceButton(display: PDisplay; device: PXDevice; button: cuint;
  modifiers: cuint; modifier_device: PXDevice; grab_window: TWindow;
  owner_events: Boolean; event_count: cuint; event_list: PXEventClass;
  this_device_mode: cint; other_devices_mode: cint): cint; inline;
begin
  XGrabDeviceButton := XGrabDeviceButton(display, device, button, modifiers, modifier_device, grab_window, Ord(owner_events),
    event_count, event_list, this_device_mode, other_devices_mode);
end;

function XSendExtensionEvent(display: PDisplay; device: PXDevice;
  dest: TWindow; prop: Boolean; count: cint; list: PXEventClass; event: PXEvent
  ): TStatus; inline;
begin
  XSendExtensionEvent := XSendExtensionEvent(display, device, dest, Ord(prop), count, list, event);
end;

function XGetDeviceProperty(dpy: PDisplay; dev: PXDevice; _property: TAtom;
  offset: clong; length: clong; delete: Boolean; req_type: TAtom;
  actual_type: PAtom; actual_format: Pcint; nitems: Pculong;
  bytes_after: Pculong; prop: PPcuchar): TStatus; inline;
begin
  XGetDeviceProperty := XGetDeviceProperty(dpy, dev, _property, offset, length, Ord(delete), req_type, actual_type,
    actual_format, nitems, bytes_after, prop);
end;

end.