xserver git update 9/5/2010

3 files changed, 2742 insertions, 2729 deletions

diff --git a/xorg-server/Xi/extinit.c b/xorg-server/Xi/extinit.c
index b7910cd13..07057377a 100644
--- a/xorg-server/Xi/extinit.c
+++ b/xorg-server/Xi/extinit.c
@@ -1,1310 +1,1311 @@
-/************************************************************
-
-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
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "inputstr.h"
-#include "gcstruct.h"	/* pointer for extnsionst.h */
-#include "extnsionst.h"	/* extension entry   */
-#include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>
-#include <X11/extensions/XI2proto.h>
-#include <X11/extensions/geproto.h>
-#include "geext.h" /* extension interfaces for ge */
-
-#include "dixevents.h"
-#include "exevents.h"
-#include "extinit.h"
-#include "exglobals.h"
-#include "swaprep.h"
-#include "privates.h"
-#include "protocol-versions.h"
-
-/* modules local to Xi */
-#include "allowev.h"
-#include "chgdctl.h"
-#include "chgfctl.h"
-#include "chgkbd.h"
-#include "chgprop.h"
-#include "chgptr.h"
-#include "closedev.h"
-#include "devbell.h"
-#include "getbmap.h"
-#include "getbmap.h"
-#include "getdctl.h"
-#include "getfctl.h"
-#include "getfocus.h"
-#include "getkmap.h"
-#include "getmmap.h"
-#include "getprop.h"
-#include "getselev.h"
-#include "getvers.h"
-#include "getvers.h"
-#include "grabdev.h"
-#include "grabdevb.h"
-#include "grabdevk.h"
-#include "gtmotion.h"
-#include "listdev.h"
-#include "opendev.h"
-#include "queryst.h"
-#include "selectev.h"
-#include "sendexev.h"
-#include "chgkmap.h"
-#include "setbmap.h"
-#include "setdval.h"
-#include "setfocus.h"
-#include "setmmap.h"
-#include "setmode.h"
-#include "ungrdev.h"
-#include "ungrdevb.h"
-#include "ungrdevk.h"
-#include "xiallowev.h"
-#include "xiselectev.h"
-#include "xigrabdev.h"
-#include "xipassivegrab.h"
-#include "xisetdevfocus.h"
-#include "xiproperty.h"
-#include "xichangecursor.h"
-#include "xichangehierarchy.h"
-#include "xigetclientpointer.h"
-#include "xiquerydevice.h"
-#include "xiquerypointer.h"
-#include "xiqueryversion.h"
-#include "xisetclientpointer.h"
-#include "xiwarppointer.h"
-
-
-/* Masks for XI events have to be aligned with core event (partially anyway).
- * If DeviceButtonMotionMask is != ButtonMotionMask, event delivery
- * breaks down. The device needs the dev->button->motionMask. If DBMM is
- * the same as BMM, we can ensure that both core and device events can be
- * delivered, without the need for extra structures in the DeviceIntRec. */
-const Mask DeviceKeyPressMask             = KeyPressMask;
-const Mask DeviceKeyReleaseMask           = KeyReleaseMask;
-const Mask DeviceButtonPressMask          = ButtonPressMask;
-const Mask DeviceButtonReleaseMask        = ButtonReleaseMask;
-const Mask DeviceProximityMask            = (1L << 4);
-const Mask DeviceStateNotifyMask          = (1L << 5);
-const Mask DevicePointerMotionMask        = PointerMotionMask;
-const Mask DevicePointerMotionHintMask    = PointerMotionHintMask;
-const Mask DeviceButton1MotionMask        = Button1MotionMask;
-const Mask DeviceButton2MotionMask        = Button2MotionMask;
-const Mask DeviceButton3MotionMask        = Button3MotionMask;
-const Mask DeviceButton4MotionMask        = Button4MotionMask;
-const Mask DeviceButton5MotionMask        = Button5MotionMask;
-const Mask DeviceButtonMotionMask         = ButtonMotionMask;
-const Mask DeviceFocusChangeMask          = (1L << 14);
-const Mask DeviceMappingNotifyMask        = (1L << 15);
-const Mask ChangeDeviceNotifyMask         = (1L << 16);
-const Mask DeviceButtonGrabMask           = (1L << 17);
-const Mask DeviceOwnerGrabButtonMask      = (1L << 17);
-const Mask DevicePresenceNotifyMask       = (1L << 18);
-const Mask DeviceEnterWindowMask          = (1L << 18);
-const Mask DeviceLeaveWindowMask          = (1L << 19);
-const Mask DevicePropertyNotifyMask       = (1L << 20);
-const Mask XIAllMasks                     = (1L << 21) - 1;
-
-int ExtEventIndex;
-Mask ExtExclusiveMasks[EMASKSIZE];
-
-static 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];
-
-static DeviceIntRec xi_all_devices;
-static DeviceIntRec xi_all_master_devices;
-
-/**
- * Dispatch vector. Functions defined in here will be called when the matching
- * request arrives.
- */
-static int (*ProcIVector[])(ClientPtr) = {
-        NULL,                                   /*  0 */
-	ProcXGetExtensionVersion,               /*  1 */
-	ProcXListInputDevices,                  /*  2 */
-	ProcXOpenDevice,                        /*  3 */
-	ProcXCloseDevice,                       /*  4 */
-	ProcXSetDeviceMode,                     /*  5 */
-	ProcXSelectExtensionEvent,              /*  6 */
-	ProcXGetSelectedExtensionEvents,        /*  7 */
-	ProcXChangeDeviceDontPropagateList,     /*  8 */
-	ProcXGetDeviceDontPropagateList,        /*  9 */
-	ProcXGetDeviceMotionEvents,             /* 10 */
-	ProcXChangeKeyboardDevice,              /* 11 */
-	ProcXChangePointerDevice,               /* 12 */
-	ProcXGrabDevice,                        /* 13 */
-	ProcXUngrabDevice,                      /* 14 */
-	ProcXGrabDeviceKey,                     /* 15 */
-	ProcXUngrabDeviceKey,                   /* 16 */
-	ProcXGrabDeviceButton,                  /* 17 */
-	ProcXUngrabDeviceButton,                /* 18 */
-	ProcXAllowDeviceEvents,                 /* 19 */
-	ProcXGetDeviceFocus,                    /* 20 */
-	ProcXSetDeviceFocus,                    /* 21 */
-	ProcXGetFeedbackControl,                /* 22 */
-	ProcXChangeFeedbackControl,             /* 23 */
-	ProcXGetDeviceKeyMapping,               /* 24 */
-	ProcXChangeDeviceKeyMapping,            /* 25 */
-	ProcXGetDeviceModifierMapping,          /* 26 */
-	ProcXSetDeviceModifierMapping,          /* 27 */
-	ProcXGetDeviceButtonMapping,            /* 28 */
-	ProcXSetDeviceButtonMapping,            /* 29 */
-	ProcXQueryDeviceState,                  /* 30 */
-	ProcXSendExtensionEvent,                /* 31 */
-	ProcXDeviceBell,                        /* 32 */
-	ProcXSetDeviceValuators,                /* 33 */
-	ProcXGetDeviceControl,                  /* 34 */
-	ProcXChangeDeviceControl,               /* 35 */
-        /* XI 1.5 */
-        ProcXListDeviceProperties,              /* 36 */
-        ProcXChangeDeviceProperty,              /* 37 */
-        ProcXDeleteDeviceProperty,              /* 38 */
-        ProcXGetDeviceProperty,                 /* 39 */
-        /* XI 2 */
-        ProcXIQueryPointer,                     /* 40 */
-        ProcXIWarpPointer,                      /* 41 */
-        ProcXIChangeCursor,                     /* 42 */
-        ProcXIChangeHierarchy,                  /* 43 */
-        ProcXISetClientPointer,                 /* 44 */
-        ProcXIGetClientPointer,                 /* 45 */
-        ProcXISelectEvents,                     /* 46 */
-        ProcXIQueryVersion,                     /* 47 */
-        ProcXIQueryDevice,                      /* 48 */
-        ProcXISetFocus,                         /* 49 */
-        ProcXIGetFocus,                         /* 50 */
-        ProcXIGrabDevice,                       /* 51 */
-        ProcXIUngrabDevice,                     /* 52 */
-        ProcXIAllowEvents,                      /* 53 */
-        ProcXIPassiveGrabDevice,                /* 54 */
-        ProcXIPassiveUngrabDevice,              /* 55 */
-        ProcXIListProperties,                   /* 56 */
-        ProcXIChangeProperty,                   /* 57 */
-        ProcXIDeleteProperty,                   /* 58 */
-        ProcXIGetProperty,                      /* 59 */
-        ProcXIGetSelectedEvents                 /* 60 */
-};
-
-/* For swapped clients */
-static int (*SProcIVector[])(ClientPtr) = {
-        NULL,                                    /*  0 */
-	SProcXGetExtensionVersion,               /*  1 */
-	SProcXListInputDevices,                  /*  2 */
-	SProcXOpenDevice,                        /*  3 */
-	SProcXCloseDevice,                       /*  4 */
-	SProcXSetDeviceMode,                     /*  5 */
-	SProcXSelectExtensionEvent,              /*  6 */
-	SProcXGetSelectedExtensionEvents,        /*  7 */
-	SProcXChangeDeviceDontPropagateList,     /*  8 */
-	SProcXGetDeviceDontPropagateList,        /*  9 */
-	SProcXGetDeviceMotionEvents,             /* 10 */
-	SProcXChangeKeyboardDevice,              /* 11 */
-	SProcXChangePointerDevice,               /* 12 */
-	SProcXGrabDevice,                        /* 13 */
-	SProcXUngrabDevice,                      /* 14 */
-	SProcXGrabDeviceKey,                     /* 15 */
-	SProcXUngrabDeviceKey,                   /* 16 */
-	SProcXGrabDeviceButton,                  /* 17 */
-	SProcXUngrabDeviceButton,                /* 18 */
-	SProcXAllowDeviceEvents,                 /* 19 */
-	SProcXGetDeviceFocus,                    /* 20 */
-	SProcXSetDeviceFocus,                    /* 21 */
-	SProcXGetFeedbackControl,                /* 22 */
-	SProcXChangeFeedbackControl,             /* 23 */
-	SProcXGetDeviceKeyMapping,               /* 24 */
-	SProcXChangeDeviceKeyMapping,            /* 25 */
-	SProcXGetDeviceModifierMapping,          /* 26 */
-	SProcXSetDeviceModifierMapping,          /* 27 */
-	SProcXGetDeviceButtonMapping,            /* 28 */
-	SProcXSetDeviceButtonMapping,            /* 29 */
-	SProcXQueryDeviceState,                  /* 30 */
-	SProcXSendExtensionEvent,                /* 31 */
-	SProcXDeviceBell,                        /* 32 */
-	SProcXSetDeviceValuators,                /* 33 */
-	SProcXGetDeviceControl,                  /* 34 */
-	SProcXChangeDeviceControl,               /* 35 */
-        SProcXListDeviceProperties,              /* 36 */
-        SProcXChangeDeviceProperty,              /* 37 */
-        SProcXDeleteDeviceProperty,              /* 38 */
-        SProcXGetDeviceProperty,                 /* 39 */
-        SProcXIQueryPointer,                     /* 40 */
-        SProcXIWarpPointer,                      /* 41 */
-        SProcXIChangeCursor,                     /* 42 */
-        SProcXIChangeHierarchy,                  /* 43 */
-        SProcXISetClientPointer,                 /* 44 */
-        SProcXIGetClientPointer,                 /* 45 */
-        SProcXISelectEvents,                     /* 46 */
-        SProcXIQueryVersion,                     /* 47 */
-        SProcXIQueryDevice,                      /* 48 */
-        SProcXISetFocus,                         /* 49 */
-        SProcXIGetFocus,                         /* 50 */
-        SProcXIGrabDevice,                       /* 51 */
-        SProcXIUngrabDevice,                     /* 52 */
-        SProcXIAllowEvents,                      /* 53 */
-        SProcXIPassiveGrabDevice,                /* 54 */
-        SProcXIPassiveUngrabDevice,              /* 55 */
-        SProcXIListProperties,                   /* 56 */
-        SProcXIChangeProperty,                   /* 57 */
-        SProcXIDeleteProperty,                   /* 58 */
-        SProcXIGetProperty,                      /* 59 */
-        SProcXIGetSelectedEvents                 /* 60 */
-};
-
-/*****************************************************************
- *
- * Globals referenced elsewhere in the server.
- *
- */
-
-int IReqCode = 0;
-int IEventBase = 0;
-int BadDevice = 0;
-static int BadEvent = 1;
-int BadMode = 2;
-int DeviceBusy = 3;
-int BadClass = 4;
-
-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 DevicePresenceNotify;
-int DevicePropertyNotify;
-
-int RT_INPUTCLIENT;
-
-/*****************************************************************
- *
- * Externs defined elsewhere in the X server.
- *
- */
-
-extern XExtensionVersion XIVersion;
-
-
-Mask PropagateMask[MAXDEVICES];
-
-/*****************************************************************
- *
- * Versioning support
- *
- */
-
-static int XIClientPrivateKeyIndex;
-DevPrivateKey XIClientPrivateKey = &XIClientPrivateKeyIndex;
-
-
-/*****************************************************************
- *
- * Declarations of local routines.
- *
- */
-
-static void
-XIClientCallback(CallbackListPtr        *list,
-                 pointer                closure,
-                 pointer                data)
-{
-    NewClientInfoRec *clientinfo = (NewClientInfoRec*)data;
-    ClientPtr pClient = clientinfo->client;
-    XIClientPtr pXIClient;
-
-    pXIClient = dixLookupPrivate(&pClient->devPrivates, XIClientPrivateKey);
-    pXIClient->major_version = 0;
-    pXIClient->minor_version = 0;
-}
-
-/*************************************************************************
- *
- * ProcIDispatch - main dispatch routine for requests to this extension.
- * This routine is used if server and client have the same byte ordering.
- *
- */
-
-static int
-ProcIDispatch(ClientPtr client)
-{
-    REQUEST(xReq);
-    if (stuff->data > (IREQUESTS + XI2REQUESTS) || !ProcIVector[stuff->data])
-        return BadRequest;
-
-    return (*ProcIVector[stuff->data])(client);
-}
-
-/*******************************************************************************
- *
- * 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.
- *
- */
-
-static int
-SProcIDispatch(ClientPtr client)
-{
-    REQUEST(xReq);
-    if (stuff->data > IREQUESTS || !SProcIVector[stuff->data])
-        return BadRequest;
-
-    return (*SProcIVector[stuff->data])(client);
-}
-
-/**********************************************************************
- *
- * SReplyIDispatch
- * Swap any replies defined in this extension.
- *
- */
-
-static void
-SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
-					/* All we look at is the type field */
-{	/* This is common to all replies    */
-    if (rep->RepType == X_GetExtensionVersion)
-	SRepXGetExtensionVersion(client, len,
-				 (xGetExtensionVersionReply *) rep);
-    else if (rep->RepType == X_ListInputDevices)
-	SRepXListInputDevices(client, len, (xListInputDevicesReply *) rep);
-    else if (rep->RepType == X_OpenDevice)
-	SRepXOpenDevice(client, len, (xOpenDeviceReply *) rep);
-    else if (rep->RepType == X_SetDeviceMode)
-	SRepXSetDeviceMode(client, len, (xSetDeviceModeReply *) rep);
-    else if (rep->RepType == X_GetSelectedExtensionEvents)
-	SRepXGetSelectedExtensionEvents(client, len,
-					(xGetSelectedExtensionEventsReply *)
-					rep);
-    else if (rep->RepType == X_GetDeviceDontPropagateList)
-	SRepXGetDeviceDontPropagateList(client, len,
-					(xGetDeviceDontPropagateListReply *)
-					rep);
-    else if (rep->RepType == X_GetDeviceMotionEvents)
-	SRepXGetDeviceMotionEvents(client, len,
-				   (xGetDeviceMotionEventsReply *) rep);
-    else if (rep->RepType == X_GrabDevice)
-	SRepXGrabDevice(client, len, (xGrabDeviceReply *) rep);
-    else if (rep->RepType == X_GetDeviceFocus)
-	SRepXGetDeviceFocus(client, len, (xGetDeviceFocusReply *) rep);
-    else if (rep->RepType == X_GetFeedbackControl)
-	SRepXGetFeedbackControl(client, len, (xGetFeedbackControlReply *) rep);
-    else if (rep->RepType == X_GetDeviceKeyMapping)
-	SRepXGetDeviceKeyMapping(client, len,
-				 (xGetDeviceKeyMappingReply *) rep);
-    else if (rep->RepType == X_GetDeviceModifierMapping)
-	SRepXGetDeviceModifierMapping(client, len,
-				      (xGetDeviceModifierMappingReply *) rep);
-    else if (rep->RepType == X_SetDeviceModifierMapping)
-	SRepXSetDeviceModifierMapping(client, len,
-				      (xSetDeviceModifierMappingReply *) rep);
-    else if (rep->RepType == X_GetDeviceButtonMapping)
-	SRepXGetDeviceButtonMapping(client, len,
-				    (xGetDeviceButtonMappingReply *) rep);
-    else if (rep->RepType == X_SetDeviceButtonMapping)
-	SRepXSetDeviceButtonMapping(client, len,
-				    (xSetDeviceButtonMappingReply *) rep);
-    else if (rep->RepType == X_QueryDeviceState)
-	SRepXQueryDeviceState(client, len, (xQueryDeviceStateReply *) rep);
-    else if (rep->RepType == X_SetDeviceValuators)
-	SRepXSetDeviceValuators(client, len, (xSetDeviceValuatorsReply *) rep);
-    else if (rep->RepType == X_GetDeviceControl)
-	SRepXGetDeviceControl(client, len, (xGetDeviceControlReply *) rep);
-    else if (rep->RepType == X_ChangeDeviceControl)
-	SRepXChangeDeviceControl(client, len,
-				 (xChangeDeviceControlReply *) rep);
-    else if (rep->RepType == X_ListDeviceProperties)
-        SRepXListDeviceProperties(client, len, (xListDevicePropertiesReply*)rep);
-    else if (rep->RepType == X_GetDeviceProperty)
-	SRepXGetDeviceProperty(client, len, (xGetDevicePropertyReply *) rep);
-    else if (rep->RepType == X_XIQueryPointer)
-	SRepXIQueryPointer(client, len, (xXIQueryPointerReply *) rep);
-    else if (rep->RepType == X_XIGetClientPointer)
-        SRepXIGetClientPointer(client, len, (xXIGetClientPointerReply*) rep);
-    else if (rep->RepType == X_XIQueryVersion)
-        SRepXIQueryVersion(client, len, (xXIQueryVersionReply*)rep);
-    else if (rep->RepType == X_XIQueryDevice)
-        SRepXIQueryDevice(client, len, (xXIQueryDeviceReply*)rep);
-    else if (rep->RepType == X_XIGrabDevice)
-	SRepXIGrabDevice(client, len, (xXIGrabDeviceReply *) rep);
-    else if (rep->RepType == X_XIGrabDevice)
-	SRepXIPassiveGrabDevice(client, len, (xXIPassiveGrabDeviceReply *) rep);
-    else if (rep->RepType == X_XIListProperties)
-	SRepXIListProperties(client, len, (xXIListPropertiesReply *) rep);
-    else if (rep->RepType == X_XIGetProperty)
-	SRepXIGetProperty(client, len, (xXIGetPropertyReply *) rep);
-    else if (rep->RepType == X_XIGetSelectedEvents)
-	SRepXIGetSelectedEvents(client, len, (xXIGetSelectedEventsReply *) rep);
-    else if (rep->RepType == X_XIGetFocus)
-	SRepXIGetFocus(client, len, (xXIGetFocusReply *) rep);
-    else {
-	FatalError("XINPUT confused sending swapped reply");
-    }
-}
-
-/************************************************************************
- *
- * This function swaps the DeviceValuator event.
- *
- */
-
-static void
-SEventDeviceValuator(deviceValuator * from, deviceValuator * to)
-{
-    char n;
-    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      */
-    }
-}
-
-static void
-SEventFocus(deviceFocus * from, deviceFocus * to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->time, n);
-    swapl(&to->window, n);
-}
-
-static void
-SDeviceStateNotifyEvent(deviceStateNotify * from, deviceStateNotify * to)
-{
-    int i;
-    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      */
-    }
-}
-
-static void
-SDeviceKeyStateNotifyEvent(deviceKeyStateNotify * from,
-			   deviceKeyStateNotify * to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber, n);
-}
-
-static void
-SDeviceButtonStateNotifyEvent(deviceButtonStateNotify * from,
-			      deviceButtonStateNotify * to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber, n);
-}
-
-static void
-SChangeDeviceNotifyEvent(changeDeviceNotify * from, changeDeviceNotify * to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->time, n);
-}
-
-static void
-SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->time, n);
-}
-
-static void
-SDevicePresenceNotifyEvent (devicePresenceNotify *from, devicePresenceNotify *to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swapl(&to->time, n);
-    swaps(&to->control, n);
-}
-
-static void
-SDevicePropertyNotifyEvent (devicePropertyNotify *from, devicePropertyNotify *to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swapl(&to->time, n);
-    swapl(&to->atom, n);
-}
-
-static void
-SDeviceLeaveNotifyEvent (xXILeaveEvent *from, xXILeaveEvent *to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swapl(&to->length, n);
-    swaps(&to->evtype, n);
-    swaps(&to->deviceid, n);
-    swapl(&to->time, n);
-    swapl(&to->root, n);
-    swapl(&to->event, n);
-    swapl(&to->child, n);
-    swapl(&to->root_x, n);
-    swapl(&to->root_y, n);
-    swapl(&to->event_x, n);
-    swapl(&to->event_y, n);
-    swaps(&to->sourceid, n);
-    swaps(&to->buttons_len, n);
-    swapl(&to->mods.base_mods, n);
-    swapl(&to->mods.latched_mods, n);
-    swapl(&to->mods.locked_mods, n);
-}
-
-static void
-SDeviceChangedEvent(xXIDeviceChangedEvent* from, xXIDeviceChangedEvent* to)
-{
-    char n;
-    int i, j;
-    xXIAnyInfo *any;
-
-    *to = *from;
-    memcpy(&to[1], &from[1], from->length * 4);
-
-    any = (xXIAnyInfo*)&to[1];
-    for (i = 0; i < to->num_classes; i++)
-    {
-        int length = any->length;
-
-        switch(any->type)
-        {
-            case KeyClass:
-                {
-                    xXIKeyInfo *ki = (xXIKeyInfo*)any;
-                    uint32_t *key = (uint32_t*)&ki[1];
-                    for (j = 0; j < ki->num_keycodes; j++, key++)
-                        swapl(key, n);
-                    swaps(&ki->num_keycodes, n);
-                }
-                break;
-            case ButtonClass:
-                {
-                    xXIButtonInfo *bi = (xXIButtonInfo*)any;
-                    Atom *labels = (Atom*)((char*)bi + sizeof(xXIButtonInfo) +
-                                           pad_to_int32(bits_to_bytes(bi->num_buttons)));
-                    for (j = 0; j < bi->num_buttons; j++)
-                        swapl(&labels[j], n);
-                    swaps(&bi->num_buttons, n);
-                }
-                break;
-            case ValuatorClass:
-                {
-                    xXIValuatorInfo* ai = (xXIValuatorInfo*)any;
-                    swapl(&ai->label, n);
-                    swapl(&ai->min.integral, n);
-                    swapl(&ai->min.frac, n);
-                    swapl(&ai->max.integral, n);
-                    swapl(&ai->max.frac, n);
-                    swapl(&ai->resolution, n);
-                    swaps(&ai->number, n);
-                }
-                break;
-        }
-
-        swaps(&any->type, n);
-        swaps(&any->length, n);
-        swaps(&any->sourceid, n);
-
-        any = (xXIAnyInfo*)((char*)any + length * 4);
-    }
-
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->length, n);
-    swaps(&to->evtype, n);
-    swaps(&to->deviceid, n);
-    swapl(&to->time, n);
-    swaps(&to->num_classes, n);
-    swaps(&to->sourceid, n);
-
-}
-
-static void SDeviceEvent(xXIDeviceEvent *from, xXIDeviceEvent *to)
-{
-    int i;
-    char n;
-    char *ptr;
-    char *vmask;
-
-    memcpy(to, from, sizeof(xEvent) + from->length * 4);
-
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->length, n);
-    swaps(&to->evtype, n);
-    swaps(&to->deviceid, n);
-    swapl(&to->time, n);
-    swapl(&to->detail, n);
-    swapl(&to->root, n);
-    swapl(&to->event, n);
-    swapl(&to->child, n);
-    swapl(&to->root_x, n);
-    swapl(&to->root_y, n);
-    swapl(&to->event_x, n);
-    swapl(&to->event_y, n);
-    swaps(&to->buttons_len, n);
-    swaps(&to->valuators_len, n);
-    swaps(&to->sourceid, n);
-    swapl(&to->mods.base_mods, n);
-    swapl(&to->mods.latched_mods, n);
-    swapl(&to->mods.locked_mods, n);
-    swapl(&to->mods.effective_mods, n);
-
-    ptr = (char*)(&to[1]);
-    ptr += from->buttons_len * 4;
-    vmask = ptr; /* valuator mask */
-    ptr += from->valuators_len * 4;
-    for (i = 0; i < from->valuators_len * 32; i++)
-    {
-        if (BitIsOn(vmask, i))
-        {
-            swapl(((uint32_t*)ptr), n);
-            ptr += 4;
-            swapl(((uint32_t*)ptr), n);
-            ptr += 4;
-        }
-    }
-}
-
-static void SDeviceHierarchyEvent(xXIHierarchyEvent *from,
-                                  xXIHierarchyEvent *to)
-{
-    int i;
-    char n;
-    xXIHierarchyInfo *info;
-
-    *to = *from;
-    memcpy(&to[1], &from[1], from->length * 4);
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->length, n);
-    swaps(&to->evtype, n);
-    swaps(&to->deviceid, n);
-    swapl(&to->time, n);
-    swapl(&to->flags, n);
-    swaps(&to->num_info, n);
-
-    info = (xXIHierarchyInfo*)&to[1];
-    for (i = 0; i< from->num_info; i++)
-    {
-        swaps(&info->deviceid, n);
-        swaps(&info->attachment, n);
-        info++;
-    }
-}
-
-static void SXIPropertyEvent(xXIPropertyEvent *from, xXIPropertyEvent *to)
-{
-    char n;
-
-    *to = *from;
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->length, n);
-    swaps(&to->evtype, n);
-    swaps(&to->deviceid, n);
-    swapl(&to->property, n);
-}
-
-static void SRawEvent(xXIRawEvent *from, xXIRawEvent *to)
-{
-    char n;
-    int i;
-    FP3232 *values;
-    unsigned char *mask;
-
-    memcpy(to, from, sizeof(xEvent) + from->length * 4);
-
-    swaps(&to->sequenceNumber, n);
-    swapl(&to->length, n);
-    swaps(&to->evtype, n);
-    swaps(&to->deviceid, n);
-    swapl(&to->time, n);
-    swapl(&to->detail, n);
-
-
-    mask = (unsigned char*)&to[1];
-    values = (FP3232*)(mask + from->valuators_len * 4);
-
-    for (i = 0; i < from->valuators_len * 4 * 8; i++)
-    {
-        if (BitIsOn(mask, i))
-        {
-            /* for each bit set there are two FP3232 values on the wire, in
-             * the order abcABC for data and data_raw. Here we swap as if
-             * they were in aAbBcC order because it's easier and really
-             * doesn't matter.
-             */
-            swapl(&values->integral, n);
-            swapl(&values->frac, n);
-            values++;
-            swapl(&values->integral, n);
-            swapl(&values->frac, n);
-            values++;
-        }
-    }
-
-    swaps(&to->valuators_len, n);
-}
-
-
-/** Event swapping function for XI2 events. */
-void
-XI2EventSwap(xGenericEvent *from, xGenericEvent *to)
-{
-    switch(from->evtype)
-    {
-        case XI_Enter:
-        case XI_Leave:
-            SDeviceLeaveNotifyEvent((xXILeaveEvent*)from, (xXILeaveEvent*)to);
-            break;
-        case XI_DeviceChanged:
-            SDeviceChangedEvent((xXIDeviceChangedEvent*)from,
-                                (xXIDeviceChangedEvent*)to);
-            break;
-        case XI_HierarchyChanged:
-            SDeviceHierarchyEvent((xXIHierarchyEvent*)from, (xXIHierarchyEvent*)to);
-            break;
-        case XI_PropertyEvent:
-            SXIPropertyEvent((xXIPropertyEvent*)from,
-                           (xXIPropertyEvent*)to);
-            break;
-        case XI_Motion:
-        case XI_KeyPress:
-        case XI_KeyRelease:
-        case XI_ButtonPress:
-        case XI_ButtonRelease:
-            SDeviceEvent((xXIDeviceEvent*)from, (xXIDeviceEvent*)to);
-            break;
-        case XI_RawMotion:
-        case XI_RawKeyPress:
-        case XI_RawKeyRelease:
-        case XI_RawButtonPress:
-        case XI_RawButtonRelease:
-            SRawEvent((xXIRawEvent*)from, (xXIRawEvent*)to);
-            break;
-        default:
-            ErrorF("[Xi] Unknown event type to swap. This is a bug.\n");
-            break;
-    }
-}
-
-/**************************************************************************
- *
- * Allow the specified event to have its propagation suppressed.
- * The default is to not allow suppression of propagation.
- *
- */
-
-static void
-AllowPropagateSuppress(Mask mask)
-{
-    int i;
-
-    for (i = 0; i < MAXDEVICES; i++)
-	PropagateMask[i] |= mask;
-}
-
-/**************************************************************************
- *
- * 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.
- *
- */
-
-static void
-SetEventInfo(Mask mask, int constant)
-{
-    EventInfo[ExtEventIndex].mask = mask;
-    EventInfo[ExtEventIndex++].type = constant;
-}
-
-/**************************************************************************
- *
- * 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.
- *
- */
-
-static void
-SetExclusiveAccess(Mask mask)
-{
-    int i;
-
-    for (i = 0; i < MAXDEVICES; i++)
-	ExtExclusiveMasks[i] |= mask;
-}
-
-/**************************************************************************
- *
- * Assign the specified mask to the specified event.
- *
- */
-
-static void
-SetMaskForExtEvent(Mask mask, int event)
-{
-    int i;
-
-    EventInfo[ExtEventIndex].mask = mask;
-    EventInfo[ExtEventIndex++].type = event;
-
-    if ((event < LASTEvent) || (event >= 128))
-	FatalError("MaskForExtensionEvent: bogus event number");
-
-    for (i = 0; i < MAXDEVICES; i++)
-        SetMaskForEvent(i, mask, event);
-}
-
-/************************************************************************
- *
- * This function sets up extension event types and masks.
- *
- */
-
-static void
-FixExtensionEvents(ExtensionEntry * extEntry)
-{
-    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;
-    DevicePresenceNotify = DeviceButtonStateNotify + 1;
-    DevicePropertyNotify = DevicePresenceNotify + 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;
-
-    SetMaskForExtEvent(DeviceKeyPressMask, DeviceKeyPress);
-    AllowPropagateSuppress(DeviceKeyPressMask);
-    SetCriticalEvent(DeviceKeyPress);
-
-    SetMaskForExtEvent(DeviceKeyReleaseMask, DeviceKeyRelease);
-    AllowPropagateSuppress(DeviceKeyReleaseMask);
-    SetCriticalEvent(DeviceKeyRelease);
-
-    SetMaskForExtEvent(DeviceButtonPressMask, DeviceButtonPress);
-    AllowPropagateSuppress(DeviceButtonPressMask);
-    SetCriticalEvent(DeviceButtonPress);
-
-    SetMaskForExtEvent(DeviceButtonReleaseMask, DeviceButtonRelease);
-    AllowPropagateSuppress(DeviceButtonReleaseMask);
-    SetCriticalEvent(DeviceButtonRelease);
-
-    SetMaskForExtEvent(DeviceProximityMask, ProximityIn);
-    SetMaskForExtEvent(DeviceProximityMask, ProximityOut);
-
-    SetMaskForExtEvent(DeviceStateNotifyMask, DeviceStateNotify);
-
-    SetMaskForExtEvent(DevicePointerMotionMask, DeviceMotionNotify);
-    AllowPropagateSuppress(DevicePointerMotionMask);
-    SetCriticalEvent(DeviceMotionNotify);
-
-    SetEventInfo(DevicePointerMotionHintMask, _devicePointerMotionHint);
-    SetEventInfo(DeviceButton1MotionMask, _deviceButton1Motion);
-    SetEventInfo(DeviceButton2MotionMask, _deviceButton2Motion);
-    SetEventInfo(DeviceButton3MotionMask, _deviceButton3Motion);
-    SetEventInfo(DeviceButton4MotionMask, _deviceButton4Motion);
-    SetEventInfo(DeviceButton5MotionMask, _deviceButton5Motion);
-    SetEventInfo(DeviceButtonMotionMask, _deviceButtonMotion);
-
-    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusIn);
-    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusOut);
-
-    SetMaskForExtEvent(DeviceMappingNotifyMask, DeviceMappingNotify);
-    SetMaskForExtEvent(ChangeDeviceNotifyMask, ChangeDeviceNotify);
-
-    SetEventInfo(DeviceButtonGrabMask, _deviceButtonGrab);
-    SetExclusiveAccess(DeviceButtonGrabMask);
-
-    SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
-    SetEventInfo(DevicePresenceNotifyMask, _devicePresence);
-    SetMaskForExtEvent(DevicePropertyNotifyMask, DevicePropertyNotify);
-
-    SetEventInfo(0, _noExtensionEvent);
-}
-
-/************************************************************************
- *
- * This function restores extension event types and masks to their
- * initial state.
- *
- */
-
-static void
-RestoreExtensionEvents(void)
-{
-    int i, j;
-
-    IReqCode = 0;
-    IEventBase = 0;
-
-    for (i = 0; i < ExtEventIndex - 1; i++) {
-	if ((EventInfo[i].type >= LASTEvent) && (EventInfo[i].type < 128))
-        {
-            for (j = 0; j < MAXDEVICES; j++)
-                SetMaskForEvent(j, 0, EventInfo[i].type);
-        }
-	EventInfo[i].mask = 0;
-	EventInfo[i].type = 0;
-    }
-    ExtEventIndex = 0;
-    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;
-    DevicePresenceNotify = 14;
-    DevicePropertyNotify = 15;
-
-    BadDevice = 0;
-    BadEvent = 1;
-    BadMode = 2;
-    DeviceBusy = 3;
-    BadClass = 4;
-
-}
-
-/***********************************************************************
- *
- * IResetProc.
- * Remove reply-swapping routine.
- * Remove event-swapping routine.
- *
- */
-
-static void
-IResetProc(ExtensionEntry * unused)
-{
-
-    ReplySwapVector[IReqCode] = ReplyNotSwappd;
-    EventSwapVector[DeviceValuator] = NotImplemented;
-    EventSwapVector[DeviceKeyPress] = NotImplemented;
-    EventSwapVector[DeviceKeyRelease] = NotImplemented;
-    EventSwapVector[DeviceButtonPress] = NotImplemented;
-    EventSwapVector[DeviceButtonRelease] = NotImplemented;
-    EventSwapVector[DeviceMotionNotify] = NotImplemented;
-    EventSwapVector[DeviceFocusIn] = NotImplemented;
-    EventSwapVector[DeviceFocusOut] = NotImplemented;
-    EventSwapVector[ProximityIn] = NotImplemented;
-    EventSwapVector[ProximityOut] = NotImplemented;
-    EventSwapVector[DeviceStateNotify] = NotImplemented;
-    EventSwapVector[DeviceKeyStateNotify] = NotImplemented;
-    EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
-    EventSwapVector[DeviceMappingNotify] = NotImplemented;
-    EventSwapVector[ChangeDeviceNotify] = NotImplemented;
-    EventSwapVector[DevicePresenceNotify] = NotImplemented;
-    EventSwapVector[DevicePropertyNotify] = NotImplemented;
-    RestoreExtensionEvents();
-}
-
-
-/***********************************************************************
- *
- * Assign an id and type to an input device.
- *
- */
-
-void
-AssignTypeAndName(DeviceIntPtr dev, Atom type, char *name)
-{
-    dev->xinput_type = type;
-    dev->name = (char *)xalloc(strlen(name) + 1);
-    strcpy(dev->name, name);
-}
-
-/***********************************************************************
- *
- * Make device type atoms.
- *
- */
-
-static void
-MakeDeviceTypeAtoms(void)
-{
-    int i;
-
-    for (i = 0; i < NUMTYPES; i++)
-	dev_type[i].type =
-	    MakeAtom(dev_type[i].name, strlen(dev_type[i].name), 1);
-}
-
-/*****************************************************************************
- *
- *	SEventIDispatch
- *
- *	Swap any events defined in this extension.
- */
-#define DO_SWAP(func,type) func ((type *)from, (type *)to)
-
-static void
-SEventIDispatch(xEvent * from, xEvent * to)
-{
-    int type = from->u.u.type & 0177;
-
-    if (type == DeviceValuator)
-	DO_SWAP(SEventDeviceValuator, deviceValuator);
-    else if (type == DeviceKeyPress) {
-	SKeyButtonPtrEvent(from, to);
-	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-    } else if (type == DeviceKeyRelease) {
-	SKeyButtonPtrEvent(from, to);
-	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-    } else if (type == DeviceButtonPress) {
-	SKeyButtonPtrEvent(from, to);
-	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-    } else if (type == DeviceButtonRelease) {
-	SKeyButtonPtrEvent(from, to);
-	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-    } else if (type == DeviceMotionNotify) {
-	SKeyButtonPtrEvent(from, to);
-	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-    } else if (type == DeviceFocusIn)
-	DO_SWAP(SEventFocus, deviceFocus);
-    else if (type == DeviceFocusOut)
-	DO_SWAP(SEventFocus, deviceFocus);
-    else if (type == ProximityIn) {
-	SKeyButtonPtrEvent(from, to);
-	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-    } else if (type == ProximityOut) {
-	SKeyButtonPtrEvent(from, to);
-	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-    } else if (type == DeviceStateNotify)
-	DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
-    else if (type == DeviceKeyStateNotify)
-	DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
-    else if (type == DeviceButtonStateNotify)
-	DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
-    else if (type == DeviceMappingNotify)
-	DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
-    else if (type == ChangeDeviceNotify)
-	DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
-    else if (type == DevicePresenceNotify)
-	DO_SWAP(SDevicePresenceNotifyEvent, devicePresenceNotify);
-    else if (type == DevicePropertyNotify)
-	DO_SWAP(SDevicePropertyNotifyEvent, devicePropertyNotify);
-    else {
-	FatalError("XInputExtension: Impossible event!\n");
-    }
-}
-
-/**********************************************************************
- *
- * 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.
- *
- * XI is mandatory nowadays, so if we fail to init XI, we die.
- */
-
-void
-XInputExtensionInit(void)
-{
-    ExtensionEntry *extEntry;
-    XExtensionVersion thisversion = { XI_Present,
-        SERVER_XI_MAJOR_VERSION,
-        SERVER_XI_MINOR_VERSION,
-    };
-
-    if (!dixRequestPrivate(XIClientPrivateKey, sizeof(XIClientRec)))
-        FatalError("Cannot request private for XI.\n");
-
-    if (!AddCallback(&ClientStateCallback, XIClientCallback, 0))
-        FatalError("Failed to add callback to XI.\n");
-
-    extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,
-			    SProcIDispatch, IResetProc, StandardMinorOpcode);
-    if (extEntry) {
-	IReqCode = extEntry->base;
-	IEventBase = extEntry->eventBase;
-	XIVersion = thisversion;
-	MakeDeviceTypeAtoms();
-	RT_INPUTCLIENT = CreateNewResourceType((DeleteType) InputClientGone,
-					       "INPUTCLIENT");
-	if (!RT_INPUTCLIENT)
-	    FatalError("Failed to add resource type for XI.\n");
-	FixExtensionEvents(extEntry);
-	ReplySwapVector[IReqCode] = (ReplySwapPtr) SReplyIDispatch;
-	EventSwapVector[DeviceValuator] = SEventIDispatch;
-	EventSwapVector[DeviceKeyPress] = SEventIDispatch;
-	EventSwapVector[DeviceKeyRelease] = SEventIDispatch;
-	EventSwapVector[DeviceButtonPress] = SEventIDispatch;
-	EventSwapVector[DeviceButtonRelease] = SEventIDispatch;
-	EventSwapVector[DeviceMotionNotify] = SEventIDispatch;
-	EventSwapVector[DeviceFocusIn] = SEventIDispatch;
-	EventSwapVector[DeviceFocusOut] = SEventIDispatch;
-	EventSwapVector[ProximityIn] = SEventIDispatch;
-	EventSwapVector[ProximityOut] = SEventIDispatch;
-	EventSwapVector[DeviceStateNotify] = SEventIDispatch;
-	EventSwapVector[DeviceKeyStateNotify] = SEventIDispatch;
-	EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
-	EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
-	EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
-	EventSwapVector[DevicePresenceNotify] = SEventIDispatch;
-
-	GERegisterExtension(IReqCode, XI2EventSwap);
-
-
-	memset(&xi_all_devices, 0, sizeof(xi_all_devices));
-	memset(&xi_all_master_devices, 0, sizeof(xi_all_master_devices));
-	xi_all_devices.id = XIAllDevices;
-	xi_all_devices.name = "XIAllDevices";
-	xi_all_master_devices.id = XIAllMasterDevices;
-	xi_all_master_devices.name = "XIAllMasterDevices";
-
-	inputInfo.all_devices = &xi_all_devices;
-	inputInfo.all_master_devices = &xi_all_master_devices;
-    } else {
-	FatalError("IExtensionInit: AddExtensions failed\n");
-    }
-}
-
+/************************************************************

+

+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

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "inputstr.h"

+#include "gcstruct.h"	/* pointer for extnsionst.h */

