R6.6 is the Xorg base-lineXORG-MAIN

38 files changed, 9696 insertions, 0 deletions

diff --git a/Xi/allowev.c b/Xi/allowev.c
new file mode 100644
index 000000000..db98d8c93
--- /dev/null
+++ b/Xi/allowev.c
@@ -0,0 +1,139 @@
+/* $Xorg: allowev.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Function to allow frozen events to be routed from extension input devices.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure allows frozen events to be routed.
+ *
+ */
+
+int
+SProcXAllowDeviceEvents(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xAllowDeviceEventsReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xAllowDeviceEventsReq);
+    swapl(&stuff->time, n);
+    return(ProcXAllowDeviceEvents(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure allows frozen events to be routed.
+ *
+ */
+
+int
+ProcXAllowDeviceEvents(client)
+    register ClientPtr client;
+    {
+    TimeStamp		time;
+    DeviceIntPtr	thisdev;
+    void AllowSome ();
+
+    REQUEST(xAllowDeviceEventsReq);
+    REQUEST_SIZE_MATCH(xAllowDeviceEventsReq);
+
+    thisdev = LookupDeviceIntRec (stuff->deviceid);
+    if (thisdev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, BadDevice);
+	return Success;
+	}
+    time = ClientTimeToServerTime(stuff->time);
+
+    switch (stuff->mode)
+        {
+	case ReplayThisDevice:
+	    AllowSome(client, time, thisdev, NOT_GRABBED);
+	    break;
+	case SyncThisDevice: 
+	    AllowSome(client, time, thisdev, FREEZE_NEXT_EVENT);
+	    break;
+	case AsyncThisDevice: 
+	    AllowSome(client, time, thisdev, THAWED);
+	    break;
+	case AsyncOtherDevices: 
+	    AllowSome(client, time, thisdev, THAW_OTHERS);
+	    break;
+	case SyncAll:
+	    AllowSome(client, time, thisdev, FREEZE_BOTH_NEXT_EVENT);
+	    break;
+	case AsyncAll:
+	    AllowSome(client, time, thisdev, THAWED_BOTH);
+	    break;
+	default: 
+	    SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, 
+		BadValue);
+	    client->errorValue = stuff->mode;
+	    return Success;
+        }
+    return Success;
+    }
diff --git a/Xi/chgdctl.c b/Xi/chgdctl.c
new file mode 100644
index 000000000..e5dab66c1
--- /dev/null
+++ b/Xi/chgdctl.c
@@ -0,0 +1,209 @@
+/* $Xorg: chgdctl.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Change Device control attributes for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"			/* control constants */
+
+extern	int 	IReqCode;
+extern	int	BadDevice, DeviceBusy;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure changes the control attributes for an extension device,
+ * for clients on machines with a different byte ordering than the server.
+ *
+ */
+
+int
+SProcXChangeDeviceControl(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xChangeDeviceControlReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
+    swaps(&stuff->control, n);
+    return(ProcXChangeDeviceControl(client));
+    }
+
+/***********************************************************************
+ *
+ * Change the control attributes.
+ *
+ */
+
+ProcXChangeDeviceControl(client)
+    ClientPtr client;
+    {
+    int i, len, status;
+    DeviceIntPtr dev;
+    xDeviceResolutionCtl *r;
+    xChangeDeviceControlReply rep;
+    AxisInfoPtr a;
+    CARD32 *resolution;
+
+    REQUEST(xChangeDeviceControlReq);
+    REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
+
+    len = stuff->length - (sizeof(xChangeDeviceControlReq) >>2);
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_ChangeDeviceControl;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    switch (stuff->control) 
+	{
+	case DEVICE_RESOLUTION:
+    	    r = (xDeviceResolutionCtl *) &stuff[1];
+	    if ((len < (sizeof(xDeviceResolutionCtl)>>2)) ||
+	        (len != (sizeof(xDeviceResolutionCtl)>>2) +
+		 r->num_valuators))
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 
+			0, BadLength);
+		return Success;
+		}
+	    if (!dev->valuator)
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
+		    BadMatch);
+		return Success;
+		}
+	    if ((dev->grab) && !SameClient(dev->grab, client))
+		{
+		rep.status = AlreadyGrabbed;
+		WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), 
+		    &rep);
+		return Success;
+		}
+	    resolution = (CARD32 *) (r + 1);
+	    if (r->first_valuator + r->num_valuators > dev->valuator->numAxes)
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
+		    BadValue);
+		return Success;
+		}
+	    status = ChangeDeviceControl(client, dev, r);
+	    if (status == Success)
+		{
+	        a = &dev->valuator->axes[r->first_valuator];
+		for (i=0; i<r->num_valuators; i++)
+		    if (*(resolution+i) < (a+i)->min_resolution ||
+		        *(resolution+i) > (a+i)->max_resolution)
+			{
+			SendErrorToClient (client, IReqCode, 
+			    X_ChangeDeviceControl, 0, BadValue);
+			return Success;
+			}
+		for (i=0; i<r->num_valuators; i++)
+		    (a++)->resolution = *resolution++; 
+		}
+	    else if (status == DeviceBusy)
+		{
+		rep.status = DeviceBusy;
+		WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), 
+		    &rep);
+		return Success;
+		}
+	    else 
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
+		    BadMatch);
+		return Success;
+		}
+	    break;
+	default:
+	    SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
+		BadValue);
+	    return Success;
+	}
+    WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the xChangeDeviceControl function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXChangeDeviceControl (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xChangeDeviceControlReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
+
diff --git a/Xi/chgfctl.c b/Xi/chgfctl.c
new file mode 100644
index 000000000..0b945de23
--- /dev/null
+++ b/Xi/chgfctl.c
@@ -0,0 +1,649 @@
+/* $Xorg: chgfctl.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Change feedback control attributes for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"			/* control constants */
+
+#define DO_ALL    (-1)
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure changes the control attributes for an extension device,
+ * for clients on machines with a different byte ordering than the server.
+ *
+ */
+
+int
+SProcXChangeFeedbackControl(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xChangeFeedbackControlReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeFeedbackControlReq);
+    swapl(&stuff->mask, n);
+    return(ProcXChangeFeedbackControl(client));
+    }
+
+/***********************************************************************
+ *
+ * Change the control attributes.
+ *
+ */
+
+ProcXChangeFeedbackControl(client)
+    ClientPtr client;
+    {
+    int len;
+    DeviceIntPtr dev;
+    KbdFeedbackPtr k;
+    PtrFeedbackPtr p;
+    IntegerFeedbackPtr i;
+    StringFeedbackPtr s;
+    BellFeedbackPtr b;
+    LedFeedbackPtr l;
+
+    REQUEST(xChangeFeedbackControlReq);
+    REQUEST_AT_LEAST_SIZE(xChangeFeedbackControlReq);
+
+    len = stuff->length - (sizeof(xChangeFeedbackControlReq) >>2);
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    switch (stuff->feedbackid)
+	{
+	case KbdFeedbackClass:
+	    if (len != (sizeof(xKbdFeedbackCtl)>>2))
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
+			0, BadLength);
+		return Success;
+		}
+	    for (k=dev->kbdfeed; k; k=k->next)
+		if (k->ctrl.id == ((xKbdFeedbackCtl *) &stuff[1])->id)
+		    {
+		    ChangeKbdFeedback (client, dev, stuff->mask, k, &stuff[1]);
+		    return Success;
+		    }
+	    break;
+	case PtrFeedbackClass:
+	    if (len != (sizeof(xPtrFeedbackCtl)>>2))
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
+			0, BadLength);
+		return Success;
+		}
+	    for (p=dev->ptrfeed; p; p=p->next)
+		if (p->ctrl.id == ((xPtrFeedbackCtl *) &stuff[1])->id)
+		    {
+		    ChangePtrFeedback (client, dev, stuff->mask, p, &stuff[1]);
+		    return Success;
+		    }
+	    break;
+	case StringFeedbackClass:
+	    {
+	    register char n;
+	    xStringFeedbackCtl *f = ((xStringFeedbackCtl *) &stuff[1]);
+	    if (client->swapped)
+		{
+		swaps(&f->num_keysyms,n);
+		}
+	    if (len != ((sizeof(xStringFeedbackCtl)>>2) + f->num_keysyms))
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
+			0, BadLength);
+		return Success;
+		}
+	    for (s=dev->stringfeed; s; s=s->next)
+		if (s->ctrl.id == ((xStringFeedbackCtl *) &stuff[1])->id)
+		    {
+		    ChangeStringFeedback (client, dev, stuff->mask,s,&stuff[1]);
+		    return Success;
+		    }
+	    break;
+	    }
+	case IntegerFeedbackClass:
+	    if (len != (sizeof(xIntegerFeedbackCtl)>>2))
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
+			0, BadLength);
+		return Success;
+		}
+	    for (i=dev->intfeed; i; i=i->next)
+		if (i->ctrl.id == ((xIntegerFeedbackCtl *) &stuff[1])->id)
+		    {
+		    ChangeIntegerFeedback (client, dev,stuff->mask,i,&stuff[1]);
+		    return Success;
+		    }
+	    break;
+	case LedFeedbackClass:
+	    if (len != (sizeof(xLedFeedbackCtl)>>2))
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
+			0, BadLength);
+		return Success;
+		}
+	    for (l=dev->leds; l; l=l->next)
+		if (l->ctrl.id == ((xLedFeedbackCtl *) &stuff[1])->id)
+		    {
+		    ChangeLedFeedback (client, dev, stuff->mask, l, &stuff[1]);
+		    return Success;
+		    }
+	    break;
+	case BellFeedbackClass:
+	    if (len != (sizeof(xBellFeedbackCtl)>>2))
+		{
+		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
+			0, BadLength);
+		return Success;
+		}
+	    for (b=dev->bell; b; b=b->next)
+		if (b->ctrl.id == ((xBellFeedbackCtl *) &stuff[1])->id)
+		    {
+		    ChangeBellFeedback (client, dev, stuff->mask, b, &stuff[1]);
+		    return Success;
+		    }
+	    break;
+	default:
+	    break;
+	}
+
+    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, BadMatch);
+    return Success;
+    } 
+
+/******************************************************************************
+ *
+ * This procedure changes KbdFeedbackClass data.
+ *
+ */
+
+ChangeKbdFeedback (client, dev, mask, k, f)
+    ClientPtr client;
+    DeviceIntPtr dev;
+    unsigned long 	mask;
+    KbdFeedbackPtr	k;
+    xKbdFeedbackCtl 	*f;
+    {
+    register char n;
+    KeybdCtrl kctrl;
+    int t;
+    int key = DO_ALL;
+
+    if (client->swapped)
+	{
+	swaps(&f->length,n);
+	swaps(&f->pitch,n);
+	swaps(&f->duration,n);
+	swapl(&f->led_mask,n);
+	swapl(&f->led_values,n);
+	}
+
+    kctrl = k->ctrl;
+    if (mask & DvKeyClickPercent)
+	{
+	t = f->click;
+	if (t == -1)
+	    t = defaultKeyboardControl.click;
+	else if (t < 0 || t > 100)
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	kctrl.click = t;
+        }
+
+    if (mask & DvPercent)
+	{
+	t = f->percent;
+	if (t == -1)
+	    t = defaultKeyboardControl.bell;
+	else if (t < 0 || t > 100)
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	kctrl.bell = t;
+	}
+
+    if (mask & DvPitch)
+	{
+	t = f->pitch;
+	if (t == -1)
+	    t = defaultKeyboardControl.bell_pitch;
+	else if (t < 0)
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	kctrl.bell_pitch = t;
+	}
+
+    if (mask & DvDuration)
+	{
+	t = f->duration;
+	if (t == -1)
+	    t = defaultKeyboardControl.bell_duration;
+	else if (t < 0)
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	kctrl.bell_duration = t;
+        }
+
+    if (mask & DvLed)
+        {
+	kctrl.leds &= ~(f->led_mask);
+	kctrl.leds |= (f->led_mask & f->led_values);
+        }
+
+    if (mask & DvKey)
+	{
+	key = (KeyCode) f->key;
+	if (key < 8 || key > 255)
+	    {
+	    client->errorValue = key;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	if (!(mask & DvAutoRepeatMode))
+	    {
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadMatch);
+	    return Success;
+	    }
+	}
+
+    if (mask & DvAutoRepeatMode)
+	{
+	int index = (key >> 3);
+	int kmask = (1 << (key & 7));
+	t = (CARD8) f->auto_repeat_mode;
+	if (t == AutoRepeatModeOff)
+	    {
+	    if (key == DO_ALL)
+		kctrl.autoRepeat = FALSE;
+	    else
+		kctrl.autoRepeats[index] &= ~kmask;
+	    }
+	else if (t == AutoRepeatModeOn)
+	    {
+	    if (key == DO_ALL)
+		kctrl.autoRepeat = TRUE;
+	    else
+		kctrl.autoRepeats[index] |= kmask;
+	    }
+	else if (t == AutoRepeatModeDefault)
+	    {
+	    if (key == DO_ALL)
+		kctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
+	    else
+		kctrl.autoRepeats[index] &= ~kmask;
+		kctrl.autoRepeats[index] =
+			(kctrl.autoRepeats[index] & ~kmask) |
+			(defaultKeyboardControl.autoRepeats[index] & kmask);
+	    }
+	else
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+        }
+
+    k->ctrl = kctrl;
+    (*k->CtrlProc)(dev, &k->ctrl);
+    return Success;
+    }
+
+/******************************************************************************
+ *
+ * This procedure changes PtrFeedbackClass data.
+ *
+ */
+
+ChangePtrFeedback (client, dev, mask, p, f)
+    ClientPtr 		client;
+    DeviceIntPtr 	dev;
+    unsigned long 	mask;
+    PtrFeedbackPtr 	p;
+    xPtrFeedbackCtl 	*f;
+    {
+    register char n;
+    PtrCtrl pctrl;		/* might get BadValue part way through */
+
+    if (client->swapped)
+	{
+	swaps(&f->length,n);
+	swaps(&f->num,n);
+	swaps(&f->denom,n);
+	swaps(&f->thresh,n);
+	}
+
+    pctrl = p->ctrl;
+    if (mask & DvAccelNum)
+	{
+	int	accelNum;
+
+	accelNum = f->num;
+	if (accelNum == -1)
+	    pctrl.num = defaultPointerControl.num;
+	else if (accelNum < 0)
+	    {
+	    client->errorValue = accelNum;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	else pctrl.num = accelNum;
+	}
+
+    if (mask & DvAccelDenom)
+	{
+	int	accelDenom;
+
+	accelDenom = f->denom;
+	if (accelDenom == -1)
+	    pctrl.den = defaultPointerControl.den;
+	else if (accelDenom <= 0)
+	    {
+	    client->errorValue = accelDenom;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	else pctrl.den = accelDenom;
+        }
+
+    if (mask & DvThreshold)
+	{
+	int	threshold;
+
+	threshold = f->thresh;
+	if (threshold == -1)
+	    pctrl.threshold = defaultPointerControl.threshold;
+	else if (threshold < 0)
+	    {
+	    client->errorValue = threshold;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	else pctrl.threshold = threshold;
+        }
+
+    p->ctrl = pctrl;
+    (*p->CtrlProc)(dev, &p->ctrl);
+    return Success;
+    }
+
+/******************************************************************************
+ *
+ * This procedure changes IntegerFeedbackClass data.
+ *
+ */
+
+ChangeIntegerFeedback (client, dev, mask, i, f)
+    ClientPtr 			client;
+    DeviceIntPtr 		dev;
+    unsigned long 		mask;
+    IntegerFeedbackPtr 		i;
+    xIntegerFeedbackCtl 	*f;
+    {
+    register char n;
+
+    if (client->swapped)
+	{
+	swaps(&f->length,n);
+	swapl(&f->int_to_display,n);
+	}
+
+    i->ctrl.integer_displayed = f->int_to_display;
+    (*i->CtrlProc)(dev, &i->ctrl);
+    return Success;
+    }
+
+/******************************************************************************
+ *
+ * This procedure changes StringFeedbackClass data.
+ *
+ */
+
+ChangeStringFeedback (client, dev, mask, s, f)
+    ClientPtr 		client;
+    DeviceIntPtr 	dev;
+    unsigned long 	mask;
+    StringFeedbackPtr 	s;
+    xStringFeedbackCtl 	*f;
+    {
+    register char n;
+    register long *p;
+    int		i, j, len;
+    KeySym	*syms, *sup_syms;
+
+    syms = (KeySym *) (f+1);
+    if (client->swapped)
+	{
+	swaps(&f->length,n);	/* swapped num_keysyms in calling proc */
+	p = (long *) (syms);
+	for (i=0; i<f->num_keysyms; i++)
+	    {
+	    swapl(p, n);
+	    p++;
+	    }
+	}
+
+    if (f->num_keysyms > s->ctrl.max_symbols)
+	{
+	SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, 
+	    BadValue);
+	return Success;
+	}
+    sup_syms = s->ctrl.symbols_supported;
+    for (i=0; i<f->num_keysyms; i++)
+	{
+        for (j=0; j<s->ctrl.num_symbols_supported; j++)
+	    if (*(syms+i) == *(sup_syms+j))
+		break;
+	if (j==s->ctrl.num_symbols_supported)
+	    {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadMatch);
+	    return Success;
+	    }
+	}
+
+    s->ctrl.num_symbols_displayed  = f->num_keysyms;
+    for (i=0; i<f->num_keysyms; i++)
+	*(s->ctrl.symbols_displayed+i) = *(syms+i);
+    (*s->CtrlProc)(dev, &s->ctrl);
+    return Success;
+    }
+
+/******************************************************************************
+ *
+ * This procedure changes BellFeedbackClass data.
+ *
+ */
+
+ChangeBellFeedback (client, dev, mask, b, f)
+    ClientPtr 		client;
+    DeviceIntPtr 	dev;
+    unsigned long 	mask;
+    BellFeedbackPtr 	b;
+    xBellFeedbackCtl 	*f;
+    {
+    register char n;
+    int t;
+    BellCtrl bctrl;		/* might get BadValue part way through */
+
+    if (client->swapped)
+	{
+	swaps(&f->length,n);
+	swaps(&f->pitch,n);
+	swaps(&f->duration,n);
+	}
+
+    bctrl = b->ctrl;
+    if (mask & DvPercent)
+	{
+	t = f->percent;
+	if (t == -1)
+	    t = defaultKeyboardControl.bell;
+	else if (t < 0 || t > 100)
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	bctrl.percent = t;
+	}
+
+    if (mask & DvPitch)
+	{
+	t = f->pitch;
+	if (t == -1)
+	    t = defaultKeyboardControl.bell_pitch;
+	else if (t < 0)
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	bctrl.pitch = t;
+	}
+
+    if (mask & DvDuration)
+	{
+	t = f->duration;
+	if (t == -1)
+	    t = defaultKeyboardControl.bell_duration;
+	else if (t < 0)
+	    {
+	    client->errorValue = t;
+	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
+		BadValue);
+	    return Success;
+	    }
+	bctrl.duration = t;
+        }
+    b->ctrl = bctrl;
+    (*b->CtrlProc)(dev, &b->ctrl);
+    return Success;
+    }
+
+/******************************************************************************
+ *
+ * This procedure changes LedFeedbackClass data.
+ *
+ */
+
+ChangeLedFeedback (client, dev, mask, l, f)
+    ClientPtr 		client;
+    DeviceIntPtr 	dev;
+    unsigned long 	mask;
+    LedFeedbackPtr 	l;
+    xLedFeedbackCtl 	*f;
+    {
+    register char n;
+    LedCtrl lctrl;		/* might get BadValue part way through */
+
+    if (client->swapped)
+	{
+	swaps(&f->length,n);
+	swapl(&f->led_values,n);
+	swapl(&f->led_mask,n);
+	}
+
+    f->led_mask &= l->ctrl.led_mask;	/* set only supported leds */
+    f->led_values &= l->ctrl.led_mask;	/* set only supported leds */
+    if (mask & DvLed)
+        {
+	lctrl.led_mask = f->led_mask;
+	lctrl.led_values = f->led_values;
+	(*l->CtrlProc)(dev, &lctrl);
+	l->ctrl.led_values &= ~(f->led_mask);		/* zero changed leds */
+	l->ctrl.led_values |= (f->led_mask & f->led_values);/* OR in set leds*/
+        }
+
+    return Success;
+    }
diff --git a/Xi/chgkbd.c b/Xi/chgkbd.c
new file mode 100644
index 000000000..f48b4682b
--- /dev/null
+++ b/Xi/chgkbd.c
@@ -0,0 +1,208 @@
+/* $Xorg: chgkbd.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to change the keyboard device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	int 		ChangeDeviceNotify;
+extern	Mask		ChangeDeviceNotifyMask;
+extern	InputInfo	inputInfo;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure changes the keyboard device.
+ *
+ */
+
+int
+SProcXChangeKeyboardDevice(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xChangeKeyboardDeviceReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
+    return(ProcXChangeKeyboardDevice(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure is invoked to swap the request bytes if the server and
+ * client have a different byte order.
+ *
+ */
+
+ProcXChangeKeyboardDevice (client)
+    register ClientPtr client;
+    {
+    int				i;
+    DeviceIntPtr 		xkbd = inputInfo.keyboard;
+    DeviceIntPtr 		dev;
+    FocusClassPtr		xf = xkbd->focus;
+    FocusClassPtr		df;
+    KeyClassPtr 		k;
+    xChangeKeyboardDeviceReply	rep;
+    changeDeviceNotify		ev;
+    extern Bool Must_have_memory;
+
+    REQUEST(xChangeKeyboardDeviceReq);
+    REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_ChangeKeyboardDevice;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	rep.status = -1;
+	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    k = dev->key;
+    if (k == NULL)
+	{
+	rep.status = -1;
+	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0, 
+		BadMatch);
+	return Success;
+	}
+
+    if (((dev->grab) && !SameClient(dev->grab, client)) ||
+        ((xkbd->grab) && !SameClient(xkbd->grab, client)))
+	rep.status = AlreadyGrabbed;
+    else if ((dev->sync.frozen &&
+	     dev->sync.other && !SameClient(dev->sync.other, client)) ||
+	     (xkbd->sync.frozen &&
+	      xkbd->sync.other && !SameClient(xkbd->sync.other, client)))
+	rep.status = GrabFrozen;
+    else
+	{
+	if (ChangeKeyboardDevice (xkbd, dev) != Success)
+	    {
+	    SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0, 
+		BadDevice);
+	    return Success;
+	    }
+	if (!dev->focus)
+	    InitFocusClassDeviceStruct (dev);
+	if (!dev->kbdfeed)
+	   InitKbdFeedbackClassDeviceStruct(dev, (BellProcPtr)NoopDDA,
+					    (KbdCtrlProcPtr)NoopDDA);
+	df = dev->focus;
+	df->win = xf->win;
+	df->revert = xf->revert;
+	df->time = xf->time;
+	df->traceGood = xf->traceGood;
+	if (df->traceSize != xf->traceSize)
+	    {
+	    Must_have_memory = TRUE; /* XXX */
+	    df->trace = (WindowPtr *) xrealloc(df->trace, 
+		xf->traceSize * sizeof(WindowPtr));
+	    Must_have_memory = FALSE; /* XXX */
+	    }
+	df->traceSize = xf->traceSize;
+	for (i=0; i<df->traceSize; i++)
+	    df->trace[i] = xf->trace[i];
+	RegisterOtherDevice (xkbd);
+	RegisterKeyboardDevice ((DevicePtr)dev);
+
+	ev.type = ChangeDeviceNotify;
+	ev.deviceid = stuff->deviceid;
+	ev.time = currentTime.milliseconds;
+	ev.request = NewKeyboard;
+
+	SendEventToAllWindows (dev, ChangeDeviceNotifyMask, &ev, 1);
+	SendMappingNotify (MappingKeyboard, k->curKeySyms.minKeyCode, 
+	    k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode + 1,client);
+
+	rep.status = 0;
+	}
+
+    WriteReplyToClient (client, sizeof (xChangeKeyboardDeviceReply), 
+	&rep);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XChangeKeyboardDevice 
+ * function, if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXChangeKeyboardDevice (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xChangeKeyboardDeviceReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/chgkmap.c b/Xi/chgkmap.c
new file mode 100644
index 000000000..3e70f2dcf
--- /dev/null
+++ b/Xi/chgkmap.c
@@ -0,0 +1,129 @@
+/* $Xorg: chgkmap.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Change key mapping for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	int	DeviceMappingNotify;
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure swaps the request when the client and
+ * server have different byte orderings.
+ *
+ */
+
+int
+SProcXChangeDeviceKeyMapping(client)
+    register ClientPtr client;
+    {
+    register char n;
+    register long *p;
+    register int i, count;
+
+    REQUEST(xChangeDeviceKeyMappingReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq);
+    p = (long *) &stuff[1];
+    count = stuff->keyCodes * stuff->keySymsPerKeyCode;
+    for (i = 0; i < count; i++)
+        {
+        swapl(p, n);
+	p++;
+        }
+    return(ProcXChangeDeviceKeyMapping(client));
+    }
+
+/***********************************************************************
+ *
+ * Change the device key mapping.
+ *
+ */
+
+ProcXChangeDeviceKeyMapping(client)
+    register ClientPtr client;
+    {
+    int	ret;
+    unsigned len;
+    DeviceIntPtr dev;
+
+    REQUEST(xChangeDeviceKeyMappingReq);
+    REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_ChangeDeviceKeyMapping, 0, 
+		BadDevice);
+	return Success;
+	}
+    len = stuff->length - (sizeof(xChangeDeviceKeyMappingReq) >> 2);  
+
+    ret = ChangeKeyMapping (client, dev, len, DeviceMappingNotify, 
+	stuff->firstKeyCode, stuff->keyCodes, stuff->keySymsPerKeyCode, 
+	&stuff[1]);
+
+    if (ret != Success)
+	SendErrorToClient (client, IReqCode, X_ChangeDeviceKeyMapping, 0, 
+		ret);
+    return Success;
+    }
diff --git a/Xi/chgprop.c b/Xi/chgprop.c
new file mode 100644
index 000000000..769bcbbb9
--- /dev/null
+++ b/Xi/chgprop.c
@@ -0,0 +1,165 @@
+/* $Xorg: chgprop.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Function to modify the dont-propagate-list for an extension input device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 	BadMode;
+extern	int 	BadClass;
+extern	int 	IReqCode;
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure returns the extension version.
+ *
+ */
+
+int
+SProcXChangeDeviceDontPropagateList(client)
+    register ClientPtr client;
+    {
+    register char n;
+    register long *p;
+    register int i;
+
+    REQUEST(xChangeDeviceDontPropagateListReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
+    swapl(&stuff->window, n);
+    swaps(&stuff->count, n);
+    p = (long *) &stuff[1];
+    for (i=0; i<stuff->count; i++)
+        {
+        swapl(p, n);
+	p++;
+        }
+    return(ProcXChangeDeviceDontPropagateList(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure changes the dont-propagate list for the specified window.
+ *
+ */
+
+ProcXChangeDeviceDontPropagateList (client)
+    register ClientPtr client;
+    {
+    int			i;
+    WindowPtr		pWin;
+    struct 		tmask tmp[EMASKSIZE];
+    OtherInputMasks	*others;
+
+    REQUEST(xChangeDeviceDontPropagateListReq);
+    REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
+
+    if (stuff->length !=(sizeof(xChangeDeviceDontPropagateListReq)>>2) + 
+	stuff->count)
+	{
+	SendErrorToClient (client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
+	    BadLength);
+	return Success;
+	}
+
+    pWin = (WindowPtr) LookupWindow (stuff->window, client);
+    if (!pWin)
+        {
+	client->errorValue = stuff->window;
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0, 
+		BadWindow);
+	return Success;
+        }
+
+    if (stuff->mode != AddToList && stuff->mode != DeleteFromList)
+        {
+	client->errorValue = stuff->window;
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0, 
+		BadMode);
+	return Success;
+        }
+
+    if (CreateMaskFromList (client, (XEventClass *)&stuff[1], 
+	stuff->count, tmp, NULL, X_ChangeDeviceDontPropagateList) != Success)
+	    return Success;
+
+    others = wOtherInputMasks(pWin);
+    if (!others && stuff->mode == DeleteFromList)
+	return Success;
+    for (i=0; i<EMASKSIZE; i++)
+	{
+	if (tmp[i].mask == 0)
+	    continue;
+
+	if (stuff->mode == DeleteFromList)
+	    tmp[i].mask = (others->dontPropagateMask[i] & ~tmp[i].mask);
+	else if (others)
+	    tmp[i].mask |= others->dontPropagateMask[i];
+
+	if (DeviceEventSuppressForWindow (pWin,client,tmp[i].mask,i) != Success)
+	    {
+	    SendErrorToClient ( client, IReqCode, X_ChangeDeviceDontPropagateList, 0, 
+		BadClass);
+	    return Success;
+	    }
+	}
+
+    return Success;
+    }
diff --git a/Xi/chgptr.c b/Xi/chgptr.c
new file mode 100644
index 000000000..8c65c6ec2
--- /dev/null
+++ b/Xi/chgptr.c
@@ -0,0 +1,252 @@
+/* $Xorg: chgptr.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to change the pointer device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "XI.h"
+#include "XIproto.h"
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "scrnintstr.h"			/* screen structure  */
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	int 		ChangeDeviceNotify;
+extern	Mask		ChangeDeviceNotifyMask;
+extern	InputInfo	inputInfo;
+extern	ScreenInfo	screenInfo;
+extern	WindowPtr	*WindowTable;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure is invoked to swap the request bytes if the server and
+ * client have a different byte order.
+ *
+ */
+
+int
+SProcXChangePointerDevice(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xChangePointerDeviceReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
+    return(ProcXChangePointerDevice(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure changes the device used as the X pointer.
+ *
+ */
+
+ProcXChangePointerDevice (client)
+    register ClientPtr client;
+    {
+    DeviceIntPtr 	xptr = inputInfo.pointer;
+    DeviceIntPtr 	dev;
+    ValuatorClassPtr 	v;
+    xChangePointerDeviceReply	rep;
+    changeDeviceNotify	ev;
+
+    REQUEST(xChangePointerDeviceReq);
+    REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_ChangePointerDevice;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	rep.status = -1;
+	SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, 
+	    BadDevice);
+	return Success;
+	}
+
+    v = dev->valuator;
+    if (v == NULL || v->numAxes < 2 || 
+	stuff->xaxis >= v->numAxes ||
+	stuff->yaxis >= v->numAxes)
+	{
+	rep.status = -1;
+	SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, BadMatch);
+	return Success;
+	}
+
+    if (((dev->grab) && !SameClient(dev->grab, client)) ||
+        ((xptr->grab) && !SameClient(xptr->grab, client)))
+	rep.status = AlreadyGrabbed;
+    else if ((dev->sync.frozen &&
+	     dev->sync.other && !SameClient(dev->sync.other, client)) ||
+	     (xptr->sync.frozen &&
+	      xptr->sync.other && !SameClient(xptr->sync.other, client)))
+	rep.status = GrabFrozen;
+    else
+	{
+	if (ChangePointerDevice (
+	    xptr, dev, stuff->xaxis, stuff->yaxis) != Success)
+	    {
+	    SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, 
+		BadDevice);
+	    return Success;
+	    }
+	if (dev->focus)
+	    DeleteFocusClassDeviceStruct(dev);
+	if (!dev->button)
+	    InitButtonClassDeviceStruct (dev, 0, NULL);
+	if (!dev->ptrfeed)
+	   InitPtrFeedbackClassDeviceStruct(dev, (PtrCtrlProcPtr)NoopDDA);
+	RegisterOtherDevice (xptr);
+	RegisterPointerDevice ((DevicePtr)dev);
+
+	ev.type = ChangeDeviceNotify;
+	ev.deviceid = stuff->deviceid;
+	ev.time = currentTime.milliseconds;
+	ev.request = NewPointer;
+
+	SendEventToAllWindows (dev, ChangeDeviceNotifyMask, &ev, 1);
+	SendMappingNotify (MappingPointer, 0, 0, client);
+
+	rep.status = 0;
+	}
+
+    WriteReplyToClient (client, sizeof (xChangePointerDeviceReply), 
+	&rep);
+    return Success;
+    }
+
+DeleteFocusClassDeviceStruct(dev)
+    DeviceIntPtr dev;
+    {
+    xfree(dev->focus->trace);
+    xfree(dev->focus);
+    dev->focus = NULL;
+    }
+
+/***********************************************************************
+ *
+ * Send an event to interested clients in all windows on all screens.
+ *
+ */
+
+SendEventToAllWindows (dev, mask, ev, count)
+    DeviceIntPtr dev;
+    Mask mask;
+    xEvent *ev;
+    int count;
+    {
+    int i;
+    WindowPtr pWin, p1;
+
+    for (i=0; i<screenInfo.numScreens; i++)
+	{
+	pWin = WindowTable[i];
+	(void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
+	p1 = pWin->firstChild;
+	FindInterestedChildren (dev, p1, mask, ev, count);
+	}
+    }
+
+/***********************************************************************
+ *
+ * Walk through the window tree, finding all clients that want to know
+ * about the ChangeDeviceNotify Event.
+ *
+ */
+
+FindInterestedChildren (dev, p1, mask, ev, count)
+    DeviceIntPtr	dev;
+    WindowPtr 		p1;
+    Mask		mask;
+    xEvent		*ev;
+    int			count;
+    {
+    WindowPtr p2;
+
+    while (p1)
+        {
+        p2 = p1->firstChild;
+	(void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
+	FindInterestedChildren (dev, p2, mask, ev, count);
+	p1 = p1->nextSib;
+        }
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XChangePointerDevice 
+ * function, if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXChangePointerDevice (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xChangePointerDeviceReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/closedev.c b/Xi/closedev.c
new file mode 100644
index 000000000..66fb185cb
--- /dev/null
+++ b/Xi/closedev.c
@@ -0,0 +1,185 @@
+/* $Xorg: closedev.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to close an extension input device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "scrnintstr.h"			/* screen structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	ScreenInfo	screenInfo;
+extern	WindowPtr	*WindowTable;
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure closes an input device.
+ *
+ */
+
+int
+SProcXCloseDevice(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xCloseDeviceReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCloseDeviceReq);
+    return(ProcXCloseDevice(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure closes an input device.
+ *
+ */
+
+int
+ProcXCloseDevice(client)
+    register ClientPtr client;
+    {
+    int			i;
+    WindowPtr 		pWin, p1;
+    DeviceIntPtr 	d;
+
+    REQUEST(xCloseDeviceReq);
+    REQUEST_SIZE_MATCH(xCloseDeviceReq);
+
+    d = LookupDeviceIntRec (stuff->deviceid);
+    if (d == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_CloseDevice, 0, BadDevice);
+        return Success;
+	}
+
+    if (d->grab && SameClient(d->grab, client))
+	(*d->DeactivateGrab)(d);		       /* release active grab */
+
+    /* Remove event selections from all windows for events from this device 
+       and selected by this client.
+       Delete passive grabs from all windows for this device.	   */
+
+    for (i=0; i<screenInfo.numScreens; i++)
+	{
+	pWin = WindowTable[i];
+        DeleteDeviceEvents (d, pWin, client);
+	p1 = pWin->firstChild;
+	DeleteEventsFromChildren (d, p1, client);
+	}
+
+    CloseInputDevice (d, client);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * Walk througth the window tree, deleting event selections for this client
+ * from this device from all windows.
+ *
+ */
+
+DeleteEventsFromChildren(dev, p1, client)
+    DeviceIntPtr	dev;
+    WindowPtr 		p1;
+    ClientPtr		client;
+    {
+    WindowPtr p2;
+
+    while (p1)
+        {
+        p2 = p1->firstChild;
+	DeleteDeviceEvents (dev, p1, client);
+	DeleteEventsFromChildren(dev, p2, client);
+	p1 = p1->nextSib;
+        }
+    }
+
+/***********************************************************************
+ *
+ * Clear out event selections and passive grabs from a window for the
+ * specified device.
+ *
+ */
+
+DeleteDeviceEvents (dev, pWin, client)
+    DeviceIntPtr	dev;
+    WindowPtr		pWin;
+    ClientPtr		client;
+    {
+    InputClientsPtr	others;
+    OtherInputMasks	*pOthers;
+    GrabPtr		grab, next;
+
+    if (pOthers=wOtherInputMasks(pWin))
+	for (others=pOthers->inputClients; others; 
+	    others = others->next)
+	    if (SameClient(others,client))
+		others->mask[dev->id] = NoEventMask;
+
+    for (grab = wPassiveGrabs(pWin); grab; grab=next)
+	{
+	next = grab->next;
+	if ((grab->device == dev) &&
+	    (client->clientAsMask == CLIENT_BITS(grab->resource)))
+		FreeResource (grab->resource, RT_NONE);
+	}
+    }
diff --git a/Xi/devbell.c b/Xi/devbell.c
new file mode 100644
index 000000000..60e58e147
--- /dev/null
+++ b/Xi/devbell.c
@@ -0,0 +1,167 @@
+/* $Xorg: devbell.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to change the keyboard device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure is invoked to swap the request bytes if the server and
+ * client have a different byte order.
+ *
+ */
+
+int
+SProcXDeviceBell(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xDeviceBellReq);
+    swaps(&stuff->length, n);
+    return(ProcXDeviceBell(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure rings a bell on an extension device.
+ *
+ */
+
+ProcXDeviceBell (client)
+    register ClientPtr client;
+    {
+    DeviceIntPtr dev;
+    KbdFeedbackPtr k;
+    BellFeedbackPtr b;
+    int base;
+    int newpercent;
+    CARD8 class;
+    pointer ctrl;
+    void (*proc)();
+
+    REQUEST(xDeviceBellReq);
+    REQUEST_SIZE_MATCH(xDeviceBellReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	client->errorValue = stuff->deviceid;
+	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadDevice);
+	return Success;
+	}
+
+    if (stuff->percent < -100 || stuff->percent > 100)
+	{
+	client->errorValue = stuff->percent;
+	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	return Success;
+	}
+    if (stuff->feedbackclass == KbdFeedbackClass)
+	{
+	for (k=dev->kbdfeed; k; k=k->next)
+	    if (k->ctrl.id == stuff->feedbackid)
+		break;
+	if (!k)
+	    {
+	    client->errorValue = stuff->feedbackid;
+	    SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	    return Success;
+	    }
+	base = k->ctrl.bell;
+	proc = k->BellProc;
+	ctrl = (pointer) &(k->ctrl);
+	class = KbdFeedbackClass;
+	}
+    else if (stuff->feedbackclass == BellFeedbackClass)
+	{
+	for (b=dev->bell; b; b=b->next)
+	    if (b->ctrl.id == stuff->feedbackid)
+		break;
+	if (!b)
+	    {
+	    client->errorValue = stuff->feedbackid;
+	    SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	    return Success;
+	    }
+	base = b->ctrl.percent;
+	proc = b->BellProc;
+	ctrl = (pointer) &(b->ctrl);
+	class = BellFeedbackClass;
+	}
+    else
+	{
+	client->errorValue = stuff->feedbackclass;
+	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	return Success;
+	}
+    newpercent = (base * stuff->percent) / 100;
+    if (stuff->percent < 0)
+        newpercent = base + newpercent;
+    else
+    	newpercent = base - newpercent + stuff->percent;
+    (*proc)(newpercent, dev, ctrl, class);
+
+    return Success;
+    }
diff --git a/Xi/exevents.c b/Xi/exevents.c
new file mode 100644
index 000000000..7131b3c7a
--- /dev/null
+++ b/Xi/exevents.c
@@ -0,0 +1,1388 @@
+/* $Xorg: exevents.c,v 1.4 2001/02/09 02:04:33 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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Routines to register and initialize extension input devices.
+ *  This also contains ProcessOtherEvent, the routine called from DDX
+ *  to route extension events.
+ *
+ */
+
+#define	 NEED_EVENTS
+#include "X.h"
+#include "Xproto.h"
+#include "XI.h"
+#include "XIproto.h"
+#include "inputstr.h"
+#include "windowstr.h"
+#include "miscstruct.h"
+#include "region.h"
+
+#define WID(w) ((w) ? ((w)->drawable.id) : 0)
+#define AllModifiersMask ( \
+	ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | \
+	Mod3Mask | Mod4Mask | Mod5Mask )
+#define AllButtonsMask ( \
+	Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask )
+#define Motion_Filter(class) (DevicePointerMotionMask | \
+			      (class)->state | (class)->motionMask)
+
+void 			ActivateKeyboardGrab();
+void 			DeactivateKeyboardGrab();
+void 			ProcessOtherEvent();
+void 			RecalculateDeviceDeliverableEvents();
+static Bool		ShouldFreeInputMasks();
+static Bool		MakeInputMasks ();
+extern int		DeviceKeyPress;
+extern int		DeviceButtonPress;
+extern int		DeviceValuator;
+extern Mask 		DevicePointerMotionMask;
+extern Mask 		DeviceMappingNotifyMask;
+extern Mask 		DeviceButtonMotionMask;
+extern Mask 		DeviceButtonGrabMask;
+extern Mask 		DeviceOwnerGrabButtonMask;
+extern Mask		PropagateMask[];
+extern WindowPtr 	GetSpriteWindow();
+extern InputInfo	inputInfo;
+extern int		RT_INPUTCLIENT;
+
+/**************************************************************************
+ *
+ * Procedures for extension device event routing.
+ *
+ */
+
+void
+RegisterOtherDevice (device)
+    DevicePtr device;
+    {
+    device->processInputProc = ProcessOtherEvent;
+    device->realInputProc = ProcessOtherEvent;
+    ((DeviceIntPtr)device)->ActivateGrab = ActivateKeyboardGrab;
+    ((DeviceIntPtr)device)->DeactivateGrab = DeactivateKeyboardGrab;
+    }
+
+extern	int	DeviceMotionNotify;
+
+/*ARGSUSED*/
+void
+ProcessOtherEvent (xE, other, count)
+    deviceKeyButtonPointer *xE;
+    register DeviceIntPtr other;
+    int count;
+    {
+    extern	int	DeviceKeyRelease;
+    extern	int	DeviceButtonRelease;
+    extern	int	ProximityIn;
+    extern	int	ProximityOut;
+    register BYTE   	*kptr;
+    register int    	i;
+    register CARD16 	modifiers;
+    register CARD16 	mask;
+    GrabPtr         	grab = other->grab;
+    Bool            	deactivateDeviceGrab = FALSE;
+    int             	key, bit, rootX, rootY;
+    ButtonClassPtr	b = other->button;
+    KeyClassPtr		k = other->key;
+    ValuatorClassPtr	v = other->valuator;
+    void		NoticeEventTime();
+    deviceValuator	*xV = (deviceValuator *) xE;
+
+    if (xE->type != DeviceValuator) {
+        GetSpritePosition(&rootX, &rootY);
+        xE->root_x = rootX;
+        xE->root_y = rootY;
+        key = xE->detail;
+        NoticeEventTime(xE);
+        xE->state = inputInfo.keyboard->key->state | 
+		    inputInfo.pointer->button->state;
+        bit = 1 << (key & 7);
+    }
+    if (DeviceEventCallback)
+    {
+	DeviceEventInfoRec eventinfo;
+	eventinfo.events = (xEventPtr) xE;
+	eventinfo.count = count;
+	CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+    }
+    for (i=1; i<count; i++)
+	if ((++xV)->type == DeviceValuator)
+	    {
+	    int first = xV->first_valuator;
+	    int *axisvals;
+
+	    if (xV->num_valuators && (!v || (xV->num_valuators && (first + xV->num_valuators > v->numAxes))))
+		FatalError("Bad valuators reported for device %s\n",other->name);
+	    xV->device_state = 0;
+	    if (k)
+		xV->device_state |= k->state;
+	    if (b)
+	        xV->device_state |= b->state;
+	    if (v && v->axisVal)
+		{
+	        axisvals = v->axisVal;
+	        switch (xV->num_valuators) {
+		    case 6:
+		        *(axisvals+first+5) = xV->valuator5;
+		    case 5:
+		        *(axisvals+first+4) = xV->valuator4;
+		    case 4:
+		        *(axisvals+first+3) = xV->valuator3;
+		    case 3:
+		        *(axisvals+first+2) = xV->valuator2;
+		    case 2:
+		        *(axisvals+first+1) = xV->valuator1;
+		    case 1:
+		        *(axisvals+first) = xV->valuator0;
+		    case 0:
+		    default:
+		        break;
+		    }
+		}
+	    }
+    
+    if (xE->type == DeviceKeyPress)
+	{
+	modifiers = k->modifierMap[key];
+        kptr = &k->down[key >> 3];
+	if (*kptr & bit) /* allow ddx to generate multiple downs */
+	    {   
+	    if (!modifiers)
+		{
+		xE->type = DeviceKeyRelease;
+		ProcessOtherEvent(xE, other, count);
+		xE->type = DeviceKeyPress;
+		/* release can have side effects, don't fall through */
+		ProcessOtherEvent(xE, other, count);
+		}
+	    return;
+	    }
+	if (other->valuator)
+	    other->valuator->motionHintWindow = NullWindow;
+	*kptr |= bit;
+	k->prev_state = k->state;
+	for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
+	    {
+	    if (mask & modifiers) 
+	        {
+		/* This key affects modifier "i" */
+		k->modifierKeyCount[i]++;
+		k->state |= mask;
+		modifiers &= ~mask;
+		}
+	    }
+	if (!grab && CheckDeviceGrabs(other, xE, 0, count))
+	    {
+	    other->activatingKey = key;
+	    return;
+	    }
+	}
+    else if (xE->type == DeviceKeyRelease)
+	{
+        kptr = &k->down[key >> 3];
+	if (!(*kptr & bit)) /* guard against duplicates */
+	    return;
+	modifiers = k->modifierMap[key];
+	if (other->valuator)
+	    other->valuator->motionHintWindow = NullWindow;
+	*kptr &= ~bit;
+	k->prev_state = k->state;
+	for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
+	    {
+	    if (mask & modifiers) 
+	        {
+		/* This key affects modifier "i" */
+		if (--k->modifierKeyCount[i] <= 0) 
+		    {
+		    k->modifierKeyCount[i] = 0;
+		    k->state &= ~mask;
+		    }
+		modifiers &= ~mask;
+		}
+	    }
+
+	if (other->fromPassiveGrab && (key == other->activatingKey))
+	    deactivateDeviceGrab = TRUE;
+	}
+    else if (xE->type == DeviceButtonPress)
+	{
+        kptr = &b->down[key >> 3];
+	*kptr |= bit;
+	if (other->valuator)
+	    other->valuator->motionHintWindow = NullWindow;
+	b->buttonsDown++;
+	b->motionMask = DeviceButtonMotionMask;
+	xE->detail = b->map[key];
+	if (xE->detail == 0)
+	     return;
+	if (xE->detail <= 5)
+	    b->state |= (Button1Mask >> 1) << xE->detail;
+	SetMaskForEvent(Motion_Filter(b),DeviceMotionNotify);
+	if (!grab)
+	    if (CheckDeviceGrabs(other, xE, 0, count))
+		return;
+
+	}
+    else if (xE->type == DeviceButtonRelease)
+	{
+        kptr = &b->down[key >> 3];
+	*kptr &= ~bit;
+	if (other->valuator)
+	    other->valuator->motionHintWindow = NullWindow;
+	if (!--b->buttonsDown)
+		b->motionMask = 0;
+	xE->detail = b->map[key];
+	if (xE->detail == 0)
+	    return;
+	if (xE->detail <= 5)
+	    b->state &= ~((Button1Mask >> 1) << xE->detail);
+	SetMaskForEvent(Motion_Filter(b),DeviceMotionNotify);
+	if (!b->state && other->fromPassiveGrab)
+	    deactivateDeviceGrab = TRUE;
+	}
+    else if (xE->type == ProximityIn)
+	other->valuator->mode &= ~OutOfProximity;
+    else if (xE->type == ProximityOut)
+	other->valuator->mode |= OutOfProximity;
+
+    if (grab)
+	DeliverGrabbedEvent(xE, other, deactivateDeviceGrab, count);
+    else if (other->focus)
+	DeliverFocusedEvent(other, xE, GetSpriteWindow(), count);
+    else
+	DeliverDeviceEvents(GetSpriteWindow(), xE, NullGrab, NullWindow,
+			    other, count);
+
+    if (deactivateDeviceGrab == TRUE)
+        (*other->DeactivateGrab)(other);
+    }
+
+InitProximityClassDeviceStruct(dev)
+    DeviceIntPtr dev;
+    {
+    register ProximityClassPtr proxc;
+
+    proxc = (ProximityClassPtr)xalloc(sizeof(ProximityClassRec));
+    if (!proxc)
+	return FALSE;
+    dev->proximity = proxc;
+    return TRUE;
+    }
+
+InitValuatorAxisStruct(dev, axnum, minval, maxval, resolution, min_res, max_res)
+    DeviceIntPtr dev;
+    int axnum;
+    int minval;
+    int maxval;
+    int resolution;
+    {
+    register AxisInfoPtr ax = dev->valuator->axes + axnum;
+
+    ax->min_value = minval;
+    ax->max_value = maxval;
+    ax->resolution = resolution;
+    ax->min_resolution = min_res;
+    ax->max_resolution = max_res;
+    }
+
+static void FixDeviceStateNotify (dev, ev, k, b, v, first)
+    DeviceIntPtr dev;
+    deviceStateNotify *ev;
+    KeyClassPtr k;
+    ButtonClassPtr b;
+    ValuatorClassPtr v;
+    int first;
+    {
+    extern      int     DeviceStateNotify;
+
+    ev->type = DeviceStateNotify;
+    ev->deviceid = dev->id;
+    ev->time = currentTime.milliseconds;
+    ev->classes_reported = 0;
+    ev->num_keys = 0;
+    ev->num_buttons = 0;
+    ev->num_valuators = 0;
+
+    if (b) {
+	ev->classes_reported |= (1 << ButtonClass);
+	ev->num_buttons = b->numButtons;
+	memmove((char *) &ev->buttons[0], (char *) b->down, 4);
+	}
+    else if (k) {
+	ev->classes_reported |= (1 << KeyClass);
+	ev->num_keys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
+	memmove((char *) &ev->keys[0], (char *) k->down, 4);
+	}
+    if (v) {
+	int nval = v->numAxes - first;
+	ev->classes_reported |= (1 << ValuatorClass);
+	ev->classes_reported |= (dev->valuator->mode << ModeBitsShift);
+	ev->num_valuators = nval < 3 ? nval : 3;
+	switch (ev->num_valuators) 
+	    {
+	    case 3:
+		ev->valuator2 = v->axisVal[first+2];
+	    case 2:
+		ev->valuator1 = v->axisVal[first+1];
+	    case 1:
+		ev->valuator0 = v->axisVal[first];
+	    break;
+	    }
+	}
+    }
+
+static void FixDeviceValuator (dev, ev, v, first)
+    DeviceIntPtr dev;
+    deviceValuator *ev;
+    ValuatorClassPtr v;
+    int first;
+    {
+    int nval = v->numAxes - first;
+
+    ev->type = DeviceValuator;
+    ev->deviceid = dev->id;
+    ev->num_valuators = nval < 3 ? nval : 3;
+    ev->first_valuator = first;
+    switch (ev->num_valuators) {
+	case 3:
+	    ev->valuator2 = v->axisVal[first+2];
+	case 2:
+	    ev->valuator1 = v->axisVal[first+1];
+	case 1:
+	    ev->valuator0 = v->axisVal[first];
+	break;
+	}
+    first += ev->num_valuators;
+    }
+
+DeviceFocusEvent(dev, type, mode, detail, pWin)
+    DeviceIntPtr dev;
+    int type, mode, detail;
+    register WindowPtr pWin;
+    {
+    extern      int     DeviceFocusIn;
+    extern      int     DeviceFocusOut;
+    extern      int     DeviceKeyStateNotify;
+    extern      int     DeviceButtonStateNotify;
+    extern      int     DeviceValuatorStateNotify;
+    extern      Mask    DeviceStateNotifyMask;
+    extern      Mask    DeviceFocusChangeMask;
+    deviceFocus	event;
+
+    if (type == FocusIn)
+	type = DeviceFocusIn;
+    else
+	type = DeviceFocusOut;
+
+    event.deviceid = dev->id;
+    event.mode = mode;
+    event.type = type;
+    event.detail = detail;
+    event.window = pWin->drawable.id;
+    event.time = currentTime.milliseconds;
+
+    (void)
+    DeliverEventsToWindow(pWin, &event, 1, DeviceFocusChangeMask, NullGrab, 
+	dev->id);
+
+    if ((type == DeviceFocusIn) && 
+	(wOtherInputMasks(pWin)) &&
+	(wOtherInputMasks(pWin)->inputEvents[dev->id] & DeviceStateNotifyMask))
+        {
+	int			i,j;
+	int 			evcount = 1;
+	deviceStateNotify 	*ev, *sev;
+	deviceKeyStateNotify 	*kev;
+	deviceButtonStateNotify *bev;
+
+	KeyClassPtr k;
+	ButtonClassPtr b;
+	ValuatorClassPtr v;
+	int nval=0, nkeys=0, nbuttons=0, first=0;
+
+	if ((b=dev->button) != NULL) {
+	    nbuttons = b->numButtons;
+	    if (nbuttons > 32)
+		evcount++;
+	}
+	if ((k=dev->key) != NULL) {
+	    nkeys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
+	    if (nkeys > 32)
+		evcount++;
+	    if (nbuttons > 0) {
+		evcount++;
+	    }
+	}
+	if ((v=dev->valuator) != NULL) {
+	    nval = v->numAxes;
+
+	    if (nval > 3)
+		evcount++;
+	    if (nval > 6) {
+		if (!(k && b))
+		    evcount++;
+		if (nval > 9)
+		    evcount += ((nval - 7) / 3);
+	    }
+	}
+
+	sev = ev = (deviceStateNotify *) xalloc(evcount * sizeof(xEvent));
+	FixDeviceStateNotify (dev, ev, NULL, NULL, NULL, first);
+
+	if (b != NULL) {
+	    FixDeviceStateNotify (dev, ev++, NULL, b, v, first);
+	    first += 3;
+	    nval -= 3;
+	    if (nbuttons > 32) {
+		(ev-1)->deviceid |= MORE_EVENTS;
+		bev = (deviceButtonStateNotify *) ev++; 
+		bev->type = DeviceButtonStateNotify;
+		bev->deviceid = dev->id;
+		memmove((char *) &bev->buttons[0], (char *) &b->down[4], 28);
+	    }
+	    if (nval > 0) {
+		(ev-1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		first += 3;
+		nval -= 3;
+	    }
+	}
+
+	if (k != NULL) {
+	    FixDeviceStateNotify (dev, ev++, k, NULL, v, first);
+	    first += 3;
+	    nval -= 3;
+	    if (nkeys > 32) {
+		(ev-1)->deviceid |= MORE_EVENTS;
+		kev = (deviceKeyStateNotify *) ev++; 
+		kev->type = DeviceKeyStateNotify;
+		kev->deviceid = dev->id;
+		memmove((char *) &kev->keys[0], (char *) &k->down[4], 28);
+	    }
+	    if (nval > 0) {
+		(ev-1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		first += 3;
+		nval -= 3;
+	    }
+	}
+
+	while (nval > 0) {
+	    FixDeviceStateNotify (dev, ev++, NULL, NULL, v, first);
+	    first += 3;
+	    nval -= 3;
+	    if (nval > 0) {
+		(ev-1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator (dev, ev++, v, first);
+		first += 3;
+		nval -= 3;
+	    }
+	}
+
+	(void) DeliverEventsToWindow(pWin, sev, evcount, DeviceStateNotifyMask, 
+	    NullGrab, dev->id);
+	xfree (sev);
+        }
+    }
+
+int
+GrabButton(client, dev, this_device_mode, other_devices_mode, modifiers,
+	modifier_device, button, grabWindow, ownerEvents, rcursor, rconfineTo,
+	eventMask)
+    ClientPtr client;
+    DeviceIntPtr dev;
+    BYTE this_device_mode;
+    BYTE other_devices_mode;
+    CARD16 modifiers;
+    DeviceIntPtr modifier_device;
+    CARD8 button;
+    Window grabWindow;
+    BOOL ownerEvents;
+    Cursor rcursor;
+    Window rconfineTo;
+    Mask eventMask;
+   
+{
+    WindowPtr pWin, confineTo;
+    CursorPtr cursor;
+    GrabPtr CreateGrab();
+    GrabPtr grab;
+
+    if ((this_device_mode != GrabModeSync) &&
+	(this_device_mode != GrabModeAsync))
+    {
+	client->errorValue = this_device_mode;
+        return BadValue;
+    }
+    if ((other_devices_mode != GrabModeSync) &&
+	(other_devices_mode != GrabModeAsync))
+    {
+	client->errorValue = other_devices_mode;
+        return BadValue;
+    }
+    if ((modifiers != AnyModifier) &&
+	(modifiers & ~AllModifiersMask))
+    {
+	client->errorValue = modifiers;
+	return BadValue;
+    }
+    if ((ownerEvents != xFalse) && (ownerEvents != xTrue))
+    {
+	client->errorValue = ownerEvents;
+	return BadValue;
+    }
+    pWin = LookupWindow(grabWindow, client);
+    if (!pWin)
+	return BadWindow;
+    if (rconfineTo == None)
+	confineTo = NullWindow;
+    else
+    {
+	confineTo = LookupWindow(rconfineTo, client);
+	if (!confineTo)
+	    return BadWindow;
+    }
+    if (rcursor == None)
+	cursor = NullCursor;
+    else
+    {
+	cursor = (CursorPtr)LookupIDByType(rcursor, RT_CURSOR);
+	if (!cursor)
+	{
+	    client->errorValue = rcursor;
+	    return BadCursor;
+	}
+    }
+
+    grab = CreateGrab(client->index, dev, pWin, eventMask,
+	(Bool)ownerEvents, (Bool) this_device_mode, (Bool)other_devices_mode,
+	modifier_device, modifiers, DeviceButtonPress, button, confineTo, 
+	cursor);
+    if (!grab)
+	return BadAlloc;
+    return AddPassiveGrabToList(grab);
+    }
+
+int
+GrabKey(client, dev, this_device_mode, other_devices_mode, modifiers,
+    modifier_device, key, grabWindow, ownerEvents, mask)
+    ClientPtr client;
+    DeviceIntPtr dev;
+    BYTE this_device_mode;
+    BYTE other_devices_mode;
+    CARD16 modifiers;
+    DeviceIntPtr modifier_device;
+    CARD8 key;
+    Window grabWindow;
+    BOOL ownerEvents;
+    Mask mask;
+   
+{
+    WindowPtr pWin;
+    GrabPtr CreateGrab();
+    GrabPtr grab;
+    KeyClassPtr k = dev->key;
+
+    if (k==NULL)
+	return BadMatch;
+    if ((other_devices_mode != GrabModeSync) &&
+	(other_devices_mode != GrabModeAsync))
+    {
+	client->errorValue = other_devices_mode;
+        return BadValue;
+    }
+    if ((this_device_mode != GrabModeSync) &&
+	(this_device_mode != GrabModeAsync))
+    {
+	client->errorValue = this_device_mode;
+        return BadValue;
+    }
+    if (((key > k->curKeySyms.maxKeyCode) || 
+	 (key < k->curKeySyms.minKeyCode))
+	&& (key != AnyKey))
+    {
+	client->errorValue = key;
+        return BadValue;
+    }
+    if ((modifiers != AnyModifier) &&
+	(modifiers & ~AllModifiersMask))
+    {
+	client->errorValue = modifiers;
+	return BadValue;
+    }
+    if ((ownerEvents != xTrue) && (ownerEvents != xFalse))
+    {
+	client->errorValue = ownerEvents;
+        return BadValue;
+    }
+    pWin = LookupWindow(grabWindow, client);
+    if (!pWin)
+	return BadWindow;
+
+    grab = CreateGrab(client->index, dev, pWin, 
+	mask, ownerEvents, this_device_mode, other_devices_mode, 
+	modifier_device, modifiers, DeviceKeyPress, key, NullWindow, 
+	NullCursor);
+    if (!grab)
+	return BadAlloc;
+    return AddPassiveGrabToList(grab);
+    }
+
+extern Mask DevicePointerMotionHintMask;
+
+int
+SelectForWindow(dev, pWin, client, mask, exclusivemasks, validmasks)
+	DeviceIntPtr dev;
+	WindowPtr pWin;
+	ClientPtr client;
+	Mask mask;
+	Mask exclusivemasks;
+	Mask validmasks;
+{
+    int mskidx = dev->id;
+    int i, ret;
+    Mask check;
+    InputClientsPtr others;
+
+    if (mask & ~validmasks)
+    {
+	client->errorValue = mask;
+	return BadValue;
+    }
+    check = (mask & exclusivemasks);
+    if (wOtherInputMasks(pWin))
+	{
+	if (check & wOtherInputMasks(pWin)->inputEvents[mskidx])
+	    {			       /* It is illegal for two different
+				          clients to select on any of the
+				          events for maskcheck. However,
+				          it is OK, for some client to
+				          continue selecting on one of those
+				          events.  */
+	    for (others = wOtherInputMasks(pWin)->inputClients; others; 
+		others = others->next)
+	        {
+	        if (!SameClient(others, client) && (check & 
+		    others->mask[mskidx]))
+		    return BadAccess;
+	        }
+            }
+	for (others = wOtherInputMasks(pWin)->inputClients; others; 
+		others = others->next)
+	    {
+	    if (SameClient(others, client))
+	        {
+		check = others->mask[mskidx];
+		others->mask[mskidx] = mask;
+		if (mask == 0)
+		    {
+		    for (i=0; i<EMASKSIZE; i++)
+			if (i != mskidx && others->mask[i] != 0)
+			    break;
+		    if (i == EMASKSIZE)
+			{
+			RecalculateDeviceDeliverableEvents(pWin);
+			if (ShouldFreeInputMasks(pWin, FALSE))
+			    FreeResource(others->resource, RT_NONE);
+		        return Success;
+			}
+		    }
+		goto maskSet;
+	        }
+	    }
+	}
+    check = 0;
+    if ((ret = AddExtensionClient (pWin, client, mask, mskidx)) != Success)
+	return ret;
+maskSet: 
+    if (dev->valuator)
+	if ((dev->valuator->motionHintWindow == pWin) &&
+	    (mask & DevicePointerMotionHintMask) &&
+	    !(check & DevicePointerMotionHintMask) &&
+	    !dev->grab)
+	    dev->valuator->motionHintWindow = NullWindow;
+    RecalculateDeviceDeliverableEvents(pWin);
+    return Success;
+}
+
+int 
+AddExtensionClient (pWin, client, mask, mskidx)
+    WindowPtr pWin;
+    ClientPtr client;
+    Mask mask;
+    int mskidx;
+    {
+    InputClientsPtr others;
+
+    if (!pWin->optional && !MakeWindowOptional (pWin))
+	return BadAlloc;
+    others = (InputClients *) xalloc(sizeof(InputClients));
+    if (!others)
+	return BadAlloc;
+    if (!pWin->optional->inputMasks && !MakeInputMasks (pWin))
+	return BadAlloc;
+    bzero((char *) &others->mask[0], sizeof(Mask)*EMASKSIZE);
+    others->mask[mskidx] = mask;
+    others->resource = FakeClientID(client->index);
+    others->next = pWin->optional->inputMasks->inputClients;
+    pWin->optional->inputMasks->inputClients = others;
+    if (!AddResource(others->resource, RT_INPUTCLIENT, (pointer)pWin))
+	return BadAlloc;
+    return Success;
+    }
+
+static Bool
+MakeInputMasks (pWin)
+    WindowPtr	pWin;
+    {
+    struct _OtherInputMasks *imasks;
+
+    imasks = (struct _OtherInputMasks *) 
+	xalloc (sizeof (struct _OtherInputMasks));
+    if (!imasks)
+	return FALSE;
+    bzero((char *) imasks, sizeof (struct _OtherInputMasks));
+    pWin->optional->inputMasks = imasks;
+    return TRUE;
+    }
+
+void
+RecalculateDeviceDeliverableEvents(pWin)
+    WindowPtr pWin;
+    {
+    register InputClientsPtr others;
+    struct _OtherInputMasks *inputMasks;   /* default: NULL */
+    register WindowPtr pChild, tmp;
+    int i;
+
+    pChild = pWin;
+    while (1)
+	{
+	if (inputMasks = wOtherInputMasks(pChild))
+	    {
+	    for (others = inputMasks->inputClients; others; 
+		others = others->next)
+		{
+		for (i=0; i<EMASKSIZE; i++)
+		    inputMasks->inputEvents[i] |= others->mask[i];
+		}
+	    for (i=0; i<EMASKSIZE; i++)
+		inputMasks->deliverableEvents[i] = inputMasks->inputEvents[i];
+	    for (tmp = pChild->parent; tmp; tmp=tmp->parent)
+		if (wOtherInputMasks(tmp))
+		    for (i=0; i<EMASKSIZE; i++)
+			inputMasks->deliverableEvents[i] |=
+			(wOtherInputMasks(tmp)->deliverableEvents[i] 
+			& ~inputMasks->dontPropagateMask[i] & PropagateMask[i]);
+	    }
+	if (pChild->firstChild)
+	    {
+	    pChild = pChild->firstChild;
+	    continue;
+	    }
+	while (!pChild->nextSib && (pChild != pWin))
+	    pChild = pChild->parent;
+	if (pChild == pWin)
+	    break;
+	pChild = pChild->nextSib;
+	}
+    }
+
+int
+InputClientGone(pWin, id)
+    register WindowPtr pWin;
+    XID   id;
+    {
+    register InputClientsPtr other, prev;
+    if (!wOtherInputMasks(pWin))
+	return(Success);
+    prev = 0;
+    for (other = wOtherInputMasks(pWin)->inputClients; other; 
+	other = other->next)
+	{
+	if (other->resource == id)
+	    {
+	    if (prev)
+		{
+		prev->next = other->next;
+		xfree(other);
+		}
+	    else if (!(other->next))
+		{
+	        if (ShouldFreeInputMasks(pWin, TRUE))
+		    {
+		    wOtherInputMasks(pWin)->inputClients = other->next;
+		    xfree(wOtherInputMasks(pWin));
+		    pWin->optional->inputMasks = (OtherInputMasks *) NULL;
+		    CheckWindowOptionalNeed (pWin);
+		    xfree(other);
+		    }
+		else
+		    {
+		    other->resource = FakeClientID(0);
+		    if (!AddResource(other->resource, RT_INPUTCLIENT, 
+			(pointer)pWin))
+			return BadAlloc;
+		    }
+		}
+	    else
+		{
+		wOtherInputMasks(pWin)->inputClients = other->next;
+		xfree(other);
+		}
+	    RecalculateDeviceDeliverableEvents(pWin);
+	    return(Success);
+	    }
+	prev = other;
+        }
+    FatalError("client not on device event list");
+    /*NOTREACHED*/
+    }
+
+int
+SendEvent (client, d, dest, propagate, ev, mask, count)
+    ClientPtr		client;
+    DeviceIntPtr	d;
+    Window		dest;
+    Bool		propagate;
+    xEvent		*ev;
+    Mask		mask;
+    {
+    WindowPtr pWin;
+    WindowPtr effectiveFocus = NullWindow; /* only set if dest==InputFocus */
+    WindowPtr GetCurrentRootWindow();
+    WindowPtr spriteWin=GetSpriteWindow();
+
+    if (dest == PointerWindow)
+	pWin = spriteWin;
+    else if (dest == InputFocus)
+    {
+	WindowPtr inputFocus;
+	
+	if (!d->focus)
+	    inputFocus = spriteWin;
+	else
+	    inputFocus = d->focus->win;
+
+	if (inputFocus == FollowKeyboardWin)
+	    inputFocus = inputInfo.keyboard->focus->win;
+
+	if (inputFocus == NoneWin)
+	    return Success;
+
+	/* If the input focus is PointerRootWin, send the event to where
+	the pointer is if possible, then perhaps propogate up to root. */
+   	if (inputFocus == PointerRootWin)
+	    inputFocus = GetCurrentRootWindow();
+
+	if (IsParent(inputFocus, spriteWin))
+	{
+	    effectiveFocus = inputFocus;
+	    pWin = spriteWin;
+	}
+	else
+	    effectiveFocus = pWin = inputFocus;
+    }
+    else
+	pWin = LookupWindow(dest, client);
+    if (!pWin)
+	return BadWindow;
+    if ((propagate != xFalse) && (propagate != xTrue))
+    {
+	client->errorValue = propagate;
+	return BadValue;
+    }
+    ev->u.u.type |= 0x80;
+    if (propagate)
+    {
+	for (;pWin; pWin = pWin->parent)
+	{
+	    if (DeliverEventsToWindow( pWin, ev, count, mask, NullGrab, d->id))
+		return Success;
+	    if (pWin == effectiveFocus)
+		return Success;
+	    if (wOtherInputMasks(pWin))
+		mask &= ~wOtherInputMasks(pWin)->dontPropagateMask[d->id];
+	    if (!mask)
+		break;
+	}
+    }
+    else
+	(void)(DeliverEventsToWindow( pWin, ev, count, mask, NullGrab, d->id));
+    return Success;
+    }
+
+int
+SetButtonMapping (client, dev, nElts, map)
+    ClientPtr client;
+    DeviceIntPtr dev;
+    int nElts;
+    BYTE *map;
+    {
+    register int i;
+    ButtonClassPtr b = dev->button;
+
+    if (b == NULL)
+	return BadMatch;
+
+    if (nElts != b->numButtons)
+    {
+	client->errorValue = nElts;
+	return BadValue;
+    }
+    if (BadDeviceMap(&map[0], nElts, 1, 255, &client->errorValue))
+	return BadValue;
+    for (i=0; i < nElts; i++)
+	if ((b->map[i + 1] != map[i]) &&
+		BitIsOn(b->down, i + 1))
+    	    return MappingBusy;
+    for (i = 0; i < nElts; i++)
+	b->map[i + 1] = map[i];
+    return Success;
+    }
+
+int 
+SetModifierMapping(client, dev, len, rlen, numKeyPerModifier, inputMap, k)
+    ClientPtr client;
+    DeviceIntPtr dev;
+    int len;
+    int rlen;
+    int numKeyPerModifier;
+    KeyCode *inputMap;
+    KeyClassPtr *k;
+{
+    KeyCode *map;
+    int inputMapLen;
+    register int i;
+    
+    *k = dev->key;
+    if (*k == NULL)
+	return BadMatch;
+    if (len != ((numKeyPerModifier<<1) + rlen))
+	return BadLength;
+
+    inputMapLen = 8*numKeyPerModifier;
+
+    /*
+     *	Now enforce the restriction that "all of the non-zero keycodes must be
+     *	in the range specified by min-keycode and max-keycode in the
+     *	connection setup (else a Value error)"
+     */
+    i = inputMapLen;
+    while (i--) {
+	if (inputMap[i]
+	    && (inputMap[i] < (*k)->curKeySyms.minKeyCode
+		|| inputMap[i] > (*k)->curKeySyms.maxKeyCode)) {
+		client->errorValue = inputMap[i];
+		return -1; /* BadValue collides with MappingFailed */
+		}
+    }
+
+    /*
+     *	Now enforce the restriction that none of the old or new
+     *	modifier keys may be down while we change the mapping,  and
+     *	that the DDX layer likes the choice.
+     */
+    if (!AllModifierKeysAreUp (dev, (*k)->modifierKeyMap, 
+	(int)(*k)->maxKeysPerModifier, inputMap, (int)numKeyPerModifier)
+	    ||
+	!AllModifierKeysAreUp(dev, inputMap, (int)numKeyPerModifier,
+	      (*k)->modifierKeyMap, (int)(*k)->maxKeysPerModifier)) {
+	return MappingBusy;
+    } else {
+	for (i = 0; i < inputMapLen; i++) {
+	    if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr)dev)) {
+		return MappingFailed;
+	    }
+	}
+    }
+
+    /*
+     *	Now build the keyboard's modifier bitmap from the
+     *	list of keycodes.
+     */
+    if (inputMapLen) {
+	map = (KeyCode *)xalloc(inputMapLen);
+        if (!map)
+            return BadAlloc;
+    }
+    if ((*k)->modifierKeyMap)
+        xfree((*k)->modifierKeyMap);
+    if (inputMapLen) {
+        (*k)->modifierKeyMap = map;
+        memmove((char *)(*k)->modifierKeyMap, (char *)inputMap, inputMapLen);
+    } else
+	(*k)->modifierKeyMap = NULL;
+
+    (*k)->maxKeysPerModifier = numKeyPerModifier;
+    for (i = 0; i < MAP_LENGTH; i++)
+        (*k)->modifierMap[i] = 0;
+    for (i = 0; i < inputMapLen; i++) if (inputMap[i]) {
+        (*k)->modifierMap[inputMap[i]]
+          |= (1<<(i/ (*k)->maxKeysPerModifier));
+    }
+
+    return(MappingSuccess);
+    }
+
+int
+SendDeviceMappingNotify(request, firstKeyCode, count, dev)
+    CARD8 request, count;
+    KeyCode firstKeyCode;
+    DeviceIntPtr dev;
+    {
+    xEvent event;
+    deviceMappingNotify         *ev = (deviceMappingNotify *) &event;
+    extern              	int     DeviceMappingNotify;
+
+    ev->type = DeviceMappingNotify;
+    ev->request = request;
+    ev->deviceid = dev->id;
+    ev->time = currentTime.milliseconds;
+    if (request == MappingKeyboard)
+	{
+	ev->firstKeyCode = firstKeyCode;
+	ev->count = count;
+	}
+
+    SendEventToAllWindows (dev, DeviceMappingNotifyMask, ev, 1);
+    }
+
+int
+ChangeKeyMapping(client, dev, len, type, firstKeyCode, keyCodes, 
+	keySymsPerKeyCode, map)
+    ClientPtr 	client;
+    DeviceIntPtr dev;
+    unsigned 	len;
+    int 	type;
+    KeyCode 	firstKeyCode;
+    CARD8 	keyCodes;
+    CARD8 	keySymsPerKeyCode;
+    KeySym	*map;
+{
+    KeySymsRec keysyms;
+    KeyClassPtr k = dev->key;
+
+    if (k == NULL)
+	return (BadMatch);
+
+    if (len != (keyCodes * keySymsPerKeyCode))
+            return BadLength;
+
+    if ((firstKeyCode < k->curKeySyms.minKeyCode) ||
+	(firstKeyCode + keyCodes - 1 > k->curKeySyms.maxKeyCode))
+    {
+	    client->errorValue = firstKeyCode;
+	    return BadValue;
+    }
+    if (keySymsPerKeyCode == 0)
+    {
+	    client->errorValue = 0;
+            return BadValue;
+    }
+    keysyms.minKeyCode = firstKeyCode;
+    keysyms.maxKeyCode = firstKeyCode + keyCodes - 1;
+    keysyms.mapWidth = keySymsPerKeyCode;
+    keysyms.map = map;
+    if (!SetKeySymsMap(&k->curKeySyms, &keysyms))
+	return BadAlloc;
+    SendDeviceMappingNotify(MappingKeyboard, firstKeyCode, keyCodes,
+	dev);
+    return client->noClientException;
+    }
+
+void
+DeleteWindowFromAnyExtEvents(pWin, freeResources)
+    WindowPtr		pWin;
+    Bool		freeResources;
+    {
+    int			i;
+    DeviceIntPtr	dev;
+    InputClientsPtr	ic;
+    struct _OtherInputMasks *inputMasks;
+
+    for (dev=inputInfo.devices; dev; dev=dev->next)
+	{
+	if (dev == inputInfo.pointer ||
+	    dev == inputInfo.keyboard)
+	    continue;
+	DeleteDeviceFromAnyExtEvents(pWin, dev);
+	}
+
+    for (dev=inputInfo.off_devices; dev; dev=dev->next)
+	DeleteDeviceFromAnyExtEvents(pWin, dev);
+
+    if (freeResources)
+	while (inputMasks = wOtherInputMasks(pWin))
+	    {
+	    ic = inputMasks->inputClients;
+	    for (i=0; i<EMASKSIZE; i++)
+		inputMasks->dontPropagateMask[i] = 0;
+	    FreeResource(ic->resource, RT_NONE);
+	    }
+    }
+
+DeleteDeviceFromAnyExtEvents(pWin, dev)
+    WindowPtr		pWin;
+    DeviceIntPtr	dev;
+    {
+    WindowPtr		parent;
+
+    /* Deactivate any grabs performed on this window, before making
+	any input focus changes.
+        Deactivating a device grab should cause focus events. */
+
+    if (dev->grab && (dev->grab->window == pWin))
+	(*dev->DeactivateGrab)(dev);
+
+    /* If the focus window is a root window (ie. has no parent) 
+	then don't delete the focus from it. */
+    
+    if (dev->focus && (pWin==dev->focus->win) && (pWin->parent != NullWindow))
+	{
+	int focusEventMode = NotifyNormal;
+
+ 	/* If a grab is in progress, then alter the mode of focus events. */
+
+	if (dev->grab)
+	    focusEventMode = NotifyWhileGrabbed;
+
+	switch (dev->focus->revert)
+	    {
+	    case RevertToNone:
+		DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
+		dev->focus->win = NoneWin;
+		dev->focus->traceGood = 0;
+		break;
+	    case RevertToParent:
+		parent = pWin;
+		do
+		    {
+		    parent = parent->parent;
+		    dev->focus->traceGood--;
+		    } while (!parent->realized);
+		DoFocusEvents(dev, pWin, parent, focusEventMode);
+		dev->focus->win = parent;
+		dev->focus->revert = RevertToNone;
+		break;
+	    case RevertToPointerRoot:
+		DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
+		dev->focus->win = PointerRootWin;
+		dev->focus->traceGood = 0;
+		break;
+	    case RevertToFollowKeyboard:
+		if (inputInfo.keyboard->focus->win) {
+		    DoFocusEvents(dev, pWin, inputInfo.keyboard->focus->win,
+				  focusEventMode);
+		    dev->focus->win = FollowKeyboardWin;
+		    dev->focus->traceGood = 0;
+		} else {
+		    DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
+		    dev->focus->win = NoneWin;
+		    dev->focus->traceGood = 0;
+		}
+		break;
+	    }
+	}
+
+    if (dev->valuator)
+	if (dev->valuator->motionHintWindow == pWin)
+	    dev->valuator->motionHintWindow = NullWindow;
+    }
+
+int
+MaybeSendDeviceMotionNotifyHint (pEvents, mask)
+    deviceKeyButtonPointer *pEvents;
+    Mask mask;
+    {
+    DeviceIntPtr dev;
+    DeviceIntPtr LookupDeviceIntRec ();
+
+    dev = LookupDeviceIntRec (pEvents->deviceid & DEVICE_BITS);
+    if (pEvents->type == DeviceMotionNotify)
+	{
+	if (mask & DevicePointerMotionHintMask)
+	    {
+	    if (WID(dev->valuator->motionHintWindow) == pEvents->event)
+		{
+		return 1; /* don't send, but pretend we did */
+		}
+	    pEvents->detail = NotifyHint;
+	    }
+	 else
+	    {
+	    pEvents->detail = NotifyNormal;
+	    }
+	}
+    return (0);
+    }
+
+int
+CheckDeviceGrabAndHintWindow (pWin, type, xE, grab, client, deliveryMask)
+    WindowPtr pWin;
+    int type;
+    deviceKeyButtonPointer *xE;
+    GrabPtr grab;
+    ClientPtr client;
+    Mask deliveryMask;
+    {
+    DeviceIntPtr dev;
+    DeviceIntPtr LookupDeviceIntRec ();
+
+    dev = LookupDeviceIntRec (xE->deviceid & DEVICE_BITS);
+    if (type == DeviceMotionNotify)
+	dev->valuator->motionHintWindow = pWin;
+    else if ((type == DeviceButtonPress) && (!grab) && 
+	(deliveryMask & DeviceButtonGrabMask))
+        {
+	GrabRec tempGrab;
+
+	tempGrab.device = dev;
+	tempGrab.resource = client->clientAsMask;
+	tempGrab.window = pWin;
+	tempGrab.ownerEvents = (deliveryMask & DeviceOwnerGrabButtonMask) ? TRUE : FALSE;
+	tempGrab.eventMask = deliveryMask;
+	tempGrab.keyboardMode = GrabModeAsync;
+	tempGrab.pointerMode = GrabModeAsync;
+	tempGrab.confineTo = NullWindow;
+	tempGrab.cursor = NullCursor;
+	(*dev->ActivateGrab)(dev, &tempGrab, currentTime, TRUE);
+        }
+    }
+
+Mask
+DeviceEventMaskForClient(dev, pWin, client)
+    DeviceIntPtr	dev;
+    WindowPtr		pWin;
+    ClientPtr		client;
+    {
+    register InputClientsPtr other;
+
+    if (!wOtherInputMasks(pWin))
+	return 0;
+    for (other = wOtherInputMasks(pWin)->inputClients; other; 
+	other = other->next)
+	{
+	if (SameClient(other, client))
+	    return other->mask[dev->id];
+	}
+    return 0;
+    }
+
+void
+MaybeStopDeviceHint(dev, client)
+    register DeviceIntPtr dev;
+    ClientPtr client;
+{
+    WindowPtr pWin;
+    GrabPtr grab = dev->grab;
+    pWin = dev->valuator->motionHintWindow;
+
+    if ((grab && SameClient(grab, client) &&
+	 ((grab->eventMask & DevicePointerMotionHintMask) ||
+	  (grab->ownerEvents &&
+	   (DeviceEventMaskForClient(dev, pWin, client) &
+	    DevicePointerMotionHintMask)))) ||
+	(!grab &&
+	 (DeviceEventMaskForClient(dev, pWin, client) &
+	  DevicePointerMotionHintMask)))
+	dev->valuator->motionHintWindow = NullWindow;
+}
+
+int
+DeviceEventSuppressForWindow(pWin, client, mask, maskndx)
+	WindowPtr pWin;
+	ClientPtr client;
+	Mask mask;
+	int maskndx;
+    {
+    struct _OtherInputMasks *inputMasks = wOtherInputMasks (pWin);
+
+    if (mask & ~PropagateMask[maskndx])
+	{
+	client->errorValue = mask;
+	return BadValue;
+	}
+
+    if (mask == 0) 
+	{
+	if (inputMasks)
+	    inputMasks->dontPropagateMask[maskndx] = mask;
+	} 
+    else 
+	{
+	if (!inputMasks)
+	    AddExtensionClient (pWin, client, 0, 0);
+	inputMasks = wOtherInputMasks(pWin);
+	inputMasks->dontPropagateMask[maskndx] = mask;
+	}
+    RecalculateDeviceDeliverableEvents(pWin);
+    if (ShouldFreeInputMasks(pWin, FALSE))
+        FreeResource(inputMasks->inputClients->resource, RT_NONE);
+    return Success;
+    }
+
+static Bool
+ShouldFreeInputMasks (pWin, ignoreSelectedEvents)
+    WindowPtr pWin;
+    Bool ignoreSelectedEvents;
+    {
+    int i;
+    Mask allInputEventMasks = 0;
+    struct _OtherInputMasks *inputMasks = wOtherInputMasks (pWin);
+
+    for (i=0; i<EMASKSIZE; i++)
+	allInputEventMasks |= inputMasks->dontPropagateMask[i];
+    if (!ignoreSelectedEvents)
+	for (i=0; i<EMASKSIZE; i++)
+	    allInputEventMasks |= inputMasks->inputEvents[i];
+    if (allInputEventMasks == 0)
+	return TRUE;
+    else
+	return FALSE;
+    }
diff --git a/Xi/extinit.c b/Xi/extinit.c
new file mode 100644
index 000000000..37148ebd2
--- /dev/null
+++ b/Xi/extinit.c
@@ -0,0 +1,962 @@
+/* $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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Dispatch routines and initialization routines for the X input extension.
+ *
+ */
+
+#define	 NUMTYPES 15
+
+#define	 NEED_EVENTS
+#include "X.h"
+#include "Xproto.h"
+#include "inputstr.h"
+#include "gcstruct.h"   		/* pointer for extnsionst.h*/
+#include "extnsionst.h"			/* extension entry   */
+#include "XI.h"
+#include "XIproto.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	void			(* ReplySwapVector[256]) ();
+extern	void			(* EventSwapVector[128]) ();
+extern	XExtensionVersion	AllExtensionVersions[];
+extern	InputInfo		inputInfo;
+Mask	PropagateMask[MAX_DEVICES];
+
+/*****************************************************************
+ *
+ * Declarations of local routines.
+ *
+ */
+
+int	ProcIDispatch();
+int	SProcIDispatch();
+void	SReplyIDispatch();
+void	IResetProc();
+void	SEventIDispatch();
+void	NotImplemented();
+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, *AddExtension();
+    int XShutDownDevice();
+    int InputClientGone();
+
+    extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,
+		   SProcIDispatch, IResetProc, StandardMinorOpcode);
+    if (extEntry)
+        {
+	IReqCode = extEntry->base;
+	AllExtensionVersions[IReqCode-128] = thisversion;
+	MakeDeviceTypeAtoms ();
+	RT_INPUTCLIENT = CreateNewResourceType(InputClientGone);
+	FixExtensionEvents (extEntry);
+	ReplySwapVector[IReqCode] = 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.
+ *
+ */
+
+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, rep);
+    else if (rep->RepType == X_ListInputDevices)
+	SRepXListInputDevices (client, len, rep);
+    else if (rep->RepType == X_OpenDevice)
+	SRepXOpenDevice (client, len, rep);
+    else if (rep->RepType == X_SetDeviceMode)
+	SRepXSetDeviceMode (client, len, rep);
+    else if (rep->RepType == X_GetSelectedExtensionEvents)
+	SRepXGetSelectedExtensionEvents (client, len, rep);
+    else if (rep->RepType == X_GetDeviceDontPropagateList)
+	SRepXGetDeviceDontPropagateList (client, len, rep);
+    else if (rep->RepType == X_GetDeviceMotionEvents)
+	SRepXGetDeviceMotionEvents (client, len, rep);
+    else if (rep->RepType == X_ChangeKeyboardDevice)
+	SRepXChangeKeyboardDevice (client, len, rep);
+    else if (rep->RepType == X_ChangePointerDevice)
+	SRepXChangePointerDevice (client, len, rep);
+    else if (rep->RepType == X_GrabDevice)
+	SRepXGrabDevice (client, len, rep);
+    else if (rep->RepType == X_GetDeviceFocus)
+	SRepXGetDeviceFocus (client, len, rep);
+    else if (rep->RepType == X_GetFeedbackControl)
+	SRepXGetFeedbackControl (client, len, rep);
+    else if (rep->RepType == X_GetDeviceKeyMapping)
+	SRepXGetDeviceKeyMapping (client, len, rep);
+    else if (rep->RepType == X_GetDeviceModifierMapping)
+	SRepXGetDeviceModifierMapping (client, len, rep);
+    else if (rep->RepType == X_SetDeviceModifierMapping)
+	SRepXSetDeviceModifierMapping (client, len, rep);
+    else if (rep->RepType == X_GetDeviceButtonMapping)
+	SRepXGetDeviceButtonMapping (client, len, rep);
+    else if (rep->RepType == X_SetDeviceButtonMapping)
+	SRepXSetDeviceButtonMapping (client, len, rep);
+    else if (rep->RepType == X_QueryDeviceState)
+	SRepXQueryDeviceState (client, len, rep);
+    else if (rep->RepType == X_SetDeviceValuators)
+	SRepXSetDeviceValuators (client, len, rep);
+    else if (rep->RepType == X_GetDeviceControl)
+	SRepXGetDeviceControl (client, len, rep);
+    else if (rep->RepType == X_ChangeDeviceControl)
+	SRepXChangeDeviceControl (client, len, rep);
+    else
+	{
+	    FatalError("XINPUT confused sending swapped reply");
+	}
+    }
+
+/*****************************************************************************
+ *
+ *	SEventIDispatch
+ *
+ *	Swap any events defined in this extension.
+ */
+void
+SEventIDispatch (from, to)
+    xEvent	*from;
+    xEvent	*to;
+    {
+    int		type = from->u.u.type & 0177;
+
+    if (type == DeviceValuator)
+	SEventDeviceValuator (from, to);
+    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)
+        SEventFocus (from, to);
+    else if (type == DeviceFocusOut)
+        SEventFocus (from, to);
+    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)
+        SDeviceStateNotifyEvent (from, to);
+    else if (type == DeviceKeyStateNotify)
+        SDeviceKeyStateNotifyEvent (from, to);
+    else if (type == DeviceButtonStateNotify)
+        SDeviceButtonStateNotifyEvent (from, to);
+    else if (type == DeviceMappingNotify)
+        SDeviceMappingNotifyEvent (from, to);
+    else if (type == ChangeDeviceNotify)
+        SChangeDeviceNotifyEvent (from, to);
+    else
+	{
+	FatalError("XInputExtension: Impossible event!\n");
+	}
+    }
+
+/************************************************************************
+ *
+ * This function swaps the DeviceValuator event.
+ *
+ */
+
+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	    */
+	}
+    }
+
+SEventFocus (from, to)
+    deviceFocus	*from;
+    deviceFocus	*to;
+    {
+    register char	n;
+
+    *to = *from;
+    swaps(&to->sequenceNumber,n);
+    swapl(&to->time, n);
+    swapl(&to->window, n);
+    }
+
+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	    */
+	}
+    }
+
+SDeviceKeyStateNotifyEvent (from, to)
+    deviceKeyStateNotify	*from;
+    deviceKeyStateNotify	*to;
+    {
+    register char	n;
+
+    *to = *from;
+    swaps(&to->sequenceNumber,n);
+    }
+
+SDeviceButtonStateNotifyEvent (from, to)
+    deviceButtonStateNotify	*from;
+    deviceButtonStateNotify	*to;
+    {
+    register char	n;
+
+    *to = *from;
+    swaps(&to->sequenceNumber,n);
+    }
+
+SChangeDeviceNotifyEvent (from, to)
+    changeDeviceNotify	*from;
+    changeDeviceNotify	*to;
+    {
+    register char	n;
+
+    *to = *from;
+    swaps(&to->sequenceNumber,n);
+    swapl(&to->time, n);
+    }
+
+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.
+ *
+ */
+
+FixExtensionEvents (extEntry)
+    ExtensionEntry 	*extEntry;
+    {
+    Mask		mask, GetNextExtEventMask();
+    void		SetMaskForExtEvent();
+    void		SetEventInfo();
+    void		AllowPropagateSuppress();
+    void		SetExclusiveAccess();
+
+    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.
+ *
+ */
+
+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()
+    {
+
+    ReplySwapVector[IReqCode] = NotImplemented;
+    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.
+ *
+ */
+
+int
+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.
+ *
+ */
+
+int
+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 (id)
+    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;
+    }
diff --git a/Xi/getbmap.c b/Xi/getbmap.c
new file mode 100644
index 000000000..35c2d5c7d
--- /dev/null
+++ b/Xi/getbmap.c
@@ -0,0 +1,147 @@
+/* $Xorg: getbmap.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to return the version of the extension.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure gets the button mapping for the specified device.
+ *
+ */
+
+int
+SProcXGetDeviceButtonMapping(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetDeviceButtonMappingReq);
+    swaps(&stuff->length, n);
+    return(ProcXGetDeviceButtonMapping(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure gets the button mapping for the specified device.
+ *
+ */
+
+ProcXGetDeviceButtonMapping (client)
+    register ClientPtr client;
+    {
+    DeviceIntPtr	dev;
+    xGetDeviceButtonMappingReply	rep;
+    ButtonClassPtr	b;
+
+    REQUEST(xGetDeviceButtonMappingReq);
+    REQUEST_SIZE_MATCH(xGetDeviceButtonMappingReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetDeviceButtonMapping;
+    rep.nElts = 0;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    b = dev->button;
+    if (b == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0, 
+		BadMatch);
+	return Success;
+	}
+    rep.nElts = b->numButtons;
+    rep.length = (rep.nElts + (4-1))/4;
+    WriteReplyToClient (client, sizeof (xGetDeviceButtonMappingReply), &rep);
+    (void)WriteToClient(client, rep.nElts,
+			(char *)&b->map[1]);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGetDeviceButtonMapping function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetDeviceButtonMapping (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetDeviceButtonMappingReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/getdctl.c b/Xi/getdctl.c
new file mode 100644
index 000000000..684160706
--- /dev/null
+++ b/Xi/getdctl.c
@@ -0,0 +1,224 @@
+/* $Xorg: getdctl.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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Get Device control attributes for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+void		CopySwapDeviceResolution();
+
+/***********************************************************************
+ *
+ * This procedure gets the control attributes for an extension device,
+ * for clients on machines with a different byte ordering than the server.
+ *
+ */
+
+int
+SProcXGetDeviceControl(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetDeviceControlReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGetDeviceControlReq);
+    swaps(&stuff->control, n);
+    return(ProcXGetDeviceControl(client));
+    }
+
+/***********************************************************************
+ *
+ * Get the state of the specified device control.
+ *
+ */
+
+ProcXGetDeviceControl(client)
+    ClientPtr client;
+    {
+    int	total_length = 0;
+    char *buf, *savbuf;
+    register DeviceIntPtr dev;
+    xGetDeviceControlReply rep;
+
+    REQUEST(xGetDeviceControlReq);
+    REQUEST_SIZE_MATCH(xGetDeviceControlReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_GetDeviceControl, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetDeviceControl;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    switch (stuff->control)
+	{
+	case DEVICE_RESOLUTION:
+	    if (!dev->valuator)
+		{
+		SendErrorToClient (client, IReqCode, X_GetDeviceControl, 0, 
+		    BadMatch);
+		return Success;
+		}
+	    total_length = sizeof (xDeviceResolutionState) +
+		(3 * sizeof(int) * dev->valuator->numAxes);
+	    break;
+	default:
+	    SendErrorToClient (client, IReqCode, X_GetDeviceControl, 0, 
+		BadValue);
+	    return Success;
+	}
+
+    buf = (char *) Xalloc (total_length);
+    if (!buf)
+	{
+	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, 
+		BadAlloc);
+	return Success;
+	}
+    savbuf=buf;
+
+    switch (stuff->control)
+	{
+	case DEVICE_RESOLUTION:
+	    CopySwapDeviceResolution(client, dev->valuator, buf,
+		total_length);
+	    break;
+	default:
+	    break;
+	}
+
+    rep.length = (total_length+3) >> 2;
+    WriteReplyToClient(client, sizeof(xGetDeviceControlReply), &rep);
+    WriteToClient(client, total_length, savbuf);
+    Xfree (savbuf);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies DeviceResolution data, swapping if necessary.
+ *
+ */
+
+void
+CopySwapDeviceResolution (client, v, buf, length)
+    ClientPtr 		client;
+    ValuatorClassPtr	v;
+    char 		*buf;
+    int			length;
+    {
+    register char 	n;
+    AxisInfoPtr	a;
+    xDeviceResolutionState *r;
+    int i, *iptr;
+
+    r = (xDeviceResolutionState *) buf;
+    r->control = DEVICE_RESOLUTION;
+    r->length =  length;
+    r->num_valuators =  v->numAxes;
+    buf += sizeof (xDeviceResolutionState);
+    iptr = (int *) buf;
+    for (i=0,a=v->axes; i<v->numAxes; i++,a++)
+	*iptr++ = a->resolution;
+    for (i=0,a=v->axes; i<v->numAxes; i++,a++)
+	*iptr++ = a->min_resolution;
+    for (i=0,a=v->axes; i<v->numAxes; i++,a++)
+	*iptr++ = a->max_resolution;
+    if (client->swapped)
+	{
+	swaps (&r->control,n);
+	swaps (&r->length,n);
+	swapl (&r->num_valuators,n);
+	iptr = (int *) buf;
+	for (i=0; i < (3 * v->numAxes); i++,iptr++)
+	    {
+	    swapl (iptr,n);
+	    }
+	}
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the xGetDeviceControl function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetDeviceControl (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetDeviceControlReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
+
diff --git a/Xi/getfctl.c b/Xi/getfctl.c
new file mode 100644
index 000000000..e06470fbc
--- /dev/null
+++ b/Xi/getfctl.c
@@ -0,0 +1,421 @@
+/* $Xorg: getfctl.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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Get feedback control attributes for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+void		CopySwapKbdFeedback();
+void		CopySwapPtrFeedback();
+void		CopySwapIntegerFeedback();
+void		CopySwapStringFeedback();
+void		CopySwapLedFeedback();
+void		CopySwapBellFeedback();
+
+/***********************************************************************
+ *
+ * This procedure gets the control attributes for an extension device,
+ * for clients on machines with a different byte ordering than the server.
+ *
+ */
+
+int
+SProcXGetFeedbackControl(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetFeedbackControlReq);
+    swaps(&stuff->length, n);
+    return(ProcXGetFeedbackControl(client));
+    }
+
+/***********************************************************************
+ *
+ * Get the feedback control state.
+ *
+ */
+
+ProcXGetFeedbackControl(client)
+    ClientPtr client;
+    {
+    int	total_length = 0;
+    char *buf, *savbuf;
+    register DeviceIntPtr dev;
+    KbdFeedbackPtr k;
+    PtrFeedbackPtr p;
+    IntegerFeedbackPtr i;
+    StringFeedbackPtr s;
+    BellFeedbackPtr b;
+    LedFeedbackPtr l;
+    xGetFeedbackControlReply rep;
+
+    REQUEST(xGetFeedbackControlReq);
+    REQUEST_SIZE_MATCH(xGetFeedbackControlReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_GetFeedbackControl, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetFeedbackControl;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.num_feedbacks = 0;
+
+    for (k=dev->kbdfeed; k; k=k->next)
+	{
+	rep.num_feedbacks++;
+	total_length += sizeof(xKbdFeedbackState);
+	}
+    for (p=dev->ptrfeed; p; p=p->next)
+	{
+	rep.num_feedbacks++;
+	total_length += sizeof(xPtrFeedbackState);
+	}
+    for (s=dev->stringfeed; s; s=s->next)
+	{
+	rep.num_feedbacks++;
+	total_length += sizeof(xStringFeedbackState) + 
+	    (s->ctrl.num_symbols_supported * sizeof (KeySym));
+	}
+    for (i=dev->intfeed; i; i=i->next)
+	{
+	rep.num_feedbacks++;
+	total_length += sizeof(xIntegerFeedbackState);
+	}
+    for (l=dev->leds; l; l=l->next)
+	{
+	rep.num_feedbacks++;
+	total_length += sizeof(xLedFeedbackState);
+	}
+    for (b=dev->bell; b; b=b->next)
+	{
+	rep.num_feedbacks++;
+	total_length += sizeof(xBellFeedbackState);
+	}
+
+    if (total_length == 0)
+	{
+	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, 
+		BadMatch);
+	return Success;
+	}
+
+    buf = (char *) Xalloc (total_length);
+    if (!buf)
+	{
+	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, 
+		BadAlloc);
+	return Success;
+	}
+    savbuf=buf;
+
+    for (k=dev->kbdfeed; k; k=k->next)
+	CopySwapKbdFeedback (client, k, &buf);
+    for (p=dev->ptrfeed; p; p=p->next)
+	CopySwapPtrFeedback (client, p, &buf);
+    for (s=dev->stringfeed; s; s=s->next)
+	CopySwapStringFeedback (client, s, &buf);
+    for (i=dev->intfeed; i; i=i->next)
+	CopySwapIntegerFeedback (client, i, &buf);
+    for (l=dev->leds; l; l=l->next)
+	CopySwapLedFeedback (client, l, &buf);
+    for (b=dev->bell; b; b=b->next)
+	CopySwapBellFeedback (client, b, &buf);
+
+    rep.length = (total_length+3) >> 2;
+    WriteReplyToClient(client, sizeof(xGetFeedbackControlReply), &rep);
+    WriteToClient(client, total_length, savbuf);
+    Xfree (savbuf);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies KbdFeedbackClass data, swapping if necessary.
+ *
+ */
+
+void
+CopySwapKbdFeedback (client, k, buf)
+    ClientPtr 		client;
+    KbdFeedbackPtr 	k;
+    char 		**buf;
+    {
+    int	i;
+    register char 	n;
+    xKbdFeedbackState	*k2;
+
+    k2 = (xKbdFeedbackState *) *buf;
+    k2->class = KbdFeedbackClass;
+    k2->length = sizeof (xKbdFeedbackState);
+    k2->id = k->ctrl.id;
+    k2->click = k->ctrl.click;
+    k2->percent = k->ctrl.bell;
+    k2->pitch = k->ctrl.bell_pitch;
+    k2->duration = k->ctrl.bell_duration;
+    k2->led_mask = k->ctrl.leds;
+    k2->global_auto_repeat = k->ctrl.autoRepeat;
+    for (i=0; i<32; i++)
+	k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
+    if (client->swapped)
+	{
+	swaps(&k2->length,n);
+	swaps(&k2->pitch,n);
+	swaps(&k2->duration,n);
+	swapl(&k2->led_mask,n);
+	swapl(&k2->led_values,n);
+	}
+    *buf += sizeof (xKbdFeedbackState);
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies PtrFeedbackClass data, swapping if necessary.
+ *
+ */
+
+void
+CopySwapPtrFeedback (client, p, buf)
+    ClientPtr 		client;
+    PtrFeedbackPtr 	p;
+    char 		**buf;
+    {
+    register char 	n;
+    xPtrFeedbackState	*p2;
+
+    p2 = (xPtrFeedbackState *) *buf;
+    p2->class = PtrFeedbackClass;
+    p2->length = sizeof (xPtrFeedbackState);
+    p2->id = p->ctrl.id;
+    p2->accelNum = p->ctrl.num;
+    p2->accelDenom = p->ctrl.den;
+    p2->threshold = p->ctrl.threshold;
+    if (client->swapped)
+	{
+	swaps(&p2->length,n);
+	swaps(&p2->accelNum,n);
+	swaps(&p2->accelDenom,n);
+	swaps(&p2->threshold,n);
+	}
+    *buf += sizeof (xPtrFeedbackState);
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies IntegerFeedbackClass data, swapping if necessary.
+ *
+ */
+
+void
+CopySwapIntegerFeedback (client, i, buf)
+    ClientPtr 		client;
+    IntegerFeedbackPtr 	i;
+    char 		**buf;
+    {
+    register char 		n;
+    xIntegerFeedbackState	*i2;
+
+    i2 = (xIntegerFeedbackState *) *buf;
+    i2->class = IntegerFeedbackClass;
+    i2->length = sizeof (xIntegerFeedbackState);
+    i2->id = i->ctrl.id;
+    i2->resolution = i->ctrl.resolution;
+    i2->min_value = i->ctrl.min_value;
+    i2->max_value = i->ctrl.max_value;
+    if (client->swapped)
+	{
+	swaps(&i2->length,n);
+	swapl(&i2->resolution,n);
+	swapl(&i2->min_value,n);
+	swapl(&i2->max_value,n);
+	}
+    *buf += sizeof (xIntegerFeedbackState);
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies StringFeedbackClass data, swapping if necessary.
+ *
+ */
+
+void
+CopySwapStringFeedback (client, s, buf)
+    ClientPtr 		client;
+    StringFeedbackPtr 	s;
+    char 		**buf;
+    {
+    int i;
+    register char 		n;
+    xStringFeedbackState	*s2;
+    KeySym			*kptr;
+
+    s2 = (xStringFeedbackState *) *buf;
+    s2->class = StringFeedbackClass;
+    s2->length = sizeof (xStringFeedbackState) + 
+        s->ctrl.num_symbols_supported * sizeof (KeySym);
+    s2->id = s->ctrl.id;
+    s2->max_symbols = s->ctrl.max_symbols;
+    s2->num_syms_supported = s->ctrl.num_symbols_supported;
+    *buf += sizeof (xStringFeedbackState);
+    kptr = (KeySym *) (*buf);
+    for (i=0; i<s->ctrl.num_symbols_supported; i++)
+	*kptr++ = *(s->ctrl.symbols_supported+i);
+    if (client->swapped)
+	{
+	swaps(&s2->length,n);
+	swaps(&s2->max_symbols,n);
+	swaps(&s2->num_syms_supported,n);
+        kptr = (KeySym *) (*buf);
+	for (i=0; i<s->ctrl.num_symbols_supported; i++,kptr++)
+	    {
+	    swapl(kptr,n);
+	    }
+	}
+    *buf += (s->ctrl.num_symbols_supported * sizeof (KeySym));
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies LedFeedbackClass data, swapping if necessary.
+ *
+ */
+
+void
+CopySwapLedFeedback (client, l, buf)
+    ClientPtr 		client;
+    LedFeedbackPtr 	l;
+    char 		**buf;
+    {
+    register char 	n;
+    xLedFeedbackState	*l2;
+
+    l2 = (xLedFeedbackState *) *buf;
+    l2->class = LedFeedbackClass;
+    l2->length = sizeof (xLedFeedbackState);
+    l2->id = l->ctrl.id;
+    l2->led_values = l->ctrl.led_values;
+    l2->led_mask = l->ctrl.led_mask;
+    if (client->swapped)
+	{
+	swaps(&l2->length,n);
+	swapl(&l2->led_values,n);
+	swapl(&l2->led_mask,n);
+	}
+    *buf += sizeof (xLedFeedbackState);
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies BellFeedbackClass data, swapping if necessary.
+ *
+ */
+
+void
+CopySwapBellFeedback (client, b, buf)
+    ClientPtr 		client;
+    BellFeedbackPtr 	b;
+    char 		**buf;
+    {
+    register char 	n;
+    xBellFeedbackState	*b2;
+
+    b2 = (xBellFeedbackState *) *buf;
+    b2->class = BellFeedbackClass;
+    b2->length = sizeof (xBellFeedbackState);
+    b2->id = b->ctrl.id;
+    b2->percent = b->ctrl.percent;
+    b2->pitch = b->ctrl.pitch;
+    b2->duration = b->ctrl.duration;
+    if (client->swapped)
+	{
+	swaps(&b2->length,n);
+	swaps(&b2->pitch,n);
+	swaps(&b2->duration,n);
+	}
+    *buf += sizeof (xBellFeedbackState);
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the xGetFeedbackControl function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetFeedbackControl (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetFeedbackControlReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    swaps(&rep->num_feedbacks, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/getfocus.c b/Xi/getfocus.c
new file mode 100644
index 000000000..1e34df413
--- /dev/null
+++ b/Xi/getfocus.c
@@ -0,0 +1,151 @@
+/* $Xorg: getfocus.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to get the focus for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "windowstr.h"			/* focus struct      */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure gets the focus for a device.
+ *
+ */
+
+int
+SProcXGetDeviceFocus(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetDeviceFocusReq);
+    swaps(&stuff->length, n);
+    return(ProcXGetDeviceFocus(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure gets the focus for a device.
+ *
+ */
+
+int
+ProcXGetDeviceFocus(client)
+    ClientPtr client;
+    {
+    DeviceIntPtr	dev;
+    FocusClassPtr 	focus;
+    xGetDeviceFocusReply rep;
+
+    REQUEST(xGetDeviceFocusReq);
+    REQUEST_SIZE_MATCH(xGetDeviceFocusReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL || !dev->focus)
+	{
+	SendErrorToClient(client, IReqCode, X_GetDeviceFocus, 0, BadDevice);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetDeviceFocus;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    focus = dev->focus;
+
+    if (focus->win == NoneWin)
+	rep.focus = None;
+    else if (focus->win == PointerRootWin)
+	rep.focus = PointerRoot;
+    else if (focus->win == FollowKeyboardWin)
+	rep.focus = FollowKeyboard;
+    else 
+	rep.focus = focus->win->drawable.id;
+
+    rep.time = focus->time.milliseconds;
+    rep.revertTo = focus->revert;
+    WriteReplyToClient (client, sizeof(xGetDeviceFocusReply), &rep);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the GetDeviceFocus function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetDeviceFocus (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetDeviceFocusReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    swapl(&rep->focus, n);
+    swapl(&rep->time, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/getkmap.c b/Xi/getkmap.c
new file mode 100644
index 000000000..783dc5506
--- /dev/null
+++ b/Xi/getkmap.c
@@ -0,0 +1,171 @@
+/* $Xorg: getkmap.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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Get the key mapping for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure gets the key mapping for an extension device,
+ * for clients on machines with a different byte ordering than the server.
+ *
+ */
+
+int
+SProcXGetDeviceKeyMapping(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetDeviceKeyMappingReq);
+    swaps(&stuff->length, n);
+    return(ProcXGetDeviceKeyMapping(client));
+    }
+
+/***********************************************************************
+ *
+ * Get the device key mapping.
+ *
+ */
+
+ProcXGetDeviceKeyMapping(client)
+    register ClientPtr client;
+    {
+    extern	void	CopySwap32Write();
+    xGetDeviceKeyMappingReply rep;
+    DeviceIntPtr dev;
+    KeySymsPtr	k;
+
+    REQUEST(xGetDeviceKeyMappingReq);
+    REQUEST_SIZE_MATCH(xGetDeviceKeyMappingReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    if (dev->key == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
+		BadMatch);
+	return Success;
+	}
+    k =  &dev->key->curKeySyms;
+
+    if ((stuff->firstKeyCode < k->minKeyCode) ||
+        (stuff->firstKeyCode > k->maxKeyCode))
+        {
+	client->errorValue = stuff->firstKeyCode;
+	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
+		BadValue);
+	return Success;
+        }
+
+    if (stuff->firstKeyCode + stuff->count > k->maxKeyCode + 1)
+        {
+	client->errorValue = stuff->count;
+	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
+		BadValue);
+	return Success;
+        }
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetDeviceKeyMapping;
+    rep.sequenceNumber = client->sequence;
+    rep.keySymsPerKeyCode = k->mapWidth;
+    rep.length = (k->mapWidth * stuff->count); /* KeySyms are 4 bytes */
+    WriteReplyToClient(client, sizeof(xGetDeviceKeyMappingReply), &rep);
+
+    client->pSwapReplyFunc = CopySwap32Write;
+    WriteSwappedDataToClient(
+	client,
+	k->mapWidth * stuff->count * sizeof(KeySym),
+	&k->map[(stuff->firstKeyCode - k->minKeyCode) *
+	k->mapWidth]);
+
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGetDeviceKeyMapping function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetDeviceKeyMapping (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetDeviceKeyMappingReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
+
diff --git a/Xi/getmmap.c b/Xi/getmmap.c
new file mode 100644
index 000000000..93b5748c0
--- /dev/null
+++ b/Xi/getmmap.c
@@ -0,0 +1,151 @@
+/* $Xorg: getmmap.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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Get the modifier mapping for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"			/* Request macro     */
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure gets the modifier mapping for an extension device,
+ * for clients on machines with a different byte ordering than the server.
+ *
+ */
+
+int
+SProcXGetDeviceModifierMapping(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetDeviceModifierMappingReq);
+    swaps(&stuff->length, n);
+    return(ProcXGetDeviceModifierMapping(client));
+    }
+
+/***********************************************************************
+ *
+ * Get the device Modifier mapping.
+ *
+ */
+
+ProcXGetDeviceModifierMapping(client)
+    ClientPtr client;
+    {
+    CARD8				maxkeys;
+    DeviceIntPtr			dev;
+    xGetDeviceModifierMappingReply 	rep;
+    KeyClassPtr 			kp;
+    
+    REQUEST(xGetDeviceModifierMappingReq);
+    REQUEST_SIZE_MATCH(xGetDeviceModifierMappingReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_GetDeviceModifierMapping, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    kp = dev->key;
+    if (kp == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_GetDeviceModifierMapping, 0, 
+		BadMatch);
+	return Success;
+	}
+    maxkeys =  kp->maxKeysPerModifier;
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetDeviceModifierMapping;
+    rep.numKeyPerModifier = maxkeys;
+    rep.sequenceNumber = client->sequence;
+    /* length counts 4 byte quantities - there are 8 modifiers 1 byte big */
+    rep.length = 2*maxkeys;
+
+    WriteReplyToClient(client, sizeof(xGetDeviceModifierMappingReply), &rep);
+
+    /* Reply with the (modified by DDX) map that SetModifierMapping passed in */
+    WriteToClient(client, 8*maxkeys, (char *)kp->modifierKeyMap);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGetDeviceModifierMapping function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetDeviceModifierMapping (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetDeviceModifierMappingReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/getprop.c b/Xi/getprop.c
new file mode 100644
index 000000000..ee53b87cb
--- /dev/null
+++ b/Xi/getprop.c
@@ -0,0 +1,207 @@
+/* $Xorg: getprop.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Function to return the dont-propagate-list for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structs    */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	void		(* ReplySwapVector[256]) ();
+extern			XExtEventInfo EventInfo[];
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle a request from a client with a different byte order.
+ *
+ */
+
+int
+SProcXGetDeviceDontPropagateList(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetDeviceDontPropagateListReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGetDeviceDontPropagateListReq);
+    swapl(&stuff->window, n);
+    return(ProcXGetDeviceDontPropagateList(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure lists the input devices available to the server.
+ *
+ */
+
+ProcXGetDeviceDontPropagateList (client)
+    register ClientPtr client;
+    {
+    CARD16				count = 0;
+    int					i;
+    XEventClass				*buf, *tbuf;
+    WindowPtr 				pWin;
+    xGetDeviceDontPropagateListReply	rep;
+    XEventClass 			*ClassFromMask ();
+    void				Swap32Write();
+    OtherInputMasks			*others;
+
+    REQUEST(xGetDeviceDontPropagateListReq);
+    REQUEST_SIZE_MATCH(xGetDeviceDontPropagateListReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetDeviceDontPropagateList;
+    rep.sequenceNumber = client->sequence;
+    rep.length = 0;
+    rep.count = 0;
+
+    pWin = (WindowPtr) LookupWindow (stuff->window, client);
+    if (!pWin)
+        {
+	client->errorValue = stuff->window;
+	SendErrorToClient(client, IReqCode, X_GetDeviceDontPropagateList, 0, 
+		BadWindow);
+	return Success;
+        }
+
+    if (others = wOtherInputMasks(pWin))
+	{
+	for (i=0; i<EMASKSIZE; i++)
+	    tbuf = ClassFromMask (NULL, others->dontPropagateMask[i], i, 
+		&count, COUNT);
+	if (count)
+	    {
+	    rep.count = count;
+	    buf = (XEventClass *) Xalloc (rep.count * sizeof(XEventClass));
+	    rep.length = (rep.count * sizeof (XEventClass) + 3) >> 2;
+
+	    tbuf = buf;
+	    for (i=0; i<EMASKSIZE; i++)
+		tbuf = ClassFromMask (tbuf, others->dontPropagateMask[i], i, 
+		    NULL, CREATE);
+	    }
+	}
+
+    WriteReplyToClient (client, sizeof (xGetDeviceDontPropagateListReply), 
+	&rep);
+
+    if (count)
+	{
+	client->pSwapReplyFunc = Swap32Write;
+	WriteSwappedDataToClient( client, count * sizeof(XEventClass), buf);
+	Xfree (buf);
+	}
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure gets a list of event classes from a mask word.
+ * A single mask may translate to more than one event class.
+ *
+ */
+
+XEventClass
+*ClassFromMask (buf, mask, maskndx, count, mode)
+    XEventClass *buf;
+    Mask	mask;
+    int		maskndx;
+    CARD16	*count;
+    int		mode;
+    {
+    int		i,j;
+    int		id = maskndx;
+    Mask	tmask = 0x80000000;
+    extern int	ExtEventIndex;
+
+    for (i=0; i<32; i++,tmask>>=1)
+	if (tmask & mask)
+	    {
+	    for (j=0; j<ExtEventIndex; j++)
+		if (EventInfo[j].mask == tmask)
+		    {
+		    if (mode == COUNT)
+			(*count)++;
+		    else
+		        *buf++ = (id << 8) | EventInfo[j].type;
+		    }
+	    }
+    return (buf);
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGetDeviceDontPropagateList function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetDeviceDontPropagateList (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetDeviceDontPropagateListReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    swaps(&rep->count, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/getselev.c b/Xi/getselev.c
new file mode 100644
index 000000000..8ac16d1d0
--- /dev/null
+++ b/Xi/getselev.c
@@ -0,0 +1,189 @@
+/************************************************************
+
+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.
+
+********************************************************/
+
+/* $Xorg: getselev.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
+
+/***********************************************************************
+ *
+ * Extension function to get the current selected events for a given window.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "XI.h"
+#include "XIproto.h"
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window struct     */
+
+extern	int 		IReqCode;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure gets the current selected extension events.
+ *
+ */
+
+int
+SProcXGetSelectedExtensionEvents(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetSelectedExtensionEventsReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGetSelectedExtensionEventsReq);
+    swapl(&stuff->window, n);
+    return(ProcXGetSelectedExtensionEvents(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure gets the current device select mask,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+int
+ProcXGetSelectedExtensionEvents(client)
+    register ClientPtr client;
+    {
+    int					i;
+    int					total_length = 0;
+    xGetSelectedExtensionEventsReply	rep;
+    WindowPtr				pWin;
+    XEventClass				*buf;
+    XEventClass				*tclient;
+    XEventClass				*aclient;
+    XEventClass 			*ClassFromMask ();
+    void				Swap32Write();
+    OtherInputMasks			*pOthers;
+    InputClientsPtr			others;
+
+    REQUEST(xGetSelectedExtensionEventsReq);
+    REQUEST_SIZE_MATCH(xGetSelectedExtensionEventsReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetSelectedExtensionEvents;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.this_client_count = 0;
+    rep.all_clients_count = 0;
+
+    if (!(pWin = LookupWindow(stuff->window, client)))
+        {
+	SendErrorToClient(client, IReqCode, X_GetSelectedExtensionEvents, 0, 
+		BadWindow);
+	return Success;
+        }
+
+    if (pOthers=wOtherInputMasks(pWin))
+	{
+	for (others = pOthers->inputClients; others; others=others->next)
+	    for (i=0; i<EMASKSIZE; i++)
+		tclient = ClassFromMask (NULL, others->mask[i], i, 
+		    &rep.all_clients_count, COUNT);
+
+	for (others = pOthers->inputClients; others; others=others->next)
+	    if (SameClient(others, client))
+		{
+		for (i=0; i<EMASKSIZE; i++)
+		    tclient = ClassFromMask (NULL, others->mask[i], i, 
+			&rep.this_client_count, COUNT);
+		break;
+		}
+
+	total_length = (rep.all_clients_count + rep.this_client_count) * 
+	    sizeof (XEventClass);
+	rep.length = (total_length + 3) >> 2;
+	buf = (XEventClass *) Xalloc (total_length);
+
+	tclient = buf;
+	aclient = buf + rep.this_client_count;
+	if (others)
+	    for (i=0; i<EMASKSIZE; i++)
+		tclient = ClassFromMask (tclient, others->mask[i], i, NULL, CREATE);
+
+	for (others = pOthers->inputClients; others; others=others->next)
+	    for (i=0; i<EMASKSIZE; i++)
+		aclient = ClassFromMask (aclient, others->mask[i], i, NULL, CREATE);
+	}
+
+    WriteReplyToClient (client, sizeof(xGetSelectedExtensionEventsReply), &rep);
+
+    if (total_length)
+	{
+	client->pSwapReplyFunc = Swap32Write;
+	WriteSwappedDataToClient( client, total_length, buf);
+	Xfree (buf);
+	}
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGetSelectedExtensionEvents function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetSelectedExtensionEvents (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetSelectedExtensionEventsReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    swaps(&rep->this_client_count, n);
+    swaps(&rep->all_clients_count, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/getvers.c b/Xi/getvers.c
new file mode 100644
index 000000000..8628a2851
--- /dev/null
+++ b/Xi/getvers.c
@@ -0,0 +1,148 @@
+/* $Xorg: getvers.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to return the version of the extension.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+XExtensionVersion	AllExtensionVersions[128];
+
+/***********************************************************************
+ *
+ * Handle a request from a client with a different byte order than us.
+ *
+ */
+
+int
+SProcXGetExtensionVersion(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetExtensionVersionReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
+    swaps(&stuff->nbytes, n);
+    return(ProcXGetExtensionVersion(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure lists the input devices available to the server.
+ *
+ */
+
+ProcXGetExtensionVersion (client)
+    register ClientPtr client;
+    {
+    xGetExtensionVersionReply	rep;
+
+    REQUEST(xGetExtensionVersionReq);
+    REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
+
+    if (stuff->length != (sizeof(xGetExtensionVersionReq) + 
+	stuff->nbytes + 3)>>2)
+	{
+	SendErrorToClient(client, IReqCode, X_GetExtensionVersion, 0, 
+		BadLength);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GetExtensionVersion;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.major_version = 0;
+    rep.minor_version = 0;
+
+    rep.present = TRUE;
+    if (rep.present)
+	{
+	rep.major_version = 
+	    AllExtensionVersions[IReqCode-128].major_version;
+	rep.minor_version = 
+	    AllExtensionVersions[IReqCode-128].minor_version;
+	}
+    WriteReplyToClient (client, sizeof (xGetExtensionVersionReply), &rep);
+
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGetExtensionVersion function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetExtensionVersion (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetExtensionVersionReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    swaps(&rep->major_version, n);
+    swaps(&rep->minor_version, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/grabdev.c b/Xi/grabdev.c
new file mode 100644
index 000000000..cb2370adf
--- /dev/null
+++ b/Xi/grabdev.c
@@ -0,0 +1,225 @@
+/* $Xorg: grabdev.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to grab an extension device.
+ *
+ */
+
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int		BadDevice;
+extern	int		BadClass;
+extern	XExtEventInfo	EventInfo[];
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Swap the request if the requestor has a different byte order than us.
+ *
+ */
+
+int
+SProcXGrabDevice(client)
+    register ClientPtr client;
+    {
+    register char n;
+    register long *p;
+    register int i;
+
+    REQUEST(xGrabDeviceReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
+    swapl(&stuff->grabWindow, n);
+    swapl(&stuff->time, n);
+    swaps(&stuff->event_count, n);
+    p = (long *) &stuff[1];
+    for (i=0; i<stuff->event_count; i++)
+        {
+        swapl(p, n);
+	p++;
+        }
+
+    return(ProcXGrabDevice(client));
+    }
+
+/***********************************************************************
+ *
+ * Grab an extension device.
+ *
+ */
+
+int
+ProcXGrabDevice(client)
+    ClientPtr client;
+    {
+    int			error;
+    xGrabDeviceReply 	rep;
+    DeviceIntPtr 	dev;
+    struct tmask	tmp[EMASKSIZE];
+
+    REQUEST(xGrabDeviceReq);
+    REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
+
+    if (stuff->length !=(sizeof(xGrabDeviceReq)>>2) + stuff->event_count)
+	{
+	SendErrorToClient (client, IReqCode, X_GrabDevice, 0, BadLength);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_GrabDevice;
+    rep.sequenceNumber = client->sequence;
+    rep.length = 0;
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, BadDevice);
+	return Success;
+	}
+
+    if (CreateMaskFromList (client, (XEventClass *)&stuff[1], 
+	stuff->event_count, tmp, dev, X_GrabDevice) != Success)
+	return Success;
+
+    error = GrabDevice (client, dev, stuff->this_device_mode, 
+	stuff->other_devices_mode, stuff->grabWindow, stuff->ownerEvents, 
+	stuff->time, tmp[stuff->deviceid].mask, &rep.status);
+
+    if (error != Success)
+	{
+	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, error);
+	return Success;
+	}
+    WriteReplyToClient(client, sizeof(xGrabDeviceReply), &rep);
+    return Success;
+    }
+
+
+/***********************************************************************
+ *
+ * This procedure creates an event mask from a list of XEventClasses.
+ *
+ */
+
+int
+CreateMaskFromList (client, list, count, mask, dev, req)
+    ClientPtr		client;
+    XEventClass		*list;
+    int			count;
+    struct tmask	mask[];
+    DeviceIntPtr	dev;
+    int			req;
+    {
+    int			i,j;
+    int			device;
+    DeviceIntPtr	tdev;
+    extern int		ExtEventIndex;
+
+    for (i=0; i<EMASKSIZE; i++)
+	{
+	mask[i].mask = 0;
+	mask[i].dev = NULL;
+	}
+
+    for (i=0; i<count; i++, list++)
+	{
+	device = *list >> 8;
+	if (device > 255)
+	    {
+	    SendErrorToClient(client, IReqCode, req, 0, BadClass);
+	    return BadClass;
+	    }
+	tdev = LookupDeviceIntRec (device);
+	if (tdev==NULL || (dev != NULL && tdev != dev))
+	    {
+	    SendErrorToClient(client, IReqCode, req, 0, BadClass);
+	    return BadClass;
+	    }
+
+	for (j=0; j<ExtEventIndex; j++)
+	    if (EventInfo[j].type == (*list & 0xff))
+		{
+		mask[device].mask |= EventInfo[j].mask;
+		mask[device].dev = (Pointer) tdev;
+		break;
+		}
+	}
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGrabDevice function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGrabDevice (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGrabDeviceReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/grabdevb.c b/Xi/grabdevb.c
new file mode 100644
index 000000000..ddc44c12d
--- /dev/null
+++ b/Xi/grabdevb.c
@@ -0,0 +1,163 @@
+/* $Xorg: grabdevb.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to grab a button on an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle requests from clients with a different byte order.
+ *
+ */
+
+int
+SProcXGrabDeviceButton(client)
+    register ClientPtr client;
+    {
+    register char n;
+    register long *p;
+    register int i;
+
+    REQUEST(xGrabDeviceButtonReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->modifiers, n);
+    swaps(&stuff->event_count, n);
+    p = (long *) &stuff[1];
+    for (i=0; i<stuff->event_count; i++)
+        {
+        swapl(p, n);
+	p++;
+        }
+
+    return(ProcXGrabDeviceButton(client));
+    }
+
+/***********************************************************************
+ *
+ * Grab a button on an extension device.
+ *
+ */
+
+int
+ProcXGrabDeviceButton(client)
+    ClientPtr client;
+    {
+    int			ret;
+    DeviceIntPtr	dev;
+    DeviceIntPtr	mdev;
+    XEventClass		*class;
+    struct tmask	tmp[EMASKSIZE];
+
+    REQUEST(xGrabDeviceButtonReq);
+    REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
+
+    if (stuff->length !=(sizeof(xGrabDeviceButtonReq)>>2) + stuff->event_count)
+	{
+	SendErrorToClient (client, IReqCode, X_GrabDeviceButton, 0, BadLength);
+	return Success;
+	}
+
+    dev = LookupDeviceIntRec (stuff->grabbed_device);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, 
+	    BadDevice);
+	return Success;
+	}
+    if (stuff->modifier_device != UseXKeyboard)
+	{
+	mdev = LookupDeviceIntRec (stuff->modifier_device);
+	if (mdev == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, 
+	        BadDevice);
+	    return Success;
+	    }
+	if (mdev->key == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, 
+		BadMatch);
+	    return Success;
+	    }
+	}
+    else
+	mdev = (DeviceIntPtr) LookupKeyboardDevice();
+
+    class = (XEventClass *) (&stuff[1]);	/* first word of values */
+
+    if ((ret = CreateMaskFromList (client, class,
+	stuff->event_count, tmp, dev, X_GrabDeviceButton)) != Success)
+	    return Success;
+    ret = GrabButton(client, dev, stuff->this_device_mode, 
+	stuff->other_devices_mode, stuff->modifiers, mdev, stuff->button, 
+	stuff->grabWindow, stuff->ownerEvents, NullCursor, NullWindow, 
+	tmp[stuff->grabbed_device].mask);
+
+    if (ret != Success)
+	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, ret);
+    return(Success);
+    }
diff --git a/Xi/grabdevk.c b/Xi/grabdevk.c
new file mode 100644
index 000000000..6db6b8d09
--- /dev/null
+++ b/Xi/grabdevk.c
@@ -0,0 +1,169 @@
+/* $Xorg: grabdevk.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to grab a key on an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int		BadClass;
+extern	int		BadDevice;
+extern	InputInfo	inputInfo;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle requests from clients with a different byte order.
+ *
+ */
+
+int
+SProcXGrabDeviceKey(client)
+    register ClientPtr client;
+    {
+    register char n;
+    register long *p;
+    register int i;
+
+    REQUEST(xGrabDeviceKeyReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->modifiers, n);
+    swaps(&stuff->event_count, n);
+    p = (long *) &stuff[1];
+    for (i=0; i<stuff->event_count; i++)
+        {
+        swapl(p, n);
+	p++;
+        }
+    return(ProcXGrabDeviceKey(client));
+    }
+
+/***********************************************************************
+ *
+ * Grab a key on an extension device.
+ *
+ */
+
+int
+ProcXGrabDeviceKey(client)
+    ClientPtr client;
+    {
+    int			ret;
+    DeviceIntPtr 	dev;
+    DeviceIntPtr 	mdev;
+    XEventClass		*class;
+    struct tmask	tmp[EMASKSIZE];
+
+    REQUEST(xGrabDeviceKeyReq);
+    REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
+
+    if (stuff->length !=(sizeof(xGrabDeviceKeyReq)>>2) + stuff->event_count)
+	{
+	SendErrorToClient (client, IReqCode, X_GrabDeviceKey, 0, BadLength);
+	return Success;
+	}
+
+    dev = LookupDeviceIntRec (stuff->grabbed_device);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, 
+	    BadDevice);
+	return Success;
+	}
+
+    if (stuff->modifier_device != UseXKeyboard)
+	{
+	mdev = LookupDeviceIntRec (stuff->modifier_device);
+	if (mdev == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, 
+	        BadDevice);
+	    return Success;
+	    }
+	if (mdev->key == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, 
+		BadMatch);
+	    return Success;
+	    }
+	}
+    else
+	mdev = (DeviceIntPtr) LookupKeyboardDevice();
+
+    class = (XEventClass *) (&stuff[1]);	/* first word of values */
+
+    if ((ret = CreateMaskFromList (client, class, 
+	stuff->event_count, tmp, dev, X_GrabDeviceKey)) != Success)
+	    return Success;
+
+    ret = GrabKey(client, dev, stuff->this_device_mode, 
+	stuff->other_devices_mode, stuff->modifiers, mdev, stuff->key, 
+	stuff->grabWindow, stuff->ownerEvents, tmp[stuff->grabbed_device].mask);
+
+    if (ret != Success)
+        {
+	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, ret);
+        return Success;
+        }
+
+    return Success;
+    }
diff --git a/Xi/gtmotion.c b/Xi/gtmotion.c
new file mode 100644
index 000000000..65a4e0a19
--- /dev/null
+++ b/Xi/gtmotion.c
@@ -0,0 +1,206 @@
+/* $Xorg: gtmotion.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to get the motion history from an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Swap the request if server and client have different byte ordering.
+ *
+ */
+
+int
+SProcXGetDeviceMotionEvents(client)
+register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xGetDeviceMotionEventsReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
+    swapl(&stuff->start, n);
+    swapl(&stuff->stop, n);
+    return(ProcXGetDeviceMotionEvents(client));
+    }
+
+/****************************************************************************
+ *
+ * Get the motion history for an extension pointer devices.
+ *
+ */
+
+int
+ProcXGetDeviceMotionEvents(client)
+    ClientPtr client;
+{
+    INT32 *coords = NULL, *bufptr;
+    xGetDeviceMotionEventsReply rep;
+    int     i, j, num_events, axes, size, tsize;
+    unsigned long nEvents;
+    DeviceIntPtr dev;
+    TimeStamp start, stop;
+    void XSwapTimeCoordWrite();
+    int	length = 0;
+    ValuatorClassPtr 	v;
+
+    REQUEST(xGetDeviceMotionEventsReq);
+
+    REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0, 
+	    BadDevice);
+	return Success;
+	}
+    v = dev->valuator;
+    if (v==NULL || v->numAxes == 0)
+	{
+	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0, 
+	    BadMatch);
+	return Success;
+	}
+    if (dev->valuator->motionHintWindow)
+	MaybeStopDeviceHint(dev, client);
+    axes = v->numAxes;
+    rep.repType = X_Reply;
+    rep.RepType = X_GetDeviceMotionEvents;
+    rep.sequenceNumber = client->sequence;
+    rep.nEvents = 0;
+    rep.axes = axes;
+    rep.mode = v->mode & DeviceMode;
+    rep.length = 0;
+    start = ClientTimeToServerTime(stuff->start);
+    stop = ClientTimeToServerTime(stuff->stop);
+    if (CompareTimeStamps(start, stop) == LATER ||
+	CompareTimeStamps(start, currentTime) == LATER)
+	{
+    	WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
+        return Success;
+	}
+    if (CompareTimeStamps(stop, currentTime) == LATER)
+        stop = currentTime;
+    num_events = v->numMotionEvents;
+    if (num_events)
+    {
+	size = sizeof(Time) + (axes * sizeof (INT32));
+	tsize = num_events * size;
+	coords = (INT32 *) ALLOCATE_LOCAL(tsize);
+	if (!coords)
+	    {
+	    SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0, 
+	        BadAlloc);
+	    return Success;
+	    }
+	rep.nEvents = (v->GetMotionProc) (
+		dev, (xTimecoord *)coords, /* XXX */
+		start.milliseconds, stop.milliseconds, (ScreenPtr)NULL);
+    }
+    if (rep.nEvents > 0)
+	{
+        length = (rep.nEvents * size +3) >> 2;
+        rep.length = length;
+	}
+    nEvents = rep.nEvents;
+    WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
+    if (nEvents)
+        {
+	if (client->swapped)
+	    {
+    	    register 	char n;
+
+	    bufptr = coords;
+	    for (i=0; i<nEvents * (axes+1); i++)
+		{
+    		swapl(bufptr, n);
+		bufptr++;
+		}
+	    }
+	WriteToClient(client, length * 4, (char *)coords);
+        }
+    if (coords)
+	DEALLOCATE_LOCAL(coords);
+    return Success;
+}
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XGetDeviceMotionEvents function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXGetDeviceMotionEvents (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xGetDeviceMotionEventsReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    swapl(&rep->nEvents, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/listdev.c b/Xi/listdev.c
new file mode 100644
index 000000000..ff6155f19
--- /dev/null
+++ b/Xi/listdev.c
@@ -0,0 +1,409 @@
+/* $Xorg: listdev.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Extension function to list the available input devices.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+#define VPC	20			/* Max # valuators per chunk */
+extern InputInfo inputInfo;
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	void	(*ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+
+void		CopySwapKeyClass ();
+void		CopySwapButtonClass ();
+int		CopySwapValuatorClass ();
+void		SizeDeviceInfo ();
+void		ListDeviceInfo ();
+void		AddOtherInputDevices ();
+void		CopyDeviceName ();
+void		CopySwapDevice ();
+
+/***********************************************************************
+ *
+ * This procedure lists the input devices available to the server.
+ *
+ */
+
+int
+SProcXListInputDevices(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xListInputDevicesReq);
+    swaps(&stuff->length, n);
+    return(ProcXListInputDevices(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure lists the input devices available to the server.
+ *
+ */
+
+ProcXListInputDevices (client)
+    register ClientPtr client;
+    {
+    xListInputDevicesReply	rep;
+    int			numdevs;
+    int 		namesize = 1;	/* need 1 extra byte for strcpy */
+    int 		size = 0;
+    int 		total_length;
+    char		*devbuf;
+    char		*classbuf;
+    char		*namebuf;
+    char		*savbuf;
+    xDeviceInfo 	*dev;
+    DeviceIntPtr 	d;
+
+    REQUEST(xListInputDevicesReq);
+    REQUEST_SIZE_MATCH(xListInputDevicesReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_ListInputDevices;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    AddOtherInputDevices ();
+    numdevs = inputInfo.numDevices;
+
+    for (d=inputInfo.devices; d; d=d->next)
+	SizeDeviceInfo (d, &namesize, &size);
+    for (d=inputInfo.off_devices; d; d=d->next)
+	SizeDeviceInfo (d, &namesize, &size);
+
+    total_length = numdevs * sizeof (xDeviceInfo) + size + namesize;
+    devbuf = (char *) Xalloc (total_length);
+    classbuf = devbuf + (numdevs * sizeof (xDeviceInfo));
+    namebuf = classbuf + size;
+    savbuf = devbuf;
+
+    dev = (xDeviceInfoPtr) devbuf;
+    for (d=inputInfo.devices; d; d=d->next,dev++)
+        ListDeviceInfo (client, d, dev, &devbuf, &classbuf, &namebuf);
+    for (d=inputInfo.off_devices; d; d=d->next,dev++)
+        ListDeviceInfo (client, d, dev, &devbuf, &classbuf, &namebuf);
+
+    rep.ndevices = numdevs;
+    rep.length = (total_length + 3) >> 2;
+    WriteReplyToClient (client, sizeof (xListInputDevicesReply), &rep);
+    WriteToClient(client, total_length, savbuf);
+    Xfree (savbuf);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure calculates the size of the information to be returned
+ * for an input device.
+ *
+ */
+
+void
+SizeDeviceInfo (d, namesize, size)
+    DeviceIntPtr d;
+    int *namesize;
+    int *size;
+    {
+    int chunks;
+
+    *namesize += 1;
+    if (d->name)
+	*namesize += strlen (d->name);
+    if (d->key != NULL)
+	*size += sizeof (xKeyInfo);
+    if (d->button != NULL)
+	*size += sizeof (xButtonInfo);
+    if (d->valuator != NULL)
+	{
+	chunks = ((int) d->valuator->numAxes + 19) / VPC;
+	*size += (chunks * sizeof(xValuatorInfo) + 
+		d->valuator->numAxes * sizeof(xAxisInfo));
+	}
+    }
+
+/***********************************************************************
+ *
+ * This procedure lists information to be returned for an input device.
+ *
+ */
+
+void
+ListDeviceInfo (client, d, dev, devbuf, classbuf, namebuf)
+    ClientPtr client;
+    DeviceIntPtr d;
+    xDeviceInfoPtr dev;
+    char **devbuf;
+    char **classbuf;
+    char **namebuf;
+    {
+    CopyDeviceName (namebuf, d->name);
+    CopySwapDevice (client, d, 0, devbuf);
+    if (d->key != NULL)
+	{
+	CopySwapKeyClass(client, d->key, classbuf);
+	dev->num_classes++;
+	}
+    if (d->button != NULL)
+	{
+	CopySwapButtonClass(client, d->button, classbuf);
+	dev->num_classes++;
+	}
+    if (d->valuator != NULL)
+	{
+	dev->num_classes += CopySwapValuatorClass(client, d->valuator, classbuf);
+	}
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies data to the DeviceInfo struct, swapping if necessary.
+ *
+ * We need the extra byte in the allocated buffer, because the trailing null
+ * hammers one extra byte, which is overwritten by the next name except for
+ * the last name copied.
+ *
+ */
+
+void
+CopyDeviceName (namebuf, name)
+    char **namebuf;
+    char *name;
+    {
+    char *nameptr = (char *) *namebuf;
+
+    if (name)
+	{
+	*nameptr++ = strlen (name);
+	strcpy (nameptr, name);
+	*namebuf += (strlen (name)+1);
+	}
+    else
+	{
+	*nameptr++ = 0;
+	*namebuf += 1;
+	}
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies data to the DeviceInfo struct, swapping if necessary.
+ *
+ */
+
+void
+CopySwapDevice (client, d, num_classes, buf)
+    register ClientPtr 	client;
+    DeviceIntPtr	d;
+    int			num_classes;
+    char 		**buf;
+    {
+    register char 	n;
+    xDeviceInfoPtr dev;
+
+    dev = (xDeviceInfoPtr) *buf;
+
+    dev->id = d->id;
+    dev->type = d->type;
+    dev->num_classes = num_classes;
+    if (d == inputInfo.keyboard)
+	dev->use = IsXKeyboard;
+    else if (d == inputInfo.pointer)
+	dev->use = IsXPointer;
+    else
+	dev->use = IsXExtensionDevice;
+    if (client->swapped)
+	{
+	swapl(&dev->type, n);	/* macro - braces are required */
+	}
+    *buf += sizeof (xDeviceInfo);
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies KeyClass information, swapping if necessary.
+ *
+ */
+
+void
+CopySwapKeyClass (client, k, buf)
+    register ClientPtr 	client;
+    KeyClassPtr 	k;
+    char 		**buf;
+    {
+    register char 	n;
+    xKeyInfoPtr 	k2;
+
+    k2 = (xKeyInfoPtr) *buf;
+    k2->class = KeyClass;
+    k2->length = sizeof (xKeyInfo);
+    k2->min_keycode = k->curKeySyms.minKeyCode;
+    k2->max_keycode = k->curKeySyms.maxKeyCode;
+    k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
+    if (client->swapped)
+	{
+	swaps(&k2->num_keys,n);
+	}
+    *buf += sizeof (xKeyInfo);
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies ButtonClass information, swapping if necessary.
+ *
+ */
+
+void
+CopySwapButtonClass (client, b, buf)
+    register ClientPtr 	client;
+    ButtonClassPtr 	b;
+    char 		**buf;
+    {
+    register char 	n;
+    xButtonInfoPtr 	b2;
+
+    b2 = (xButtonInfoPtr) *buf;
+    b2->class = ButtonClass;
+    b2->length = sizeof (xButtonInfo);
+    b2->num_buttons = b->numButtons;
+    if (client->swapped)
+	{
+	swaps(&b2->num_buttons,n);	/* macro - braces are required */
+	}
+    *buf += sizeof (xButtonInfo);
+    }
+
+/***********************************************************************
+ *
+ * This procedure copies ValuatorClass information, swapping if necessary.
+ *
+ * Devices may have up to 255 valuators.  The length of a ValuatorClass is
+ * defined to be sizeof(ValuatorClassInfo) + num_axes * sizeof (xAxisInfo).
+ * The maximum length is therefore (8 + 255 * 12) = 3068.  However, the 
+ * length field is one byte.  If a device has more than 20 valuators, we
+ * must therefore return multiple valuator classes to the client.
+ *
+ */
+
+int
+CopySwapValuatorClass (client, v, buf)
+    register ClientPtr 	client;
+    ValuatorClassPtr 	v;
+    char 		**buf;
+{
+    int			i, j, axes, t_axes;
+    register char 	n;
+    xValuatorInfoPtr 	v2;
+    AxisInfo 		*a;
+    xAxisInfoPtr 	a2;
+
+    for (i=0,axes=v->numAxes; i < ((v->numAxes+19)/VPC);  i++, axes-=VPC) {
+	t_axes = axes < VPC ? axes : VPC;
+	if (t_axes < 0)
+	    t_axes = v->numAxes % VPC;
+	v2 = (xValuatorInfoPtr) *buf;
+	v2->class = ValuatorClass;
+	v2->length = sizeof (xValuatorInfo) + t_axes * sizeof (xAxisInfo);
+	v2->num_axes  = t_axes;
+	v2->mode  = v->mode & DeviceMode;
+	v2->motion_buffer_size  = v->numMotionEvents;
+	if (client->swapped)
+	    {
+	    swapl(&v2->motion_buffer_size,n);
+	    }
+	*buf += sizeof (xValuatorInfo);
+	a = v->axes + (VPC * i);
+	a2 = (xAxisInfoPtr) *buf;
+	for (j=0; j<t_axes; j++) {
+	    a2->min_value = a->min_value;
+	    a2->max_value = a->max_value;
+	    a2->resolution = a->resolution;
+	    if (client->swapped) {
+		swapl(&a2->min_value,n);
+		swapl(&a2->max_value,n);
+		swapl(&a2->resolution,n);
+	    }
+	    a2++;
+	    a++;
+	    *buf += sizeof (xAxisInfo);
+	}
+    }
+    return (i);
+}
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XListInputDevices function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXListInputDevices (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xListInputDevicesReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/opendev.c b/Xi/opendev.c
new file mode 100644
index 000000000..30d6293f0
--- /dev/null
+++ b/Xi/opendev.c
@@ -0,0 +1,199 @@
+/* $Xorg: opendev.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to open an extension input device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "XI.h"
+#include "XIproto.h"
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	CARD8		event_base [];
+extern	InputInfo	inputInfo;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure swaps the request if the server and client have different
+ * byte orderings.
+ *
+ */
+
+int
+SProcXOpenDevice(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xOpenDeviceReq);
+    swaps(&stuff->length, n);
+    return(ProcXOpenDevice(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure causes the server to open an input device.
+ *
+ */
+
+int
+ProcXOpenDevice(client)
+    register ClientPtr client;
+    {
+    xInputClassInfo evbase [numInputClasses];
+    Bool enableit = FALSE;
+    int j=0;
+    int status = Success;
+    xOpenDeviceReply	rep;
+    DeviceIntPtr dev;
+    void OpenInputDevice();
+
+    REQUEST(xOpenDeviceReq);
+    REQUEST_SIZE_MATCH(xOpenDeviceReq);
+
+    if (stuff->deviceid == inputInfo.pointer->id || 
+	stuff->deviceid == inputInfo.keyboard->id)
+	{
+	SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice);
+        return Success;
+	}
+
+    if ((dev = LookupDeviceIntRec(stuff->deviceid)) == NULL) /* not open */
+	{
+        for (dev=inputInfo.off_devices; dev; dev=dev->next)
+	    if (dev->id == stuff->deviceid)
+		break;
+	if (dev == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice);
+	    return Success;
+	    }
+	enableit = TRUE;
+	}
+
+    OpenInputDevice (dev, client, &status);
+    if (status != Success)
+	{
+	SendErrorToClient(client, IReqCode, X_OpenDevice, 0, status);
+	return Success;
+	}
+    if (enableit && dev->inited && dev->startup)
+	(void)EnableDevice(dev);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_OpenDevice;
+    rep.sequenceNumber = client->sequence;
+    if (dev->key != NULL)
+	{
+	evbase[j].class = KeyClass;
+	evbase[j++].event_type_base = event_base[KeyClass];
+	}
+    if (dev->button != NULL)
+	{
+	evbase[j].class = ButtonClass;
+	evbase[j++].event_type_base = event_base[ButtonClass];
+	}
+    if (dev->valuator != NULL)
+	{
+	evbase[j].class = ValuatorClass;
+	evbase[j++].event_type_base = event_base[ValuatorClass];
+	}
+    if (dev->kbdfeed != NULL || dev->ptrfeed != NULL || dev->leds != NULL ||
+	dev->intfeed != NULL || dev->bell != NULL || dev->stringfeed != NULL)
+	{
+	evbase[j].class = FeedbackClass;
+	evbase[j++].event_type_base = event_base[FeedbackClass];
+	}
+    if (dev->focus != NULL)
+	{
+	evbase[j].class = FocusClass;
+	evbase[j++].event_type_base = event_base[FocusClass];
+	}
+    if (dev->proximity != NULL)
+	{
+	evbase[j].class = ProximityClass;
+	evbase[j++].event_type_base = event_base[ProximityClass];
+	}
+    evbase[j].class = OtherClass;
+    evbase[j++].event_type_base = event_base[OtherClass];
+    rep.length = (j * sizeof (xInputClassInfo) + 3) >> 2;
+    rep.num_classes = j;
+    WriteReplyToClient (client, sizeof (xOpenDeviceReply), &rep);
+    WriteToClient(client, j * sizeof (xInputClassInfo), (char *)evbase);
+    return (Success);
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XOpenDevice function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXOpenDevice (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xOpenDeviceReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/queryst.c b/Xi/queryst.c
new file mode 100644
index 000000000..66319b2f3
--- /dev/null
+++ b/Xi/queryst.c
@@ -0,0 +1,208 @@
+/* $Xorg: queryst.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
+/*
+
+Copyright 1998, 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.
+
+*/
+
+/***********************************************************************
+ *
+ * Request to query the state of an extension input device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure allows a client to query the state of a device.
+ *
+ */
+
+int
+SProcXQueryDeviceState(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xQueryDeviceStateReq);
+    swaps(&stuff->length, n);
+    return(ProcXQueryDeviceState(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure allows frozen events to be routed.
+ *
+ */
+
+int
+ProcXQueryDeviceState(client)
+    register ClientPtr client;
+    {
+    register char 		n;
+    int 			i;
+    int 			num_classes = 0;
+    int 			total_length = 0;
+    char			*buf, *savbuf;
+    KeyClassPtr 		k;
+    xKeyState			*tk;
+    ButtonClassPtr 		b;
+    xButtonState		*tb;
+    ValuatorClassPtr 		v;
+    xValuatorState		*tv;
+    xQueryDeviceStateReply	rep;
+    DeviceIntPtr		dev;
+    int				*values;
+
+    REQUEST(xQueryDeviceStateReq);
+    REQUEST_SIZE_MATCH(xQueryDeviceStateReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_QueryDeviceState;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    v = dev->valuator;
+    if (v != NULL && v->motionHintWindow != NULL)
+	MaybeStopDeviceHint(dev, client);
+
+    k = dev->key;
+    if (k != NULL)
+	{
+	total_length += sizeof (xKeyState);
+	num_classes++;
+	}
+
+    b = dev->button;
+    if (b != NULL)
+	{
+	total_length += sizeof (xButtonState);
+	num_classes++;
+	}
+
+    if (v != NULL)
+	{
+	total_length += (sizeof(xValuatorState) + 
+			(v->numAxes * sizeof(int)));
+	num_classes++;
+	}
+    buf = (char *) Xalloc (total_length);
+    if (!buf)
+	{
+	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, 
+		BadAlloc);
+	return Success;
+	}
+    savbuf = buf;
+
+    if (k != NULL)
+	{
+	tk = (xKeyState *) buf;
+	tk->class = KeyClass;
+	tk->length = sizeof (xKeyState);
+	tk->num_keys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode + 1;
+	for (i = 0; i<32; i++)
+	    tk->keys[i] = k->down[i];
+	buf += sizeof (xKeyState);
+	}
+
+    if (b != NULL)
+	{
+	tb = (xButtonState *) buf;
+	tb->class = ButtonClass;
+	tb->length = sizeof (xButtonState);
+	tb->num_buttons = b->numButtons;
+	for (i = 0; i<32; i++)
+	    tb->buttons[i] = b->down[i];
+	buf += sizeof (xButtonState);
+	}
+
+    if (v != NULL)
+	{
+	tv = (xValuatorState *) buf;
+	tv->class = ValuatorClass;
+	tv->length = sizeof (xValuatorState);
+	tv->num_valuators = v->numAxes;
+	tv->mode = v->mode;
+	buf += sizeof(xValuatorState);
+	for (i=0, values=v->axisVal; i<v->numAxes; i++)
+	    {
+	    *((int *) buf) = *values++;
+	    if (client->swapped)
+		{
+		swapl ((int *) buf, n);/* macro - braces needed */
+		}
+	    buf += sizeof(int);
+	    }
+	}
+
+    rep.num_classes = num_classes;
+    rep.length = (total_length + 3) >> 2;
+    WriteReplyToClient (client, sizeof(xQueryDeviceStateReply), &rep);
+    if (total_length > 0)
+	WriteToClient (client, total_length, savbuf);
+    Xfree (savbuf);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XQueryDeviceState function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXQueryDeviceState (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xQueryDeviceStateReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/selectev.c b/Xi/selectev.c
new file mode 100644
index 000000000..510062993
--- /dev/null
+++ b/Xi/selectev.c
@@ -0,0 +1,150 @@
+/* $Xorg: selectev.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to select input from an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	Mask		ExtExclusiveMasks[];
+extern	Mask		ExtValidMasks[];
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle requests from clients with a different byte order.
+ *
+ */
+
+int
+SProcXSelectExtensionEvent (client)
+register ClientPtr client;
+    {
+    register char n;
+    register long *p;
+    register int i;
+
+    REQUEST(xSelectExtensionEventReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
+    swapl(&stuff->window, n);
+    swaps(&stuff->count, n);
+    p = (long *) &stuff[1];
+    for (i=0; i<stuff->count; i++)
+        {
+        swapl(p, n);
+	p++;
+        }
+    return(ProcXSelectExtensionEvent(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure selects input from an extension device.
+ *
+ */
+
+int
+ProcXSelectExtensionEvent (client)
+    register ClientPtr client;
+    {
+    int			ret;
+    int			i;
+    WindowPtr 		pWin;
+    struct tmask	tmp[EMASKSIZE];
+
+    REQUEST(xSelectExtensionEventReq);
+    REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
+
+    if (stuff->length !=(sizeof(xSelectExtensionEventReq)>>2) + stuff->count)
+	{
+	SendErrorToClient (client, IReqCode, X_SelectExtensionEvent, 0, 
+		BadLength);
+	return Success;
+	}
+
+    pWin = (WindowPtr) LookupWindow (stuff->window, client);
+    if (!pWin)
+        {
+	client->errorValue = stuff->window;
+	SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0, 
+		BadWindow);
+	return Success;
+        }
+
+    if ((ret = CreateMaskFromList (client, (XEventClass *)&stuff[1], 
+	stuff->count, tmp, NULL, X_SelectExtensionEvent)) != Success)
+	return Success;
+
+    for (i=0; i<EMASKSIZE; i++)
+	if (tmp[i].dev != NULL)
+	    {
+	    if ((ret = SelectForWindow(tmp[i].dev, pWin, client, tmp[i].mask, 
+		ExtExclusiveMasks[i], ExtValidMasks[i])) != Success)
+		{
+		SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0, 
+			ret);
+		return Success;
+		}
+	    }
+
+    return Success;
+    }
diff --git a/Xi/sendexev.c b/Xi/sendexev.c
new file mode 100644
index 000000000..36a1ad326
--- /dev/null
+++ b/Xi/sendexev.c
@@ -0,0 +1,173 @@
+/* $Xorg: sendexev.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to send an extension event.
+ *
+ */
+
+#define EXTENSION_EVENT_BASE  64
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* Window      	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+extern	void		(* EventSwapVector[128]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle requests from clients with a different byte order than us.
+ *
+ */
+
+int
+SProcXSendExtensionEvent(client)
+    register ClientPtr client;
+    {
+    register char n;
+    register long *p;
+    register int i;
+    xEvent eventT;
+    xEvent *eventP;
+    void (*proc)(), NotImplemented();
+
+    REQUEST(xSendExtensionEventReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
+    swapl(&stuff->destination, n);
+    swaps(&stuff->count, n);
+    eventP = (xEvent *) &stuff[1];
+    for (i=0; i<stuff->num_events; i++,eventP++)
+        {
+	proc = EventSwapVector[eventP->u.u.type & 0177];
+ 	if (proc == NotImplemented)   /* no swapping proc; invalid event type? */
+	    return (BadValue);
+	(*proc)(eventP, &eventT);
+	*eventP = eventT;
+	}
+
+    p = (long *) (((xEvent *) &stuff[1]) + stuff->num_events);
+    for (i=0; i<stuff->count; i++)
+        {
+        swapl(p, n);
+	p++;
+        }
+    return(ProcXSendExtensionEvent(client));
+    }
+
+/***********************************************************************
+ *
+ * Send an event to some client, as if it had come from an extension input 
+ * device.
+ *
+ */
+
+ProcXSendExtensionEvent (client)
+    register ClientPtr client;
+    {
+    int			ret;
+    extern int 		lastEvent; 		/* Defined in extension.c */
+    DeviceIntPtr	dev;
+    xEvent		*first;
+    XEventClass		*list;
+    struct tmask	tmp[EMASKSIZE];
+
+    REQUEST(xSendExtensionEventReq);
+    REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
+
+    if (stuff->length !=(sizeof(xSendExtensionEventReq)>>2) + stuff->count +
+	(stuff->num_events * (sizeof (xEvent) >> 2)))
+	{
+	SendErrorToClient (client, IReqCode, X_SendExtensionEvent, 0, 
+		BadLength);
+	return Success;
+	}
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    /* The client's event type must be one defined by an extension. */
+
+    first = ((xEvent *) &stuff[1]);
+    if ( ! ((EXTENSION_EVENT_BASE  <= first->u.u.type) &&
+	(first->u.u.type < lastEvent)) )
+	{
+	client->errorValue = first->u.u.type;
+	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, 
+		BadValue);
+	return Success;
+	}
+
+    list = (XEventClass *) (first + stuff->num_events);
+    if ((ret = CreateMaskFromList (client, list, stuff->count, tmp, dev, 
+	X_SendExtensionEvent)) != Success)
+	return Success;
+
+    ret =  (SendEvent (client, dev, stuff->destination,
+	stuff->propagate, &stuff[1], tmp[stuff->deviceid].mask, 
+	stuff->num_events));
+
+    if (ret != Success)
+	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, ret);
+
+    return Success;
+    }
diff --git a/Xi/setbmap.c b/Xi/setbmap.c
new file mode 100644
index 000000000..b5335de05
--- /dev/null
+++ b/Xi/setbmap.c
@@ -0,0 +1,163 @@
+/* $Xorg: setbmap.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to change the button mapping of an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#define IsOn(ptr, bit) \
+	(((BYTE *) (ptr))[(bit)>>3] & (1 << ((bit) & 7)))
+
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int 		BadDevice;
+extern	int 		DeviceMappingNotify;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure changes the button mapping.
+ *
+ */
+
+int
+SProcXSetDeviceButtonMapping(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xSetDeviceButtonMappingReq);
+    swaps(&stuff->length, n);
+    return(ProcXSetDeviceButtonMapping(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure lists the input devices available to the server.
+ *
+ */
+
+ProcXSetDeviceButtonMapping (client)
+    register ClientPtr client;
+    {
+    int					ret;
+    xSetDeviceButtonMappingReply	rep;
+    DeviceIntPtr dev;
+
+    REQUEST(xSetDeviceButtonMappingReq);
+    REQUEST_AT_LEAST_SIZE(xSetDeviceButtonMappingReq);
+
+    if (stuff->length != (sizeof(xSetDeviceButtonMappingReq) + 
+	stuff->map_length + 3)>>2)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, 
+		BadLength);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_SetDeviceButtonMapping;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.status = MappingSuccess;
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    ret = SetButtonMapping (client, dev, stuff->map_length, &stuff[1]);
+
+    if (ret == BadValue || ret == BadMatch)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, 
+		ret);
+	return Success;
+	}
+    else
+	{
+	rep.status = ret;
+	WriteReplyToClient(client, sizeof(xSetDeviceButtonMappingReply), &rep);
+	}
+
+    if (ret != MappingBusy)
+        SendDeviceMappingNotify(MappingPointer, 0, 0, dev);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XSetDeviceButtonMapping function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXSetDeviceButtonMapping (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xSetDeviceButtonMappingReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/setdval.c b/Xi/setdval.c
new file mode 100644
index 000000000..533b1ef5b
--- /dev/null
+++ b/Xi/setdval.c
@@ -0,0 +1,167 @@
+/* $Xorg: setdval.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to change the mode of an extension input device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "XI.h"
+#include "XIproto.h"
+#include "inputstr.h"			/* DeviceIntPtr	     */
+
+extern	int 		IReqCode;
+extern	int		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle a request from a client with a different byte order.
+ *
+ */
+
+int
+SProcXSetDeviceValuators(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xSetDeviceValuatorsReq);
+    swaps(&stuff->length, n);
+    return(ProcXSetDeviceValuators(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure sets the value of valuators on an extension input device.
+ *
+ */
+
+int
+ProcXSetDeviceValuators(client)
+    register ClientPtr client;
+    {
+    DeviceIntPtr dev;
+    xSetDeviceValuatorsReply	rep;
+
+    REQUEST(xSetDeviceValuatorsReq);
+    REQUEST_AT_LEAST_SIZE(xSetDeviceValuatorsReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_SetDeviceValuators;
+    rep.length = 0;
+    rep.status = Success;
+    rep.sequenceNumber = client->sequence;
+
+    if (stuff->length !=(sizeof(xSetDeviceValuatorsReq)>>2) + 
+	stuff->num_valuators)
+	{
+	SendErrorToClient (client, IReqCode, X_SetDeviceValuators, 0, 
+		BadLength);
+	return Success;
+	}
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_SetDeviceValuators, 0, 
+	    BadDevice);
+	return Success;
+	}
+    if (dev->valuator == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, 
+		BadMatch);
+	return Success;
+	}
+
+    if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, 
+		BadValue);
+	return Success;
+	}
+
+    if ((dev->grab) && !SameClient(dev->grab, client))
+	rep.status = AlreadyGrabbed;
+    else
+	rep.status = SetDeviceValuators (client, dev, (int *) &stuff[1],
+	    stuff->first_valuator, stuff->num_valuators);
+
+    if (rep.status != Success && rep.status != AlreadyGrabbed)
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, 
+	    rep.status);
+    else
+	WriteReplyToClient (client, sizeof (xSetDeviceValuatorsReply), &rep);
+
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XSetDeviceValuators function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXSetDeviceValuators (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xSetDeviceValuatorsReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/setfocus.c b/Xi/setfocus.c
new file mode 100644
index 000000000..afa5de15b
--- /dev/null
+++ b/Xi/setfocus.c
@@ -0,0 +1,119 @@
+/* $Xorg: setfocus.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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to set the focus for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "windowstr.h"			/* focus struct      */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 		IReqCode;
+extern	int		BadDevice;
+extern	InputInfo	inputInfo;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure sets the focus for a device.
+ *
+ */
+
+int
+SProcXSetDeviceFocus(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xSetDeviceFocusReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xSetDeviceFocusReq);
+    swapl(&stuff->focus, n);
+    swapl(&stuff->time, n);
+    return(ProcXSetDeviceFocus(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure sets the focus for a device.
+ *
+ */
+
+int
+ProcXSetDeviceFocus(client)
+    register ClientPtr client;
+    {
+    int				ret;
+    register DeviceIntPtr	dev;
+
+    REQUEST(xSetDeviceFocusReq);
+    REQUEST_SIZE_MATCH(xSetDeviceFocusReq);
+
+    dev = LookupDeviceIntRec (stuff->device);
+    if (dev==NULL || !dev->focus)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, BadDevice);
+	return Success;
+	}
+
+    ret = SetInputFocus (client, dev, stuff->focus, stuff->revertTo, 
+	stuff->time, TRUE);
+    if (ret != Success)
+	SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, ret);
+
+    return Success;
+    }
diff --git a/Xi/setmmap.c b/Xi/setmmap.c
new file mode 100644
index 000000000..16f3373a8
--- /dev/null
+++ b/Xi/setmmap.c
@@ -0,0 +1,157 @@
+/* $Xorg: setmmap.c,v 1.4 2001/02/09 02:04:35 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.
+
+********************************************************/
+
+/********************************************************************
+ *
+ *  Set modifier mapping for an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "XI.h"
+#include "XIproto.h"
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	int	DeviceMappingNotify;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * This procedure sets the modifier mapping for an extension device,
+ * for clients on machines with a different byte ordering than the server.
+ *
+ */
+
+int
+SProcXSetDeviceModifierMapping(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xSetDeviceModifierMappingReq);
+    swaps(&stuff->length, n);
+    return(ProcXSetDeviceModifierMapping(client));
+    }
+
+/***********************************************************************
+ *
+ * Set the device Modifier mapping.
+ *
+ */
+
+ProcXSetDeviceModifierMapping(client)
+    ClientPtr client;
+    {
+    int					ret;
+    xSetDeviceModifierMappingReply	rep;
+    DeviceIntPtr			dev;
+    KeyClassPtr 			kp;
+    
+    REQUEST(xSetDeviceModifierMappingReq);
+    REQUEST_AT_LEAST_SIZE(xSetDeviceModifierMappingReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_SetDeviceModifierMapping, 0, 
+		BadDevice);
+	return Success;
+	}
+
+    rep.repType = X_Reply;
+    rep.RepType = X_SetDeviceModifierMapping;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    ret = SetModifierMapping(client, dev, stuff->length,
+	(sizeof (xSetDeviceModifierMappingReq)>>2), stuff->numKeyPerModifier, 
+	&stuff[1], &kp);
+
+    if (ret==MappingSuccess || ret==MappingBusy || ret==MappingFailed)
+        {
+	rep.success = ret;
+	if (ret == MappingSuccess)
+            SendDeviceMappingNotify(MappingModifier, 0, 0, dev);
+        WriteReplyToClient(client, sizeof(xSetDeviceModifierMappingReply),&rep);
+        }
+    else
+	{
+	if (ret==-1)
+	    ret=BadValue;
+	SendErrorToClient (client, IReqCode, X_SetDeviceModifierMapping, 0,ret);
+	}
+
+
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XSetDeviceModifierMapping function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXSetDeviceModifierMapping (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xSetDeviceModifierMappingReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
+
diff --git a/Xi/setmode.c b/Xi/setmode.c
new file mode 100644
index 000000000..f2458f4e6
--- /dev/null
+++ b/Xi/setmode.c
@@ -0,0 +1,151 @@
+/* $Xorg: setmode.c,v 1.4 2001/02/09 02:04:35 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to change the mode of an extension input device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "XI.h"
+#include "XIproto.h"
+#include "inputstr.h"			/* DeviceIntPtr	     */
+
+extern	int 		IReqCode;
+extern	int		BadDevice;
+extern	void		(* ReplySwapVector[256]) ();
+DeviceIntPtr		LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle a request from a client with a different byte order.
+ *
+ */
+
+int
+SProcXSetDeviceMode(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xSetDeviceModeReq);
+    swaps(&stuff->length, n);
+    return(ProcXSetDeviceMode(client));
+    }
+
+/***********************************************************************
+ *
+ * This procedure sets the mode of a device.
+ *
+ */
+
+int
+ProcXSetDeviceMode(client)
+    register ClientPtr client;
+    {
+    DeviceIntPtr dev;
+    xSetDeviceModeReply	rep;
+
+    REQUEST(xSetDeviceModeReq);
+    REQUEST_SIZE_MATCH(xSetDeviceModeReq);
+
+    rep.repType = X_Reply;
+    rep.RepType = X_SetDeviceMode;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient (client, IReqCode, X_SetDeviceMode, 0, BadDevice);
+	return Success;
+	}
+    if (dev->valuator == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, BadMatch);
+	return Success;
+	}
+    if ((dev->grab) && !SameClient(dev->grab, client))
+	rep.status = AlreadyGrabbed;
+    else
+	rep.status = SetDeviceMode (client, dev, stuff->mode);
+
+    if (rep.status == Success) 
+  	dev->valuator->mode = stuff->mode;
+    else if (rep.status != AlreadyGrabbed)
+	{
+	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, rep.status);
+        return Success;
+	}
+
+    WriteReplyToClient (client, sizeof (xSetDeviceModeReply), &rep);
+    return Success;
+    }
+
+/***********************************************************************
+ *
+ * This procedure writes the reply for the XSetDeviceMode function,
+ * if the client and server have a different byte ordering.
+ *
+ */
+
+SRepXSetDeviceMode (client, size, rep)
+    ClientPtr	client;
+    int		size;
+    xSetDeviceModeReply	*rep;
+    {
+    register char n;
+
+    swaps(&rep->sequenceNumber, n);
+    swapl(&rep->length, n);
+    WriteToClient(client, size, (char *)rep);
+    }
diff --git a/Xi/stubs.c b/Xi/stubs.c
new file mode 100644
index 000000000..9c9269719
--- /dev/null
+++ b/Xi/stubs.c
@@ -0,0 +1,307 @@
+/* $Xorg: stubs.c,v 1.4 2001/02/09 02:04:35 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.
+
+********************************************************/
+
+/*
+ * stubs.c -- stub routines for the X server side of the XINPUT
+ * extension.  This file is mainly to be used only as documentation.
+ * There is not much code here, and you can't get a working XINPUT
+ * server just using this.
+ * The Xvfb server uses this file so it will compile with the same
+ * object files as the real X server for a platform that has XINPUT.
+ * Xnest could do the same thing.
+ */
+
+#define	 NEED_EVENTS
+#include "X.h"
+#include "Xproto.h"
+#include "inputstr.h"
+#include "XI.h"
+#include "XIproto.h"
+
+/***********************************************************************
+ *
+ * Caller:	ProcXChangeKeyboardDevice
+ *
+ * This procedure does the implementation-dependent portion of the work
+ * needed to change the keyboard device.
+ *
+ * The X keyboard device has a FocusRec.  If the device that has been 
+ * made into the new X keyboard did not have a FocusRec, 
+ * ProcXChangeKeyboardDevice will allocate one for it.
+ *
+ * If you do not want clients to be able to focus the old X keyboard
+ * device, call DeleteFocusClassDeviceStruct to free the FocusRec.
+ *
+ * If you support input devices with keys that you do not want to be 
+ * used as the X keyboard, you need to check for them here and return 
+ * a BadDevice error.
+ *
+ * The default implementation is to do nothing (assume you do want
+ * clients to be able to focus the old X keyboard).  The commented-out
+ * sample code shows what you might do if you don't want the default.
+ *
+ */
+
+int
+ChangeKeyboardDevice (old_dev, new_dev)
+    DeviceIntPtr	old_dev;
+    DeviceIntPtr	new_dev;
+    {
+    /***********************************************************************
+     DeleteFocusClassDeviceStruct(old_dev);	 * defined in xchgptr.c *
+    **********************************************************************/
+    }
+
+
+/***********************************************************************
+ *
+ * Caller:	ProcXChangePointerDevice
+ *
+ * This procedure does the implementation-dependent portion of the work
+ * needed to change the pointer device.
+ *
+ * The X pointer device does not have a FocusRec.  If the device that
+ * has been made into the new X pointer had a FocusRec, 
+ * ProcXChangePointerDevice will free it.
+ *
+ * If you want clients to be able to focus the old pointer device that
+ * has now become accessible through the input extension, you need to 
+ * add a FocusRec to it here.
+ *
+ * The XChangePointerDevice protocol request also allows the client
+ * to choose which axes of the new pointer device are used to move 
+ * the X cursor in the X- and Y- directions.  If the axes are different
+ * than the default ones, you need to keep track of that here.
+ *
+ * If you support input devices with valuators that you do not want to be 
+ * used as the X pointer, you need to check for them here and return a 
+ * BadDevice error.
+ *
+ * The default implementation is to do nothing (assume you don't want
+ * clients to be able to focus the old X pointer).  The commented-out
+ * sample code shows what you might do if you don't want the default.
+ *
+ */
+
+int
+ChangePointerDevice (old_dev, new_dev, x, y)
+    DeviceIntPtr	old_dev, new_dev;
+    unsigned char	x, y;
+    {
+    /***********************************************************************
+    InitFocusClassDeviceStruct(old_dev);	* allow focusing old ptr*
+
+    x_axis = x;					* keep track of new x-axis*
+    y_axis = y;					* keep track of new y-axis*
+    if (x_axis != 0 || y_axis != 1)
+	axes_changed = TRUE;			* remember axes have changed*
+    else
+	axes_changed = FALSE;
+    *************************************************************************/
+    }
+
+/***********************************************************************
+ *
+ * Caller:	ProcXCloseDevice
+ *
+ * Take care of implementation-dependent details of closing a device.
+ * Some implementations may actually close the device, others may just
+ * remove this clients interest in that device.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are initialized during X server initialization and kept open).
+ *
+ */
+
+void
+CloseInputDevice (d, client)
+    DeviceIntPtr d;
+    ClientPtr client;
+    {
+    }
+
+/***********************************************************************
+ *
+ * Caller:	ProcXListInputDevices
+ *
+ * This is the implementation-dependent routine to initialize an input 
+ * device to the point that information about it can be listed.
+ * Some implementations open all input devices when the server is first
+ * initialized, and never close them.  Other implementations open only
+ * the X pointer and keyboard devices during server initialization,
+ * and only open other input devices when some client makes an
+ * XOpenDevice request.  If some other process has the device open, the
+ * server may not be able to get information about the device to list it.
+ *
+ * This procedure should be used by implementations that do not initialize
+ * all input devices at server startup.  It should do device-dependent
+ * initialization for any devices not previously initialized, and call
+ * AddInputDevice for each of those devices so that a DeviceIntRec will be 
+ * created for them.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are initialized during X server initialization and kept open).
+ * The commented-out sample code shows what you might do if you don't want 
+ * the default.
+ *
+ */
+
+void
+AddOtherInputDevices ()
+    {
+    DeviceIntPtr dev;
+    DeviceProc deviceProc;
+    pointer private;
+
+    /**********************************************************************
+     for each uninitialized device, do something like: 
+
+    dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE);
+    dev->public.devicePrivate = private;
+    RegisterOtherDevice(dev);
+    dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
+    ************************************************************************/
+
+    }
+
+/***********************************************************************
+ *
+ * Caller:	ProcXOpenDevice
+ *
+ * This is the implementation-dependent routine to open an input device.
+ * Some implementations open all input devices when the server is first
+ * initialized, and never close them.  Other implementations open only
+ * the X pointer and keyboard devices during server initialization,
+ * and only open other input devices when some client makes an
+ * XOpenDevice request.  This entry point is for the latter type of 
+ * implementation.
+ *
+ * If the physical device is not already open, do it here.  In this case,
+ * you need to keep track of the fact that one or more clients has the
+ * device open, and physically close it when the last client that has
+ * it open does an XCloseDevice.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are opened during X server initialization and kept open).
+ *
+ */
+
+void
+OpenInputDevice (dev, client, status)
+    DeviceIntPtr dev;
+    ClientPtr client;
+    int *status;
+    {
+    }
+
+/****************************************************************************
+ *
+ * Caller:	ProcXSetDeviceMode
+ *
+ * Change the mode of an extension device.
+ * This function is used to change the mode of a device from reporting
+ * relative motion to reporting absolute positional information, and
+ * vice versa.
+ * The default implementation below is that no such devices are supported.
+ *
+ */
+
+int
+SetDeviceMode (client, dev, mode)
+    register	ClientPtr	client;
+    DeviceIntPtr dev;
+    int		mode;
+    {
+    return BadMatch;
+    }
+
+/****************************************************************************
+ *
+ * Caller:	ProcXSetDeviceValuators
+ *
+ * Set the value of valuators on an extension input device.
+ * This function is used to set the initial value of valuators on
+ * those input devices that are capable of reporting either relative
+ * motion or an absolute position, and allow an initial position to be set.
+ * The default implementation below is that no such devices are supported.
+ *
+ */
+
+int
+SetDeviceValuators (client, dev, valuators, first_valuator, num_valuators)
+    register	ClientPtr	client;
+    DeviceIntPtr dev;
+    int		*valuators;
+    int		first_valuator;
+    int		num_valuators;
+    {
+    return BadMatch;
+    }
+
+/****************************************************************************
+ *
+ * Caller:	ProcXChangeDeviceControl
+ *
+ * Change the specified device controls on an extension input device.
+ *
+ */
+
+int
+ChangeDeviceControl (client, dev, control)
+    register	ClientPtr	client;
+    DeviceIntPtr dev;
+    xDeviceCtl	*control;
+    {
+    switch (control->control)
+	{
+	case DEVICE_RESOLUTION:
+	    return (BadMatch);
+	default:
+	    return (BadMatch);
+	}
+    }
diff --git a/Xi/ungrdev.c b/Xi/ungrdev.c
new file mode 100644
index 000000000..90a01a4bc
--- /dev/null
+++ b/Xi/ungrdev.c
@@ -0,0 +1,118 @@
+/* $Xorg: ungrdev.c,v 1.4 2001/02/09 02:04:35 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to release a grab of an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XIproto.h"
+
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle requests from a client with a different byte order.
+ *
+ */
+
+int
+SProcXUngrabDevice(client)
+register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xUngrabDeviceReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xUngrabDeviceReq);
+    swapl(&stuff->time, n);
+    return(ProcXUngrabDevice(client));
+    }
+
+/***********************************************************************
+ *
+ * Release a grab of an extension device.
+ *
+ */
+
+int
+ProcXUngrabDevice(client)
+register ClientPtr client;
+    {
+    DeviceIntPtr 	dev;
+    GrabPtr 		grab;
+    TimeStamp 		time;
+
+    REQUEST(xUngrabDeviceReq);
+    REQUEST_SIZE_MATCH(xUngrabDeviceReq);
+
+    dev = LookupDeviceIntRec (stuff->deviceid);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDevice, 0, BadDevice);
+	return Success;
+	}
+    grab =  dev->grab;
+
+    time = ClientTimeToServerTime(stuff->time);
+    if ((CompareTimeStamps(time, currentTime) != LATER) &&
+	(CompareTimeStamps(time, dev->grabTime) != EARLIER) &&
+	(grab) && SameClient(grab, client))
+	(*dev->DeactivateGrab)(dev);
+    return Success;
+    }
diff --git a/Xi/ungrdevb.c b/Xi/ungrdevb.c
new file mode 100644
index 000000000..917efda9c
--- /dev/null
+++ b/Xi/ungrdevb.c
@@ -0,0 +1,172 @@
+/* $Xorg: ungrdevb.c,v 1.4 2001/02/09 02:04:35 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to release a grab of a button on an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+#define AllModifiersMask ( \
+	ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | \
+	Mod3Mask | Mod4Mask | Mod5Mask )
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	int	DeviceButtonPress;
+extern	void	(* ReplySwapVector[256]) ();
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle requests from a client with a different byte order.
+ *
+ */
+
+int
+SProcXUngrabDeviceButton(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xUngrabDeviceButtonReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->modifiers, n);
+    return(ProcXUngrabDeviceButton(client));
+    }
+
+/***********************************************************************
+ *
+ * Release a grab of a button on an extension device.
+ *
+ */
+
+int
+ProcXUngrabDeviceButton(client)
+    ClientPtr client;
+    {
+    DeviceIntPtr	dev;
+    DeviceIntPtr	mdev;
+    WindowPtr		pWin;
+    GrabRec		temporaryGrab;
+
+    REQUEST(xUngrabDeviceButtonReq);
+    REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq);
+
+    dev = LookupDeviceIntRec (stuff->grabbed_device);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
+	    BadDevice);
+	return Success;
+	}
+    if (dev->button == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
+		BadMatch);
+	return Success;
+	}
+
+    if (stuff->modifier_device != UseXKeyboard)
+	{
+	mdev = LookupDeviceIntRec (stuff->modifier_device);
+	if (mdev == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
+	        BadDevice);
+	    return Success;
+	    }
+	if (mdev->key == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
+		BadMatch);
+	    return Success;
+	    }
+	}
+    else
+	mdev = (DeviceIntPtr) LookupKeyboardDevice();
+
+    pWin = LookupWindow(stuff->grabWindow, client);
+    if (!pWin)
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
+	    BadWindow);
+	return Success;
+	}
+
+    if ((stuff->modifiers != AnyModifier) &&
+	(stuff->modifiers & ~AllModifiersMask))
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
+	    BadValue);
+	return Success;
+	}
+
+    temporaryGrab.resource = client->clientAsMask;
+    temporaryGrab.device = dev;
+    temporaryGrab.window = pWin;
+    temporaryGrab.type = DeviceButtonPress;
+    temporaryGrab.modifierDevice = mdev;
+    temporaryGrab.modifiersDetail.exact = stuff->modifiers;
+    temporaryGrab.modifiersDetail.pMask = NULL;
+    temporaryGrab.detail.exact = stuff->button;
+    temporaryGrab.detail.pMask = NULL;
+
+    DeletePassiveGrabFromList(&temporaryGrab);
+    return Success;
+    }
diff --git a/Xi/ungrdevk.c b/Xi/ungrdevk.c
new file mode 100644
index 000000000..26c75f365
--- /dev/null
+++ b/Xi/ungrdevk.c
@@ -0,0 +1,178 @@
+/* $Xorg: ungrdevk.c,v 1.4 2001/02/09 02:04:35 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.
+
+********************************************************/
+
+/***********************************************************************
+ *
+ * Request to release a grab of a key on an extension device.
+ *
+ */
+
+#define	 NEED_EVENTS
+#define	 NEED_REPLIES
+#include "X.h"				/* for inputstr.h    */
+#include "Xproto.h"			/* Request macro     */
+#include "inputstr.h"			/* DeviceIntPtr	     */
+#include "windowstr.h"			/* window structure  */
+#include "XI.h"
+#include "XIproto.h"
+
+#define AllModifiersMask ( \
+	ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | \
+	Mod3Mask | Mod4Mask | Mod5Mask )
+extern	int 	IReqCode;
+extern	int	BadDevice;
+extern	void	(* ReplySwapVector[256]) ();
+extern	int	DeviceKeyPress;
+DeviceIntPtr	LookupDeviceIntRec();
+
+/***********************************************************************
+ *
+ * Handle requests from a client with a different byte order.
+ *
+ */
+
+int
+SProcXUngrabDeviceKey(client)
+    register ClientPtr client;
+    {
+    register char n;
+
+    REQUEST(xUngrabDeviceKeyReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->modifiers, n);
+    return(ProcXUngrabDeviceKey(client));
+    }
+
+/***********************************************************************
+ *
+ * Release a grab of a key on an extension device.
+ *
+ */
+
+int
+ProcXUngrabDeviceKey(client)
+    ClientPtr client;
+    {
+    DeviceIntPtr	dev;
+    DeviceIntPtr	mdev;
+    WindowPtr 		pWin;
+    GrabRec 		temporaryGrab;
+
+    REQUEST(xUngrabDeviceKeyReq);
+    REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq);
+
+    dev = LookupDeviceIntRec (stuff->grabbed_device);
+    if (dev == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
+	    BadDevice);
+	return Success;
+	}
+    if (dev->key == NULL)
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch);
+	return Success;
+	}
+
+    if (stuff->modifier_device != UseXKeyboard)
+	{
+	mdev = LookupDeviceIntRec (stuff->modifier_device);
+	if (mdev == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
+	        BadDevice);
+	    return Success;
+	    }
+	if (mdev->key == NULL)
+	    {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
+		BadMatch);
+	    return Success;
+	    }
+	}
+    else
+	mdev = (DeviceIntPtr) LookupKeyboardDevice();
+
+    pWin = LookupWindow(stuff->grabWindow, client);
+    if (!pWin)
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
+	    BadWindow);
+	return Success;
+	}
+    if (((stuff->key > dev->key->curKeySyms.maxKeyCode) ||
+	 (stuff->key < dev->key->curKeySyms.minKeyCode))
+	&& (stuff->key != AnyKey))
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
+	    BadValue);
+	return Success;
+	}
+    if ((stuff->modifiers != AnyModifier) &&
+	(stuff->modifiers & ~AllModifiersMask))
+	{
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
+	    BadValue);
+	return Success;
+	}
+
+    temporaryGrab.resource = client->clientAsMask;
+    temporaryGrab.device = dev;
+    temporaryGrab.window = pWin;
+    temporaryGrab.type  = DeviceKeyPress;
+    temporaryGrab.modifierDevice = mdev;
+    temporaryGrab.modifiersDetail.exact = stuff->modifiers;
+    temporaryGrab.modifiersDetail.pMask = NULL;
+    temporaryGrab.detail.exact = stuff->key;
+    temporaryGrab.detail.pMask = NULL;
+
+    DeletePassiveGrabFromList(&temporaryGrab);
+    return Success;
+    }