#define NUMTYPES 15
#define NEED_EVENTS
#define NEED_REPLIES
#include "X.h"
#include "Xproto.h"
#include "inputstr.h"
#include "gcstruct.h"
#include "extnsionst.h"
#include "XI.h"
#include "XIproto.h"
#include "dixevents.h"
#include "exevents.h"
#include "extinit.h"
#include "exglobals.h"
#include "swaprep.h"
#include "allowev.h"
#include "chgdctl.h"
#include "chgfctl.h"
#include "chgkbd.h"
#include "chgprop.h"
#include "chgptr.h"
#include "closedev.h"
#include "devbell.h"
#include "getbmap.h"
#include "getbmap.h"
#include "getdctl.h"
#include "getfctl.h"
#include "getfocus.h"
#include "getkmap.h"
#include "getmmap.h"
#include "getprop.h"
#include "getselev.h"
#include "getvers.h"
#include "getvers.h"
#include "grabdev.h"
#include "grabdevb.h"
#include "grabdevk.h"
#include "gtmotion.h"
#include "listdev.h"
#include "opendev.h"
#include "queryst.h"
#include "selectev.h"
#include "sendexev.h"
#include "chgkmap.h"
#include "setbmap.h"
#include "setdval.h"
#include "setfocus.h"
#include "setmmap.h"
#include "setmode.h"
#include "ungrdev.h"
#include "ungrdevb.h"
#include "ungrdevk.h"
static Mask lastExtEventMask = 1;
int ExtEventIndex;
Mask ExtValidMasks[EMASKSIZE];
Mask ExtExclusiveMasks[EMASKSIZE];
struct dev_type
{
Atom type;
char *name;
}dev_type [] = {{0,XI_KEYBOARD},
{0,XI_MOUSE},
{0,XI_TABLET},
{0,XI_TOUCHSCREEN},
{0,XI_TOUCHPAD},
{0,XI_BARCODE},
{0,XI_BUTTONBOX},
{0,XI_KNOB_BOX},
{0,XI_ONE_KNOB},
{0,XI_NINE_KNOB},
{0,XI_TRACKBALL},
{0,XI_QUADRATURE},
{0,XI_ID_MODULE},
{0,XI_SPACEBALL},
{0,XI_DATAGLOVE},
{0,XI_EYETRACKER},
{0,XI_CURSORKEYS},
{0,XI_FOOTMOUSE}};
CARD8 event_base [numInputClasses];
XExtEventInfo EventInfo[32];
int IReqCode = 0;
int BadDevice = 0;
int BadEvent = 1;
int BadMode = 2;
int DeviceBusy = 3;
int BadClass = 4;
Mask DevicePointerMotionMask;
Mask DevicePointerMotionHintMask;
Mask DeviceFocusChangeMask;
Mask DeviceStateNotifyMask;
Mask ChangeDeviceNotifyMask;
Mask DeviceMappingNotifyMask;
Mask DeviceOwnerGrabButtonMask;
Mask DeviceButtonGrabMask;
Mask DeviceButtonMotionMask;
int DeviceValuator;
int DeviceKeyPress;
int DeviceKeyRelease;
int DeviceButtonPress;
int DeviceButtonRelease;
int DeviceMotionNotify;
int DeviceFocusIn;
int DeviceFocusOut;
int ProximityIn;
int ProximityOut;
int DeviceStateNotify;
int DeviceKeyStateNotify;
int DeviceButtonStateNotify;
int DeviceMappingNotify;
int ChangeDeviceNotify;
int RT_INPUTCLIENT;
extern XExtensionVersion AllExtensionVersions[];
Mask PropagateMask[MAX_DEVICES];
static XExtensionVersion thisversion =
{XI_Present,
XI_Add_XChangeDeviceControl_Major,
XI_Add_XChangeDeviceControl_Minor};
void
XInputExtensionInit()
{
ExtensionEntry *extEntry;
extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,
SProcIDispatch, IResetProc, StandardMinorOpcode);
if (extEntry)
{
IReqCode = extEntry->base;
AllExtensionVersions[IReqCode-128] = thisversion;
MakeDeviceTypeAtoms ();
RT_INPUTCLIENT = CreateNewResourceType((DeleteType)InputClientGone);
FixExtensionEvents (extEntry);
ReplySwapVector[IReqCode] = (ReplySwapPtr)SReplyIDispatch;
EventSwapVector[DeviceValuator] = SEventIDispatch;
EventSwapVector[DeviceKeyPress] = SEventIDispatch;
EventSwapVector[DeviceKeyRelease] = SEventIDispatch;
EventSwapVector[DeviceButtonPress] = SEventIDispatch;
EventSwapVector[DeviceButtonRelease] = SEventIDispatch;
EventSwapVector[DeviceMotionNotify] = SEventIDispatch;
EventSwapVector[DeviceFocusIn] = SEventIDispatch;
EventSwapVector[DeviceFocusOut] = SEventIDispatch;
EventSwapVector[ProximityIn] = SEventIDispatch;
EventSwapVector[ProximityOut] = SEventIDispatch;
EventSwapVector[DeviceStateNotify] = SEventIDispatch;
EventSwapVector[DeviceKeyStateNotify] = SEventIDispatch;
EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
}
else
{
FatalError("IExtensionInit: AddExtensions failed\n");
}
}
int
ProcIDispatch (client)
register ClientPtr client;
{
REQUEST(xReq);
if (stuff->data == X_GetExtensionVersion)
return(ProcXGetExtensionVersion(client));
if (stuff->data == X_ListInputDevices)
return(ProcXListInputDevices(client));
else if (stuff->data == X_OpenDevice)
return(ProcXOpenDevice(client));
else if (stuff->data == X_CloseDevice)
return(ProcXCloseDevice(client));
else if (stuff->data == X_SetDeviceMode)
return(ProcXSetDeviceMode(client));
else if (stuff->data == X_SelectExtensionEvent)
return(ProcXSelectExtensionEvent(client));
else if (stuff->data == X_GetSelectedExtensionEvents)
return(ProcXGetSelectedExtensionEvents(client));
else if (stuff->data == X_ChangeDeviceDontPropagateList)
return(ProcXChangeDeviceDontPropagateList(client));
else if (stuff->data == X_GetDeviceDontPropagateList)
return(ProcXGetDeviceDontPropagateList(client));
else if (stuff->data == X_GetDeviceMotionEvents)
return(ProcXGetDeviceMotionEvents(client));
else if (stuff->data == X_ChangeKeyboardDevice)
return(ProcXChangeKeyboardDevice(client));
else if (stuff->data == X_ChangePointerDevice)
return(ProcXChangePointerDevice(client));
else if (stuff->data == X_GrabDevice)
return(ProcXGrabDevice(client));
else if (stuff->data == X_UngrabDevice)
return(ProcXUngrabDevice(client));
else if (stuff->data == X_GrabDeviceKey)
return(ProcXGrabDeviceKey(client));
else if (stuff->data == X_UngrabDeviceKey)
return(ProcXUngrabDeviceKey(client));
else if (stuff->data == X_GrabDeviceButton)
return(ProcXGrabDeviceButton(client));
else if (stuff->data == X_UngrabDeviceButton)
return(ProcXUngrabDeviceButton(client));
else if (stuff->data == X_AllowDeviceEvents)
return(ProcXAllowDeviceEvents(client));
else if (stuff->data == X_GetDeviceFocus)
return(ProcXGetDeviceFocus(client));
else if (stuff->data == X_SetDeviceFocus)
return(ProcXSetDeviceFocus(client));
else if (stuff->data == X_GetFeedbackControl)
return(ProcXGetFeedbackControl(client));
else if (stuff->data == X_ChangeFeedbackControl)
return(ProcXChangeFeedbackControl(client));
else if (stuff->data == X_GetDeviceKeyMapping)
return(ProcXGetDeviceKeyMapping(client));
else if (stuff->data == X_ChangeDeviceKeyMapping)
return(ProcXChangeDeviceKeyMapping(client));
else if (stuff->data == X_GetDeviceModifierMapping)
return(ProcXGetDeviceModifierMapping(client));
else if (stuff->data == X_SetDeviceModifierMapping)
return(ProcXSetDeviceModifierMapping(client));
else if (stuff->data == X_GetDeviceButtonMapping)
return(ProcXGetDeviceButtonMapping(client));
else if (stuff->data == X_SetDeviceButtonMapping)
return(ProcXSetDeviceButtonMapping(client));
else if (stuff->data == X_QueryDeviceState)
return(ProcXQueryDeviceState(client));
else if (stuff->data == X_SendExtensionEvent)
return(ProcXSendExtensionEvent(client));
else if (stuff->data == X_DeviceBell)
return(ProcXDeviceBell(client));
else if (stuff->data == X_SetDeviceValuators)
return(ProcXSetDeviceValuators(client));
else if (stuff->data == X_GetDeviceControl)
return(ProcXGetDeviceControl(client));
else if (stuff->data == X_ChangeDeviceControl)
return(ProcXChangeDeviceControl(client));
else
{
SendErrorToClient(client, IReqCode, stuff->data, 0, BadRequest);
}
return(BadRequest);
}
int
SProcIDispatch(client)
register ClientPtr client;
{
REQUEST(xReq);
if (stuff->data == X_GetExtensionVersion)
return(SProcXGetExtensionVersion(client));
if (stuff->data == X_ListInputDevices)
return(SProcXListInputDevices(client));
else if (stuff->data == X_OpenDevice)
return(SProcXOpenDevice(client));
else if (stuff->data == X_CloseDevice)
return(SProcXCloseDevice(client));
else if (stuff->data == X_SetDeviceMode)
return(SProcXSetDeviceMode(client));
else if (stuff->data == X_SelectExtensionEvent)
return(SProcXSelectExtensionEvent(client));
else if (stuff->data == X_GetSelectedExtensionEvents)
return(SProcXGetSelectedExtensionEvents(client));
else if (stuff->data == X_ChangeDeviceDontPropagateList)
return(SProcXChangeDeviceDontPropagateList(client));
else if (stuff->data == X_GetDeviceDontPropagateList)
return(SProcXGetDeviceDontPropagateList(client));
else if (stuff->data == X_GetDeviceMotionEvents)
return(SProcXGetDeviceMotionEvents(client));
else if (stuff->data == X_ChangeKeyboardDevice)
return(SProcXChangeKeyboardDevice(client));
else if (stuff->data == X_ChangePointerDevice)
return(SProcXChangePointerDevice(client));
else if (stuff->data == X_GrabDevice)
return(SProcXGrabDevice(client));
else if (stuff->data == X_UngrabDevice)
return(SProcXUngrabDevice(client));
else if (stuff->data == X_GrabDeviceKey)
return(SProcXGrabDeviceKey(client));
else if (stuff->data == X_UngrabDeviceKey)
return(SProcXUngrabDeviceKey(client));
else if (stuff->data == X_GrabDeviceButton)
return(SProcXGrabDeviceButton(client));
else if (stuff->data == X_UngrabDeviceButton)
return(SProcXUngrabDeviceButton(client));
else if (stuff->data == X_AllowDeviceEvents)
return(SProcXAllowDeviceEvents(client));
else if (stuff->data == X_GetDeviceFocus)
return(SProcXGetDeviceFocus(client));
else if (stuff->data == X_SetDeviceFocus)
return(SProcXSetDeviceFocus(client));
else if (stuff->data == X_GetFeedbackControl)
return(SProcXGetFeedbackControl(client));
else if (stuff->data == X_ChangeFeedbackControl)
return(SProcXChangeFeedbackControl(client));
else if (stuff->data == X_GetDeviceKeyMapping)
return(SProcXGetDeviceKeyMapping(client));
else if (stuff->data == X_ChangeDeviceKeyMapping)
return(SProcXChangeDeviceKeyMapping(client));
else if (stuff->data == X_GetDeviceModifierMapping)
return(SProcXGetDeviceModifierMapping(client));
else if (stuff->data == X_SetDeviceModifierMapping)
return(SProcXSetDeviceModifierMapping(client));
else if (stuff->data == X_GetDeviceButtonMapping)
return(SProcXGetDeviceButtonMapping(client));
else if (stuff->data == X_SetDeviceButtonMapping)
return(SProcXSetDeviceButtonMapping(client));
else if (stuff->data == X_QueryDeviceState)
return(SProcXQueryDeviceState(client));
else if (stuff->data == X_SendExtensionEvent)
return(SProcXSendExtensionEvent(client));
else if (stuff->data == X_DeviceBell)
return(SProcXDeviceBell(client));
else if (stuff->data == X_SetDeviceValuators)
return(SProcXSetDeviceValuators(client));
else if (stuff->data == X_GetDeviceControl)
return(SProcXGetDeviceControl(client));
else if (stuff->data == X_ChangeDeviceControl)
return(SProcXChangeDeviceControl(client));
else
{
SendErrorToClient(client, IReqCode, stuff->data, 0, BadRequest);
}
return(BadRequest);
}
#define DISPATCH(code) \
if (rep->RepType == X_##code) \
SRepX##code (client, len, (x##code##Reply *) rep)
void
SReplyIDispatch (client, len, rep)
ClientPtr client;
int len;
xGrabDeviceReply *rep;
{
if (rep->RepType == X_GetExtensionVersion)
SRepXGetExtensionVersion (client, len, (xGetExtensionVersionReply *)rep);
else if (rep->RepType == X_ListInputDevices)
SRepXListInputDevices (client, len, (xListInputDevicesReply *)rep);
else if (rep->RepType == X_OpenDevice)
SRepXOpenDevice (client, len, (xOpenDeviceReply *)rep);
else if (rep->RepType == X_SetDeviceMode)
SRepXSetDeviceMode (client, len, (xSetDeviceModeReply *) rep);
else if (rep->RepType == X_GetSelectedExtensionEvents)
SRepXGetSelectedExtensionEvents (client, len, (xGetSelectedExtensionEventsReply *) rep);
else if (rep->RepType == X_GetDeviceDontPropagateList)
SRepXGetDeviceDontPropagateList (client, len, (xGetDeviceDontPropagateListReply *)rep);
else if (rep->RepType == X_GetDeviceMotionEvents)
SRepXGetDeviceMotionEvents (client, len, (xGetDeviceMotionEventsReply *) rep);
else if (rep->RepType == X_ChangeKeyboardDevice)
SRepXChangeKeyboardDevice (client, len, (xChangeKeyboardDeviceReply *) rep);
else if (rep->RepType == X_ChangePointerDevice)
SRepXChangePointerDevice (client, len, (xChangePointerDeviceReply *)rep);
else if (rep->RepType == X_GrabDevice)
SRepXGrabDevice (client, len, (xGrabDeviceReply *)rep);
else if (rep->RepType == X_GetDeviceFocus)
SRepXGetDeviceFocus (client, len, (xGetDeviceFocusReply *)rep);
else if (rep->RepType == X_GetFeedbackControl)
SRepXGetFeedbackControl (client, len, (xGetFeedbackControlReply *)rep);
else if (rep->RepType == X_GetDeviceKeyMapping)
SRepXGetDeviceKeyMapping (client, len, (xGetDeviceKeyMappingReply *)rep);
else if (rep->RepType == X_GetDeviceModifierMapping)
SRepXGetDeviceModifierMapping (client, len, (xGetDeviceModifierMappingReply *)rep);
else if (rep->RepType == X_SetDeviceModifierMapping)
SRepXSetDeviceModifierMapping (client, len, (xSetDeviceModifierMappingReply *)rep);
else if (rep->RepType == X_GetDeviceButtonMapping)
SRepXGetDeviceButtonMapping (client, len, (xGetDeviceButtonMappingReply *)rep);
else if (rep->RepType == X_SetDeviceButtonMapping)
SRepXSetDeviceButtonMapping (client, len, (xSetDeviceButtonMappingReply *)rep);
else if (rep->RepType == X_QueryDeviceState)
SRepXQueryDeviceState (client, len, (xQueryDeviceStateReply *)rep);
else if (rep->RepType == X_SetDeviceValuators)
SRepXSetDeviceValuators (client, len, (xSetDeviceValuatorsReply *)rep);
else if (rep->RepType == X_GetDeviceControl)
SRepXGetDeviceControl (client, len, (xGetDeviceControlReply *)rep);
else if (rep->RepType == X_ChangeDeviceControl)
SRepXChangeDeviceControl (client, len, (xChangeDeviceControlReply *)rep);
else
{
FatalError("XINPUT confused sending swapped reply");
}
}
#define DO_SWAP(func,type) func ((type *)from, (type *)to)
void
SEventIDispatch (from, to)
xEvent *from;
xEvent *to;
{
int type = from->u.u.type & 0177;
if (type == DeviceValuator)
DO_SWAP(SEventDeviceValuator, deviceValuator);
else if (type == DeviceKeyPress)
{
SKeyButtonPtrEvent (from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
}
else if (type == DeviceKeyRelease)
{
SKeyButtonPtrEvent (from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
}
else if (type == DeviceButtonPress)
{
SKeyButtonPtrEvent (from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
}
else if (type == DeviceButtonRelease)
{
SKeyButtonPtrEvent (from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
}
else if (type == DeviceMotionNotify)
{
SKeyButtonPtrEvent (from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
}
else if (type == DeviceFocusIn)
DO_SWAP(SEventFocus, deviceFocus);
else if (type == DeviceFocusOut)
DO_SWAP(SEventFocus, deviceFocus);
else if (type == ProximityIn)
{
SKeyButtonPtrEvent (from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
}
else if (type == ProximityOut)
{
SKeyButtonPtrEvent (from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
}
else if (type == DeviceStateNotify)
DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
else if (type == DeviceKeyStateNotify)
DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
else if (type == DeviceButtonStateNotify)
DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
else if (type == DeviceMappingNotify)
DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
else if (type == ChangeDeviceNotify)
DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
else
{
FatalError("XInputExtension: Impossible event!\n");
}
}
void
SEventDeviceValuator (from, to)
deviceValuator *from;
deviceValuator *to;
{
register char n;
register int i;
INT32 *ip B32;
*to = *from;
swaps(&to->sequenceNumber,n);
swaps(&to->device_state,n);
ip = &to->valuator0;
for (i=0; i<6; i++)
{
swapl((ip+i),n);
}
}
void
SEventFocus (from, to)
deviceFocus *from;
deviceFocus *to;
{
register char n;
*to = *from;
swaps(&to->sequenceNumber,n);
swapl(&to->time, n);
swapl(&to->window, n);
}
void
SDeviceStateNotifyEvent (from, to)
deviceStateNotify *from;
deviceStateNotify *to;
{
register int i;
register char n;
INT32 *ip B32;
*to = *from;
swaps(&to->sequenceNumber,n);
swapl(&to->time, n);
ip = &to->valuator0;
for (i=0; i<3; i++)
{
swapl((ip+i),n);
}
}
void
SDeviceKeyStateNotifyEvent (from, to)
deviceKeyStateNotify *from;
deviceKeyStateNotify *to;
{
register char n;
*to = *from;
swaps(&to->sequenceNumber,n);
}
void
SDeviceButtonStateNotifyEvent (from, to)
deviceButtonStateNotify *from;
deviceButtonStateNotify *to;
{
register char n;
*to = *from;
swaps(&to->sequenceNumber,n);
}
void
SChangeDeviceNotifyEvent (from, to)
changeDeviceNotify *from;
changeDeviceNotify *to;
{
register char n;
*to = *from;
swaps(&to->sequenceNumber,n);
swapl(&to->time, n);
}
void
SDeviceMappingNotifyEvent (from, to)
deviceMappingNotify *from;
deviceMappingNotify *to;
{
register char n;
*to = *from;
swaps(&to->sequenceNumber,n);
swapl(&to->time, n);
}
void
FixExtensionEvents (extEntry)
ExtensionEntry *extEntry;
{
Mask mask;
DeviceValuator = extEntry->eventBase;
DeviceKeyPress = DeviceValuator + 1;
DeviceKeyRelease = DeviceKeyPress + 1;
DeviceButtonPress = DeviceKeyRelease + 1;
DeviceButtonRelease = DeviceButtonPress + 1;
DeviceMotionNotify = DeviceButtonRelease + 1;
DeviceFocusIn = DeviceMotionNotify + 1;
DeviceFocusOut = DeviceFocusIn + 1;
ProximityIn = DeviceFocusOut + 1;
ProximityOut = ProximityIn + 1;
DeviceStateNotify = ProximityOut + 1;
DeviceMappingNotify = DeviceStateNotify + 1;
ChangeDeviceNotify = DeviceMappingNotify + 1;
DeviceKeyStateNotify = ChangeDeviceNotify + 1;
DeviceButtonStateNotify = DeviceKeyStateNotify + 1;
event_base[KeyClass] = DeviceKeyPress;
event_base[ButtonClass] = DeviceButtonPress;
event_base[ValuatorClass] = DeviceMotionNotify;
event_base[ProximityClass] = ProximityIn;
event_base[FocusClass] = DeviceFocusIn;
event_base[OtherClass] = DeviceStateNotify;
BadDevice += extEntry->errorBase;
BadEvent += extEntry->errorBase;
BadMode += extEntry->errorBase;
DeviceBusy += extEntry->errorBase;
BadClass += extEntry->errorBase;
mask = GetNextExtEventMask ();
SetMaskForExtEvent (mask, DeviceKeyPress);
AllowPropagateSuppress (mask);
mask = GetNextExtEventMask ();
SetMaskForExtEvent (mask, DeviceKeyRelease);
AllowPropagateSuppress (mask);
mask = GetNextExtEventMask ();
SetMaskForExtEvent (mask, DeviceButtonPress);
AllowPropagateSuppress (mask);
mask = GetNextExtEventMask ();
SetMaskForExtEvent (mask, DeviceButtonRelease);
AllowPropagateSuppress (mask);
mask = GetNextExtEventMask ();
SetMaskForExtEvent (mask, ProximityIn);
SetMaskForExtEvent (mask, ProximityOut);
AllowPropagateSuppress (mask);
mask = GetNextExtEventMask ();
DeviceStateNotifyMask = mask;
SetMaskForExtEvent (mask, DeviceStateNotify);
mask = GetNextExtEventMask ();
DevicePointerMotionMask = mask;
SetMaskForExtEvent (mask, DeviceMotionNotify);
AllowPropagateSuppress (mask);
DevicePointerMotionHintMask = GetNextExtEventMask();
SetEventInfo (DevicePointerMotionHintMask, _devicePointerMotionHint);
SetEventInfo (GetNextExtEventMask(), _deviceButton1Motion);
SetEventInfo (GetNextExtEventMask(), _deviceButton2Motion);
SetEventInfo (GetNextExtEventMask(), _deviceButton3Motion);
SetEventInfo (GetNextExtEventMask(), _deviceButton4Motion);
SetEventInfo (GetNextExtEventMask(), _deviceButton5Motion);
DeviceButtonMotionMask = GetNextExtEventMask();
SetEventInfo (DeviceButtonMotionMask, _deviceButtonMotion);
DeviceFocusChangeMask = GetNextExtEventMask ();
SetMaskForExtEvent (DeviceFocusChangeMask, DeviceFocusIn);
SetMaskForExtEvent (DeviceFocusChangeMask, DeviceFocusOut);
mask = GetNextExtEventMask ();
SetMaskForExtEvent (mask, DeviceMappingNotify);
DeviceMappingNotifyMask = mask;
mask = GetNextExtEventMask ();
SetMaskForExtEvent (mask, ChangeDeviceNotify);
ChangeDeviceNotifyMask = mask;
DeviceButtonGrabMask = GetNextExtEventMask();
SetEventInfo (DeviceButtonGrabMask, _deviceButtonGrab);
SetExclusiveAccess (DeviceButtonGrabMask);
DeviceOwnerGrabButtonMask = GetNextExtEventMask();
SetEventInfo (DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
SetEventInfo (0, _noExtensionEvent);
}
void
RestoreExtensionEvents ()
{
int i;
IReqCode = 0;
for (i=0; i<ExtEventIndex-1; i++)
{
if ((EventInfo[i].type >= LASTEvent) && (EventInfo[i].type < 128))
SetMaskForEvent(0,EventInfo[i].type);
EventInfo[i].mask = 0;
EventInfo[i].type = 0;
}
ExtEventIndex = 0;
lastExtEventMask = 1;
DeviceValuator = 0;
DeviceKeyPress = 1;
DeviceKeyRelease = 2;
DeviceButtonPress = 3;
DeviceButtonRelease = 4;
DeviceMotionNotify = 5;
DeviceFocusIn = 6;
DeviceFocusOut = 7;
ProximityIn = 8;
ProximityOut = 9;
DeviceStateNotify = 10;
DeviceMappingNotify = 11;
ChangeDeviceNotify = 12;
DeviceKeyStateNotify = 13;
DeviceButtonStateNotify = 13;
BadDevice = 0;
BadEvent = 1;
BadMode = 2;
DeviceBusy = 3;
BadClass = 4;
}
void
IResetProc(unused)
ExtensionEntry *unused;
{
ReplySwapVector[IReqCode] = ReplyNotSwappd;
EventSwapVector[DeviceValuator] = NotImplemented;
EventSwapVector[DeviceKeyPress] = NotImplemented;
EventSwapVector[DeviceKeyRelease] = NotImplemented;
EventSwapVector[DeviceButtonPress] = NotImplemented;
EventSwapVector[DeviceButtonRelease] = NotImplemented;
EventSwapVector[DeviceMotionNotify] = NotImplemented;
EventSwapVector[DeviceFocusIn] = NotImplemented;
EventSwapVector[DeviceFocusOut] = NotImplemented;
EventSwapVector[ProximityIn] = NotImplemented;
EventSwapVector[ProximityOut] = NotImplemented;
EventSwapVector[DeviceStateNotify] = NotImplemented;
EventSwapVector[DeviceKeyStateNotify] = NotImplemented;
EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
EventSwapVector[DeviceMappingNotify] = NotImplemented;
EventSwapVector[ChangeDeviceNotify] = NotImplemented;
RestoreExtensionEvents ();
}
void
AssignTypeAndName (dev, type, name)
DeviceIntPtr dev;
Atom type;
char *name;
{
dev->type = type;
dev->name = (char *) xalloc(strlen(name)+1);
strcpy (dev->name, name);
}
void
MakeDeviceTypeAtoms ()
{
int i;
for (i=0; i<NUMTYPES; i++)
dev_type[i].type =
MakeAtom (dev_type[i].name, strlen(dev_type[i].name), 1);
}
DeviceIntPtr
LookupDeviceIntRec (
CARD8 id)
{
DeviceIntPtr dev;
for (dev=inputInfo.devices; dev; dev=dev->next)
{
if (dev->id == id)
{
if (id == inputInfo.pointer->id || id == inputInfo.keyboard->id)
return (NULL);
return (dev);
}
}
return (NULL);
}
void
SetExclusiveAccess (mask)
Mask mask;
{
int i;
for (i=0; i<MAX_DEVICES; i++)
ExtExclusiveMasks[i] |= mask;
}
void
AllowPropagateSuppress (mask)
Mask mask;
{
int i;
for (i=0; i<MAX_DEVICES; i++)
PropagateMask[i] |= mask;
}
Mask
GetNextExtEventMask ()
{
int i;
Mask mask = lastExtEventMask;
if (lastExtEventMask == 0)
{
FatalError("GetNextExtEventMask: no more events are available.");
}
lastExtEventMask <<= 1;
for (i=0; i<MAX_DEVICES; i++)
ExtValidMasks[i] |= mask;
return mask;
}
void
SetMaskForExtEvent(mask, event)
Mask mask;
int event;
{
EventInfo[ExtEventIndex].mask = mask;
EventInfo[ExtEventIndex++].type = event;
if ((event < LASTEvent) || (event >= 128))
FatalError("MaskForExtensionEvent: bogus event number");
SetMaskForEvent(mask,event);
}
void
SetEventInfo(mask, constant)
Mask mask;
int constant;
{
EventInfo[ExtEventIndex].mask = mask;
EventInfo[ExtEventIndex++].type = constant;
}