+#include "extnsionst.h"	/* extension entry   */

+#include <X11/extensions/XI.h>

+#include <X11/extensions/XIproto.h>

+#include <X11/extensions/XI2proto.h>

+#include <X11/extensions/geproto.h>

+#include "geext.h" /* extension interfaces for ge */

+

+#include "dixevents.h"

+#include "exevents.h"

+#include "extinit.h"

+#include "exglobals.h"

+#include "swaprep.h"

+#include "privates.h"

+#include "protocol-versions.h"

+

+/* modules local to Xi */

+#include "allowev.h"

+#include "chgdctl.h"

+#include "chgfctl.h"

+#include "chgkbd.h"

+#include "chgprop.h"

+#include "chgptr.h"

+#include "closedev.h"

+#include "devbell.h"

+#include "getbmap.h"

+#include "getbmap.h"

+#include "getdctl.h"

+#include "getfctl.h"

+#include "getfocus.h"

+#include "getkmap.h"

+#include "getmmap.h"

+#include "getprop.h"

+#include "getselev.h"

+#include "getvers.h"

+#include "getvers.h"

+#include "grabdev.h"

+#include "grabdevb.h"

+#include "grabdevk.h"

+#include "gtmotion.h"

+#include "listdev.h"

+#include "opendev.h"

+#include "queryst.h"

+#include "selectev.h"

+#include "sendexev.h"

+#include "chgkmap.h"

+#include "setbmap.h"

+#include "setdval.h"

+#include "setfocus.h"

+#include "setmmap.h"

+#include "setmode.h"

+#include "ungrdev.h"

+#include "ungrdevb.h"

+#include "ungrdevk.h"

+#include "xiallowev.h"

+#include "xiselectev.h"

