mirror of
https://github.com/moparisthebest/Simba
synced 2024-11-17 23:05:00 -05:00
3fef7ac7ed
git-svn-id: http://www.villavu.com/repositories/merlijn/mufasa@475 3f818213-9676-44b0-a9b4-5e4c4e03d09d
1015 lines
33 KiB
ObjectPascal
1015 lines
33 KiB
ObjectPascal
{ $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.
|