moparisthebest/Simba
1
0
Fork 0
mirror of https://github.com/moparisthebest/Simba synced 2024-12-24 08:18:52 -05:00
Code Issues Releases Wiki Activity
7b1e8d6f6a
Simba/Units/Linux/xinput.pas

1015 lines
33 KiB
ObjectPascal
Raw Blame History

{ $Xorg: XInput.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $ }
{***********************************************************
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.
******************************************************* }
unit xinput;
interface
uses
x, xlib, xi, ctypes;
type
PXEventClass = ^XEventClass;
PpXEventClass = ^PXEventClass;
{$IFDEF FPC}
{$PACKRECORDS C}
{$ENDIF}
const
_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;
{**************************************************************
*
* 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.
*
}
type
TXDeviceKeyEvent = record
_type : cint; { of event }
serial : culong; { # of last request processed }
send_event : cbool; { 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 : cint; { x, y coordinates in event window }
y : cint;
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 : cbool; { 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;
TXDeviceKeyPressedEvent = TXDeviceKeyEvent;
TXDeviceKeyReleasedEvent = TXDeviceKeyEvent;
{******************************************************************
*
* DeviceButton events. These events are sent by extension devices
* that support input class Buttons.
*
}
TXDeviceButtonEvent = record
_type : cint; { of event }
serial : culong; { # of last request processed by server }
send_event : cbool; { 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 : cint; { x, y coordinates in event window }
y : cint;
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 : cbool; { 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;
TXDeviceButtonPressedEvent = TXDeviceButtonEvent;
TXDeviceButtonReleasedEvent = TXDeviceButtonEvent;
{******************************************************************
*
* DeviceMotionNotify event. These events are sent by extension devices
* that support input class Valuators.
*
}
TXDeviceMotionEvent = record
_type : cint; { of event }
serial : culong; { # of last request processed by server }
send_event : cbool; { 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 : cbool; { 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.
*
}
TXDeviceFocusChangeEvent = record
_type : cint; { of event }
serial : culong; { # of last request processed by server }
send_event : cbool; { 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;
TXDeviceFocusInEvent = TXDeviceFocusChangeEvent;
TXDeviceFocusOutEvent = TXDeviceFocusChangeEvent;
{******************************************************************
*
* ProximityNotify events. These events are sent by those absolute
* positioning devices that are capable of generating proximity information.
*
}
TXProximityNotifyEvent = record
_type : cint; { ProximityIn or ProximityOut }
serial : culong; { # of last request processed by server }
send_event : cbool; { 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 : cint;
y : cint;
x_root : cint;
y_root : cint;
state : cuint;
same_screen : cbool;
device_state : cuint; { device key or button mask }
axes_count : cuchar;
first_axis : cuchar;
axis_data : array[0..5] of cint;
end;
TXProximityInEvent = TXProximityNotifyEvent;
TXProximityOutEvent = TXProximityNotifyEvent;
{******************************************************************
*
* DeviceStateNotify events are generated on EnterWindow and FocusIn
* for those clients who have selected DeviceState.
*
}
TXInputClass = record
c_class : cuchar;
_length : cuchar;
end;
PXInputClass = ^TXInputClass;
TXDeviceStateNotifyEvent = record
_type : cint;
serial : culong; { # of last request processed by server }
send_event : cbool; { 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 char;
end;
TXValuatorStatus = record
c_class : cuchar;
_length : cuchar;
num_valuators : cuchar;
mode : cuchar;
valuators : array[0..5] of cint;
end;
TXKeyStatus = record
c_class : cuchar;
_length : cuchar;
num_keys : cshort;
keys : array[0..31] of char;
end;
TXButtonStatus = record
c_class : cuchar;
_length : cuchar;
num_buttons : cshort;
buttons : array[0..31] of char;
end;
{******************************************************************
*
* DeviceMappingNotify event. This event is sent when the key mapping,
* modifier mapping, or button mapping of an extension device is changed.
*
}
TXDeviceMappingEvent = record
_type : cint;
serial : culong; { # of last request processed by server }
send_event : cbool; { 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.
*
}
TXChangeDeviceNotifyEvent = record
_type : cint;
serial : culong; { # of last request processed by server }
send_event : cbool; { 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.
}
TXDevicePresenceNotifyEvent = record
_type : cint;
serial : culong; { # of last request processed by server }
send_event : cbool; { true if this came from a SendEvent request }
display : PDisplay; { Display the event was read from }
window : TWindow; { unused }
time : TTime;
devchange : cbool;
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.
}
TXDevicePropertyNotifyEvent = record
_type : cint;
serial : culong; { # of last request processed by server }
send_event : cbool; { 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.
*
}
TXFeedbackState = record
c_class : TXID;
_length : cint;
id : TXID;
end;
PXFeedbackState = ^TXFeedbackState;
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 char;
end;
TXPtrFeedbackState = record
c_class : TXID;
_length : cint;
id : TXID;
accelNum : cint;
accelDenom : cint;
threshold : cint;
end;
TXIntegerFeedbackState = record
c_class : TXID;
_length : cint;
id : TXID;
resolution : cint;
minVal : cint;
maxVal : cint;
end;
TXStringFeedbackState = record
c_class : TXID;
_length : cint;
id : TXID;
max_symbols : cint;
num_syms_supported : cint;
syms_supported : PKeySym;
end;
TXBellFeedbackState = record
c_class : TXID;
_length : cint;
id : TXID;
percent : cint;
pitch : cint;
duration : cint;
end;
TXLedFeedbackState = record
c_class : TXID;
_length : cint;
id : TXID;
led_values : cint;
led_mask : cint;
end;
TXFeedbackControl = record
c_class : TXID;
_length : cint;
id : TXID;
end;
PXFeedbackControl = ^TXFeedbackControl;
TXPtrFeedbackControl = record
c_class : TXID;
_length : cint;
id : TXID;
accelNum : cint;
accelDenom : cint;
threshold : cint;
end;
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;
TXStringFeedbackControl = record
c_class : TXID;
_length : cint;
id : TXID;
num_keysyms : cint;
syms_to_display : PKeySym;
end;
TXIntegerFeedbackControl = record
c_class : TXID;
_length : cint;
id : TXID;
int_to_display : cint;
end;
TXBellFeedbackControl = record
c_class : TXID;
_length : cint;
id : TXID;
percent : cint;
pitch : cint;
duration : cint;
end;
TXLedFeedbackControl = record
c_class : TXID;
_length : cint;
id : TXID;
led_mask : cint;
led_values : cint;
end;
{******************************************************************
*
* Device control structures.
*
}
TXDeviceControl = record
control : TXID;
_length : cint;
end;
PXDeviceControl = ^TXDeviceControl;
TXDeviceResolutionControl = record
control : TXID;
_length : cint;
first_valuator : cint;
num_valuators : cint;
resolutions : ^cint;
end;
TXDeviceResolutionState = record
control : TXID;
_length : cint;
num_valuators : cint;
resolutions : ^cint;
min_resolutions : ^cint;
max_resolutions : ^cint;
end;
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;
TXDeviceAbsCalibState = TXDeviceAbsCalibControl;
TXDeviceAbsAreaControl = record
control : TXID;
_length : cint;
offset_x : cint;
offset_y : cint;
width : cint;
height : cint;
screen : cint;
following : TXID;
end;
TXDeviceAbsAreaState = TXDeviceAbsAreaControl;
TXDeviceCoreControl = record
control : TXID;
_length : cint;
status : cint;
end;
TXDeviceCoreState = record
control : TXID;
_length : cint;
status : cint;
iscore : cint;
end;
TXDeviceEnableControl = record
control : TXID;
_length : cint;
enable : cint;
end;
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.
*
}
_XAnyClassinfo = record
c_class : TXID;
_length : cint;
end;
TXAnyClassInfo = _XAnyClassinfo;
PXAnyClassInfo = ^TXAnyClassInfo;
_XDeviceInfo = record
id : TXID;
_type : TAtom;
name : ^char;
num_classes : cint;
use : cint;
inputclassinfo : PXAnyClassInfo;
end;
TXDeviceInfo = _XDeviceInfo;
PXDeviceInfo = ^TXDeviceInfo;
_XKeyInfo = record
c_class : TXID;
_length : cint;
min_keycode : cushort;
max_keycode : cushort;
num_keys : cushort;
end;
TXKeyInfo = _XKeyInfo;
PXKeyInfo = ^TXKeyInfo;
_XButtonInfo = record
c_class : TXID;
_length : cint;
num_buttons : cshort;
end;
TXButtonInfo = _XButtonInfo;
PXButtonInfo = ^TXButtonInfo;
_XAxisInfo = record
resolution : cint;
min_value : cint;
max_value : cint;
end;
TXAxisInfo = _XAxisInfo;
PXAxisInfo = ^TXAxisInfo;
_XValuatorInfo = record
c_class : TXID;
_length : cint;
num_axes : cuchar;
mode : cuchar;
motion_buffer : culong;
axes : PXAxisInfo;
end;
TXValuatorInfo = _XValuatorInfo;
PXValuatorInfo = ^TXValuatorInfo;
{******************************************************************
*
* 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.
*
}
TXInputClassInfo = record
input_class : cuchar;
event_type_base : cuchar;
end;
PXInputClassInfo = ^TXInputClassInfo;
TXDevice = record
device_id : TXID;
num_classes : cint;
classes : PXInputClassInfo;
end;
PXDevice = ^TXDevice;
{******************************************************************
*
* The following structure is used to return information for the
* XGetSelectedExtensionEvents function.
*
}
TXEventList = record
event_type : XEventClass;
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.
*
}
TXDeviceTimeCoord = record
time : TTime;
data : pcint;
end;
PXDeviceTimeCoord = ^TXDeviceTimeCoord;
{******************************************************************
*
* Device state structure.
* This is returned by the XQueryDeviceState request.
*
}
TXDeviceState = record
device_id : TXID;
num_classes : cint;
data : PXInputClass;
end;
PXDeviceState = ^TXDeviceState;
{******************************************************************
*
* 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.
*
}
TXValuatorState = record
c_class : cuchar;
_length : cuchar;
num_valuators : cuchar;
mode : cuchar;
valuators : pcint;
end;
TXKeyState = record
c_class : cuchar;
_length : cuchar;
num_keys : cshort;
keys : array[0..31] of char;
end;
TXButtonState = record
c_class : cuchar;
_length : cuchar;
num_buttons : cshort;
buttons : array[0..31] of char;
end;
{******************************************************************
*
* Function definitions.
*
}
function XChangeKeyboardDevice(display:PDisplay; device:PXDevice):cint;cdecl; external;
function XChangePointerDevice(display:PDisplay; device:pXDevice; xaxis:cint; yaxis:cint):cint;cdecl; external;
function XGrabDevice(display:pDisplay; device:pXDevice; grab_window:TWindow; ownerEvents:cbool; event_count:cint;
event_list:PXEventClass; this_device_mode:cint; other_devices_mode:cint; time:TTime):cint;cdecl; external;
function XUngrabDevice(display:pDisplay; device:pXDevice; time:TTime):cint;cdecl; external;
function XGrabDeviceKey(display:pDisplay; device:pXDevice; key:cuint; modifiers:cuint; modifier_device:pXDevice;
grab_window:TWindow; owner_events:cbool; event_count:cuint; event_list:pXEventClass; this_device_mode:cint;
other_devices_mode:cint):cint;cdecl; external;
function XUngrabDeviceKey(display:pDisplay; device:pXDevice; key:cuint; modifiers:cuint; modifier_dev:pXDevice;
grab_window:TWindow):cint;cdecl; external;
function XGrabDeviceButton(display:pDisplay; device:pXDevice; button:cuint; modifier:cuint; modifier_device:pXDevice;
grab_window:TWindow; owner_events:cbool; event_count:cuint; event_list:pXEventClass; this_device_mode:cint;
other_devices_mode:cint):cint;cdecl; external;
function XUngrabDeviceButton(display:pDisplay; device:pXDevice; button:cuint; modifiers:cuint; modifier_dev:pXDevice;
grab_window:TWindow):cint;cdecl; external;
function XAllowDeviceEvents(display:pDisplay; device:pXDevice; event_mode:cint; time:TTime):cint;cdecl;external;
function XGetDeviceFocus(display:pDisplay; device:pXDevice; focus:pWindow; revert_to:pcint; time:pTime):cint;cdecl;external;
function XSetDeviceFocus(display:pDisplay; device:pXDevice; focus:TWindow; revert_to:cint; time:TTime):cint;cdecl;external;
function XGetFeedbackControl(display:pDisplay; device:pXDevice; num_feedbacks:pcint): PXFeedbackState;cdecl;external;
procedure XFreeFeedbackList(list:pXFeedbackState);cdecl;external;
function XChangeFeedbackControl(display:pDisplay; device:pXDevice; mask:culong; f:pXFeedbackControl):cint;cdecl;external;
function XDeviceBell(display:pDisplay; device:pXDevice; feedbackclass:TXID; feedbackid:TXID; percent:cint):cint;cdecl;external;
function XGetDeviceKeyMapping(display:pDisplay; device:pXDevice; first:cuint; keycount:cint; syms_per_code:pcint):PKeySym;cdecl;external;
function XChangeDeviceKeyMapping(display:pDisplay; device:pXDevice; first:cint; syms_per_code:cint; keysyms:pKeySym;
count:cint):cint;cdecl;external;
function XGetDeviceModifierMapping(display:pDisplay; device:pXDevice):PXModifierKeymap;cdecl;external;
function XSetDeviceModifierMapping(display:pDisplay; device:pXDevice; modmap:pXModifierKeymap):cint;cdecl;external;
function XSetDeviceButtonMapping(display:pDisplay; device:pXDevice; map:array of pcuchar; nmap:cint):cint;cdecl;external;
function XGetDeviceButtonMapping(display:pDisplay; device:pXDevice; map:array of pcuchar; nmap:cuint):cint;cdecl;external;
function XQueryDeviceState(display:pDisplay; device:pXDevice):PXDeviceState;cdecl;external;
procedure XFreeDeviceState(list:pXDeviceState);cdecl;external;
(* Const before type ignored *)
function XGetExtensionVersion(display:pDisplay; name:pchar):PXExtensionVersion;cdecl;external;
function XListInputDevices(display:pDisplay; ndevices:pcint):PXDeviceInfo;cdecl;external;
procedure XFreeDeviceList(list:pXDeviceInfo);cdecl;external;
function XOpenDevice(display:pDisplay; id:TXID):PXDevice;cdecl;external;
function XCloseDevice(display:pDisplay; device:pXDevice):cint;cdecl;external;
function XSetDeviceMode(display:pDisplay; device:pXDevice; mode:cint):cint;cdecl;external;
function XSetDeviceValuators(display:pDisplay; device:pXDevice; valuators:pcint; first_valuator:cint; num_valuators:cint):cint;cdecl;external;
function XGetDeviceControl(display:pDisplay; device:pXDevice; control:cint):PXDeviceControl;cdecl;external;
function XChangeDeviceControl(display:pDisplay; device:pXDevice; control:cint; d:pXDeviceControl):cint;cdecl;external;
function XSelectExtensionEvent(display:pDisplay; w:TWindow; event_list:pXEventClass; count:cint):cint;cdecl;external;
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;
function XChangeDeviceDontPropagateList(display:pDisplay; window:TWindow; count:cint; events:pXEventClass; mode:cint):cint;cdecl;external;
function XGetDeviceDontPropagateList(display:pDisplay; window:TWindow; count:pcint):PXEventClass;cdecl;external;
function XSendExtensionEvent(display:pDisplay; device:pXDevice; dest:TWindow; prop:cbool; count:cint;
list:pXEventClass; event:pXEvent):TStatus;cdecl;external;
function XGetDeviceMotionEvents(display:pDisplay; device:pXDevice; start:TTime; stop:TTime; nEvents:pcint;
mode:pcint; axis_count:pcint):PXDeviceTimeCoord;cdecl;external;
procedure XFreeDeviceMotionEvents(events:pXDeviceTimeCoord);cdecl;external;
procedure XFreeDeviceControl(control:pXDeviceControl);cdecl;external;
type
TXIPropertyInfo = record
pending : cbool;
range : cbool;
immutable : cbool;
fromClient : cbool;
num_values : cint;
values : ^longint;
end;
function XListDeviceProperties(dpy:pDisplay; dev:pXDevice; nprops_return:pcint):PAtom;cdecl;external;
(* Const before type ignored *)
procedure XChangeDeviceProperty(dpy:pDisplay; dev:pXDevice; _property:TAtom; _type:TAtom; format:cint;
mode:cint; data:pcuchar; nelements:cint);cdecl;external;
procedure XDeleteDeviceProperty(dpy:pDisplay; dev:pXDevice; _property:TAtom);cdecl;external;
function XGetDeviceProperty(dpy:pDisplay; dev:pXDevice; _property:TAtom; offset:longint; _length:longint;
_delete:cbool; req_type:TAtom; actual_type:pAtom; actual_format:pcint; nitems:pculong;
bytes_after:pculong; prop:Ppcuchar):TStatus;cdecl;external;
procedure FindTypeAndClass(d: PXDevice; _type, _class, classid: cint; offset: cint); inline;
procedure DeviceKeyPress(d: PXDevice; _type, _class: cint); inline;
procedure DeviceKeyRelease(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButtonPress(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButtonRelease(d: PXDevice; _type, _class: cint); inline;
procedure DeviceMotionNotify(d: PXDevice; _type, _class: cint); inline;
procedure DeviceFocusIn(d: PXDevice; _type, _class: cint); inline;
procedure DeviceFocusOut(d: PXDevice; _type, _class: cint); inline;
procedure ProximityIn(d: PXDevice; _type, _class: cint); inline;
procedure ProximityOut(d: PXDevice; _type, _class: cint); inline;
procedure DeviceStateNotify(d: PXDevice; _type, _class: cint); inline;
procedure DeviceMappingNotify(d: PXDevice; _type, _class: cint); inline;
procedure ChangeDeviceNotify(d: PXDevice; _type, _class: cint); inline;
procedure DevicePropertyNotify(d: PXDevice; _type, _class: cint); inline;
procedure DevicePointerMotionHint(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButton1Motion(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButton2Motion(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButton3Motion(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButton4Motion(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButton5Motion(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButtonMotion(d: PXDevice; _type, _class: cint); inline;
procedure DeviceOwnerGrabButton(d: PXDevice; _type, _class: cint); inline;
procedure DeviceButtonPressGrab(d: PXDevice; _type, _class: cint); inline;
implementation
// Most important macro
procedure FindTypeAndClass(d: PXDevice; _type, _class, classid: cint; offset: cint); inline;
var
_i: integer;
_ip: PXInputClassInfo;
begin
_type := 0;
_class := 0;
_ip := d^.classes;
for _i := 0 to d^.num_classes do
begin
if _ip^.input_class = classid then
begin
_type := _ip^.event_type_base + offset;
_class := d^.device_id shl 8 or _type;
end;
Inc(_ip);
end;
end;
{
#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; }
procedure DeviceKeyPress(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, KeyClass, _deviceKeyPress);
end;
procedure DeviceKeyRelease(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, KeyClass, _deviceKeyRelease);
end;
procedure DeviceButtonPress(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, ButtonClass, _deviceButtonPress);
end;
procedure DeviceButtonRelease(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, ButtonClass, _deviceButtonRelease);
end;
procedure DeviceMotionNotify(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, ValuatorClass, _deviceMotionNotify);
end;
procedure DeviceFocusIn(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, FocusClass, _deviceFocusIn);
end;
procedure DeviceFocusOut(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, FocusClass, _deviceFocusOut);
end;
procedure ProximityIn(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, ProximityClass, _proximityIn);
end;
procedure ProximityOut(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, ProximityClass, _proximityOut);
end;
procedure DeviceStateNotify(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, OtherClass, _deviceStateNotify);
end;
procedure DeviceMappingNotify(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, OtherClass, _deviceMappingNotify);
end;
procedure ChangeDeviceNotify(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, OtherClass, _changeDeviceNotify);
end;
procedure DevicePropertyNotify(d: PXDevice; _type, _class: cint); inline;
begin
FindTypeAndClass(d, _type, _class, OtherClass, _propertyNotify);
end;
procedure DevicePointerMotionHint(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _devicePointerMotionHint;
end;
procedure DeviceButton1Motion(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceButton1Motion;
end;
procedure DeviceButton2Motion(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceButton2Motion;
end;
procedure DeviceButton3Motion(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceButton3Motion;
end;
procedure DeviceButton4Motion(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceButton4Motion;
end;
procedure DeviceButton5Motion(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceButton5Motion;
end;
procedure DeviceButtonMotion(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceButtonMotion;
end;
procedure DeviceOwnerGrabButton(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceOwnerGrabButton;
end;
procedure DeviceButtonPressGrab(d: PXDevice; _type, _class: cint); inline;
begin
_class := d^.device_id shl 8 or _deviceButtonGrab;
end;
end.
Reference in New Issue View Git Blame Copy Permalink