+#include "xigrabdev.h"

+#include "xipassivegrab.h"

+#include "xisetdevfocus.h"

+#include "xiproperty.h"

+#include "xichangecursor.h"

+#include "xichangehierarchy.h"

+#include "xigetclientpointer.h"

+#include "xiquerydevice.h"

+#include "xiquerypointer.h"

+#include "xiqueryversion.h"

+#include "xisetclientpointer.h"

+#include "xiwarppointer.h"

+

+

+/* Masks for XI events have to be aligned with core event (partially anyway).

+ * If DeviceButtonMotionMask is != ButtonMotionMask, event delivery

+ * breaks down. The device needs the dev->button->motionMask. If DBMM is

+ * the same as BMM, we can ensure that both core and device events can be

+ * delivered, without the need for extra structures in the DeviceIntRec. */

+const Mask DeviceKeyPressMask             = KeyPressMask;

+const Mask DeviceKeyReleaseMask           = KeyReleaseMask;

+const Mask DeviceButtonPressMask          = ButtonPressMask;

+const Mask DeviceButtonReleaseMask        = ButtonReleaseMask;

+const Mask DeviceProximityMask            = (1L << 4);

+const Mask DeviceStateNotifyMask          = (1L << 5);

+const Mask DevicePointerMotionMask        = PointerMotionMask;

+const Mask DevicePointerMotionHintMask    = PointerMotionHintMask;

+const Mask DeviceButton1MotionMask        = Button1MotionMask;

+const Mask DeviceButton2MotionMask        = Button2MotionMask;

+const Mask DeviceButton3MotionMask        = Button3MotionMask;

+const Mask DeviceButton4MotionMask        = Button4MotionMask;

+const Mask DeviceButton5MotionMask        = Button5MotionMask;

+const Mask DeviceButtonMotionMask         = ButtonMotionMask;

+const Mask DeviceFocusChangeMask          = (1L << 14);

+const Mask DeviceMappingNotifyMask        = (1L << 15);

+const Mask ChangeDeviceNotifyMask         = (1L << 16);

+const Mask DeviceButtonGrabMask           = (1L << 17);

+const Mask DeviceOwnerGrabButtonMask      = (1L << 17);

+const Mask DevicePresenceNotifyMask       = (1L << 18);

+const Mask DeviceEnterWindowMask          = (1L << 18);

+const Mask DeviceLeaveWindowMask          = (1L << 19);

+const Mask DevicePropertyNotifyMask       = (1L << 20);

+const Mask XIAllMasks                     = (1L << 21) - 1;

+

+int ExtEventIndex;

+Mask ExtExclusiveMasks[EMASKSIZE];

+

+static 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];

+

+static DeviceIntRec xi_all_devices;

+static DeviceIntRec xi_all_master_devices;

+

+/**

+ * Dispatch vector. Functions defined in here will be called when the matching

+ * request arrives.

+ */

+static int (*ProcIVector[])(ClientPtr) = {

+        NULL,                                   /*  0 */

+	ProcXGetExtensionVersion,               /*  1 */

+	ProcXListInputDevices,                  /*  2 */

+	ProcXOpenDevice,                        /*  3 */

+	ProcXCloseDevice,                       /*  4 */

+	ProcXSetDeviceMode,                     /*  5 */

+	ProcXSelectExtensionEvent,              /*  6 */

+	ProcXGetSelectedExtensionEvents,        /*  7 */

+	ProcXChangeDeviceDontPropagateList,     /*  8 */

+	ProcXGetDeviceDontPropagateList,        /*  9 */

+	ProcXGetDeviceMotionEvents,             /* 10 */

+	ProcXChangeKeyboardDevice,              /* 11 */

+	ProcXChangePointerDevice,               /* 12 */

+	ProcXGrabDevice,                        /* 13 */

+	ProcXUngrabDevice,                      /* 14 */

+	ProcXGrabDeviceKey,                     /* 15 */

+	ProcXUngrabDeviceKey,                   /* 16 */

+	ProcXGrabDeviceButton,                  /* 17 */

+	ProcXUngrabDeviceButton,                /* 18 */

+	ProcXAllowDeviceEvents,                 /* 19 */

+	ProcXGetDeviceFocus,                    /* 20 */

+	ProcXSetDeviceFocus,                    /* 21 */

+	ProcXGetFeedbackControl,                /* 22 */

+	ProcXChangeFeedbackControl,             /* 23 */

+	ProcXGetDeviceKeyMapping,               /* 24 */

+	ProcXChangeDeviceKeyMapping,            /* 25 */

+	ProcXGetDeviceModifierMapping,          /* 26 */

+	ProcXSetDeviceModifierMapping,          /* 27 */

+	ProcXGetDeviceButtonMapping,            /* 28 */

+	ProcXSetDeviceButtonMapping,            /* 29 */

+	ProcXQueryDeviceState,                  /* 30 */

+	ProcXSendExtensionEvent,                /* 31 */

+	ProcXDeviceBell,                        /* 32 */

+	ProcXSetDeviceValuators,                /* 33 */

+	ProcXGetDeviceControl,                  /* 34 */

+	ProcXChangeDeviceControl,               /* 35 */

+        /* XI 1.5 */

+        ProcXListDeviceProperties,              /* 36 */

+        ProcXChangeDeviceProperty,              /* 37 */

+        ProcXDeleteDeviceProperty,              /* 38 */

+        ProcXGetDeviceProperty,                 /* 39 */

+        /* XI 2 */

+        ProcXIQueryPointer,                     /* 40 */

+        ProcXIWarpPointer,                      /* 41 */

+        ProcXIChangeCursor,                     /* 42 */

+        ProcXIChangeHierarchy,                  /* 43 */

+        ProcXISetClientPointer,                 /* 44 */

+        ProcXIGetClientPointer,                 /* 45 */

+        ProcXISelectEvents,                     /* 46 */

+        ProcXIQueryVersion,                     /* 47 */

+        ProcXIQueryDevice,                      /* 48 */

+        ProcXISetFocus,                         /* 49 */

+        ProcXIGetFocus,                         /* 50 */

+        ProcXIGrabDevice,                       /* 51 */

+        ProcXIUngrabDevice,                     /* 52 */

+        ProcXIAllowEvents,                      /* 53 */

+        ProcXIPassiveGrabDevice,                /* 54 */

+        ProcXIPassiveUngrabDevice,              /* 55 */

+        ProcXIListProperties,                   /* 56 */

+        ProcXIChangeProperty,                   /* 57 */

+        ProcXIDeleteProperty,                   /* 58 */

+        ProcXIGetProperty,                      /* 59 */

+        ProcXIGetSelectedEvents                 /* 60 */

+};

+

+/* For swapped clients */

+static int (*SProcIVector[])(ClientPtr) = {

+        NULL,                                    /*  0 */

+	SProcXGetExtensionVersion,               /*  1 */

+	SProcXListInputDevices,                  /*  2 */

+	SProcXOpenDevice,                        /*  3 */

+	SProcXCloseDevice,                       /*  4 */

+	SProcXSetDeviceMode,                     /*  5 */

+	SProcXSelectExtensionEvent,              /*  6 */

+	SProcXGetSelectedExtensionEvents,        /*  7 */

+	SProcXChangeDeviceDontPropagateList,     /*  8 */

+	SProcXGetDeviceDontPropagateList,        /*  9 */

+	SProcXGetDeviceMotionEvents,             /* 10 */

+	SProcXChangeKeyboardDevice,              /* 11 */

+	SProcXChangePointerDevice,               /* 12 */

+	SProcXGrabDevice,                        /* 13 */

+	SProcXUngrabDevice,                      /* 14 */

+	SProcXGrabDeviceKey,                     /* 15 */

+	SProcXUngrabDeviceKey,                   /* 16 */

+	SProcXGrabDeviceButton,                  /* 17 */

+	SProcXUngrabDeviceButton,                /* 18 */

+	SProcXAllowDeviceEvents,                 /* 19 */

+	SProcXGetDeviceFocus,                    /* 20 */

+	SProcXSetDeviceFocus,                    /* 21 */

+	SProcXGetFeedbackControl,                /* 22 */

+	SProcXChangeFeedbackControl,             /* 23 */

+	SProcXGetDeviceKeyMapping,               /* 24 */

+	SProcXChangeDeviceKeyMapping,            /* 25 */

+	SProcXGetDeviceModifierMapping,          /* 26 */

+	SProcXSetDeviceModifierMapping,          /* 27 */

+	SProcXGetDeviceButtonMapping,            /* 28 */

+	SProcXSetDeviceButtonMapping,            /* 29 */

+	SProcXQueryDeviceState,                  /* 30 */

+	SProcXSendExtensionEvent,                /* 31 */

+	SProcXDeviceBell,                        /* 32 */

+	SProcXSetDeviceValuators,                /* 33 */

+	SProcXGetDeviceControl,                  /* 34 */

+	SProcXChangeDeviceControl,               /* 35 */

+        SProcXListDeviceProperties,              /* 36 */

+        SProcXChangeDeviceProperty,              /* 37 */

+        SProcXDeleteDeviceProperty,              /* 38 */

+        SProcXGetDeviceProperty,                 /* 39 */

+        SProcXIQueryPointer,                     /* 40 */

+        SProcXIWarpPointer,                      /* 41 */

+        SProcXIChangeCursor,                     /* 42 */

+        SProcXIChangeHierarchy,                  /* 43 */

+        SProcXISetClientPointer,                 /* 44 */

+        SProcXIGetClientPointer,                 /* 45 */

+        SProcXISelectEvents,                     /* 46 */

+        SProcXIQueryVersion,                     /* 47 */

+        SProcXIQueryDevice,                      /* 48 */

+        SProcXISetFocus,                         /* 49 */

+        SProcXIGetFocus,                         /* 50 */

+        SProcXIGrabDevice,                       /* 51 */

+        SProcXIUngrabDevice,                     /* 52 */

+        SProcXIAllowEvents,                      /* 53 */

+        SProcXIPassiveGrabDevice,                /* 54 */

+        SProcXIPassiveUngrabDevice,              /* 55 */

+        SProcXIListProperties,                   /* 56 */

+        SProcXIChangeProperty,                   /* 57 */

+        SProcXIDeleteProperty,                   /* 58 */

+        SProcXIGetProperty,                      /* 59 */

+        SProcXIGetSelectedEvents                 /* 60 */

+};

+

+/*****************************************************************

+ *

+ * Globals referenced elsewhere in the server.

+ *

+ */

+

+int IReqCode = 0;

+int IEventBase = 0;

+int BadDevice = 0;

+static int BadEvent = 1;

+int BadMode = 2;

+int DeviceBusy = 3;

+int BadClass = 4;

+

+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 DevicePresenceNotify;

+int DevicePropertyNotify;

+

+int RT_INPUTCLIENT;

+

+/*****************************************************************

+ *

+ * Externs defined elsewhere in the X server.

+ *

+ */

+

+extern XExtensionVersion XIVersion;

+

+

+Mask PropagateMask[MAXDEVICES];

+

+/*****************************************************************

+ *

+ * Versioning support

+ *

+ */

+

+static int XIClientPrivateKeyIndex;

+DevPrivateKey XIClientPrivateKey = &XIClientPrivateKeyIndex;

+

+

+/*****************************************************************

+ *

+ * Declarations of local routines.

+ *

+ */

+

+static void

+XIClientCallback(CallbackListPtr        *list,

+                 pointer                closure,

+                 pointer                data)

+{

+    NewClientInfoRec *clientinfo = (NewClientInfoRec*)data;

+    ClientPtr pClient = clientinfo->client;

+    XIClientPtr pXIClient;

+

+    pXIClient = dixLookupPrivate(&pClient->devPrivates, XIClientPrivateKey);

+    pXIClient->major_version = 0;

+    pXIClient->minor_version = 0;

+}

+

+/*************************************************************************

+ *

+ * ProcIDispatch - main dispatch routine for requests to this extension.

+ * This routine is used if server and client have the same byte ordering.

+ *

+ */

+

+static int

+ProcIDispatch(ClientPtr client)

+{

+    REQUEST(xReq);

+    if (stuff->data > (IREQUESTS + XI2REQUESTS) || !ProcIVector[stuff->data])

+        return BadRequest;

+

+    return (*ProcIVector[stuff->data])(client);

+}

+

+/*******************************************************************************

+ *

+ * 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.

+ *

+ */

+

+static int

+SProcIDispatch(ClientPtr client)

+{

+    REQUEST(xReq);

+    if (stuff->data > IREQUESTS || !SProcIVector[stuff->data])

+        return BadRequest;

+

+    return (*SProcIVector[stuff->data])(client);

+}

+

+/**********************************************************************

+ *

+ * SReplyIDispatch

+ * Swap any replies defined in this extension.

+ *

+ */

+

+static void

+SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)

+					/* All we look at is the type field */

+{	/* This is common to all replies    */

+    if (rep->RepType == X_GetExtensionVersion)

+	SRepXGetExtensionVersion(client, len,

+				 (xGetExtensionVersionReply *) rep);

+    else if (rep->RepType == X_ListInputDevices)

+	SRepXListInputDevices(client, len, (xListInputDevicesReply *) rep);

+    else if (rep->RepType == X_OpenDevice)

+	SRepXOpenDevice(client, len, (xOpenDeviceReply *) rep);

+    else if (rep->RepType == X_SetDeviceMode)

+	SRepXSetDeviceMode(client, len, (xSetDeviceModeReply *) rep);

+    else if (rep->RepType == X_GetSelectedExtensionEvents)

+	SRepXGetSelectedExtensionEvents(client, len,

+					(xGetSelectedExtensionEventsReply *)

+					rep);

+    else if (rep->RepType == X_GetDeviceDontPropagateList)

+	SRepXGetDeviceDontPropagateList(client, len,

+					(xGetDeviceDontPropagateListReply *)

+					rep);

+    else if (rep->RepType == X_GetDeviceMotionEvents)

+	SRepXGetDeviceMotionEvents(client, len,

+				   (xGetDeviceMotionEventsReply *) rep);

+    else if (rep->RepType == X_GrabDevice)

+	SRepXGrabDevice(client, len, (xGrabDeviceReply *) rep);

+    else if (rep->RepType == X_GetDeviceFocus)

+	SRepXGetDeviceFocus(client, len, (xGetDeviceFocusReply *) rep);

+    else if (rep->RepType == X_GetFeedbackControl)

+	SRepXGetFeedbackControl(client, len, (xGetFeedbackControlReply *) rep);

+    else if (rep->RepType == X_GetDeviceKeyMapping)

+	SRepXGetDeviceKeyMapping(client, len,

+				 (xGetDeviceKeyMappingReply *) rep);

+    else if (rep->RepType == X_GetDeviceModifierMapping)

+	SRepXGetDeviceModifierMapping(client, len,

+				      (xGetDeviceModifierMappingReply *) rep);

+    else if (rep->RepType == X_SetDeviceModifierMapping)

+	SRepXSetDeviceModifierMapping(client, len,

+				      (xSetDeviceModifierMappingReply *) rep);

+    else if (rep->RepType == X_GetDeviceButtonMapping)

+	SRepXGetDeviceButtonMapping(client, len,

+				    (xGetDeviceButtonMappingReply *) rep);

+    else if (rep->RepType == X_SetDeviceButtonMapping)

+	SRepXSetDeviceButtonMapping(client, len,

+				    (xSetDeviceButtonMappingReply *) rep);

+    else if (rep->RepType == X_QueryDeviceState)

+	SRepXQueryDeviceState(client, len, (xQueryDeviceStateReply *) rep);

+    else if (rep->RepType == X_SetDeviceValuators)

+	SRepXSetDeviceValuators(client, len, (xSetDeviceValuatorsReply *) rep);

+    else if (rep->RepType == X_GetDeviceControl)

+	SRepXGetDeviceControl(client, len, (xGetDeviceControlReply *) rep);

+    else if (rep->RepType == X_ChangeDeviceControl)

+	SRepXChangeDeviceControl(client, len,

+				 (xChangeDeviceControlReply *) rep);

+    else if (rep->RepType == X_ListDeviceProperties)

+        SRepXListDeviceProperties(client, len, (xListDevicePropertiesReply*)rep);

+    else if (rep->RepType == X_GetDeviceProperty)

+	SRepXGetDeviceProperty(client, len, (xGetDevicePropertyReply *) rep);

+    else if (rep->RepType == X_XIQueryPointer)

+	SRepXIQueryPointer(client, len, (xXIQueryPointerReply *) rep);

+    else if (rep->RepType == X_XIGetClientPointer)

+        SRepXIGetClientPointer(client, len, (xXIGetClientPointerReply*) rep);

+    else if (rep->RepType == X_XIQueryVersion)

+        SRepXIQueryVersion(client, len, (xXIQueryVersionReply*)rep);

+    else if (rep->RepType == X_XIQueryDevice)

+        SRepXIQueryDevice(client, len, (xXIQueryDeviceReply*)rep);

+    else if (rep->RepType == X_XIGrabDevice)

+	SRepXIGrabDevice(client, len, (xXIGrabDeviceReply *) rep);

+    else if (rep->RepType == X_XIGrabDevice)

+	SRepXIPassiveGrabDevice(client, len, (xXIPassiveGrabDeviceReply *) rep);

+    else if (rep->RepType == X_XIListProperties)

+	SRepXIListProperties(client, len, (xXIListPropertiesReply *) rep);

+    else if (rep->RepType == X_XIGetProperty)

+	SRepXIGetProperty(client, len, (xXIGetPropertyReply *) rep);

+    else if (rep->RepType == X_XIGetSelectedEvents)

+	SRepXIGetSelectedEvents(client, len, (xXIGetSelectedEventsReply *) rep);

+    else if (rep->RepType == X_XIGetFocus)

+	SRepXIGetFocus(client, len, (xXIGetFocusReply *) rep);

+    else {

+	FatalError("XINPUT confused sending swapped reply");

+    }

+}

+

+/************************************************************************

+ *

+ * This function swaps the DeviceValuator event.

+ *

+ */

+

+static void

+SEventDeviceValuator(deviceValuator * from, deviceValuator * to)

+{

+    char n;

+    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      */

+    }

+}

+

+static void

+SEventFocus(deviceFocus * from, deviceFocus * to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->time, n);

+    swapl(&to->window, n);

+}

+

+static void

+SDeviceStateNotifyEvent(deviceStateNotify * from, deviceStateNotify * to)

+{

+    int i;

+    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      */

+    }

+}

+

+static void

+SDeviceKeyStateNotifyEvent(deviceKeyStateNotify * from,

+			   deviceKeyStateNotify * to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber, n);

+}

+

+static void

+SDeviceButtonStateNotifyEvent(deviceButtonStateNotify * from,

+			      deviceButtonStateNotify * to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber, n);

+}

+

+static void

+SChangeDeviceNotifyEvent(changeDeviceNotify * from, changeDeviceNotify * to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->time, n);

+}

+

+static void

+SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->time, n);

+}

+

+static void

+SDevicePresenceNotifyEvent (devicePresenceNotify *from, devicePresenceNotify *to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber,n);

+    swapl(&to->time, n);

+    swaps(&to->control, n);

+}

+

+static void

+SDevicePropertyNotifyEvent (devicePropertyNotify *from, devicePropertyNotify *to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber,n);

+    swapl(&to->time, n);

+    swapl(&to->atom, n);

+}

+

+static void

+SDeviceLeaveNotifyEvent (xXILeaveEvent *from, xXILeaveEvent *to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber,n);

+    swapl(&to->length, n);

+    swaps(&to->evtype, n);

+    swaps(&to->deviceid, n);

+    swapl(&to->time, n);

+    swapl(&to->root, n);

+    swapl(&to->event, n);

+    swapl(&to->child, n);

+    swapl(&to->root_x, n);

+    swapl(&to->root_y, n);

+    swapl(&to->event_x, n);

+    swapl(&to->event_y, n);

+    swaps(&to->sourceid, n);

+    swaps(&to->buttons_len, n);

+    swapl(&to->mods.base_mods, n);

+    swapl(&to->mods.latched_mods, n);

+    swapl(&to->mods.locked_mods, n);

+}

+

+static void

+SDeviceChangedEvent(xXIDeviceChangedEvent* from, xXIDeviceChangedEvent* to)

+{

+    char n;

+    int i, j;

+    xXIAnyInfo *any;

+

+    *to = *from;

+    memcpy(&to[1], &from[1], from->length * 4);

+

+    any = (xXIAnyInfo*)&to[1];

+    for (i = 0; i < to->num_classes; i++)

+    {

+        int length = any->length;

+

+        switch(any->type)

+        {

+            case KeyClass:

+                {

+                    xXIKeyInfo *ki = (xXIKeyInfo*)any;

+                    uint32_t *key = (uint32_t*)&ki[1];

+                    for (j = 0; j < ki->num_keycodes; j++, key++)

+                        swapl(key, n);

+                    swaps(&ki->num_keycodes, n);

+                }

+                break;

+            case ButtonClass:

+                {

+                    xXIButtonInfo *bi = (xXIButtonInfo*)any;

+                    Atom *labels = (Atom*)((char*)bi + sizeof(xXIButtonInfo) +

+                                           pad_to_int32(bits_to_bytes(bi->num_buttons)));

+                    for (j = 0; j < bi->num_buttons; j++)

+                        swapl(&labels[j], n);

+                    swaps(&bi->num_buttons, n);

+                }

+                break;

+            case ValuatorClass:

+                {

+                    xXIValuatorInfo* ai = (xXIValuatorInfo*)any;

+                    swapl(&ai->label, n);

+                    swapl(&ai->min.integral, n);

+                    swapl(&ai->min.frac, n);

+                    swapl(&ai->max.integral, n);

+                    swapl(&ai->max.frac, n);

+                    swapl(&ai->resolution, n);

+                    swaps(&ai->number, n);

+                }

+                break;

+        }

+

+        swaps(&any->type, n);

+        swaps(&any->length, n);

+        swaps(&any->sourceid, n);

+

+        any = (xXIAnyInfo*)((char*)any + length * 4);

+    }

+

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->length, n);

