aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/Xi/extinit.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/programs/Xserver/Xi/extinit.c')
-rw-r--r--nx-X11/programs/Xserver/Xi/extinit.c1016
1 files changed, 1016 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/Xi/extinit.c b/nx-X11/programs/Xserver/Xi/extinit.c
new file mode 100644
index 000000000..0b27b5cf7
--- /dev/null
+++ b/nx-X11/programs/Xserver/Xi/extinit.c
@@ -0,0 +1,1016 @@
+/* $Xorg: extinit.c,v 1.4 2001/02/09 02:04:34 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.
+
+********************************************************/
+/* $XFree86: xc/programs/Xserver/Xi/extinit.c,v 3.6 2001/12/14 19:58:55 dawes Exp $ */
+
+/********************************************************************
+ *
+ * Dispatch routines and initialization routines for the X input extension.
+ *
+ */
+
+#define NUMTYPES 15
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "inputstr.h"
+#include "gcstruct.h" /* pointer for extnsionst.h*/
+#include "extnsionst.h" /* extension entry */
+#include <X11/extensions/XI.h>
+#include <X11/extensions/XIproto.h>
+
+#include "dixevents.h"
+#include "exevents.h"
+#include "extinit.h"
+#include "exglobals.h"
+#include "swaprep.h"
+
+/* modules local to Xi */
+#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];
+
+/*****************************************************************
+ *
+ * Globals referenced elsewhere in the server.
+ *
+ */
+
+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;
+
+/*****************************************************************
+ *
+ * Externs defined elsewhere in the X server.
+ *
+ */
+
+extern XExtensionVersion AllExtensionVersions[];
+
+Mask PropagateMask[MAX_DEVICES];
+
+/*****************************************************************
+ *
+ * Declarations of local routines.
+ *
+ */
+
+static XExtensionVersion thisversion =
+ {XI_Present,
+ XI_Add_XChangeDeviceControl_Major,
+ XI_Add_XChangeDeviceControl_Minor};
+
+/**********************************************************************
+ *
+ * IExtensionInit - initialize the input extension.
+ *
+ * Called from InitExtensions in main() or from QueryExtension() if the
+ * extension is dynamically loaded.
+ *
+ * This extension has several events and errors.
+ *
+ */
+
+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");
+ }
+ }
+
+/*************************************************************************
+ *
+ * ProcIDispatch - main dispatch routine for requests to this extension.
+ * This routine is used if server and client have the same byte ordering.
+ *
+ */
+
+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);
+ }
+
+/*******************************************************************************
+ *
+ * SProcXDispatch
+ *
+ * Main swapped dispatch routine for requests to this extension.
+ * This routine is used if server and client do not have the same byte ordering.
+ *
+ */
+
+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);
+ }
+
+/**********************************************************************
+ *
+ * SReplyIDispatch
+ * Swap any replies defined in this extension.
+ *
+ */
+
+/* FIXME: this would be more concise and readable in ANSI C */
+#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; /* All we look at is the type field */
+{ /* This is common to all replies */
+ 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");
+ }
+ }
+
+/*****************************************************************************
+ *
+ * SEventIDispatch
+ *
+ * Swap any events defined in this extension.
+ */
+#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");
+ }
+ }
+
+/************************************************************************
+ *
+ * This function swaps the DeviceValuator event.
+ *
+ */
+
+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); /* macro - braces are required */
+ }
+ }
+
+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); /* macro - braces are required */
+ }
+ }
+
+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);
+ }
+
+/************************************************************************
+ *
+ * This function sets up extension event types and masks.
+ *
+ */
+
+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);
+ }
+
+/************************************************************************
+ *
+ * This function restores extension event types and masks to their
+ * initial state.
+ *
+ */
+
+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;
+
+ }
+
+/***********************************************************************
+ *
+ * IResetProc.
+ * Remove reply-swapping routine.
+ * Remove event-swapping routine.
+ *
+ */
+
+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 ();
+ }
+
+/***********************************************************************
+ *
+ * Assign an id and type to an input device.
+ *
+ */
+
+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);
+ }
+
+/***********************************************************************
+ *
+ * Make device type atoms.
+ *
+ */
+
+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);
+ }
+
+/**************************************************************************
+ *
+ * Return a DeviceIntPtr corresponding to a specified device id.
+ * This will not return the pointer or keyboard, or devices that are not on.
+ *
+ */
+
+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);
+ }
+
+/**************************************************************************
+ *
+ * Allow the specified event to be restricted to being selected by one
+ * client at a time.
+ * The default is to allow more than one client to select the event.
+ *
+ */
+
+void
+SetExclusiveAccess (mask)
+ Mask mask;
+ {
+ int i;
+
+ for (i=0; i<MAX_DEVICES; i++)
+ ExtExclusiveMasks[i] |= mask;
+ }
+
+/**************************************************************************
+ *
+ * Allow the specified event to have its propagation suppressed.
+ * The default is to not allow suppression of propagation.
+ *
+ */
+
+void
+AllowPropagateSuppress (mask)
+ Mask mask;
+ {
+ int i;
+
+ for (i=0; i<MAX_DEVICES; i++)
+ PropagateMask[i] |= mask;
+ }
+
+/**************************************************************************
+ *
+ * Return the next available extension event 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;
+ }
+
+/**************************************************************************
+ *
+ * Assign the specified mask to the specified event.
+ *
+ */
+
+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);
+ }
+
+/**************************************************************************
+ *
+ * Record an event mask where there is no unique corresponding event type.
+ * We can't call SetMaskForEvent, since that would clobber the existing
+ * mask for that event. MotionHint and ButtonMotion are examples.
+ *
+ * Since extension event types will never be less than 64, we can use
+ * 0-63 in the EventInfo array as the "type" to be used to look up this
+ * mask. This means that the corresponding macros such as
+ * DevicePointerMotionHint must have access to the same constants.
+ *
+ */
+
+void
+SetEventInfo(mask, constant)
+ Mask mask;
+ int constant;
+ {
+ EventInfo[ExtEventIndex].mask = mask;
+ EventInfo[ExtEventIndex++].type = constant;
+ }