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