+    swaps(&to->evtype, n);

+    swaps(&to->deviceid, n);

+    swapl(&to->time, n);

+    swaps(&to->num_classes, n);

+    swaps(&to->sourceid, n);

+

+}

+

+static void SDeviceEvent(xXIDeviceEvent *from, xXIDeviceEvent *to)

+{

+    int i;

+    char n;

+    char *ptr;

+    char *vmask;

+

+    memcpy(to, from, sizeof(xEvent) + from->length * 4);

+

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->length, n);

+    swaps(&to->evtype, n);

+    swaps(&to->deviceid, n);

+    swapl(&to->time, n);

+    swapl(&to->detail, n);

+    swapl(&to->root, n);

+    swapl(&to->event, n);

+    swapl(&to->child, n);

+    swapl(&to->root_x, n);

+    swapl(&to->root_y, n);

+    swapl(&to->event_x, n);

+    swapl(&to->event_y, n);

+    swaps(&to->buttons_len, n);

+    swaps(&to->valuators_len, n);

+    swaps(&to->sourceid, n);

+    swapl(&to->mods.base_mods, n);

+    swapl(&to->mods.latched_mods, n);

+    swapl(&to->mods.locked_mods, n);

+    swapl(&to->mods.effective_mods, n);

+

+    ptr = (char*)(&to[1]);

+    ptr += from->buttons_len * 4;

+    vmask = ptr; /* valuator mask */

+    ptr += from->valuators_len * 4;

+    for (i = 0; i < from->valuators_len * 32; i++)

+    {

+        if (BitIsOn(vmask, i))

+        {

+            swapl(((uint32_t*)ptr), n);

+            ptr += 4;

+            swapl(((uint32_t*)ptr), n);

+            ptr += 4;

+        }

+    }

+}

+

+static void SDeviceHierarchyEvent(xXIHierarchyEvent *from,

+                                  xXIHierarchyEvent *to)

+{

+    int i;

+    char n;

+    xXIHierarchyInfo *info;

+

+    *to = *from;

+    memcpy(&to[1], &from[1], from->length * 4);

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->length, n);

+    swaps(&to->evtype, n);

+    swaps(&to->deviceid, n);

+    swapl(&to->time, n);

+    swapl(&to->flags, n);

+    swaps(&to->num_info, n);

+

+    info = (xXIHierarchyInfo*)&to[1];

+    for (i = 0; i< from->num_info; i++)

+    {

+        swaps(&info->deviceid, n);

+        swaps(&info->attachment, n);

+        info++;

+    }

+}

+

+static void SXIPropertyEvent(xXIPropertyEvent *from, xXIPropertyEvent *to)

+{

+    char n;

+

+    *to = *from;

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->length, n);

+    swaps(&to->evtype, n);

+    swaps(&to->deviceid, n);

+    swapl(&to->property, n);

+}

+

+static void SRawEvent(xXIRawEvent *from, xXIRawEvent *to)

+{

+    char n;

+    int i;

+    FP3232 *values;

+    unsigned char *mask;

+

+    memcpy(to, from, sizeof(xEvent) + from->length * 4);

+

+    swaps(&to->sequenceNumber, n);

+    swapl(&to->length, n);

+    swaps(&to->evtype, n);

+    swaps(&to->deviceid, n);

+    swapl(&to->time, n);

+    swapl(&to->detail, n);

+

+

+    mask = (unsigned char*)&to[1];

+    values = (FP3232*)(mask + from->valuators_len * 4);

+

+    for (i = 0; i < from->valuators_len * 4 * 8; i++)

+    {

+        if (BitIsOn(mask, i))

+        {

+            /* for each bit set there are two FP3232 values on the wire, in

+             * the order abcABC for data and data_raw. Here we swap as if

+             * they were in aAbBcC order because it's easier and really

+             * doesn't matter.

+             */

+            swapl(&values->integral, n);

+            swapl(&values->frac, n);

+            values++;

+            swapl(&values->integral, n);

+            swapl(&values->frac, n);

+            values++;

+        }

+    }

+

+    swaps(&to->valuators_len, n);

+}

+

+

+/** Event swapping function for XI2 events. */

+void

+XI2EventSwap(xGenericEvent *from, xGenericEvent *to)

+{

+    switch(from->evtype)

+    {

+        case XI_Enter:

+        case XI_Leave:

+            SDeviceLeaveNotifyEvent((xXILeaveEvent*)from, (xXILeaveEvent*)to);

+            break;

+        case XI_DeviceChanged:

+            SDeviceChangedEvent((xXIDeviceChangedEvent*)from,

+                                (xXIDeviceChangedEvent*)to);

+            break;

+        case XI_HierarchyChanged:

+            SDeviceHierarchyEvent((xXIHierarchyEvent*)from, (xXIHierarchyEvent*)to);

+            break;

+        case XI_PropertyEvent:

+            SXIPropertyEvent((xXIPropertyEvent*)from,

+                           (xXIPropertyEvent*)to);

+            break;

+        case XI_Motion:

+        case XI_KeyPress:

+        case XI_KeyRelease:

+        case XI_ButtonPress:

+        case XI_ButtonRelease:

+            SDeviceEvent((xXIDeviceEvent*)from, (xXIDeviceEvent*)to);

+            break;

+        case XI_RawMotion:

+        case XI_RawKeyPress:

+        case XI_RawKeyRelease:

+        case XI_RawButtonPress:

+        case XI_RawButtonRelease:

+            SRawEvent((xXIRawEvent*)from, (xXIRawEvent*)to);

+            break;

+        default:

+            ErrorF("[Xi] Unknown event type to swap. This is a bug.\n");

+            break;

+    }

+}

+

+/**************************************************************************

+ *

+ * Allow the specified event to have its propagation suppressed.

+ * The default is to not allow suppression of propagation.

+ *

+ */

+

+static void

+AllowPropagateSuppress(Mask mask)

+{

+    int i;

+

+    for (i = 0; i < MAXDEVICES; i++)

+	PropagateMask[i] |= mask;

+}

+

+/**************************************************************************

+ *

+ * 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.

+ *

+ */

+

+static void

+SetEventInfo(Mask mask, int constant)

+{

+    EventInfo[ExtEventIndex].mask = mask;

+    EventInfo[ExtEventIndex++].type = constant;

+}

+

+/**************************************************************************

+ *

+ * 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.

+ *

+ */

+

+static void

+SetExclusiveAccess(Mask mask)

+{

+    int i;

+

+    for (i = 0; i < MAXDEVICES; i++)

+	ExtExclusiveMasks[i] |= mask;

+}

+

+/**************************************************************************

+ *

+ * Assign the specified mask to the specified event.

+ *

+ */

+

+static void

+SetMaskForExtEvent(Mask mask, int event)

+{

+    int i;

+

+    EventInfo[ExtEventIndex].mask = mask;

+    EventInfo[ExtEventIndex++].type = event;

+

+    if ((event < LASTEvent) || (event >= 128))

+	FatalError("MaskForExtensionEvent: bogus event number");

+

+    for (i = 0; i < MAXDEVICES; i++)

+        SetMaskForEvent(i, mask, event);

+}

+

+/************************************************************************

+ *

+ * This function sets up extension event types and masks.

+ *

+ */

+

+static void

+FixExtensionEvents(ExtensionEntry * extEntry)

+{

+    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;

+    DevicePresenceNotify = DeviceButtonStateNotify + 1;

+    DevicePropertyNotify = DevicePresenceNotify + 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;

+

+    SetMaskForExtEvent(DeviceKeyPressMask, DeviceKeyPress);

+    AllowPropagateSuppress(DeviceKeyPressMask);

+    SetCriticalEvent(DeviceKeyPress);

+

+    SetMaskForExtEvent(DeviceKeyReleaseMask, DeviceKeyRelease);

+    AllowPropagateSuppress(DeviceKeyReleaseMask);

+    SetCriticalEvent(DeviceKeyRelease);

+

+    SetMaskForExtEvent(DeviceButtonPressMask, DeviceButtonPress);

+    AllowPropagateSuppress(DeviceButtonPressMask);

+    SetCriticalEvent(DeviceButtonPress);

+

+    SetMaskForExtEvent(DeviceButtonReleaseMask, DeviceButtonRelease);

+    AllowPropagateSuppress(DeviceButtonReleaseMask);

+    SetCriticalEvent(DeviceButtonRelease);

+

+    SetMaskForExtEvent(DeviceProximityMask, ProximityIn);

+    SetMaskForExtEvent(DeviceProximityMask, ProximityOut);

+

+    SetMaskForExtEvent(DeviceStateNotifyMask, DeviceStateNotify);

+

+    SetMaskForExtEvent(DevicePointerMotionMask, DeviceMotionNotify);

+    AllowPropagateSuppress(DevicePointerMotionMask);

+    SetCriticalEvent(DeviceMotionNotify);

+

+    SetEventInfo(DevicePointerMotionHintMask, _devicePointerMotionHint);

+    SetEventInfo(DeviceButton1MotionMask, _deviceButton1Motion);

+    SetEventInfo(DeviceButton2MotionMask, _deviceButton2Motion);

+    SetEventInfo(DeviceButton3MotionMask, _deviceButton3Motion);

+    SetEventInfo(DeviceButton4MotionMask, _deviceButton4Motion);

+    SetEventInfo(DeviceButton5MotionMask, _deviceButton5Motion);

+    SetEventInfo(DeviceButtonMotionMask, _deviceButtonMotion);

+

+    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusIn);

+    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusOut);

+

+    SetMaskForExtEvent(DeviceMappingNotifyMask, DeviceMappingNotify);

+    SetMaskForExtEvent(ChangeDeviceNotifyMask, ChangeDeviceNotify);

+

+    SetEventInfo(DeviceButtonGrabMask, _deviceButtonGrab);

+    SetExclusiveAccess(DeviceButtonGrabMask);

+

+    SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);

+    SetEventInfo(DevicePresenceNotifyMask, _devicePresence);

+    SetMaskForExtEvent(DevicePropertyNotifyMask, DevicePropertyNotify);

+

+    SetEventInfo(0, _noExtensionEvent);

+}

+

+/************************************************************************

+ *

+ * This function restores extension event types and masks to their

+ * initial state.

+ *

+ */

+

+static void

+RestoreExtensionEvents(void)

+{

+    int i, j;

+

+    IReqCode = 0;

+    IEventBase = 0;

+

+    for (i = 0; i < ExtEventIndex - 1; i++) {

+	if ((EventInfo[i].type >= LASTEvent) && (EventInfo[i].type < 128))

+        {

+            for (j = 0; j < MAXDEVICES; j++)

+                SetMaskForEvent(j, 0, EventInfo[i].type);

+        }

+	EventInfo[i].mask = 0;

+	EventInfo[i].type = 0;

+    }

+    ExtEventIndex = 0;

+    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;

+    DevicePresenceNotify = 14;

+    DevicePropertyNotify = 15;

+

+    BadDevice = 0;

+    BadEvent = 1;

+    BadMode = 2;

+    DeviceBusy = 3;

+    BadClass = 4;

+

+}

+

+/***********************************************************************

+ *

+ * IResetProc.

+ * Remove reply-swapping routine.

+ * Remove event-swapping routine.

+ *

+ */

+

+static void

+IResetProc(ExtensionEntry * unused)

+{

+    XIResetProperties();

+

+    ReplySwapVector[IReqCode] = ReplyNotSwappd;

+    EventSwapVector[DeviceValuator] = NotImplemented;

+    EventSwapVector[DeviceKeyPress] = NotImplemented;

+    EventSwapVector[DeviceKeyRelease] = NotImplemented;

+    EventSwapVector[DeviceButtonPress] = NotImplemented;

+    EventSwapVector[DeviceButtonRelease] = NotImplemented;

+    EventSwapVector[DeviceMotionNotify] = NotImplemented;

+    EventSwapVector[DeviceFocusIn] = NotImplemented;

+    EventSwapVector[DeviceFocusOut] = NotImplemented;

+    EventSwapVector[ProximityIn] = NotImplemented;

+    EventSwapVector[ProximityOut] = NotImplemented;

+    EventSwapVector[DeviceStateNotify] = NotImplemented;

+    EventSwapVector[DeviceKeyStateNotify] = NotImplemented;

+    EventSwapVector[DeviceButtonStateNotify] = NotImplemented;

+    EventSwapVector[DeviceMappingNotify] = NotImplemented;

+    EventSwapVector[ChangeDeviceNotify] = NotImplemented;

+    EventSwapVector[DevicePresenceNotify] = NotImplemented;

+    EventSwapVector[DevicePropertyNotify] = NotImplemented;

+    RestoreExtensionEvents();

+}

+

+

+/***********************************************************************

+ *

+ * Assign an id and type to an input device.

+ *

+ */

+

+void

+AssignTypeAndName(DeviceIntPtr dev, Atom type, char *name)

+{

+    dev->xinput_type = type;

+    dev->name = (char *)xalloc(strlen(name) + 1);

+    strcpy(dev->name, name);

+}

+

+/***********************************************************************

+ *

+ * Make device type atoms.

+ *

+ */

+

+static void

+MakeDeviceTypeAtoms(void)

+{

+    int i;

+

+    for (i = 0; i < NUMTYPES; i++)

+	dev_type[i].type =

+	    MakeAtom(dev_type[i].name, strlen(dev_type[i].name), 1);

+}

+

+/*****************************************************************************

+ *

+ *	SEventIDispatch

+ *

+ *	Swap any events defined in this extension.

+ */

+#define DO_SWAP(func,type) func ((type *)from, (type *)to)

+

+static void

+SEventIDispatch(xEvent * from, xEvent * to)

+{

+    int type = from->u.u.type & 0177;

+

+    if (type == DeviceValuator)

+	DO_SWAP(SEventDeviceValuator, deviceValuator);

+    else if (type == DeviceKeyPress) {

+	SKeyButtonPtrEvent(from, to);

+	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;

+    } else if (type == DeviceKeyRelease) {

+	SKeyButtonPtrEvent(from, to);

+	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;

+    } else if (type == DeviceButtonPress) {

+	SKeyButtonPtrEvent(from, to);

+	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;

+    } else if (type == DeviceButtonRelease) {

+	SKeyButtonPtrEvent(from, to);

+	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;

+    } else if (type == DeviceMotionNotify) {

+	SKeyButtonPtrEvent(from, to);

+	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;

+    } else if (type == DeviceFocusIn)

+	DO_SWAP(SEventFocus, deviceFocus);

+    else if (type == DeviceFocusOut)

+	DO_SWAP(SEventFocus, deviceFocus);

+    else if (type == ProximityIn) {

+	SKeyButtonPtrEvent(from, to);

+	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;

+    } else if (type == ProximityOut) {

+	SKeyButtonPtrEvent(from, to);

+	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;

+    } else if (type == DeviceStateNotify)

+	DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);

+    else if (type == DeviceKeyStateNotify)

+	DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);

+    else if (type == DeviceButtonStateNotify)

+	DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);

+    else if (type == DeviceMappingNotify)

+	DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);

+    else if (type == ChangeDeviceNotify)

+	DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);

+    else if (type == DevicePresenceNotify)

+	DO_SWAP(SDevicePresenceNotifyEvent, devicePresenceNotify);

+    else if (type == DevicePropertyNotify)

+	DO_SWAP(SDevicePropertyNotifyEvent, devicePropertyNotify);

+    else {

+	FatalError("XInputExtension: Impossible event!\n");

+    }

+}

+

+/**********************************************************************

+ *

+ * 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.

+ *

+ * XI is mandatory nowadays, so if we fail to init XI, we die.

+ */

+

+void

+XInputExtensionInit(void)

+{

+    ExtensionEntry *extEntry;

+    XExtensionVersion thisversion = { XI_Present,

+        SERVER_XI_MAJOR_VERSION,

+        SERVER_XI_MINOR_VERSION,

+    };

+

+    if (!dixRequestPrivate(XIClientPrivateKey, sizeof(XIClientRec)))

+        FatalError("Cannot request private for XI.\n");

+

+    if (!AddCallback(&ClientStateCallback, XIClientCallback, 0))

+        FatalError("Failed to add callback to XI.\n");

+

+    extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,

+			    SProcIDispatch, IResetProc, StandardMinorOpcode);

+    if (extEntry) {

+	IReqCode = extEntry->base;

+	IEventBase = extEntry->eventBase;

+	XIVersion = thisversion;

+	MakeDeviceTypeAtoms();

+	RT_INPUTCLIENT = CreateNewResourceType((DeleteType) InputClientGone,

+					       "INPUTCLIENT");

+	if (!RT_INPUTCLIENT)

+	    FatalError("Failed to add resource type for XI.\n");

+	FixExtensionEvents(extEntry);

+	ReplySwapVector[IReqCode] = (ReplySwapPtr) SReplyIDispatch;

+	EventSwapVector[DeviceValuator] = SEventIDispatch;

+	EventSwapVector[DeviceKeyPress] = SEventIDispatch;

+	EventSwapVector[DeviceKeyRelease] = SEventIDispatch;

+	EventSwapVector[DeviceButtonPress] = SEventIDispatch;

+	EventSwapVector[DeviceButtonRelease] = SEventIDispatch;

+	EventSwapVector[DeviceMotionNotify] = SEventIDispatch;

+	EventSwapVector[DeviceFocusIn] = SEventIDispatch;

+	EventSwapVector[DeviceFocusOut] = SEventIDispatch;

+	EventSwapVector[ProximityIn] = SEventIDispatch;

+	EventSwapVector[ProximityOut] = SEventIDispatch;

+	EventSwapVector[DeviceStateNotify] = SEventIDispatch;

+	EventSwapVector[DeviceKeyStateNotify] = SEventIDispatch;

+	EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;

+	EventSwapVector[DeviceMappingNotify] = SEventIDispatch;

+	EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;

+	EventSwapVector[DevicePresenceNotify] = SEventIDispatch;

+

+	GERegisterExtension(IReqCode, XI2EventSwap);

+

+

+	memset(&xi_all_devices, 0, sizeof(xi_all_devices));

+	memset(&xi_all_master_devices, 0, sizeof(xi_all_master_devices));

+	xi_all_devices.id = XIAllDevices;

+	xi_all_devices.name = "XIAllDevices";

+	xi_all_master_devices.id = XIAllMasterDevices;

+	xi_all_master_devices.name = "XIAllMasterDevices";

+

+	inputInfo.all_devices = &xi_all_devices;

+	inputInfo.all_master_devices = &xi_all_master_devices;

+    } else {

+	FatalError("IExtensionInit: AddExtensions failed\n");

+    }

+}

+

diff --git a/xorg-server/Xi/xiproperty.c b/xorg-server/Xi/xiproperty.c
index be0783107..6e298b7d1 100644
--- a/xorg-server/Xi/xiproperty.c
+++ b/xorg-server/Xi/xiproperty.c
@@ -1,1354 +1,1363 @@
-/*
- * Copyright © 2006 Keith Packard
- * Copyright © 2008 Peter Hutterer
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WAXIANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WAXIANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- */
-
-/* This code is a modified version of randr/rrproperty.c */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "dix.h"
-#include "inputstr.h"
-#include <X11/extensions/XI.h>
-#include <X11/Xatom.h>
-#include <X11/extensions/XIproto.h>
-#include <X11/extensions/XI2proto.h>
-#include "exglobals.h"
-#include "exevents.h"
-#include "swaprep.h"
-
-#include "xiproperty.h"
-#include "xserver-properties.h"
-
-/**
- * Properties used or alloced from inside the server.
- */
-static struct dev_properties
-{
-    Atom type;
-    char *name;
-} dev_properties[] = {
-    {0, XI_PROP_ENABLED},
-    {0, XI_PROP_XTEST_DEVICE},
-    {0, XATOM_FLOAT},
-    {0, ACCEL_PROP_PROFILE_NUMBER},
-    {0, ACCEL_PROP_CONSTANT_DECELERATION},
-    {0, ACCEL_PROP_ADAPTIVE_DECELERATION},
-    {0, ACCEL_PROP_VELOCITY_SCALING},
-    {0, AXIS_LABEL_PROP},
-    {0, AXIS_LABEL_PROP_REL_X},
-    {0, AXIS_LABEL_PROP_REL_Y},
-    {0, AXIS_LABEL_PROP_REL_Z},
-    {0, AXIS_LABEL_PROP_REL_RX},
-    {0, AXIS_LABEL_PROP_REL_RY},
-    {0, AXIS_LABEL_PROP_REL_RZ},
-    {0, AXIS_LABEL_PROP_REL_HWHEEL},
-    {0, AXIS_LABEL_PROP_REL_DIAL},
-    {0, AXIS_LABEL_PROP_REL_WHEEL},
-    {0, AXIS_LABEL_PROP_REL_MISC},
-    {0, AXIS_LABEL_PROP_ABS_X},
-    {0, AXIS_LABEL_PROP_ABS_Y},
-    {0, AXIS_LABEL_PROP_ABS_Z},
-    {0, AXIS_LABEL_PROP_ABS_RX},
-    {0, AXIS_LABEL_PROP_ABS_RY},
-    {0, AXIS_LABEL_PROP_ABS_RZ},
-    {0, AXIS_LABEL_PROP_ABS_THROTTLE},
-    {0, AXIS_LABEL_PROP_ABS_RUDDER},
-    {0, AXIS_LABEL_PROP_ABS_WHEEL},
-    {0, AXIS_LABEL_PROP_ABS_GAS},
-    {0, AXIS_LABEL_PROP_ABS_BRAKE},
-    {0, AXIS_LABEL_PROP_ABS_HAT0X},
-    {0, AXIS_LABEL_PROP_ABS_HAT0Y},
-    {0, AXIS_LABEL_PROP_ABS_HAT1X},
-    {0, AXIS_LABEL_PROP_ABS_HAT1Y},
-    {0, AXIS_LABEL_PROP_ABS_HAT2X},
-    {0, AXIS_LABEL_PROP_ABS_HAT2Y},
-    {0, AXIS_LABEL_PROP_ABS_HAT3X},
-    {0, AXIS_LABEL_PROP_ABS_HAT3Y},
-    {0, AXIS_LABEL_PROP_ABS_PRESSURE},
-    {0, AXIS_LABEL_PROP_ABS_DISTANCE},
-    {0, AXIS_LABEL_PROP_ABS_TILT_X},
-    {0, AXIS_LABEL_PROP_ABS_TILT_Y},
-    {0, AXIS_LABEL_PROP_ABS_TOOL_WIDTH},
-    {0, AXIS_LABEL_PROP_ABS_VOLUME},
-    {0, AXIS_LABEL_PROP_ABS_MT_TOUCH_MAJOR},
-    {0, AXIS_LABEL_PROP_ABS_MT_TOUCH_MINOR},
-    {0, AXIS_LABEL_PROP_ABS_MT_WIDTH_MAJOR},
-    {0, AXIS_LABEL_PROP_ABS_MT_WIDTH_MINOR},
-    {0, AXIS_LABEL_PROP_ABS_MT_ORIENTATION},
-    {0, AXIS_LABEL_PROP_ABS_MT_POSITION_X},
-    {0, AXIS_LABEL_PROP_ABS_MT_POSITION_Y},
-    {0, AXIS_LABEL_PROP_ABS_MT_TOOL_TYPE},
-    {0, AXIS_LABEL_PROP_ABS_MT_BLOB_ID},
-    {0, AXIS_LABEL_PROP_ABS_MT_TRACKING_ID},
-    {0, AXIS_LABEL_PROP_ABS_MT_PRESSURE},
-    {0, AXIS_LABEL_PROP_ABS_MISC},
-
-    {0, BTN_LABEL_PROP},
-    {0, BTN_LABEL_PROP_BTN_UNKNOWN},
-    {0, BTN_LABEL_PROP_BTN_WHEEL_UP},
-    {0, BTN_LABEL_PROP_BTN_WHEEL_DOWN},
-    {0, BTN_LABEL_PROP_BTN_HWHEEL_LEFT},
-    {0, BTN_LABEL_PROP_BTN_HWHEEL_RIGHT},
-    {0, BTN_LABEL_PROP_BTN_0},
-    {0, BTN_LABEL_PROP_BTN_1},
-    {0, BTN_LABEL_PROP_BTN_2},
-    {0, BTN_LABEL_PROP_BTN_3},
-    {0, BTN_LABEL_PROP_BTN_4},
-    {0, BTN_LABEL_PROP_BTN_5},
-    {0, BTN_LABEL_PROP_BTN_6},
-    {0, BTN_LABEL_PROP_BTN_7},
-    {0, BTN_LABEL_PROP_BTN_8},
-    {0, BTN_LABEL_PROP_BTN_9},
-
-    {0, BTN_LABEL_PROP_BTN_LEFT},
-    {0, BTN_LABEL_PROP_BTN_RIGHT},
-    {0, BTN_LABEL_PROP_BTN_MIDDLE},
-    {0, BTN_LABEL_PROP_BTN_SIDE},
-    {0, BTN_LABEL_PROP_BTN_EXTRA},
-    {0, BTN_LABEL_PROP_BTN_FORWARD},
-    {0, BTN_LABEL_PROP_BTN_BACK},
-    {0, BTN_LABEL_PROP_BTN_TASK},
-
-    {0, BTN_LABEL_PROP_BTN_TRIGGER},
-    {0, BTN_LABEL_PROP_BTN_THUMB},
-    {0, BTN_LABEL_PROP_BTN_THUMB2},
-    {0, BTN_LABEL_PROP_BTN_TOP},
-    {0, BTN_LABEL_PROP_BTN_TOP2},
-    {0, BTN_LABEL_PROP_BTN_PINKIE},
-    {0, BTN_LABEL_PROP_BTN_BASE},
-    {0, BTN_LABEL_PROP_BTN_BASE2},
-    {0, BTN_LABEL_PROP_BTN_BASE3},
-    {0, BTN_LABEL_PROP_BTN_BASE4},
-    {0, BTN_LABEL_PROP_BTN_BASE5},
-    {0, BTN_LABEL_PROP_BTN_BASE6},
-    {0, BTN_LABEL_PROP_BTN_DEAD},
-
-    {0, BTN_LABEL_PROP_BTN_A},
-    {0, BTN_LABEL_PROP_BTN_B},
-    {0, BTN_LABEL_PROP_BTN_C},
-    {0, BTN_LABEL_PROP_BTN_X},
-    {0, BTN_LABEL_PROP_BTN_Y},
-    {0, BTN_LABEL_PROP_BTN_Z},
-    {0, BTN_LABEL_PROP_BTN_TL},
-    {0, BTN_LABEL_PROP_BTN_TR},
-    {0, BTN_LABEL_PROP_BTN_TL2},
-    {0, BTN_LABEL_PROP_BTN_TR2},
-    {0, BTN_LABEL_PROP_BTN_SELECT},
-    {0, BTN_LABEL_PROP_BTN_START},
-    {0, BTN_LABEL_PROP_BTN_MODE},
-    {0, BTN_LABEL_PROP_BTN_THUMBL},
-    {0, BTN_LABEL_PROP_BTN_THUMBR},
-
-    {0, BTN_LABEL_PROP_BTN_TOOL_PEN},
-    {0, BTN_LABEL_PROP_BTN_TOOL_RUBBER},
-    {0, BTN_LABEL_PROP_BTN_TOOL_BRUSH},
-    {0, BTN_LABEL_PROP_BTN_TOOL_PENCIL},
-    {0, BTN_LABEL_PROP_BTN_TOOL_AIRBRUSH},
-    {0, BTN_LABEL_PROP_BTN_TOOL_FINGER},
-    {0, BTN_LABEL_PROP_BTN_TOOL_MOUSE},
-    {0, BTN_LABEL_PROP_BTN_TOOL_LENS},
-    {0, BTN_LABEL_PROP_BTN_TOUCH},
-    {0, BTN_LABEL_PROP_BTN_STYLUS},
-    {0, BTN_LABEL_PROP_BTN_STYLUS2},
-    {0, BTN_LABEL_PROP_BTN_TOOL_DOUBLETAP},
-    {0, BTN_LABEL_PROP_BTN_TOOL_TRIPLETAP},
-
-    {0, BTN_LABEL_PROP_BTN_GEAR_DOWN},
-    {0, BTN_LABEL_PROP_BTN_GEAR_UP}
-};
-
-static long XIPropHandlerID = 1;
-
-static void send_property_event(DeviceIntPtr dev, Atom property, int what)
-{
-        devicePropertyNotify    event;
-        xXIPropertyEvent        xi2;
-        int state;
-
-        if (what == XIPropertyDeleted)
-            state = PropertyDelete;
-        else
-            state = PropertyNewValue;
-
-        event.type      = DevicePropertyNotify;
-        event.deviceid  = dev->id;
-        event.state     = state;
-        event.atom      = property;
-        event.time      = currentTime.milliseconds;
-        SendEventToAllWindows(dev, DevicePropertyNotifyMask,
-                              (xEvent*)&event, 1);
-
-        xi2.type        = GenericEvent;
-        xi2.extension   = IReqCode;
-        xi2.length      = 0;
-        xi2.evtype      = XI_PropertyEvent;
-        xi2.deviceid    = dev->id;
-        xi2.time        = currentTime.milliseconds;
-        xi2.property    = property;
-        xi2.what        = what;
-        SendEventToAllWindows(dev, GetEventFilter(dev, (xEvent*)&xi2),
-                              (xEvent*)&xi2, 1);
-}
-
-static int list_atoms(DeviceIntPtr dev, int *natoms, Atom **atoms_return)
-{
-    XIPropertyPtr prop;
-    Atom *atoms         = NULL;
-    int nprops          = 0;
-
-    for (prop = dev->properties.properties; prop; prop = prop->next)
-        nprops++;
-    if (nprops)
-    {
-        Atom *a;
-
-        atoms = xalloc(nprops * sizeof(Atom));
-        if(!atoms)
-            return BadAlloc;
-        a = atoms;
-        for (prop = dev->properties.properties; prop; prop = prop->next, a++)
-            *a = prop->propertyName;
-    }
-
-    *natoms = nprops;
-    *atoms_return = atoms;
-    return Success;
-}
-
-static int
-get_property(ClientPtr client, DeviceIntPtr dev, Atom property, Atom type,
-             BOOL delete, int offset, int length,
-             int *bytes_after, Atom *type_return, int *format, int *nitems,
-             int *length_return, char **data)
-{
-    unsigned long n, len, ind;
-    int rc;
-    XIPropertyPtr prop;
-    XIPropertyValuePtr prop_value;
-
-    if (!ValidAtom(property))
-    {
-        client->errorValue = property;
-        return(BadAtom);
-    }
-    if ((delete != xTrue) && (delete != xFalse))
-    {
-        client->errorValue = delete;
-        return(BadValue);
-    }
-
-    if ((type != AnyPropertyType) && !ValidAtom(type))
-    {
-        client->errorValue = type;
-        return(BadAtom);
-    }
-
-    for (prop = dev->properties.properties; prop; prop = prop->next)
-        if (prop->propertyName == property)
-            break;
-
-    if (!prop)
-    {
-        *bytes_after = 0;
-        *type_return = None;
-        *format = 0;
-        *nitems = 0;
-        *length_return = 0;
-        return Success;
-    }
-
-    rc = XIGetDeviceProperty(dev, property, &prop_value);
-    if (rc != Success)
-    {
-        client->errorValue = property;
-        return rc;
-    }
-
-    /* If the request type and actual type don't match. Return the
-    property information, but not the data. */
-
-    if (((type != prop_value->type) && (type != AnyPropertyType)))
-    {
-        *bytes_after = prop_value->size;
-        *format = prop_value->format;
-        *length_return = 0;
-        *nitems = 0;
-        *type_return = prop_value->type;
-        return Success;
-    }
-
-    /* Return type, format, value to client */
-    n = (prop_value->format/8) * prop_value->size; /* size (bytes) of prop */
-    ind = offset << 2;
-
-   /* If offset is invalid such that it causes "len" to
-            be negative, it's a value error. */
-
-    if (n < ind)
-    {
-        client->errorValue = offset;
-        return BadValue;
-    }
-
-    len = min(n - ind, 4 * length);
-
-    *bytes_after = n - (ind + len);
-    *format = prop_value->format;
-    *length_return = len;
-    if (prop_value->format)
-        *nitems = len / (prop_value->format / 8);
-    else
-        *nitems = 0;
-    *type_return = prop_value->type;
-
-    *data = (char*)prop_value->data + ind;
-
-    return Success;
-}
-
-static int
-check_change_property(ClientPtr client, Atom property, Atom type, int format,
-                      int mode, int nitems)
-{
-    if ((mode != PropModeReplace) && (mode != PropModeAppend) &&
-        (mode != PropModePrepend))
-    {
-        client->errorValue = mode;
-        return BadValue;
-    }
-    if ((format != 8) && (format != 16) && (format != 32))
-    {
-        client->errorValue = format;
-        return BadValue;
-    }
-
-    if (!ValidAtom(property))
-    {
-        client->errorValue = property;
-        return(BadAtom);
-    }
-    if (!ValidAtom(type))
-    {
-        client->errorValue = type;
-        return(BadAtom);
-    }
-
-    return Success;
-}
-
-static int
-change_property(ClientPtr client, DeviceIntPtr dev, Atom property, Atom type,
-                int format, int mode, int len, void *data)
-{
-    int rc = Success;
-
-    rc = XIChangeDeviceProperty(dev, property, type, format, mode, len, data, TRUE);
-    if (rc != Success)
-        client->errorValue = property;
-
-    return rc;
-}
-
-/**
- * Return the atom assigned to the specified string or 0 if the atom isn't known
- * to the DIX.
- *
- * If name is NULL, None is returned.
- */
-Atom
-XIGetKnownProperty(char *name)
-{
-    int i;
-
-    if (!name)
-        return None;
-
-    for (i = 0; i < (sizeof(dev_properties)/sizeof(struct dev_properties)); i++)
-    {
-        if (strcmp(name, dev_properties[i].name) == 0){
-            if (dev_properties[i].type == None){
-		dev_properties[i].type =
-			    MakeAtom(dev_properties[i].name,
-			             strlen(dev_properties[i].name),
-			             TRUE);
-            }
-
-            return dev_properties[i].type;
-        }
-    }
-
-    return 0;
-}
-
-/**
- * Convert the given property's value(s) into @nelem_return integer values and
- * store them in @buf_return. If @nelem_return is larger than the number of
- * values in the property, @nelem_return is set to the number of values in the
- * property.
- *
- * If *@buf_return is NULL and @nelem_return is 0, memory is allocated
- * automatically and must be freed by the caller.
- *
- * Possible return codes.
- * Success ... No error.
- * BadMatch ... Wrong atom type, atom is not XA_INTEGER
- * BadAlloc ... NULL passed as buffer and allocation failed.
- * BadLength ... @buff is NULL but @nelem_return is non-zero.
- *
- * @param val The property value
- * @param nelem_return The maximum number of elements to return.
- * @param buf_return Pointer to an array of at least @nelem_return values.
- * @return Success or the error code if an error occured.
- */
-_X_EXPORT int
-XIPropToInt(XIPropertyValuePtr val, int *nelem_return, int **buf_return)
-{
-    int i;
-    int *buf;
-
-    if (val->type != XA_INTEGER)
-        return BadMatch;
-    if (!*buf_return && *nelem_return)
-        return BadLength;
-
-    switch(val->format)
-    {
-        case 8:
-        case 16:
-        case 32:
-            break;
-        default:
-            return BadValue;
-    }
-
-    buf = *buf_return;
-
-    if (!buf && !(*nelem_return))
-    {
-        buf = xcalloc(val->size, sizeof(int));
-        if (!buf)
-            return BadAlloc;
-        *buf_return = buf;
-        *nelem_return = val->size;
-    } else if (val->size < *nelem_return)
-        *nelem_return = val->size;
-
-    for (i = 0; i < val->size && i < *nelem_return; i++)
-    {
-        switch(val->format)
-        {
-            case 8:  buf[i] = ((CARD8*)val->data)[i]; break;
-            case 16: buf[i] = ((CARD16*)val->data)[i]; break;
-            case 32: buf[i] = ((CARD32*)val->data)[i]; break;
-        }
-    }
-
-    return Success;
-}
-
-/**
- * Convert the given property's value(s) into @nelem_return float values and
- * store them in @buf_return. If @nelem_return is larger than the number of
- * values in the property, @nelem_return is set to the number of values in the
- * property.
- *
- * If *@buf_return is NULL and @nelem_return is 0, memory is allocated
- * automatically and must be freed by the caller.
- *
- * Possible errors returned:
- * Success
- * BadMatch ... Wrong atom type, atom is not XA_FLOAT
- * BadValue ... Wrong format, format is not 32
- * BadAlloc ... NULL passed as buffer and allocation failed.
- * BadLength ... @buff is NULL but @nelem_return is non-zero.
- *
- * @param val The property value
- * @param nelem_return The maximum number of elements to return.
- * @param buf_return Pointer to an array of at least @nelem_return values.
- * @return Success or the error code if an error occured.
- */
-_X_EXPORT int
-XIPropToFloat(XIPropertyValuePtr val, int *nelem_return, float **buf_return)
-{
-    int i;
-    float *buf;
-
-    if (!val->type || val->type != XIGetKnownProperty(XATOM_FLOAT))
-        return BadMatch;
-
-    if (val->format != 32)
-        return BadValue;
-    if (!*buf_return && *nelem_return)
-        return BadLength;
-
-    buf = *buf_return;
-
-    if (!buf && !(*nelem_return))
-    {
-        buf = xcalloc(val->size, sizeof(float));
-        if (!buf)
-            return BadAlloc;
-        *buf_return = buf;
-        *nelem_return = val->size;
-    } else if (val->size < *nelem_return)
-        *nelem_return = val->size;
-
-    for (i = 0; i < val->size && i < *nelem_return; i++)
-           buf[i] = ((float*)val->data)[i];
-
-    return Success;
-}
-
-/* Registers a new property handler on the given device and returns a unique
- * identifier for this handler. This identifier is required to unregister the
- * property handler again.
- * @return The handler's identifier or 0 if an error occured.
- */
-long
-XIRegisterPropertyHandler(DeviceIntPtr         dev,
-                          int (*SetProperty) (DeviceIntPtr dev,
-                                              Atom property,
-                                              XIPropertyValuePtr prop,
-                                              BOOL checkonly),
-                          int (*GetProperty) (DeviceIntPtr dev,
-                                              Atom property),
-                          int (*DeleteProperty) (DeviceIntPtr dev,
-                                                 Atom property))
-{
-    XIPropertyHandlerPtr new_handler;
-
-    new_handler = xcalloc(1, sizeof(XIPropertyHandler));
-    if (!new_handler)
-        return 0;
-
-    new_handler->id = XIPropHandlerID++;
-    new_handler->SetProperty = SetProperty;
-    new_handler->GetProperty = GetProperty;
-    new_handler->DeleteProperty = DeleteProperty;
-    new_handler->next = dev->properties.handlers;
-    dev->properties.handlers = new_handler;
-
-    return new_handler->id;
-}
-
-void
-XIUnregisterPropertyHandler(DeviceIntPtr dev, long id)
-{
-    XIPropertyHandlerPtr curr, prev = NULL;
-
-    curr = dev->properties.handlers;
-    while(curr && curr->id != id)
-    {
-        prev = curr;
-        curr = curr->next;
-    }
-
-    if (!curr)
-        return;
-
-    if (!prev) /* first one */
-        dev->properties.handlers = curr->next;
-    else
-        prev->next = curr->next;
-
-    xfree(curr);
-}
-
-static XIPropertyPtr
-XICreateDeviceProperty (Atom property)
-{
-    XIPropertyPtr   prop;
-
-    prop = (XIPropertyPtr)xalloc(sizeof(XIPropertyRec));
-    if (!prop)
-        return NULL;
-
-    prop->next          = NULL;
-    prop->propertyName  = property;
-    prop->value.type   = None;
-    prop->value.format = 0;
-    prop->value.size   = 0;
-    prop->value.data   = NULL;
-    prop->deletable    = TRUE;
-
-    return prop;
-}
-
-static XIPropertyPtr
-XIFetchDeviceProperty(DeviceIntPtr dev, Atom property)
-{
-    XIPropertyPtr   prop;
-
-    for (prop = dev->properties.properties; prop; prop = prop->next)
-        if (prop->propertyName == property)
-            return prop;
-    return NULL;
-}
-
-static void
-XIDestroyDeviceProperty (XIPropertyPtr prop)
-{
-    if (prop->value.data)
-        xfree(prop->value.data);
-    xfree(prop);
-}
-
-/* This function destroys all of the device's property-related stuff,
- * including removing all device handlers.
- * DO NOT CALL FROM THE DRIVER.
- */
-void
-XIDeleteAllDeviceProperties (DeviceIntPtr device)
-{
-    XIPropertyPtr               prop, next;
-    XIPropertyHandlerPtr        curr_handler, next_handler;
-
-    for (prop = device->properties.properties; prop; prop = next)
-    {
-        next = prop->next;
-        send_property_event(device, prop->propertyName, XIPropertyDeleted);
-        XIDestroyDeviceProperty(prop);
-    }
-
-    device->properties.properties = NULL;
-
-    /* Now free all handlers */
-    curr_handler = device->properties.handlers;
-    while(curr_handler)
-    {
-        next_handler = curr_handler->next;
-        xfree(curr_handler);
-        curr_handler = next_handler;
-    }
-
-    device->properties.handlers = NULL;
-}
-
-
-int
-XIDeleteDeviceProperty (DeviceIntPtr device, Atom property, Bool fromClient)
-{
-    XIPropertyPtr               prop, *prev;
-    int                         rc = Success;
-
-    for (prev = &device->properties.properties; (prop = *prev); prev = &(prop->next))
-        if (prop->propertyName == property)
-            break;
-
-    if (!prop)
-        return Success;
-
-    if (fromClient && !prop->deletable)
-        return BadAccess;
-
-    /* Ask handlers if we may delete the property */
-    if (device->properties.handlers)
-    {
-        XIPropertyHandlerPtr handler = device->properties.handlers;
-        while(handler)
-        {
-            if (handler->DeleteProperty)
-                rc = handler->DeleteProperty(device, prop->propertyName);
-            if (rc != Success)
-                return (rc);
-            handler = handler->next;
-        }
-    }
-
-    if (prop)
-    {
-        *prev = prop->next;
-        send_property_event(device, prop->propertyName, XIPropertyDeleted);
-        XIDestroyDeviceProperty (prop);
-    }
-
-    return Success;
-}
-
-int
-XIChangeDeviceProperty (DeviceIntPtr dev, Atom property, Atom type,
-                        int format, int mode, unsigned long len,
-                        pointer value, Bool sendevent)
-{
-    XIPropertyPtr               prop;
-    int                         size_in_bytes;
-    int                         total_size;
-    unsigned long               total_len;
-    XIPropertyValuePtr          prop_value;
-    XIPropertyValueRec          new_value;
-    Bool                        add = FALSE;
-    int                         rc;
-
-    size_in_bytes = format >> 3;
-
-    /* first see if property already exists */
-    prop = XIFetchDeviceProperty (dev, property);
-    if (!prop)   /* just add to list */
-    {
-        prop = XICreateDeviceProperty (property);
-        if (!prop)
-            return(BadAlloc);
-        add = TRUE;
-        mode = PropModeReplace;
-    }
-    prop_value = &prop->value;
-
-    /* To append or prepend to a property the request format and type
-     must match those of the already defined property.  The
-     existing format and type are irrelevant when using the mode
-     "PropModeReplace" since they will be written over. */
-
-    if ((format != prop_value->format) && (mode != PropModeReplace))
-        return(BadMatch);
-    if ((prop_value->type != type) && (mode != PropModeReplace))
-        return(BadMatch);
-    new_value = *prop_value;
-    if (mode == PropModeReplace)
-        total_len = len;
-    else
-        total_len = prop_value->size + len;
-
-    if (mode == PropModeReplace || len > 0)
-    {
-        pointer            new_data = NULL, old_data = NULL;
-
-        total_size = total_len * size_in_bytes;
-        new_value.data = (pointer)xalloc (total_size);
-        if (!new_value.data && total_size)
-        {
-            if (add)
-                XIDestroyDeviceProperty (prop);
-            return BadAlloc;
-        }
-        new_value.size = len;
-        new_value.type = type;
-        new_value.format = format;
-
-        switch (mode) {
-        case PropModeReplace:
-            new_data = new_value.data;
-            old_data = NULL;
-            break;
-        case PropModeAppend:
-            new_data = (pointer) (((char *) new_value.data) +
-                                  (prop_value->size * size_in_bytes));
-            old_data = new_value.data;
-            break;
-        case PropModePrepend:
-            new_data = new_value.data;
-            old_data = (pointer) (((char *) new_value.data) +
-                                  (prop_value->size * size_in_bytes));
-            break;
-        }
-        if (new_data)
-            memcpy ((char *) new_data, (char *) value, len * size_in_bytes);
-        if (old_data)
-            memcpy ((char *) old_data, (char *) prop_value->data,
-                    prop_value->size * size_in_bytes);
-
-        if (dev->properties.handlers)
-        {
-            XIPropertyHandlerPtr handler;
-            BOOL checkonly = TRUE;
-            /* run through all handlers with checkonly TRUE, then again with
-             * checkonly FALSE. Handlers MUST return error codes on the
-             * checkonly run, errors on the second run are ignored */
-            do
-            {
-                handler = dev->properties.handlers;
-                while(handler)
-                {
-                    if (handler->SetProperty)
-                    {
-                        rc = handler->SetProperty(dev, prop->propertyName,
-                                &new_value, checkonly);
-                        if (checkonly && rc != Success)
-                        {
-                            if (new_value.data)
-                                xfree (new_value.data);
-                            return (rc);
-                        }
-                    }
-                    handler = handler->next;
-                }
-                checkonly = !checkonly;
-            } while (!checkonly);
-        }
-        if (prop_value->data)
-            xfree (prop_value->data);
-        *prop_value = new_value;
-    } else if (len == 0)
-    {
-        /* do nothing */
-    }
-
-    if (add)
-    {
-        prop->next = dev->properties.properties;
-        dev->properties.properties = prop;
-    }
-
-    if (sendevent)
-        send_property_event(dev, prop->propertyName,
-                            (add) ?  XIPropertyCreated : XIPropertyModified);
-
-    return(Success);
-}
-
-int
-XIGetDeviceProperty (DeviceIntPtr dev, Atom property, XIPropertyValuePtr *value)
-{
-    XIPropertyPtr   prop = XIFetchDeviceProperty (dev, property);
-    int rc;
-
-    if (!prop)
-    {
-        *value = NULL;
-        return BadAtom;
-    }
-
-    /* If we can, try to update the property value first */
-    if (dev->properties.handlers)
-    {
-        XIPropertyHandlerPtr handler = dev->properties.handlers;
-        while(handler)
-        {
-            if (handler->GetProperty)
-            {
-                rc = handler->GetProperty(dev, prop->propertyName);
-                if (rc != Success)
-                {
-                    *value = NULL;
-                    return rc;
-                }
-            }
-            handler = handler->next;
-        }
-    }
-
-    *value = &prop->value;
-    return Success;
-}
-
-int
-XISetDevicePropertyDeletable(DeviceIntPtr dev, Atom property, Bool deletable)
-{
-    XIPropertyPtr prop = XIFetchDeviceProperty(dev, property);
-
-    if (!prop)
-        return BadAtom;
-
-    prop->deletable = deletable;
-    return Success;
-}
-
-int
-ProcXListDeviceProperties (ClientPtr client)
-{
-    Atom                        *atoms;
-    xListDevicePropertiesReply  rep;
-    int                         natoms;
-    DeviceIntPtr                dev;
-    int                         rc = Success;
-
-    REQUEST(xListDevicePropertiesReq);
-    REQUEST_SIZE_MATCH(xListDevicePropertiesReq);
-
-    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixListPropAccess);
-    if (rc != Success)
-        return rc;
-
-    rc = list_atoms(dev, &natoms, &atoms);
-    if (rc != Success)
-        return rc;
-
-    rep.repType = X_Reply;
-    rep.RepType = X_ListDeviceProperties;
-    rep.length = natoms;
-    rep.sequenceNumber = client->sequence;
-    rep.nAtoms = natoms;
-
-    WriteReplyToClient(client, sizeof(xListDevicePropertiesReply), &rep);
-    if (natoms)
-    {
-        client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
-        WriteSwappedDataToClient(client, natoms * sizeof(Atom), atoms);
-        xfree(atoms);
-    }
-    return rc;
-}
-
-int
-ProcXChangeDeviceProperty (ClientPtr client)
-{
-    REQUEST(xChangeDevicePropertyReq);
-    DeviceIntPtr        dev;
-    unsigned long       len;
-    int                 totalSize;
-    int                 rc;
-
-    REQUEST_AT_LEAST_SIZE(xChangeDevicePropertyReq);
-    UpdateCurrentTime();
-
-    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);
-    if (rc != Success)
-        return rc;
-
-    rc = check_change_property(client, stuff->property, stuff->type,
-                               stuff->format, stuff->mode, stuff->nUnits);
-
-    len = stuff->nUnits;
-    if (len > (bytes_to_int32(0xffffffff - sizeof(xChangeDevicePropertyReq))))
-        return BadLength;
-
-    totalSize = len * (stuff->format/8);
-    REQUEST_FIXED_SIZE(xChangeDevicePropertyReq, totalSize);
-
-    rc = change_property(client, dev, stuff->property, stuff->type,
-                         stuff->format, stuff->mode, len, (void*)&stuff[1]);
-    return rc;
-}
-
-int
-ProcXDeleteDeviceProperty (ClientPtr client)
-{
-    REQUEST(xDeleteDevicePropertyReq);
-    DeviceIntPtr        dev;
-    int                 rc;
-
-    REQUEST_SIZE_MATCH(xDeleteDevicePropertyReq);
-    UpdateCurrentTime();
-    rc =  dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);
-    if (rc != Success)
-        return rc;
-
-    if (!ValidAtom(stuff->property))
-    {
-        client->errorValue = stuff->property;
-        return (BadAtom);
-    }
-
-    rc = XIDeleteDeviceProperty(dev, stuff->property, TRUE);
-    return rc;
-}
-
-int
-ProcXGetDeviceProperty (ClientPtr client)
-{
-    REQUEST(xGetDevicePropertyReq);
-    DeviceIntPtr                dev;
-    int                         length;
-    int                         rc, format, nitems, bytes_after;
-    char                        *data;
-    Atom                        type;
-    xGetDevicePropertyReply     reply;
-
-    REQUEST_SIZE_MATCH(xGetDevicePropertyReq);
-    if (stuff->delete)
-        UpdateCurrentTime();
-    rc = dixLookupDevice (&dev, stuff->deviceid, client,
-                           stuff->delete ? DixSetPropAccess :
-                           DixGetPropAccess);
-    if (rc != Success)
-        return rc;
-
-    rc = get_property(client, dev, stuff->property, stuff->type,
-            stuff->delete, stuff->longOffset, stuff->longLength,
-            &bytes_after, &type, &format, &nitems, &length, &data);
-
-    if (rc != Success)
-        return rc;
-
-    reply.repType = X_Reply;
-    reply.RepType = X_GetDeviceProperty;
-    reply.sequenceNumber = client->sequence;
-    reply.deviceid = dev->id;
-    reply.nItems = nitems;
-    reply.format = format;
-    reply.bytesAfter = bytes_after;
-    reply.propertyType = type;
-    reply.length = bytes_to_int32(length);
-
-    if (stuff->delete && (reply.bytesAfter == 0))
-        send_property_event(dev, stuff->property, XIPropertyDeleted);
-
-    WriteReplyToClient(client, sizeof(xGenericReply), &reply);
-
-    if (length)
-    {
-        switch (reply.format) {
-            case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break;
-            case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break;
-            default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break;
-        }
-        WriteSwappedDataToClient(client, length, data);
-    }
-
-    /* delete the Property */
-    if (stuff->delete && (reply.bytesAfter == 0))
-    {
-        XIPropertyPtr prop, *prev;
-        for (prev = &dev->properties.properties; (prop = *prev); prev = &prop->next)
-        {
-            if (prop->propertyName == stuff->property)
-            {
-                *prev = prop->next;
-                XIDestroyDeviceProperty(prop);
-                break;
-            }
-        }
-    }
-    return Success;
-}
-
-
-int
-SProcXListDeviceProperties (ClientPtr client)
-{
-    char n;
-    REQUEST(xListDevicePropertiesReq);
-
-    swaps(&stuff->length, n);
-
-    REQUEST_SIZE_MATCH(xListDevicePropertiesReq);
-    return (ProcXListDeviceProperties(client));
-}
-
-int
-SProcXChangeDeviceProperty (ClientPtr client)
-{
-    char n;
-    REQUEST(xChangeDevicePropertyReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->nUnits, n);
-    REQUEST_SIZE_MATCH(xChangeDevicePropertyReq);
-    return (ProcXChangeDeviceProperty(client));
-}
-
-int
-SProcXDeleteDeviceProperty (ClientPtr client)
-{
-    char n;
-    REQUEST(xDeleteDevicePropertyReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->property, n);
-    REQUEST_SIZE_MATCH(xDeleteDevicePropertyReq);
-    return (ProcXDeleteDeviceProperty(client));
-}
-
-int
-SProcXGetDeviceProperty (ClientPtr client)
-{
-    char n;
-    REQUEST(xGetDevicePropertyReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->longOffset, n);
-    swapl(&stuff->longLength, n);
-    REQUEST_SIZE_MATCH(xGetDevicePropertyReq);
-    return (ProcXGetDeviceProperty(client));
-}
-
-
-/* Reply swapping */
-
-void
-SRepXListDeviceProperties(ClientPtr client, int size,
-                          xListDevicePropertiesReply *rep)
-{
-    char n;
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swaps(&rep->nAtoms, n);
-    /* properties will be swapped later, see ProcXListDeviceProperties */
-    WriteToClient(client, size, (char*)rep);
-}
-
-void
-SRepXGetDeviceProperty(ClientPtr client, int size,
-                       xGetDevicePropertyReply *rep)
-{
-    char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swapl(&rep->propertyType, n);
-    swapl(&rep->bytesAfter, n);
-    swapl(&rep->nItems, n);
-    /* data will be swapped, see ProcXGetDeviceProperty */
-    WriteToClient(client, size, (char*)rep);
-}
-
-/* XI2 Request/reply handling */
-int
-ProcXIListProperties(ClientPtr client)
-{
-    Atom                        *atoms;
-    xXIListPropertiesReply      rep;
-    int                         natoms;
-    DeviceIntPtr                dev;
-    int                         rc = Success;
-
-    REQUEST(xXIListPropertiesReq);
-    REQUEST_SIZE_MATCH(xXIListPropertiesReq);
-
-    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixListPropAccess);
-    if (rc != Success)
-        return rc;
-
-    rc = list_atoms(dev, &natoms, &atoms);
-    if (rc != Success)
-        return rc;
-
-    rep.repType = X_Reply;
-    rep.RepType = X_XIListProperties;
-    rep.length = natoms;
-    rep.sequenceNumber = client->sequence;
-    rep.num_properties = natoms;
-
-    WriteReplyToClient(client, sizeof(xXIListPropertiesReply), &rep);
-    if (natoms)
-    {
-        client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
-        WriteSwappedDataToClient(client, natoms * sizeof(Atom), atoms);
-        xfree(atoms);
-    }
-    return rc;
-}
-
-int
-ProcXIChangeProperty(ClientPtr client)
-{
-    int                 rc;
-    DeviceIntPtr        dev;
-    int                 totalSize;
-    unsigned long       len;
-
-    REQUEST(xXIChangePropertyReq);
-    REQUEST_AT_LEAST_SIZE(xXIChangePropertyReq);
-    UpdateCurrentTime();
-
-    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);
-    if (rc != Success)
-        return rc;
-
-    rc = check_change_property(client, stuff->property, stuff->type,
-                               stuff->format, stuff->mode, stuff->num_items);
-    len = stuff->num_items;
-    if (len > bytes_to_int32(0xffffffff - sizeof(xXIChangePropertyReq)))
-        return BadLength;
-
-    totalSize = len * (stuff->format/8);
-    REQUEST_FIXED_SIZE(xXIChangePropertyReq, totalSize);
-
-    rc = change_property(client, dev, stuff->property, stuff->type,
-                         stuff->format, stuff->mode, len, (void*)&stuff[1]);
-    return rc;
-}
-
-int
-ProcXIDeleteProperty(ClientPtr client)
-{
-    DeviceIntPtr        dev;
-    int                 rc;
-    REQUEST(xXIDeletePropertyReq);
-
-    REQUEST_SIZE_MATCH(xXIDeletePropertyReq);
-    UpdateCurrentTime();
-    rc =  dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);
-    if (rc != Success)
-        return rc;
-
-    if (!ValidAtom(stuff->property))
-    {
-        client->errorValue = stuff->property;
-        return (BadAtom);
-    }
-
-    rc = XIDeleteDeviceProperty(dev, stuff->property, TRUE);
-    return rc;
-}
-
-
-int
-ProcXIGetProperty(ClientPtr client)
-{
-    REQUEST(xXIGetPropertyReq);
-    DeviceIntPtr                dev;
-    xXIGetPropertyReply         reply;
-    int                         length;
-    int                         rc, format, nitems, bytes_after;
-    char                        *data;
-    Atom                        type;
-
-    REQUEST_SIZE_MATCH(xXIGetPropertyReq);
-    if (stuff->delete)
-        UpdateCurrentTime();
-    rc = dixLookupDevice (&dev, stuff->deviceid, client,
-                           stuff->delete ? DixSetPropAccess :
-                           DixGetPropAccess);
-    if (rc != Success)
-        return rc;
-
-    rc = get_property(client, dev, stuff->property, stuff->type,
-            stuff->delete, stuff->offset, stuff->len,
-            &bytes_after, &type, &format, &nitems, &length, &data);
-
-    if (rc != Success)
-        return rc;
-
-    reply.repType = X_Reply;
-    reply.RepType = X_XIGetProperty;
-    reply.sequenceNumber = client->sequence;
-    reply.num_items = nitems;
-    reply.format = format;
-    reply.bytes_after = bytes_after;
-    reply.type = type;
-    reply.length = bytes_to_int32(length);
-
-    if (length && stuff->delete && (reply.bytes_after == 0))
-        send_property_event(dev, stuff->property, XIPropertyDeleted);
-
-    WriteReplyToClient(client, sizeof(xXIGetPropertyReply), &reply);
-
-    if (length)
-    {
-        switch (reply.format) {
-            case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break;
-            case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break;
-            default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break;
-        }
-        WriteSwappedDataToClient(client, length, data);
-    }
-
-    /* delete the Property */
-    if (stuff->delete && (reply.bytes_after == 0))
-    {
-        XIPropertyPtr prop, *prev;
-        for (prev = &dev->properties.properties; (prop = *prev); prev = &prop->next)
-        {
-            if (prop->propertyName == stuff->property)
-            {
-                *prev = prop->next;
-                XIDestroyDeviceProperty(prop);
-                break;
-            }
-        }
-    }
-
-    return Success;
-}
-
-int
-SProcXIListProperties(ClientPtr client)
-{
-    char n;
-    REQUEST(xXIListPropertiesReq);
-
-    swaps(&stuff->length, n);
-    swaps(&stuff->deviceid, n);
-
-    REQUEST_SIZE_MATCH(xXIListPropertiesReq);
-    return (ProcXIListProperties(client));
-}
-
-int
-SProcXIChangeProperty(ClientPtr client)
-{
-    char n;
-    REQUEST(xXIChangePropertyReq);
-
-    swaps(&stuff->length, n);
-    swaps(&stuff->deviceid, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->num_items, n);
-    REQUEST_SIZE_MATCH(xXIChangePropertyReq);
-    return (ProcXIChangeProperty(client));
-}
-
-int
-SProcXIDeleteProperty(ClientPtr client)
-{
-    char n;
-    REQUEST(xXIDeletePropertyReq);
-
-    swaps(&stuff->length, n);
-    swaps(&stuff->deviceid, n);
-    swapl(&stuff->property, n);
-    REQUEST_SIZE_MATCH(xXIDeletePropertyReq);
-    return (ProcXIDeleteProperty(client));
-}
-
-int
-SProcXIGetProperty(ClientPtr client)
-{
-    char n;
-    REQUEST(xXIGetPropertyReq);
-
-    swaps(&stuff->length, n);
-    swaps(&stuff->deviceid, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->offset, n);
-    swapl(&stuff->len, n);
-    REQUEST_SIZE_MATCH(xXIGetPropertyReq);
-    return (ProcXIGetProperty(client));
-}
-
-
-void
-SRepXIListProperties(ClientPtr client, int size,
-                     xXIListPropertiesReply *rep)
-{
-    char n;
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swaps(&rep->num_properties, n);
-    /* properties will be swapped later, see ProcXIListProperties */
-    WriteToClient(client, size, (char*)rep);
-}
-
-void
-SRepXIGetProperty(ClientPtr client, int size,
-                  xXIGetPropertyReply *rep)
-{
-    char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swapl(&rep->type, n);
-    swapl(&rep->bytes_after, n);
-    swapl(&rep->num_items, n);
-    /* data will be swapped, see ProcXIGetProperty */
-    WriteToClient(client, size, (char*)rep);
-}
+/*

+ * Copyright © 2006 Keith Packard

+ * Copyright © 2008 Peter Hutterer

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WAXIANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WAXIANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ */

+

+/* This code is a modified version of randr/rrproperty.c */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "dix.h"

+#include "inputstr.h"

+#include <X11/extensions/XI.h>

+#include <X11/Xatom.h>

+#include <X11/extensions/XIproto.h>

+#include <X11/extensions/XI2proto.h>

+#include "exglobals.h"

+#include "exevents.h"

+#include "swaprep.h"

+

+#include "xiproperty.h"

+#include "xserver-properties.h"

+

+/**

+ * Properties used or alloced from inside the server.

+ */

+static struct dev_properties

+{

+    Atom type;

+    char *name;

+} dev_properties[] = {

+    {0, XI_PROP_ENABLED},

+    {0, XI_PROP_XTEST_DEVICE},

+    {0, XATOM_FLOAT},

+    {0, ACCEL_PROP_PROFILE_NUMBER},

+    {0, ACCEL_PROP_CONSTANT_DECELERATION},

+    {0, ACCEL_PROP_ADAPTIVE_DECELERATION},

+    {0, ACCEL_PROP_VELOCITY_SCALING},

+    {0, AXIS_LABEL_PROP},

+    {0, AXIS_LABEL_PROP_REL_X},

+    {0, AXIS_LABEL_PROP_REL_Y},

+    {0, AXIS_LABEL_PROP_REL_Z},

+    {0, AXIS_LABEL_PROP_REL_RX},

+    {0, AXIS_LABEL_PROP_REL_RY},

+    {0, AXIS_LABEL_PROP_REL_RZ},

+    {0, AXIS_LABEL_PROP_REL_HWHEEL},

+    {0, AXIS_LABEL_PROP_REL_DIAL},

+    {0, AXIS_LABEL_PROP_REL_WHEEL},

+    {0, AXIS_LABEL_PROP_REL_MISC},

+    {0, AXIS_LABEL_PROP_ABS_X},

+    {0, AXIS_LABEL_PROP_ABS_Y},

+    {0, AXIS_LABEL_PROP_ABS_Z},

+    {0, AXIS_LABEL_PROP_ABS_RX},

+    {0, AXIS_LABEL_PROP_ABS_RY},

+    {0, AXIS_LABEL_PROP_ABS_RZ},

+    {0, AXIS_LABEL_PROP_ABS_THROTTLE},

+    {0, AXIS_LABEL_PROP_ABS_RUDDER},

+    {0, AXIS_LABEL_PROP_ABS_WHEEL},

+    {0, AXIS_LABEL_PROP_ABS_GAS},

+    {0, AXIS_LABEL_PROP_ABS_BRAKE},

+    {0, AXIS_LABEL_PROP_ABS_HAT0X},

+    {0, AXIS_LABEL_PROP_ABS_HAT0Y},

+    {0, AXIS_LABEL_PROP_ABS_HAT1X},

+    {0, AXIS_LABEL_PROP_ABS_HAT1Y},

+    {0, AXIS_LABEL_PROP_ABS_HAT2X},

+    {0, AXIS_LABEL_PROP_ABS_HAT2Y},

+    {0, AXIS_LABEL_PROP_ABS_HAT3X},

+    {0, AXIS_LABEL_PROP_ABS_HAT3Y},

+    {0, AXIS_LABEL_PROP_ABS_PRESSURE},

+    {0, AXIS_LABEL_PROP_ABS_DISTANCE},

+    {0, AXIS_LABEL_PROP_ABS_TILT_X},

+    {0, AXIS_LABEL_PROP_ABS_TILT_Y},

+    {0, AXIS_LABEL_PROP_ABS_TOOL_WIDTH},

+    {0, AXIS_LABEL_PROP_ABS_VOLUME},

+    {0, AXIS_LABEL_PROP_ABS_MT_TOUCH_MAJOR},

+    {0, AXIS_LABEL_PROP_ABS_MT_TOUCH_MINOR},

+    {0, AXIS_LABEL_PROP_ABS_MT_WIDTH_MAJOR},

+    {0, AXIS_LABEL_PROP_ABS_MT_WIDTH_MINOR},

+    {0, AXIS_LABEL_PROP_ABS_MT_ORIENTATION},

+    {0, AXIS_LABEL_PROP_ABS_MT_POSITION_X},

+    {0, AXIS_LABEL_PROP_ABS_MT_POSITION_Y},

+    {0, AXIS_LABEL_PROP_ABS_MT_TOOL_TYPE},

+    {0, AXIS_LABEL_PROP_ABS_MT_BLOB_ID},

+    {0, AXIS_LABEL_PROP_ABS_MT_TRACKING_ID},

+    {0, AXIS_LABEL_PROP_ABS_MT_PRESSURE},

+    {0, AXIS_LABEL_PROP_ABS_MISC},

+

+    {0, BTN_LABEL_PROP},

+    {0, BTN_LABEL_PROP_BTN_UNKNOWN},

+    {0, BTN_LABEL_PROP_BTN_WHEEL_UP},

+    {0, BTN_LABEL_PROP_BTN_WHEEL_DOWN},

+    {0, BTN_LABEL_PROP_BTN_HWHEEL_LEFT},

+    {0, BTN_LABEL_PROP_BTN_HWHEEL_RIGHT},

+    {0, BTN_LABEL_PROP_BTN_0},

+    {0, BTN_LABEL_PROP_BTN_1},

+    {0, BTN_LABEL_PROP_BTN_2},

+    {0, BTN_LABEL_PROP_BTN_3},

+    {0, BTN_LABEL_PROP_BTN_4},

+    {0, BTN_LABEL_PROP_BTN_5},

+    {0, BTN_LABEL_PROP_BTN_6},

+    {0, BTN_LABEL_PROP_BTN_7},

+    {0, BTN_LABEL_PROP_BTN_8},

+    {0, BTN_LABEL_PROP_BTN_9},

+

+    {0, BTN_LABEL_PROP_BTN_LEFT},

+    {0, BTN_LABEL_PROP_BTN_RIGHT},

+    {0, BTN_LABEL_PROP_BTN_MIDDLE},

+    {0, BTN_LABEL_PROP_BTN_SIDE},

+    {0, BTN_LABEL_PROP_BTN_EXTRA},

+    {0, BTN_LABEL_PROP_BTN_FORWARD},

+    {0, BTN_LABEL_PROP_BTN_BACK},

+    {0, BTN_LABEL_PROP_BTN_TASK},

+

+    {0, BTN_LABEL_PROP_BTN_TRIGGER},

+    {0, BTN_LABEL_PROP_BTN_THUMB},

+    {0, BTN_LABEL_PROP_BTN_THUMB2},

+    {0, BTN_LABEL_PROP_BTN_TOP},

+    {0, BTN_LABEL_PROP_BTN_TOP2},

+    {0, BTN_LABEL_PROP_BTN_PINKIE},

+    {0, BTN_LABEL_PROP_BTN_BASE},

+    {0, BTN_LABEL_PROP_BTN_BASE2},

+    {0, BTN_LABEL_PROP_BTN_BASE3},

+    {0, BTN_LABEL_PROP_BTN_BASE4},

+    {0, BTN_LABEL_PROP_BTN_BASE5},

+    {0, BTN_LABEL_PROP_BTN_BASE6},

+    {0, BTN_LABEL_PROP_BTN_DEAD},

+

+    {0, BTN_LABEL_PROP_BTN_A},

+    {0, BTN_LABEL_PROP_BTN_B},

+    {0, BTN_LABEL_PROP_BTN_C},

+    {0, BTN_LABEL_PROP_BTN_X},

+    {0, BTN_LABEL_PROP_BTN_Y},

+    {0, BTN_LABEL_PROP_BTN_Z},

+    {0, BTN_LABEL_PROP_BTN_TL},

+    {0, BTN_LABEL_PROP_BTN_TR},

+    {0, BTN_LABEL_PROP_BTN_TL2},

+    {0, BTN_LABEL_PROP_BTN_TR2},

+    {0, BTN_LABEL_PROP_BTN_SELECT},

+    {0, BTN_LABEL_PROP_BTN_START},

+    {0, BTN_LABEL_PROP_BTN_MODE},

+    {0, BTN_LABEL_PROP_BTN_THUMBL},

+    {0, BTN_LABEL_PROP_BTN_THUMBR},

+

+    {0, BTN_LABEL_PROP_BTN_TOOL_PEN},

+    {0, BTN_LABEL_PROP_BTN_TOOL_RUBBER},

+    {0, BTN_LABEL_PROP_BTN_TOOL_BRUSH},

+    {0, BTN_LABEL_PROP_BTN_TOOL_PENCIL},

+    {0, BTN_LABEL_PROP_BTN_TOOL_AIRBRUSH},

+    {0, BTN_LABEL_PROP_BTN_TOOL_FINGER},

+    {0, BTN_LABEL_PROP_BTN_TOOL_MOUSE},

+    {0, BTN_LABEL_PROP_BTN_TOOL_LENS},

+    {0, BTN_LABEL_PROP_BTN_TOUCH},

+    {0, BTN_LABEL_PROP_BTN_STYLUS},

+    {0, BTN_LABEL_PROP_BTN_STYLUS2},

+    {0, BTN_LABEL_PROP_BTN_TOOL_DOUBLETAP},

+    {0, BTN_LABEL_PROP_BTN_TOOL_TRIPLETAP},

+

+    {0, BTN_LABEL_PROP_BTN_GEAR_DOWN},

+    {0, BTN_LABEL_PROP_BTN_GEAR_UP}

+};

+

+static long XIPropHandlerID = 1;

+

+static void send_property_event(DeviceIntPtr dev, Atom property, int what)

+{

+        devicePropertyNotify    event;

+        xXIPropertyEvent        xi2;

+        int state;

+

+        if (what == XIPropertyDeleted)

+            state = PropertyDelete;

+        else

+            state = PropertyNewValue;

+

+        event.type      = DevicePropertyNotify;

+        event.deviceid  = dev->id;

+        event.state     = state;

+        event.atom      = property;

+        event.time      = currentTime.milliseconds;

+        SendEventToAllWindows(dev, DevicePropertyNotifyMask,

+                              (xEvent*)&event, 1);

+

+        xi2.type        = GenericEvent;

+        xi2.extension   = IReqCode;

+        xi2.length      = 0;

+        xi2.evtype      = XI_PropertyEvent;

+        xi2.deviceid    = dev->id;

+        xi2.time        = currentTime.milliseconds;

+        xi2.property    = property;

+        xi2.what        = what;

+        SendEventToAllWindows(dev, GetEventFilter(dev, (xEvent*)&xi2),

+                              (xEvent*)&xi2, 1);

+}

+

+static int list_atoms(DeviceIntPtr dev, int *natoms, Atom **atoms_return)

+{

+    XIPropertyPtr prop;

+    Atom *atoms         = NULL;

+    int nprops          = 0;

+

+    for (prop = dev->properties.properties; prop; prop = prop->next)

+        nprops++;

+    if (nprops)

+    {

+        Atom *a;

+

+        atoms = xalloc(nprops * sizeof(Atom));

+        if(!atoms)

+            return BadAlloc;

+        a = atoms;

+        for (prop = dev->properties.properties; prop; prop = prop->next, a++)

+            *a = prop->propertyName;

+    }

+

+    *natoms = nprops;

+    *atoms_return = atoms;

+    return Success;

+}

+

+static int

+get_property(ClientPtr client, DeviceIntPtr dev, Atom property, Atom type,

+             BOOL delete, int offset, int length,

+             int *bytes_after, Atom *type_return, int *format, int *nitems,

+             int *length_return, char **data)

+{

+    unsigned long n, len, ind;

+    int rc;

+    XIPropertyPtr prop;

+    XIPropertyValuePtr prop_value;

+

+    if (!ValidAtom(property))

+    {

+        client->errorValue = property;

+        return(BadAtom);

+    }

+    if ((delete != xTrue) && (delete != xFalse))

+    {

+        client->errorValue = delete;

+        return(BadValue);

+    }

+

+    if ((type != AnyPropertyType) && !ValidAtom(type))

+    {

+        client->errorValue = type;

+        return(BadAtom);

+    }

+

+    for (prop = dev->properties.properties; prop; prop = prop->next)

+        if (prop->propertyName == property)

+            break;

+

+    if (!prop)

+    {

+        *bytes_after = 0;

+        *type_return = None;

+        *format = 0;

+        *nitems = 0;

+        *length_return = 0;

+        return Success;

+    }

+

+    rc = XIGetDeviceProperty(dev, property, &prop_value);

+    if (rc != Success)

+    {

+        client->errorValue = property;

+        return rc;

+    }

+

+    /* If the request type and actual type don't match. Return the

+    property information, but not the data. */

+

+    if (((type != prop_value->type) && (type != AnyPropertyType)))

+    {

+        *bytes_after = prop_value->size;

+        *format = prop_value->format;

+        *length_return = 0;

+        *nitems = 0;

+        *type_return = prop_value->type;

+        return Success;

+    }

+

+    /* Return type, format, value to client */

+    n = (prop_value->format/8) * prop_value->size; /* size (bytes) of prop */

+    ind = offset << 2;

+

+   /* If offset is invalid such that it causes "len" to

+            be negative, it's a value error. */

+

+    if (n < ind)

+    {

+        client->errorValue = offset;

+        return BadValue;

+    }

+

+    len = min(n - ind, 4 * length);

+

+    *bytes_after = n - (ind + len);

+    *format = prop_value->format;

+    *length_return = len;

+    if (prop_value->format)

+        *nitems = len / (prop_value->format / 8);

+    else

+        *nitems = 0;

+    *type_return = prop_value->type;

+

+    *data = (char*)prop_value->data + ind;

+

+    return Success;

+}

+

+static int

+check_change_property(ClientPtr client, Atom property, Atom type, int format,

+                      int mode, int nitems)

+{

+    if ((mode != PropModeReplace) && (mode != PropModeAppend) &&

+        (mode != PropModePrepend))

+    {

+        client->errorValue = mode;

+        return BadValue;

+    }

+    if ((format != 8) && (format != 16) && (format != 32))

+    {

+        client->errorValue = format;

+        return BadValue;

+    }

+

+    if (!ValidAtom(property))

+    {

+        client->errorValue = property;

+        return(BadAtom);

+    }

+    if (!ValidAtom(type))

+    {

+        client->errorValue = type;

+        return(BadAtom);

+    }

+

+    return Success;

+}

+

+static int

+change_property(ClientPtr client, DeviceIntPtr dev, Atom property, Atom type,

+                int format, int mode, int len, void *data)

+{

+    int rc = Success;

+

+    rc = XIChangeDeviceProperty(dev, property, type, format, mode, len, data, TRUE);

+    if (rc != Success)

+        client->errorValue = property;

+

+    return rc;

+}

+

+/**

+ * Return the atom assigned to the specified string or 0 if the atom isn't known

+ * to the DIX.

+ *

+ * If name is NULL, None is returned.

+ */

+Atom

+XIGetKnownProperty(char *name)

+{

+    int i;

+

+    if (!name)

+        return None;

+

+    for (i = 0; i < (sizeof(dev_properties)/sizeof(struct dev_properties)); i++)

+    {

+        if (strcmp(name, dev_properties[i].name) == 0){

+            if (dev_properties[i].type == None){

+		dev_properties[i].type =

+			    MakeAtom(dev_properties[i].name,

+			             strlen(dev_properties[i].name),

+			             TRUE);

+            }

+

+            return dev_properties[i].type;

+        }

+    }

+

+    return 0;

+}

+

+void

+XIResetProperties(void)

+{

+    int i;

+

+    for (i = 0; i < (sizeof(dev_properties)/sizeof(struct dev_properties)); i++)

+        dev_properties[i].type = None;

+}

+

+/**

+ * Convert the given property's value(s) into @nelem_return integer values and

+ * store them in @buf_return. If @nelem_return is larger than the number of

+ * values in the property, @nelem_return is set to the number of values in the

+ * property.

+ *

+ * If *@buf_return is NULL and @nelem_return is 0, memory is allocated

+ * automatically and must be freed by the caller.

+ *

+ * Possible return codes.

+ * Success ... No error.

+ * BadMatch ... Wrong atom type, atom is not XA_INTEGER

+ * BadAlloc ... NULL passed as buffer and allocation failed.

+ * BadLength ... @buff is NULL but @nelem_return is non-zero.

+ *

+ * @param val The property value

+ * @param nelem_return The maximum number of elements to return.

+ * @param buf_return Pointer to an array of at least @nelem_return values.

+ * @return Success or the error code if an error occured.

+ */

+_X_EXPORT int

+XIPropToInt(XIPropertyValuePtr val, int *nelem_return, int **buf_return)

+{

+    int i;

+    int *buf;

+

+    if (val->type != XA_INTEGER)

+        return BadMatch;

+    if (!*buf_return && *nelem_return)

+        return BadLength;

+

+    switch(val->format)

+    {

+        case 8:

+        case 16:

+        case 32:

+            break;

+        default:

+            return BadValue;

+    }

+

+    buf = *buf_return;

+

+    if (!buf && !(*nelem_return))

+    {

+        buf = xcalloc(val->size, sizeof(int));

+        if (!buf)

+            return BadAlloc;

+        *buf_return = buf;

+        *nelem_return = val->size;

+    } else if (val->size < *nelem_return)

+        *nelem_return = val->size;

+

+    for (i = 0; i < val->size && i < *nelem_return; i++)

+    {

+        switch(val->format)

+        {

+            case 8:  buf[i] = ((CARD8*)val->data)[i]; break;

+            case 16: buf[i] = ((CARD16*)val->data)[i]; break;

+            case 32: buf[i] = ((CARD32*)val->data)[i]; break;

+        }

+    }

+

+    return Success;

+}

+

+/**

+ * Convert the given property's value(s) into @nelem_return float values and

+ * store them in @buf_return. If @nelem_return is larger than the number of

+ * values in the property, @nelem_return is set to the number of values in the

+ * property.

+ *

+ * If *@buf_return is NULL and @nelem_return is 0, memory is allocated

+ * automatically and must be freed by the caller.

+ *

+ * Possible errors returned:

+ * Success

+ * BadMatch ... Wrong atom type, atom is not XA_FLOAT

+ * BadValue ... Wrong format, format is not 32

+ * BadAlloc ... NULL passed as buffer and allocation failed.

+ * BadLength ... @buff is NULL but @nelem_return is non-zero.

+ *

+ * @param val The property value

+ * @param nelem_return The maximum number of elements to return.

+ * @param buf_return Pointer to an array of at least @nelem_return values.

+ * @return Success or the error code if an error occured.

+ */

+_X_EXPORT int

+XIPropToFloat(XIPropertyValuePtr val, int *nelem_return, float **buf_return)

+{

+    int i;

+    float *buf;

+

+    if (!val->type || val->type != XIGetKnownProperty(XATOM_FLOAT))

+        return BadMatch;

+

+    if (val->format != 32)

+        return BadValue;

+    if (!*buf_return && *nelem_return)

+        return BadLength;

+

+    buf = *buf_return;

+

+    if (!buf && !(*nelem_return))

+    {

+        buf = xcalloc(val->size, sizeof(float));

+        if (!buf)

+            return BadAlloc;

+        *buf_return = buf;

+        *nelem_return = val->size;

+    } else if (val->size < *nelem_return)

+        *nelem_return = val->size;

+

+    for (i = 0; i < val->size && i < *nelem_return; i++)

+           buf[i] = ((float*)val->data)[i];

+

+    return Success;

+}

+

+/* Registers a new property handler on the given device and returns a unique

+ * identifier for this handler. This identifier is required to unregister the

+ * property handler again.

+ * @return The handler's identifier or 0 if an error occured.

+ */

+long

+XIRegisterPropertyHandler(DeviceIntPtr         dev,

+                          int (*SetProperty) (DeviceIntPtr dev,

+                                              Atom property,

+                                              XIPropertyValuePtr prop,

+                                              BOOL checkonly),

+                          int (*GetProperty) (DeviceIntPtr dev,

+                                              Atom property),

+                          int (*DeleteProperty) (DeviceIntPtr dev,

+                                                 Atom property))

+{

+    XIPropertyHandlerPtr new_handler;

+

+    new_handler = xcalloc(1, sizeof(XIPropertyHandler));

+    if (!new_handler)

+        return 0;

+

+    new_handler->id = XIPropHandlerID++;

+    new_handler->SetProperty = SetProperty;

+    new_handler->GetProperty = GetProperty;

+    new_handler->DeleteProperty = DeleteProperty;

+    new_handler->next = dev->properties.handlers;

+    dev->properties.handlers = new_handler;

+

+    return new_handler->id;

+}

+

+void

+XIUnregisterPropertyHandler(DeviceIntPtr dev, long id)

+{

+    XIPropertyHandlerPtr curr, prev = NULL;

+

+    curr = dev->properties.handlers;

+    while(curr && curr->id != id)

+    {

+        prev = curr;

+        curr = curr->next;

+    }

+

+    if (!curr)

+        return;

+

+    if (!prev) /* first one */

+        dev->properties.handlers = curr->next;

+    else

+        prev->next = curr->next;

+

+    xfree(curr);

+}

+

+static XIPropertyPtr

+XICreateDeviceProperty (Atom property)

+{

+    XIPropertyPtr   prop;

+

+    prop = (XIPropertyPtr)xalloc(sizeof(XIPropertyRec));

+    if (!prop)

+        return NULL;

+

+    prop->next          = NULL;

+    prop->propertyName  = property;

+    prop->value.type   = None;

+    prop->value.format = 0;

+    prop->value.size   = 0;

+    prop->value.data   = NULL;

+    prop->deletable    = TRUE;

+

+    return prop;

+}

+

+static XIPropertyPtr

+XIFetchDeviceProperty(DeviceIntPtr dev, Atom property)

+{

+    XIPropertyPtr   prop;

+

+    for (prop = dev->properties.properties; prop; prop = prop->next)

+        if (prop->propertyName == property)

+            return prop;

+    return NULL;

+}

+

+static void

+XIDestroyDeviceProperty (XIPropertyPtr prop)

+{

+    if (prop->value.data)

+        xfree(prop->value.data);

+    xfree(prop);

+}

+

+/* This function destroys all of the device's property-related stuff,

+ * including removing all device handlers.

+ * DO NOT CALL FROM THE DRIVER.

+ */

+void

+XIDeleteAllDeviceProperties (DeviceIntPtr device)

+{

+    XIPropertyPtr               prop, next;

+    XIPropertyHandlerPtr        curr_handler, next_handler;

+

+    for (prop = device->properties.properties; prop; prop = next)

+    {

+        next = prop->next;

+        send_property_event(device, prop->propertyName, XIPropertyDeleted);

+        XIDestroyDeviceProperty(prop);

+    }

+

+    device->properties.properties = NULL;

+

+    /* Now free all handlers */

+    curr_handler = device->properties.handlers;

+    while(curr_handler)

+    {

+        next_handler = curr_handler->next;

+        xfree(curr_handler);

+        curr_handler = next_handler;

+    }

+

+    device->properties.handlers = NULL;

+}

+

+

+int

+XIDeleteDeviceProperty (DeviceIntPtr device, Atom property, Bool fromClient)

+{

+    XIPropertyPtr               prop, *prev;

+    int                         rc = Success;

+

+    for (prev = &device->properties.properties; (prop = *prev); prev = &(prop->next))

+        if (prop->propertyName == property)

+            break;

+

+    if (!prop)

+        return Success;

+

+    if (fromClient && !prop->deletable)

+        return BadAccess;

+

+    /* Ask handlers if we may delete the property */

+    if (device->properties.handlers)

+    {

+        XIPropertyHandlerPtr handler = device->properties.handlers;

+        while(handler)

+        {

+            if (handler->DeleteProperty)

+                rc = handler->DeleteProperty(device, prop->propertyName);

+            if (rc != Success)

+                return (rc);

+            handler = handler->next;

+        }

+    }

+

+    if (prop)

+    {

+        *prev = prop->next;

+        send_property_event(device, prop->propertyName, XIPropertyDeleted);

+        XIDestroyDeviceProperty (prop);

+    }

+

+    return Success;

+}

+

+int

+XIChangeDeviceProperty (DeviceIntPtr dev, Atom property, Atom type,

+                        int format, int mode, unsigned long len,

+                        pointer value, Bool sendevent)

+{

+    XIPropertyPtr               prop;

+    int                         size_in_bytes;

+    int                         total_size;

+    unsigned long               total_len;

+    XIPropertyValuePtr          prop_value;

+    XIPropertyValueRec          new_value;

+    Bool                        add = FALSE;

+    int                         rc;

+

+    size_in_bytes = format >> 3;

+

+    /* first see if property already exists */

+    prop = XIFetchDeviceProperty (dev, property);

+    if (!prop)   /* just add to list */

+    {

+        prop = XICreateDeviceProperty (property);

+        if (!prop)

+            return(BadAlloc);

+        add = TRUE;

+        mode = PropModeReplace;

+    }

+    prop_value = &prop->value;

+

+    /* To append or prepend to a property the request format and type

+     must match those of the already defined property.  The

+     existing format and type are irrelevant when using the mode

+     "PropModeReplace" since they will be written over. */

+

+    if ((format != prop_value->format) && (mode != PropModeReplace))

+        return(BadMatch);

+    if ((prop_value->type != type) && (mode != PropModeReplace))

+        return(BadMatch);

+    new_value = *prop_value;

+    if (mode == PropModeReplace)

+        total_len = len;

+    else

+        total_len = prop_value->size + len;

+

+    if (mode == PropModeReplace || len > 0)

+    {

+        pointer            new_data = NULL, old_data = NULL;

+

+        total_size = total_len * size_in_bytes;

+        new_value.data = (pointer)xalloc (total_size);

+        if (!new_value.data && total_size)

+        {

+            if (add)

+                XIDestroyDeviceProperty (prop);

+            return BadAlloc;

+        }

+        new_value.size = len;

+        new_value.type = type;

+        new_value.format = format;

+

+        switch (mode) {

+        case PropModeReplace:

+            new_data = new_value.data;

+            old_data = NULL;

+            break;

+        case PropModeAppend:

+            new_data = (pointer) (((char *) new_value.data) +

+                                  (prop_value->size * size_in_bytes));

+            old_data = new_value.data;

+            break;

+        case PropModePrepend:

+            new_data = new_value.data;

+            old_data = (pointer) (((char *) new_value.data) +

+                                  (prop_value->size * size_in_bytes));

+            break;

+        }

+        if (new_data)

+            memcpy ((char *) new_data, (char *) value, len * size_in_bytes);

+        if (old_data)

+            memcpy ((char *) old_data, (char *) prop_value->data,

+                    prop_value->size * size_in_bytes);

+

+        if (dev->properties.handlers)

+        {

+            XIPropertyHandlerPtr handler;

+            BOOL checkonly = TRUE;

+            /* run through all handlers with checkonly TRUE, then again with

+             * checkonly FALSE. Handlers MUST return error codes on the

+             * checkonly run, errors on the second run are ignored */

+            do

+            {

+                handler = dev->properties.handlers;

+                while(handler)

+                {

+                    if (handler->SetProperty)

+                    {

+                        rc = handler->SetProperty(dev, prop->propertyName,

+                                &new_value, checkonly);

+                        if (checkonly && rc != Success)

+                        {

+                            if (new_value.data)

+                                xfree (new_value.data);

+                            return (rc);

+                        }

+                    }

+                    handler = handler->next;

+                }

+                checkonly = !checkonly;

+            } while (!checkonly);

+        }

+        if (prop_value->data)

+            xfree (prop_value->data);

+        *prop_value = new_value;

+    } else if (len == 0)

+    {

+        /* do nothing */

+    }

+

+    if (add)

+    {

+        prop->next = dev->properties.properties;

+        dev->properties.properties = prop;

+    }

+

+    if (sendevent)

+        send_property_event(dev, prop->propertyName,

+                            (add) ?  XIPropertyCreated : XIPropertyModified);

+

+    return(Success);

+}

+

+int

+XIGetDeviceProperty (DeviceIntPtr dev, Atom property, XIPropertyValuePtr *value)

+{

+    XIPropertyPtr   prop = XIFetchDeviceProperty (dev, property);

+    int rc;

+

+    if (!prop)

+    {

+        *value = NULL;

+        return BadAtom;

+    }

+

+    /* If we can, try to update the property value first */

+    if (dev->properties.handlers)

+    {

+        XIPropertyHandlerPtr handler = dev->properties.handlers;

+        while(handler)

+        {

+            if (handler->GetProperty)

+            {

+                rc = handler->GetProperty(dev, prop->propertyName);

+                if (rc != Success)

+                {

+                    *value = NULL;

+                    return rc;

+                }

+            }

+            handler = handler->next;

+        }

+    }

+

+    *value = &prop->value;

+    return Success;

+}

+

+int

+XISetDevicePropertyDeletable(DeviceIntPtr dev, Atom property, Bool deletable)

+{

+    XIPropertyPtr prop = XIFetchDeviceProperty(dev, property);

+

+    if (!prop)

+        return BadAtom;

+

+    prop->deletable = deletable;

+    return Success;

+}

+

+int

+ProcXListDeviceProperties (ClientPtr client)

+{

+    Atom                        *atoms;

+    xListDevicePropertiesReply  rep;

+    int                         natoms;

+    DeviceIntPtr                dev;

+    int                         rc = Success;

+

+    REQUEST(xListDevicePropertiesReq);

+    REQUEST_SIZE_MATCH(xListDevicePropertiesReq);

+

+    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixListPropAccess);

+    if (rc != Success)

+        return rc;

+

+    rc = list_atoms(dev, &natoms, &atoms);

+    if (rc != Success)

+        return rc;

+

+    rep.repType = X_Reply;

+    rep.RepType = X_ListDeviceProperties;

+    rep.length = natoms;

+    rep.sequenceNumber = client->sequence;

+    rep.nAtoms = natoms;

+

+    WriteReplyToClient(client, sizeof(xListDevicePropertiesReply), &rep);

+    if (natoms)

+    {

+        client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;

+        WriteSwappedDataToClient(client, natoms * sizeof(Atom), atoms);

+        xfree(atoms);

+    }

+    return rc;

+}

+

+int

+ProcXChangeDeviceProperty (ClientPtr client)

+{

+    REQUEST(xChangeDevicePropertyReq);

+    DeviceIntPtr        dev;

+    unsigned long       len;

+    int                 totalSize;

+    int                 rc;

+

+    REQUEST_AT_LEAST_SIZE(xChangeDevicePropertyReq);

+    UpdateCurrentTime();

+

+    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);

+    if (rc != Success)

+        return rc;

+

+    rc = check_change_property(client, stuff->property, stuff->type,

+                               stuff->format, stuff->mode, stuff->nUnits);

+

+    len = stuff->nUnits;

+    if (len > (bytes_to_int32(0xffffffff - sizeof(xChangeDevicePropertyReq))))

+        return BadLength;

+

+    totalSize = len * (stuff->format/8);

+    REQUEST_FIXED_SIZE(xChangeDevicePropertyReq, totalSize);

+

+    rc = change_property(client, dev, stuff->property, stuff->type,

+                         stuff->format, stuff->mode, len, (void*)&stuff[1]);

+    return rc;

+}

+

+int

+ProcXDeleteDeviceProperty (ClientPtr client)

+{

+    REQUEST(xDeleteDevicePropertyReq);

+    DeviceIntPtr        dev;

+    int                 rc;

+

+    REQUEST_SIZE_MATCH(xDeleteDevicePropertyReq);

+    UpdateCurrentTime();

+    rc =  dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);

+    if (rc != Success)

+        return rc;

+

+    if (!ValidAtom(stuff->property))

+    {

+        client->errorValue = stuff->property;

+        return (BadAtom);

+    }

+

+    rc = XIDeleteDeviceProperty(dev, stuff->property, TRUE);

+    return rc;

+}

+

+int

+ProcXGetDeviceProperty (ClientPtr client)

+{

+    REQUEST(xGetDevicePropertyReq);

+    DeviceIntPtr                dev;

+    int                         length;

+    int                         rc, format, nitems, bytes_after;

+    char                        *data;

+    Atom                        type;

+    xGetDevicePropertyReply     reply;

+

+    REQUEST_SIZE_MATCH(xGetDevicePropertyReq);

+    if (stuff->delete)

+        UpdateCurrentTime();

+    rc = dixLookupDevice (&dev, stuff->deviceid, client,

+                           stuff->delete ? DixSetPropAccess :

+                           DixGetPropAccess);

+    if (rc != Success)

+        return rc;

+

+    rc = get_property(client, dev, stuff->property, stuff->type,

+            stuff->delete, stuff->longOffset, stuff->longLength,

+            &bytes_after, &type, &format, &nitems, &length, &data);

+

+    if (rc != Success)

+        return rc;

+

+    reply.repType = X_Reply;

+    reply.RepType = X_GetDeviceProperty;

+    reply.sequenceNumber = client->sequence;

+    reply.deviceid = dev->id;

+    reply.nItems = nitems;

+    reply.format = format;

+    reply.bytesAfter = bytes_after;

+    reply.propertyType = type;

+    reply.length = bytes_to_int32(length);

+

+    if (stuff->delete && (reply.bytesAfter == 0))

+        send_property_event(dev, stuff->property, XIPropertyDeleted);

+

+    WriteReplyToClient(client, sizeof(xGenericReply), &reply);

+

+    if (length)

+    {

+        switch (reply.format) {

+            case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break;

+            case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break;

+            default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break;

+        }

+        WriteSwappedDataToClient(client, length, data);

+    }

+

+    /* delete the Property */

+    if (stuff->delete && (reply.bytesAfter == 0))

+    {

+        XIPropertyPtr prop, *prev;

+        for (prev = &dev->properties.properties; (prop = *prev); prev = &prop->next)

+        {

+            if (prop->propertyName == stuff->property)

+            {

+                *prev = prop->next;

+                XIDestroyDeviceProperty(prop);

+                break;

+            }

+        }

+    }

+    return Success;

+}

+

+

+int

+SProcXListDeviceProperties (ClientPtr client)

+{

+    char n;

+    REQUEST(xListDevicePropertiesReq);

+

+    swaps(&stuff->length, n);

+

+    REQUEST_SIZE_MATCH(xListDevicePropertiesReq);

+    return (ProcXListDeviceProperties(client));

+}

+

+int

+SProcXChangeDeviceProperty (ClientPtr client)

+{

+    char n;

+    REQUEST(xChangeDevicePropertyReq);

+

+    swaps(&stuff->length, n);

+    swapl(&stuff->property, n);

+    swapl(&stuff->type, n);

+    swapl(&stuff->nUnits, n);

+    REQUEST_SIZE_MATCH(xChangeDevicePropertyReq);

+    return (ProcXChangeDeviceProperty(client));

+}

+

+int

+SProcXDeleteDeviceProperty (ClientPtr client)

+{

+    char n;

+    REQUEST(xDeleteDevicePropertyReq);

+

+    swaps(&stuff->length, n);

+    swapl(&stuff->property, n);

+    REQUEST_SIZE_MATCH(xDeleteDevicePropertyReq);

+    return (ProcXDeleteDeviceProperty(client));

+}

+

+int

+SProcXGetDeviceProperty (ClientPtr client)

+{

+    char n;

+    REQUEST(xGetDevicePropertyReq);

+

+    swaps(&stuff->length, n);

+    swapl(&stuff->property, n);

+    swapl(&stuff->type, n);

+    swapl(&stuff->longOffset, n);

+    swapl(&stuff->longLength, n);

+    REQUEST_SIZE_MATCH(xGetDevicePropertyReq);

+    return (ProcXGetDeviceProperty(client));

+}

+

+

+/* Reply swapping */

+

+void

+SRepXListDeviceProperties(ClientPtr client, int size,

+                          xListDevicePropertiesReply *rep)

+{

+    char n;

+    swaps(&rep->sequenceNumber, n);

+    swapl(&rep->length, n);

+    swaps(&rep->nAtoms, n);

+    /* properties will be swapped later, see ProcXListDeviceProperties */

+    WriteToClient(client, size, (char*)rep);

+}

+

+void

+SRepXGetDeviceProperty(ClientPtr client, int size,

+                       xGetDevicePropertyReply *rep)

+{

+    char n;

+

+    swaps(&rep->sequenceNumber, n);

+    swapl(&rep->length, n);

+    swapl(&rep->propertyType, n);

+    swapl(&rep->bytesAfter, n);

+    swapl(&rep->nItems, n);

+    /* data will be swapped, see ProcXGetDeviceProperty */

+    WriteToClient(client, size, (char*)rep);

+}

+

+/* XI2 Request/reply handling */

+int

+ProcXIListProperties(ClientPtr client)

+{

+    Atom                        *atoms;

+    xXIListPropertiesReply      rep;

+    int                         natoms;

+    DeviceIntPtr                dev;

+    int                         rc = Success;

+

+    REQUEST(xXIListPropertiesReq);

+    REQUEST_SIZE_MATCH(xXIListPropertiesReq);

+

+    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixListPropAccess);

+    if (rc != Success)

+        return rc;

+

+    rc = list_atoms(dev, &natoms, &atoms);

+    if (rc != Success)

+        return rc;

+

+    rep.repType = X_Reply;

+    rep.RepType = X_XIListProperties;

+    rep.length = natoms;

+    rep.sequenceNumber = client->sequence;

+    rep.num_properties = natoms;

+

+    WriteReplyToClient(client, sizeof(xXIListPropertiesReply), &rep);

+    if (natoms)

+    {

+        client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;

+        WriteSwappedDataToClient(client, natoms * sizeof(Atom), atoms);

+        xfree(atoms);

+    }

+    return rc;

+}

+

+int

+ProcXIChangeProperty(ClientPtr client)

+{

+    int                 rc;

+    DeviceIntPtr        dev;

+    int                 totalSize;

+    unsigned long       len;

+

+    REQUEST(xXIChangePropertyReq);

+    REQUEST_AT_LEAST_SIZE(xXIChangePropertyReq);

+    UpdateCurrentTime();

+

+    rc = dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);

+    if (rc != Success)

+        return rc;

+

+    rc = check_change_property(client, stuff->property, stuff->type,

+                               stuff->format, stuff->mode, stuff->num_items);

+    len = stuff->num_items;

+    if (len > bytes_to_int32(0xffffffff - sizeof(xXIChangePropertyReq)))

+        return BadLength;

+

+    totalSize = len * (stuff->format/8);

+    REQUEST_FIXED_SIZE(xXIChangePropertyReq, totalSize);

+

+    rc = change_property(client, dev, stuff->property, stuff->type,

+                         stuff->format, stuff->mode, len, (void*)&stuff[1]);

+    return rc;

+}

+

+int

+ProcXIDeleteProperty(ClientPtr client)

+{

+    DeviceIntPtr        dev;

+    int                 rc;

+    REQUEST(xXIDeletePropertyReq);

+

+    REQUEST_SIZE_MATCH(xXIDeletePropertyReq);

+    UpdateCurrentTime();

+    rc =  dixLookupDevice (&dev, stuff->deviceid, client, DixSetPropAccess);

+    if (rc != Success)

+        return rc;

+

+    if (!ValidAtom(stuff->property))

+    {

+        client->errorValue = stuff->property;

+        return (BadAtom);

+    }

+

+    rc = XIDeleteDeviceProperty(dev, stuff->property, TRUE);

+    return rc;

+}

+

+

+int

+ProcXIGetProperty(ClientPtr client)

+{

+    REQUEST(xXIGetPropertyReq);

+    DeviceIntPtr                dev;

+    xXIGetPropertyReply         reply;

+    int                         length;

+    int                         rc, format, nitems, bytes_after;

+    char                        *data;

+    Atom                        type;

+

+    REQUEST_SIZE_MATCH(xXIGetPropertyReq);

+    if (stuff->delete)

+        UpdateCurrentTime();

+    rc = dixLookupDevice (&dev, stuff->deviceid, client,

+                           stuff->delete ? DixSetPropAccess :

+                           DixGetPropAccess);

+    if (rc != Success)

+        return rc;

+

+    rc = get_property(client, dev, stuff->property, stuff->type,

+            stuff->delete, stuff->offset, stuff->len,

+            &bytes_after, &type, &format, &nitems, &length, &data);

+

+    if (rc != Success)

+        return rc;

+

+    reply.repType = X_Reply;

+    reply.RepType = X_XIGetProperty;

+    reply.sequenceNumber = client->sequence;

+    reply.num_items = nitems;

+    reply.format = format;

+    reply.bytes_after = bytes_after;

+    reply.type = type;

+    reply.length = bytes_to_int32(length);

+

+    if (length && stuff->delete && (reply.bytes_after == 0))

+        send_property_event(dev, stuff->property, XIPropertyDeleted);

+

+    WriteReplyToClient(client, sizeof(xXIGetPropertyReply), &reply);

+

+    if (length)

+    {

+        switch (reply.format) {

+            case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break;

+            case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break;

+            default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break;

+        }

+        WriteSwappedDataToClient(client, length, data);

+    }

+

+    /* delete the Property */

+    if (stuff->delete && (reply.bytes_after == 0))

+    {

+        XIPropertyPtr prop, *prev;

+        for (prev = &dev->properties.properties; (prop = *prev); prev = &prop->next)

+        {

+            if (prop->propertyName == stuff->property)

+            {

+                *prev = prop->next;

+                XIDestroyDeviceProperty(prop);

+                break;

+            }

+        }

+    }

+

+    return Success;

+}

+

+int

+SProcXIListProperties(ClientPtr client)

+{

+    char n;

+    REQUEST(xXIListPropertiesReq);

+

+    swaps(&stuff->length, n);

+    swaps(&stuff->deviceid, n);

+

+    REQUEST_SIZE_MATCH(xXIListPropertiesReq);

+    return (ProcXIListProperties(client));

+}

+

+int

+SProcXIChangeProperty(ClientPtr client)

+{

+    char n;

+    REQUEST(xXIChangePropertyReq);

+

+    swaps(&stuff->length, n);

+    swaps(&stuff->deviceid, n);

+    swapl(&stuff->property, n);

+    swapl(&stuff->type, n);

+    swapl(&stuff->num_items, n);

+    REQUEST_SIZE_MATCH(xXIChangePropertyReq);

+    return (ProcXIChangeProperty(client));

+}

+

+int

+SProcXIDeleteProperty(ClientPtr client)

+{

+    char n;

+    REQUEST(xXIDeletePropertyReq);

+

+    swaps(&stuff->length, n);

+    swaps(&stuff->deviceid, n);

+    swapl(&stuff->property, n);

+    REQUEST_SIZE_MATCH(xXIDeletePropertyReq);

+    return (ProcXIDeleteProperty(client));

+}

+

+int

+SProcXIGetProperty(ClientPtr client)

+{

+    char n;

+    REQUEST(xXIGetPropertyReq);

+

+    swaps(&stuff->length, n);

+    swaps(&stuff->deviceid, n);

+    swapl(&stuff->property, n);

+    swapl(&stuff->type, n);

+    swapl(&stuff->offset, n);

+    swapl(&stuff->len, n);

+    REQUEST_SIZE_MATCH(xXIGetPropertyReq);

+    return (ProcXIGetProperty(client));

+}

+

+

+void

+SRepXIListProperties(ClientPtr client, int size,

+                     xXIListPropertiesReply *rep)

+{

+    char n;

+    swaps(&rep->sequenceNumber, n);

+    swapl(&rep->length, n);

+    swaps(&rep->num_properties, n);

+    /* properties will be swapped later, see ProcXIListProperties */

+    WriteToClient(client, size, (char*)rep);

+}

+

+void

+SRepXIGetProperty(ClientPtr client, int size,

+                  xXIGetPropertyReply *rep)

+{

+    char n;

+

+    swaps(&rep->sequenceNumber, n);

+    swapl(&rep->length, n);

+    swapl(&rep->type, n);

+    swapl(&rep->bytes_after, n);

+    swapl(&rep->num_items, n);

+    /* data will be swapped, see ProcXIGetProperty */

+    WriteToClient(client, size, (char*)rep);

+}

diff --git a/xorg-server/Xi/xiproperty.h b/xorg-server/Xi/xiproperty.h
index 69b41fafd..a610e083c 100644
--- a/xorg-server/Xi/xiproperty.h
+++ b/xorg-server/Xi/xiproperty.h
@@ -1,65 +1,68 @@
-/*
- * Copyright © 2008 Peter Hutterer
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- * Author: Peter Hutterer
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#ifndef XIPROPERTY_H
-#define XIPROPERTY_H 1
-
-int ProcXListDeviceProperties     (ClientPtr client);
-int ProcXChangeDeviceProperty     (ClientPtr client);
-int ProcXDeleteDeviceProperty     (ClientPtr client);
-int ProcXGetDeviceProperty        (ClientPtr client);
-
-/* request swapping */
-int SProcXListDeviceProperties    (ClientPtr client);
-int SProcXChangeDeviceProperty    (ClientPtr client);
-int SProcXDeleteDeviceProperty    (ClientPtr client);
-int SProcXGetDeviceProperty       (ClientPtr client);
-
-/* reply swapping */
-void SRepXListDeviceProperties(ClientPtr client, int size,
-                               xListDevicePropertiesReply *rep);
-void SRepXGetDeviceProperty(ClientPtr client, int size,
-                            xGetDevicePropertyReply *rep);
-
-/* XI2 request/reply handling  */
-int ProcXIListProperties        (ClientPtr client);
-int ProcXIChangeProperty        (ClientPtr client);
-int ProcXIDeleteProperty        (ClientPtr client);
-int ProcXIGetProperty           (ClientPtr client);
-
-int SProcXIListProperties       (ClientPtr client);
-int SProcXIChangeProperty       (ClientPtr client);
-int SProcXIDeleteProperty       (ClientPtr client);
-int SProcXIGetProperty          (ClientPtr client);
-
-void SRepXIListProperties(ClientPtr client, int size,
-                          xXIListPropertiesReply *rep);
-void SRepXIGetProperty(ClientPtr client, int size,
-                       xXIGetPropertyReply *rep);
-#endif /* XIPROPERTY_H */
+/*

+ * Copyright © 2008 Peter Hutterer

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Author: Peter Hutterer

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#ifndef XIPROPERTY_H

+#define XIPROPERTY_H 1

+

+int ProcXListDeviceProperties     (ClientPtr client);

+int ProcXChangeDeviceProperty     (ClientPtr client);

+int ProcXDeleteDeviceProperty     (ClientPtr client);

+int ProcXGetDeviceProperty        (ClientPtr client);

+

+/* request swapping */

+int SProcXListDeviceProperties    (ClientPtr client);

+int SProcXChangeDeviceProperty    (ClientPtr client);

+int SProcXDeleteDeviceProperty    (ClientPtr client);

+int SProcXGetDeviceProperty       (ClientPtr client);

+

+/* reply swapping */

+void SRepXListDeviceProperties(ClientPtr client, int size,

+                               xListDevicePropertiesReply *rep);

+void SRepXGetDeviceProperty(ClientPtr client, int size,

+                            xGetDevicePropertyReply *rep);

+

+/* XI2 request/reply handling  */

+int ProcXIListProperties        (ClientPtr client);

+int ProcXIChangeProperty        (ClientPtr client);

+int ProcXIDeleteProperty        (ClientPtr client);

+int ProcXIGetProperty           (ClientPtr client);

+

+int SProcXIListProperties       (ClientPtr client);

+int SProcXIChangeProperty       (ClientPtr client);

+int SProcXIDeleteProperty       (ClientPtr client);

+int SProcXIGetProperty          (ClientPtr client);

+

+void SRepXIListProperties(ClientPtr client, int size,

+                          xXIListPropertiesReply *rep);

+void SRepXIGetProperty(ClientPtr client, int size,

+                       xXIGetPropertyReply *rep);

+

+void XIResetProperties(void);

+

+#endif /* XIPROPERTY_H */