xserver git update 26/5/2010

author: marha <marha@users.sourceforge.net> 2010-05-26 07:52:44 +0000
committer: marha <marha@users.sourceforge.net> 2010-05-26 07:52:44 +0000
commit: d2ae79d77679ccfc02ef5b8e42c16d398d874464 (patch)
tree: 1d566cb7bc73279e52671d2529bff1905148a32b /xorg-server
parent: 74fa9a70a4817660f1c2ec3b3cc2bbe56db4fc58 (diff)
download: vcxsrv-d2ae79d77679ccfc02ef5b8e42c16d398d874464.tar.gz
vcxsrv-d2ae79d77679ccfc02ef5b8e42c16d398d874464.tar.bz2
vcxsrv-d2ae79d77679ccfc02ef5b8e42c16d398d874464.zip
18 files changed, 2602 insertions, 2408 deletions
diff --git a/xorg-server/Xi/stubs.c b/xorg-server/Xi/stubs.c
index 04ba9769e..38798d769 100644
--- a/xorg-server/Xi/stubs.c
+++ b/xorg-server/Xi/stubs.c
@@ -1,246 +1,246 @@
-/************************************************************
-
-Copyright 1989, 1998  The Open Group
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name of The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
-
-Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
-
-			All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the name of Hewlett-Packard not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
-
-HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-
-********************************************************/
-
-/*
- * stubs.c -- stub routines for the X server side of the XINPUT
- * extension.  This file is mainly to be used only as documentation.
- * There is not much code here, and you can't get a working XINPUT
- * server just using this.
- * The Xvfb server uses this file so it will compile with the same
- * object files as the real X server for a platform that has XINPUT.
- * Xnest could do the same thing.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "inputstr.h"
-#include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>
-#include "XIstubs.h"
-#include "xace.h"
-
-/***********************************************************************
- *
- * Caller:	ProcXCloseDevice
- *
- * Take care of implementation-dependent details of closing a device.
- * Some implementations may actually close the device, others may just
- * remove this clients interest in that device.
- *
- * The default implementation is to do nothing (assume all input devices
- * are initialized during X server initialization and kept open).
- *
- */
-
-void
-CloseInputDevice(DeviceIntPtr d, ClientPtr client)
-{
-}
-
-/***********************************************************************
- *
- * Caller:	ProcXListInputDevices
- *
- * This is the implementation-dependent routine to initialize an input
- * device to the point that information about it can be listed.
- * Some implementations open all input devices when the server is first
- * initialized, and never close them.  Other implementations open only
- * the X pointer and keyboard devices during server initialization,
- * and only open other input devices when some client makes an
- * XOpenDevice request.  If some other process has the device open, the
- * server may not be able to get information about the device to list it.
- *
- * This procedure should be used by implementations that do not initialize
- * all input devices at server startup.  It should do device-dependent
- * initialization for any devices not previously initialized, and call
- * AddInputDevice for each of those devices so that a DeviceIntRec will be
- * created for them.
- *
- * The default implementation is to do nothing (assume all input devices
- * are initialized during X server initialization and kept open).
- * The commented-out sample code shows what you might do if you don't want
- * the default.
- *
- */
-
-void
-AddOtherInputDevices(void)
-{
-    /**********************************************************************
-     for each uninitialized device, do something like:
-
-    DeviceIntPtr dev;
-    DeviceProc deviceProc;
-    pointer private;
-
-    dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE);
-    dev->public.devicePrivate = private;
-    RegisterOtherDevice(dev);
-    dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
-    ************************************************************************/
-
-}
-
-/***********************************************************************
- *
- * Caller:	ProcXOpenDevice
- *
- * This is the implementation-dependent routine to open an input device.
- * Some implementations open all input devices when the server is first
- * initialized, and never close them.  Other implementations open only
- * the X pointer and keyboard devices during server initialization,
- * and only open other input devices when some client makes an
- * XOpenDevice request.  This entry point is for the latter type of
- * implementation.
- *
- * If the physical device is not already open, do it here.  In this case,
- * you need to keep track of the fact that one or more clients has the
- * device open, and physically close it when the last client that has
- * it open does an XCloseDevice.
- *
- * The default implementation is to do nothing (assume all input devices
- * are opened during X server initialization and kept open).
- *
- */
-
-void
-OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
-{
-    *status = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixUseAccess);
-}
-
-/****************************************************************************
- *
- * Caller:	ProcXSetDeviceMode
- *
- * Change the mode of an extension device.
- * This function is used to change the mode of a device from reporting
- * relative motion to reporting absolute positional information, and
- * vice versa.
- * The default implementation below is that no such devices are supported.
- *
- */
-
-int
-SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)
-{
-    return BadMatch;
-}
-
-/****************************************************************************
- *
- * Caller:	ProcXSetDeviceValuators
- *
- * Set the value of valuators on an extension input device.
- * This function is used to set the initial value of valuators on
- * those input devices that are capable of reporting either relative
- * motion or an absolute position, and allow an initial position to be set.
- * The default implementation below is that no such devices are supported.
- *
- */
-
-int
-SetDeviceValuators(ClientPtr client, DeviceIntPtr dev,
-		   int *valuators, int first_valuator, int num_valuators)
-{
-    return BadMatch;
-}
-
-/****************************************************************************
- *
- * Caller:	ProcXChangeDeviceControl
- *
- * Change the specified device controls on an extension input device.
- *
- */
-
-int
-ChangeDeviceControl(ClientPtr client, DeviceIntPtr dev,
-		    xDeviceCtl * control)
-{
-    switch (control->control) {
-    case DEVICE_RESOLUTION:
-	return (BadMatch);
-    case DEVICE_ABS_CALIB:
-    case DEVICE_ABS_AREA:
-        return (BadMatch);
-    case DEVICE_CORE:
-        return (BadMatch);
-    default:
-	return (BadMatch);
-    }
-}
-
-
-/****************************************************************************
- *
- * Caller: configAddDevice (and others)
- *
- * Add a new device with the specified options.
- *
- */
-int
-NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
-                      DeviceIntPtr *pdev)
-{
-    return BadValue;
-}
-
-/****************************************************************************
- *
- * Caller: configRemoveDevice (and others)
- *
- * Remove the specified device previously added.
- *
- */
-void
-DeleteInputDeviceRequest(DeviceIntPtr dev)
-{
-}
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
+
+			All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Hewlett-Packard not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+********************************************************/
+
+/*
+ * stubs.c -- stub routines for the X server side of the XINPUT
+ * extension.  This file is mainly to be used only as documentation.
+ * There is not much code here, and you can't get a working XINPUT
+ * server just using this.
+ * The Xvfb server uses this file so it will compile with the same
+ * object files as the real X server for a platform that has XINPUT.
+ * Xnest could do the same thing.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "inputstr.h"
+#include <X11/extensions/XI.h>
+#include <X11/extensions/XIproto.h>
+#include "XIstubs.h"
+#include "xace.h"
+
+/***********************************************************************
+ *
+ * Caller:	ProcXCloseDevice
+ *
+ * Take care of implementation-dependent details of closing a device.
+ * Some implementations may actually close the device, others may just
+ * remove this clients interest in that device.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are initialized during X server initialization and kept open).
+ *
+ */
+
+void
+CloseInputDevice(DeviceIntPtr d, ClientPtr client)
+{
+}
+
+/***********************************************************************
+ *
+ * Caller:	ProcXListInputDevices
+ *
+ * This is the implementation-dependent routine to initialize an input
+ * device to the point that information about it can be listed.
+ * Some implementations open all input devices when the server is first
+ * initialized, and never close them.  Other implementations open only
+ * the X pointer and keyboard devices during server initialization,
+ * and only open other input devices when some client makes an
+ * XOpenDevice request.  If some other process has the device open, the
+ * server may not be able to get information about the device to list it.
+ *
+ * This procedure should be used by implementations that do not initialize
+ * all input devices at server startup.  It should do device-dependent
+ * initialization for any devices not previously initialized, and call
+ * AddInputDevice for each of those devices so that a DeviceIntRec will be
+ * created for them.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are initialized during X server initialization and kept open).
+ * The commented-out sample code shows what you might do if you don't want
+ * the default.
+ *
+ */
+
+void
+AddOtherInputDevices(void)
+{
+    /**********************************************************************
+     for each uninitialized device, do something like:
+
+    DeviceIntPtr dev;
+    DeviceProc deviceProc;
+    pointer private;
+
+    dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE);
+    dev->public.devicePrivate = private;
+    RegisterOtherDevice(dev);
+    dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
+    ************************************************************************/
+
+}
+
+/***********************************************************************
+ *
+ * Caller:	ProcXOpenDevice
+ *
+ * This is the implementation-dependent routine to open an input device.
+ * Some implementations open all input devices when the server is first
+ * initialized, and never close them.  Other implementations open only
+ * the X pointer and keyboard devices during server initialization,
+ * and only open other input devices when some client makes an
+ * XOpenDevice request.  This entry point is for the latter type of
+ * implementation.
+ *
+ * If the physical device is not already open, do it here.  In this case,
+ * you need to keep track of the fact that one or more clients has the
+ * device open, and physically close it when the last client that has
+ * it open does an XCloseDevice.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are opened during X server initialization and kept open).
+ *
+ */
+
+void
+OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
+{
+    *status = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixUseAccess);
+}
+
+/****************************************************************************
+ *
+ * Caller:	ProcXSetDeviceMode
+ *
+ * Change the mode of an extension device.
+ * This function is used to change the mode of a device from reporting
+ * relative motion to reporting absolute positional information, and
+ * vice versa.
+ * The default implementation below is that no such devices are supported.
+ *
+ */
+
+int
+SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)
+{
+    return BadMatch;
+}
+
+/****************************************************************************
+ *
+ * Caller:	ProcXSetDeviceValuators
+ *
+ * Set the value of valuators on an extension input device.
+ * This function is used to set the initial value of valuators on
+ * those input devices that are capable of reporting either relative
+ * motion or an absolute position, and allow an initial position to be set.
+ * The default implementation below is that no such devices are supported.
+ *
+ */
+
+int
+SetDeviceValuators(ClientPtr client, DeviceIntPtr dev,
+		   int *valuators, int first_valuator, int num_valuators)
+{
+    return BadMatch;
+}
+
+/****************************************************************************
+ *
+ * Caller:	ProcXChangeDeviceControl
+ *
+ * Change the specified device controls on an extension input device.
+ *
+ */
+
+int
+ChangeDeviceControl(ClientPtr client, DeviceIntPtr dev,
+		    xDeviceCtl * control)
+{
+    switch (control->control) {
+    case DEVICE_RESOLUTION:
+	return (BadMatch);
+    case DEVICE_ABS_CALIB:
+    case DEVICE_ABS_AREA:
+        return (BadMatch);
+    case DEVICE_CORE:
+        return (BadMatch);
+    default:
+	return (BadMatch);
+    }
+}
+
+
+/****************************************************************************
+ *
+ * Caller: configAddDevice (and others)
+ *
+ * Add a new device with the specified options.
+ *
+ */
+int
+NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
+                      DeviceIntPtr *pdev)
+{
+    return BadValue;
+}
+
+/****************************************************************************
+ *
+ * Caller: configRemoveDevice (and others)
+ *
+ * Remove the specified device previously added.
+ *
+ */
+void
+DeleteInputDeviceRequest(DeviceIntPtr dev, int flags)
+{
+}
diff --git a/xorg-server/config/config.c b/xorg-server/config/config.c
index 1ffbdcdad..a14d2a9f8 100644
--- a/xorg-server/config/config.c
+++ b/xorg-server/config/config.c
@@ -81,7 +81,7 @@ remove_device(const char *backend, DeviceIntPtr dev)
      * already been removed. */
     OsBlockSignals();
     ProcessInputEvents();
-    DeleteInputDeviceRequest(dev);
+    DeleteInputDeviceRequest(dev, 0);
     OsReleaseSignals();
 }
 
diff --git a/xorg-server/config/dbus.c b/xorg-server/config/dbus.c
index d6316623b..3b4330adc 100644
--- a/xorg-server/config/dbus.c
+++ b/xorg-server/config/dbus.c
@@ -226,7 +226,7 @@ remove_device(DBusMessage *message, DBusMessage *reply, DBusError *error)
      * already been removed. */
     OsBlockSignals();
     ProcessInputEvents();
-    DeleteInputDeviceRequest(dev);
+    DeleteInputDeviceRequest(dev, 0);
     OsReleaseSignals();
 
     ret = Success;
diff --git a/xorg-server/dix/devices.c b/xorg-server/dix/devices.c
index 85a008004..e64b8ed56 100644
--- a/xorg-server/dix/devices.c
+++ b/xorg-server/dix/devices.c
@@ -891,7 +891,7 @@ CloseDeviceList(DeviceIntPtr *listHead)
     while (dev != NULL)
     {
         freedIds[dev->id] = TRUE;
-        DeleteInputDeviceRequest(dev);
+        DeleteInputDeviceRequest(dev, DEVICE_REMOVE_ALL);
 
         dev = *listHead;
         while (dev != NULL && freedIds[dev->id])
diff --git a/xorg-server/dix/inpututils.c b/xorg-server/dix/inpututils.c
index d2d36bd95..6d730be2d 100644
--- a/xorg-server/dix/inpututils.c
+++ b/xorg-server/dix/inpututils.c
@@ -331,3 +331,82 @@ int generate_modkeymap(ClientPtr client, DeviceIntPtr dev,
 
     return Success;
 }
+
+/**
+ * Duplicate the InputAttributes in the most obvious way.
+ * No special memory handling is used to give drivers the maximum
+ * flexibility with the data. Drivers should be able to call realloc on the
+ * product string if needed and perform similar operations.
+ */
+InputAttributes*
+DuplicateInputAttributes(InputAttributes *attrs)
+{
+    InputAttributes *new_attr;
+    int ntags = 0;
+    char **tags, **new_tags;
+
+    if (!attrs)
+        return NULL;
+
+    if (!(new_attr = calloc(1, sizeof(InputAttributes))))
+        goto unwind;
+
+    if (attrs->product && !(new_attr->product = strdup(attrs->product)))
+        goto unwind;
+    if (attrs->vendor && !(new_attr->vendor = strdup(attrs->vendor)))
+        goto unwind;
+    if (attrs->device && !(new_attr->device = strdup(attrs->device)))
+        goto unwind;
+
+    new_attr->flags = attrs->flags;
+
+    if ((tags = attrs->tags))
+    {
+        while(*tags++)
+            ntags++;
+
+        new_attr->tags = calloc(ntags + 1, sizeof(char*));
+        if (!new_attr->tags)
+            goto unwind;
+
+        tags = attrs->tags;
+        new_tags = new_attr->tags;
+
+        while(*tags)
+        {
+            *new_tags = strdup(*tags);
+            if (!*new_tags)
+                goto unwind;
+
+            tags++;
+            new_tags++;
+        }
+    }
+
+    return new_attr;
+
+unwind:
+    FreeInputAttributes(new_attr);
+    return NULL;
+}
+
+void
+FreeInputAttributes(InputAttributes *attrs)
+{
+    char **tags;
+
+    if (!attrs)
+        return;
+
+    free(attrs->product);
+    free(attrs->vendor);
+    free(attrs->device);
+
+    if ((tags = attrs->tags))
+        while(*tags)
+            free(*tags++);
+
+    free(attrs->tags);
+    free(attrs);
+}
+
diff --git a/xorg-server/hw/dmx/dmxinput.c b/xorg-server/hw/dmx/dmxinput.c
index 568bb882b..0f7f24040 100644
--- a/xorg-server/hw/dmx/dmxinput.c
+++ b/xorg-server/hw/dmx/dmxinput.c
@@ -1,119 +1,119 @@
-/*
- * Copyright 2001,2002 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * 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 on 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
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * 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.
- */
-
-/*
- * Authors:
- *   David H. Dawes <dawes@xfree86.org>
- *   Kevin E. Martin <kem@redhat.com>
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- * Provide the main entry points for input initialization and processing
- * that arequired by the dix layer.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxlog.h"
-#include "dmxinput.h"
-
-#include "inputstr.h"
-#include "input.h"
-#include "mi.h"
-
-/** Returns TRUE if the key is a valid modifier.  For PC-class
- * keyboards, all keys can be used as modifiers, so return TRUE
- * always. */
-Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
-{
-    return TRUE;
-}
-
-/** Called from dix/main.c on each server generation to initialize
- * inputs.  All the work is done in dmxInputInit.  \see
- * dmxInputInit() */
-void InitInput(int argc, char **argv)
-{
-    int          i;
-    DMXInputInfo *dmxInput;
-
-    if (!dmxNumInputs)
-        dmxLog(dmxFatal, "InitInput: no inputs specified\n");
-    
-    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++)
-        dmxInputInit(dmxInput);
-
-    mieqInit();
-}
-
-void CloseInput(void)
-{
-}
-
-/** Called from dix/dispatch.c in Dispatch() whenever input events
- * require processing.  All the work is done in the lower level
- * routines. */
-void ProcessInputEvents(void)
-{
-    int          i;
-    DMXInputInfo *dmxInput;
-
-    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++)
-        if (!dmxInput->detached && dmxInput->processInputEvents)
-            dmxInput->processInputEvents(dmxInput);
-}
-
-/** This routine is called from \a dmxwindow.c whenever the layout of
- * windows on the display might have changed.  This information is used
- * by input drivers (currently only the console driver) that provide
- * information about window layout to the user. */
-void dmxUpdateWindowInfo(DMXUpdateType type, WindowPtr pWindow)
-{
-    int          i;
-    DMXInputInfo *dmxInput;
-
-    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++)
-        if (!dmxInput->detached && dmxInput->updateWindowInfo)
-            dmxInput->updateWindowInfo(dmxInput, type, pWindow);
-}
-
-int
-NewInputDeviceRequest (InputOption *options, InputAttributes *attrs,
-                       DeviceIntPtr *pdev)
-{
-    return BadRequest;
-}
-
-void
-DeleteInputDeviceRequest(DeviceIntPtr pDev)
-{
-}
+/*
+ * Copyright 2001,2002 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * 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 on 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
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * 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.
+ */
+
+/*
+ * Authors:
+ *   David H. Dawes <dawes@xfree86.org>
+ *   Kevin E. Martin <kem@redhat.com>
+ *   Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ */
+
+/** \file
+ * Provide the main entry points for input initialization and processing
+ * that arequired by the dix layer.
+ */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxlog.h"
+#include "dmxinput.h"
+
+#include "inputstr.h"
+#include "input.h"
+#include "mi.h"
+
+/** Returns TRUE if the key is a valid modifier.  For PC-class
+ * keyboards, all keys can be used as modifiers, so return TRUE
+ * always. */
+Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
+{
+    return TRUE;
+}
+
+/** Called from dix/main.c on each server generation to initialize
+ * inputs.  All the work is done in dmxInputInit.  \see
+ * dmxInputInit() */
+void InitInput(int argc, char **argv)
+{
+    int          i;
+    DMXInputInfo *dmxInput;
+
+    if (!dmxNumInputs)
+        dmxLog(dmxFatal, "InitInput: no inputs specified\n");
+    
+    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++)
+        dmxInputInit(dmxInput);
+
+    mieqInit();
+}
+
+void CloseInput(void)
+{
+}
+
+/** Called from dix/dispatch.c in Dispatch() whenever input events
+ * require processing.  All the work is done in the lower level
+ * routines. */
+void ProcessInputEvents(void)
+{
+    int          i;
+    DMXInputInfo *dmxInput;
+
+    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++)
+        if (!dmxInput->detached && dmxInput->processInputEvents)
+            dmxInput->processInputEvents(dmxInput);
+}
+
+/** This routine is called from \a dmxwindow.c whenever the layout of
+ * windows on the display might have changed.  This information is used
+ * by input drivers (currently only the console driver) that provide
+ * information about window layout to the user. */
+void dmxUpdateWindowInfo(DMXUpdateType type, WindowPtr pWindow)
+{
+    int          i;
+    DMXInputInfo *dmxInput;
+
+    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++)
+        if (!dmxInput->detached && dmxInput->updateWindowInfo)
+            dmxInput->updateWindowInfo(dmxInput, type, pWindow);
+}
+
+int
+NewInputDeviceRequest (InputOption *options, InputAttributes *attrs,
+                       DeviceIntPtr *pdev)
+{
+    return BadRequest;
+}
+
+void
+DeleteInputDeviceRequest(DeviceIntPtr pDev, int flags)
+{
+}
diff --git a/xorg-server/hw/kdrive/linux/evdev.c b/xorg-server/hw/kdrive/linux/evdev.c
index 20df77b99..71b93931b 100644
--- a/xorg-server/hw/kdrive/linux/evdev.c
+++ b/xorg-server/hw/kdrive/linux/evdev.c
@@ -165,7 +165,7 @@ EvdevPtrRead (int evdevPort, void *closure)
     n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));
     if (n <= 0) {
         if (errno == ENODEV)
-            DeleteInputDeviceRequest(pi->dixdev);
+            DeleteInputDeviceRequest(pi->dixdev, 0);
         return;
     }
 
@@ -375,7 +375,7 @@ EvdevKbdRead (int evdevPort, void *closure)
     n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));
     if (n <= 0) {
         if (errno == ENODEV)
-            DeleteInputDeviceRequest(ki->dixdev);
+            DeleteInputDeviceRequest(ki->dixdev, 0);
         return;
     }
 
diff --git a/xorg-server/hw/xfree86/common/xf86Helper.c b/xorg-server/hw/xfree86/common/xf86Helper.c
index 1b9bd1f1e..0fa695a3a 100644
--- a/xorg-server/hw/xfree86/common/xf86Helper.c
+++ b/xorg-server/hw/xfree86/common/xf86Helper.c
@@ -330,6 +330,8 @@ xf86DeleteInput(InputInfoPtr pInp, int flags)
     if (pInp->private)
 	free(pInp->private);
 
+    FreeInputAttributes(pInp->attrs);
+
     /* Remove the entry from the list. */
     if (pInp == xf86InputDevs)
 	xf86InputDevs = pInp->next;
diff --git a/xorg-server/hw/xfree86/common/xf86Module.h b/xorg-server/hw/xfree86/common/xf86Module.h
index d61758f78..f85c54dc9 100644
--- a/xorg-server/hw/xfree86/common/xf86Module.h
+++ b/xorg-server/hw/xfree86/common/xf86Module.h
@@ -1,212 +1,212 @@
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 copyright holder(s)
- * and author(s) 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 copyright holder(s) and author(s).
- */
-
-/*
- * This file contains the parts of the loader interface that are visible
- * to modules.  This is the only loader-related header that modules should
- * include.
- *
- * It should include a bare minimum of other headers.
- *
- * Longer term, the module/loader code should probably live directly under
- * Xserver/.
- *
- * XXX This file arguably belongs in xfree86/loader/.
- */
-
-#ifndef _XF86MODULE_H
-#define _XF86MODULE_H
-
-#include "misc.h"
-#ifndef NULL
-#define NULL ((void *)0)
-#endif
-
-typedef enum {
-    LD_RESOLV_IFDONE		= 0,	/* only check if no more
-					   delays pending */
-    LD_RESOLV_NOW		= 1,	/* finish one delay step */
-    LD_RESOLV_FORCE		= 2	/* force checking... */
-} LoaderResolveOptions;
-
-#define DEFAULT_LIST ((char *)-1)
-
-/* This indicates a special module that doesn't have the usual entry point */
-#define EXTERN_MODULE ((pointer)-1)
-
-/* Built-in ABI classes.  These definitions must not be changed. */
-#define ABI_CLASS_NONE		NULL
-#define ABI_CLASS_ANSIC		"X.Org ANSI C Emulation"
-#define ABI_CLASS_VIDEODRV	"X.Org Video Driver"
-#define ABI_CLASS_XINPUT	"X.Org XInput driver"
-#define ABI_CLASS_EXTENSION	"X.Org Server Extension"
-#define ABI_CLASS_FONT		"X.Org Font Renderer"
-
-#define ABI_MINOR_MASK		0x0000FFFF
-#define ABI_MAJOR_MASK		0xFFFF0000
-#define GET_ABI_MINOR(v)	((v) & ABI_MINOR_MASK)
-#define GET_ABI_MAJOR(v)	(((v) & ABI_MAJOR_MASK) >> 16)
-#define SET_ABI_VERSION(maj, min) \
-		((((maj) << 16) & ABI_MAJOR_MASK) | ((min) & ABI_MINOR_MASK))
-
-/*
- * ABI versions.  Each version has a major and minor revision.  Modules
- * using lower minor revisions must work with servers of a higher minor
- * revision.  There is no compatibility between different major revisions.
- * Whenever the ABI_ANSIC_VERSION is changed, the others must also be
- * changed.  The minor revision mask is 0x0000FFFF and the major revision
- * mask is 0xFFFF0000.
- */
-#define ABI_ANSIC_VERSION	SET_ABI_VERSION(0, 4)
-#define ABI_VIDEODRV_VERSION	SET_ABI_VERSION(8, 0)
-#define ABI_XINPUT_VERSION	SET_ABI_VERSION(10, 0)
-#define ABI_EXTENSION_VERSION	SET_ABI_VERSION(4, 0)
-#define ABI_FONT_VERSION	SET_ABI_VERSION(0, 6)
-
-#define MODINFOSTRING1	0xef23fdc5
-#define MODINFOSTRING2	0x10dc023a
-
-#ifndef MODULEVENDORSTRING
-#define MODULEVENDORSTRING	"X.Org Foundation"
-#endif
-
-/* Error return codes for errmaj.  New codes must only be added at the end. */
-typedef enum {
-    LDR_NOERROR = 0,
-    LDR_NOMEM,		/* memory allocation failed */
-    LDR_NOENT,		/* Module file does not exist */
-    LDR_NOSUBENT,	/* pre-requsite file to be sub-loaded does not exist */
-    LDR_NOSPACE,	/* internal module array full */
-    LDR_NOMODOPEN,	/* module file could not be opened (check errmin) */
-    LDR_UNKTYPE,	/* file is not a recognized module type */
-    LDR_NOLOAD,		/* type specific loader failed */
-    LDR_ONCEONLY,	/* Module should only be loaded once (not an error) */
-    LDR_NOPORTOPEN,	/* could not open port (check errmin) */
-    LDR_NOHARDWARE,	/* could not query/initialize the hardware device */
-    LDR_MISMATCH,	/* the module didn't match the spec'd requirments */
-    LDR_BADUSAGE,	/* LoadModule is called with bad arguments */
-    LDR_INVALID,	/* The module doesn't have a valid ModuleData object */
-    LDR_BADOS,		/* The module doesn't support the OS */
-    LDR_MODSPECIFIC	/* A module-specific error in the SetupProc */
-} LoaderErrorCode;
-
-/*
- * Some common module classes.  The moduleclass can be used to identify
- * that modules loaded are of the correct type.  This is a finer
- * classification than the ABI classes even though the default set of
- * classes have the same names.  For example, not all modules that require
- * the video driver ABI are themselves video drivers.
- */
-#define MOD_CLASS_NONE		NULL
-#define MOD_CLASS_VIDEODRV	"X.Org Video Driver"
-#define MOD_CLASS_XINPUT	"X.Org XInput Driver"
-#define MOD_CLASS_FONT		"X.Org Font Renderer"
-#define MOD_CLASS_EXTENSION	"X.Org Server Extension"
-
-/* This structure is expected to be returned by the initfunc */
-typedef struct {
-    const char * modname;	/* name of module, e.g. "foo" */
-    const char * vendor;	/* vendor specific string */
-    CARD32	 _modinfo1_;	/* constant MODINFOSTRING1/2 to find */
-    CARD32	 _modinfo2_;	/* infoarea with a binary editor or sign tool */
-    CARD32	 xf86version;	/* contains XF86_VERSION_CURRENT */
-    CARD8	 majorversion;	/* module-specific major version */
-    CARD8	 minorversion;	/* module-specific minor version */
-    CARD16	 patchlevel;	/* module-specific patch level */
-    const char * abiclass;	/* ABI class that the module uses */
-    CARD32	 abiversion;	/* ABI version */
-    const char * moduleclass;	/* module class description */
-    CARD32	 checksum[4];	/* contains a digital signature of the */
-				/* version info structure */
-} XF86ModuleVersionInfo;
-
-/*
- * This structure can be used to callers of LoadModule and LoadSubModule to
- * specify version and/or ABI requirements.
- */
-typedef struct {
-    CARD8	 majorversion;	/* module-specific major version */
-    CARD8	 minorversion;	/* moudle-specific minor version */
-    CARD16	 patchlevel;	/* module-specific patch level */
-    const char * abiclass;	/* ABI class that the module uses */
-    CARD32	 abiversion;	/* ABI version */
-    const char * moduleclass;	/* module class */
-} XF86ModReqInfo;
-
-/* values to indicate unspecified fields in XF86ModReqInfo. */
-#define MAJOR_UNSPEC		0xFF
-#define MINOR_UNSPEC		0xFF
-#define PATCH_UNSPEC		0xFFFF
-#define ABI_VERS_UNSPEC		0xFFFFFFFF
-
-#define MODULE_VERSION_NUMERIC(maj, min, patch) \
-	((((maj) & 0xFF) << 24) | (((min) & 0xFF) << 16) | (patch & 0xFFFF))
-#define GET_MODULE_MAJOR_VERSION(vers)	(((vers) >> 24) & 0xFF)
-#define GET_MODULE_MINOR_VERSION(vers)	(((vers) >> 16) & 0xFF)
-#define GET_MODULE_PATCHLEVEL(vers)	((vers) & 0xFFFF)
-
-#define INITARGS void
-
-typedef void (*InitExtension)(INITARGS);
-
-typedef struct {
-    InitExtension	initFunc;
-    const char *	name;
-    Bool		*disablePtr;
-    InitExtension	setupFunc;	
-    const char **	initDependencies;
-} ExtensionModule;
-
-extern _X_EXPORT ExtensionModule *ExtensionModuleList;
-
-/* Prototypes for Loader functions that are exported to modules */
-extern _X_EXPORT pointer LoadSubModule(pointer, const char *, const char **,
-		      const char **, pointer, const XF86ModReqInfo *,
-		      int *, int *);
-extern _X_EXPORT void UnloadSubModule(pointer);
-extern _X_EXPORT void UnloadModule (pointer);
-extern _X_EXPORT pointer LoaderSymbol(const char *);
-extern _X_EXPORT char **LoaderListDirs(const char **, const char **);
-extern _X_EXPORT void LoaderFreeDirList(char **);
-extern _X_EXPORT void LoaderErrorMsg(const char *, const char *, int, int);
-extern _X_EXPORT void LoadExtension(ExtensionModule *, Bool);
-extern _X_EXPORT void LoaderGetOS(const char **name, int *major, int *minor, int *teeny);
-extern _X_EXPORT Bool LoaderShouldIgnoreABI(void);
-extern _X_EXPORT int LoaderGetABIVersion(const char *abiclass);
-
-typedef pointer (*ModuleSetupProc)(pointer, pointer, int *, int *);
-typedef void (*ModuleTearDownProc)(pointer);
-#define MODULESETUPPROTO(func) pointer func(pointer, pointer, int*, int*)
-#define MODULETEARDOWNPROTO(func) void func(pointer)
-
-typedef struct {
-    XF86ModuleVersionInfo *	vers;
-    ModuleSetupProc		setup;
-    ModuleTearDownProc		teardown;
-} XF86ModuleData;
-
-#endif /* _XF86STR_H */
+/*
+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
+ *
+ * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 copyright holder(s)
+ * and author(s) 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 copyright holder(s) and author(s).
+ */
+
+/*
+ * This file contains the parts of the loader interface that are visible
+ * to modules.  This is the only loader-related header that modules should
+ * include.
+ *
+ * It should include a bare minimum of other headers.
+ *
+ * Longer term, the module/loader code should probably live directly under
+ * Xserver/.
+ *
+ * XXX This file arguably belongs in xfree86/loader/.
+ */
+
+#ifndef _XF86MODULE_H
+#define _XF86MODULE_H
+
+#include "misc.h"
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+typedef enum {
+    LD_RESOLV_IFDONE		= 0,	/* only check if no more
+					   delays pending */
+    LD_RESOLV_NOW		= 1,	/* finish one delay step */
+    LD_RESOLV_FORCE		= 2	/* force checking... */
+} LoaderResolveOptions;
+
+#define DEFAULT_LIST ((char *)-1)
+
+/* This indicates a special module that doesn't have the usual entry point */
+#define EXTERN_MODULE ((pointer)-1)
+
+/* Built-in ABI classes.  These definitions must not be changed. */
+#define ABI_CLASS_NONE		NULL
+#define ABI_CLASS_ANSIC		"X.Org ANSI C Emulation"
+#define ABI_CLASS_VIDEODRV	"X.Org Video Driver"
+#define ABI_CLASS_XINPUT	"X.Org XInput driver"
+#define ABI_CLASS_EXTENSION	"X.Org Server Extension"
+#define ABI_CLASS_FONT		"X.Org Font Renderer"
+
+#define ABI_MINOR_MASK		0x0000FFFF
+#define ABI_MAJOR_MASK		0xFFFF0000
+#define GET_ABI_MINOR(v)	((v) & ABI_MINOR_MASK)
+#define GET_ABI_MAJOR(v)	(((v) & ABI_MAJOR_MASK) >> 16)
+#define SET_ABI_VERSION(maj, min) \
+		((((maj) << 16) & ABI_MAJOR_MASK) | ((min) & ABI_MINOR_MASK))
+
+/*
+ * ABI versions.  Each version has a major and minor revision.  Modules
+ * using lower minor revisions must work with servers of a higher minor
+ * revision.  There is no compatibility between different major revisions.
+ * Whenever the ABI_ANSIC_VERSION is changed, the others must also be
+ * changed.  The minor revision mask is 0x0000FFFF and the major revision
+ * mask is 0xFFFF0000.
+ */
+#define ABI_ANSIC_VERSION	SET_ABI_VERSION(0, 4)
+#define ABI_VIDEODRV_VERSION	SET_ABI_VERSION(8, 0)
+#define ABI_XINPUT_VERSION	SET_ABI_VERSION(11, 0)
+#define ABI_EXTENSION_VERSION	SET_ABI_VERSION(4, 0)
+#define ABI_FONT_VERSION	SET_ABI_VERSION(0, 6)
+
+#define MODINFOSTRING1	0xef23fdc5
+#define MODINFOSTRING2	0x10dc023a
+
+#ifndef MODULEVENDORSTRING
+#define MODULEVENDORSTRING	"X.Org Foundation"
+#endif
+
+/* Error return codes for errmaj.  New codes must only be added at the end. */
+typedef enum {
+    LDR_NOERROR = 0,
+    LDR_NOMEM,		/* memory allocation failed */
+    LDR_NOENT,		/* Module file does not exist */
+    LDR_NOSUBENT,	/* pre-requsite file to be sub-loaded does not exist */
+    LDR_NOSPACE,	/* internal module array full */
+    LDR_NOMODOPEN,	/* module file could not be opened (check errmin) */
+    LDR_UNKTYPE,	/* file is not a recognized module type */
+    LDR_NOLOAD,		/* type specific loader failed */
+    LDR_ONCEONLY,	/* Module should only be loaded once (not an error) */
+    LDR_NOPORTOPEN,	/* could not open port (check errmin) */
+    LDR_NOHARDWARE,	/* could not query/initialize the hardware device */
+    LDR_MISMATCH,	/* the module didn't match the spec'd requirments */
+    LDR_BADUSAGE,	/* LoadModule is called with bad arguments */
+    LDR_INVALID,	/* The module doesn't have a valid ModuleData object */
+    LDR_BADOS,		/* The module doesn't support the OS */
+    LDR_MODSPECIFIC	/* A module-specific error in the SetupProc */
+} LoaderErrorCode;
+
+/*
+ * Some common module classes.  The moduleclass can be used to identify
+ * that modules loaded are of the correct type.  This is a finer
+ * classification than the ABI classes even though the default set of
+ * classes have the same names.  For example, not all modules that require
+ * the video driver ABI are themselves video drivers.
+ */
+#define MOD_CLASS_NONE		NULL
+#define MOD_CLASS_VIDEODRV	"X.Org Video Driver"
+#define MOD_CLASS_XINPUT	"X.Org XInput Driver"
+#define MOD_CLASS_FONT		"X.Org Font Renderer"
+#define MOD_CLASS_EXTENSION	"X.Org Server Extension"
+
+/* This structure is expected to be returned by the initfunc */
+typedef struct {
+    const char * modname;	/* name of module, e.g. "foo" */
+    const char * vendor;	/* vendor specific string */
+    CARD32	 _modinfo1_;	/* constant MODINFOSTRING1/2 to find */
+    CARD32	 _modinfo2_;	/* infoarea with a binary editor or sign tool */
+    CARD32	 xf86version;	/* contains XF86_VERSION_CURRENT */
+    CARD8	 majorversion;	/* module-specific major version */
+    CARD8	 minorversion;	/* module-specific minor version */
+    CARD16	 patchlevel;	/* module-specific patch level */
+    const char * abiclass;	/* ABI class that the module uses */
+    CARD32	 abiversion;	/* ABI version */
+    const char * moduleclass;	/* module class description */
+    CARD32	 checksum[4];	/* contains a digital signature of the */
+				/* version info structure */
+} XF86ModuleVersionInfo;
+
+/*
+ * This structure can be used to callers of LoadModule and LoadSubModule to
+ * specify version and/or ABI requirements.
+ */
+typedef struct {
+    CARD8	 majorversion;	/* module-specific major version */
+    CARD8	 minorversion;	/* moudle-specific minor version */
+    CARD16	 patchlevel;	/* module-specific patch level */
+    const char * abiclass;	/* ABI class that the module uses */
+    CARD32	 abiversion;	/* ABI version */
+    const char * moduleclass;	/* module class */
+} XF86ModReqInfo;
+
+/* values to indicate unspecified fields in XF86ModReqInfo. */
+#define MAJOR_UNSPEC		0xFF
+#define MINOR_UNSPEC		0xFF
+#define PATCH_UNSPEC		0xFFFF
+#define ABI_VERS_UNSPEC		0xFFFFFFFF
+
+#define MODULE_VERSION_NUMERIC(maj, min, patch) \
+	((((maj) & 0xFF) << 24) | (((min) & 0xFF) << 16) | (patch & 0xFFFF))
+#define GET_MODULE_MAJOR_VERSION(vers)	(((vers) >> 24) & 0xFF)
+#define GET_MODULE_MINOR_VERSION(vers)	(((vers) >> 16) & 0xFF)
+#define GET_MODULE_PATCHLEVEL(vers)	((vers) & 0xFFFF)
+
+#define INITARGS void
+
+typedef void (*InitExtension)(INITARGS);
+
+typedef struct {
+    InitExtension	initFunc;
+    const char *	name;
+    Bool		*disablePtr;
+    InitExtension	setupFunc;	
+    const char **	initDependencies;
+} ExtensionModule;
+
+extern _X_EXPORT ExtensionModule *ExtensionModuleList;
+
+/* Prototypes for Loader functions that are exported to modules */
+extern _X_EXPORT pointer LoadSubModule(pointer, const char *, const char **,
+		      const char **, pointer, const XF86ModReqInfo *,
+		      int *, int *);
+extern _X_EXPORT void UnloadSubModule(pointer);
+extern _X_EXPORT void UnloadModule (pointer);
+extern _X_EXPORT pointer LoaderSymbol(const char *);
+extern _X_EXPORT char **LoaderListDirs(const char **, const char **);
+extern _X_EXPORT void LoaderFreeDirList(char **);
+extern _X_EXPORT void LoaderErrorMsg(const char *, const char *, int, int);
+extern _X_EXPORT void LoadExtension(ExtensionModule *, Bool);
+extern _X_EXPORT void LoaderGetOS(const char **name, int *major, int *minor, int *teeny);
+extern _X_EXPORT Bool LoaderShouldIgnoreABI(void);
+extern _X_EXPORT int LoaderGetABIVersion(const char *abiclass);
+
+typedef pointer (*ModuleSetupProc)(pointer, pointer, int *, int *);
+typedef void (*ModuleTearDownProc)(pointer);
+#define MODULESETUPPROTO(func) pointer func(pointer, pointer, int*, int*)
+#define MODULETEARDOWNPROTO(func) void func(pointer)
+
+typedef struct {
+    XF86ModuleVersionInfo *	vers;
+    ModuleSetupProc		setup;
+    ModuleTearDownProc		teardown;
+} XF86ModuleData;
+
+#endif /* _XF86STR_H */
diff --git a/xorg-server/hw/xfree86/common/xf86Option.c b/xorg-server/hw/xfree86/common/xf86Option.c
index 9856a6352..d1dcb0f94 100644
--- a/xorg-server/hw/xfree86/common/xf86Option.c
+++ b/xorg-server/hw/xfree86/common/xf86Option.c
@@ -164,6 +164,10 @@ xf86CollectInputOptions(InputInfoPtr pInfo, const char **defaultOpts,
 	else
 	    pInfo->options = tmp;
     }
+
+    if (pInfo->conf_idev && pInfo->conf_idev->attrs) {
+        pInfo->attrs = pInfo->conf_idev->attrs;
+    }
 }
 
 /* Created for new XInput stuff -- essentially extensions to the parser	*/
diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.c b/xorg-server/hw/xfree86/common/xf86Xinput.c
index 55cd49c1f..21921b2c3 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.c
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.c
@@ -622,7 +622,6 @@ MergeInputClasses(IDevPtr idev, InputAttributes *attrs)
         mergedopts = xf86ReplaceStrOption(mergedopts, "driver", idev->driver);
     }
     idev->commonOptions = xf86optionListMerge(idev->commonOptions, mergedopts);
-
     return Success;
 }
 
@@ -822,6 +821,8 @@ NewInputDeviceRequest (InputOption *options, InputAttributes *attrs,
         rval = MergeInputClasses(idev, attrs);
         if (rval != Success)
             goto unwind;
+
+        idev->attrs = DuplicateInputAttributes(attrs);
     }
 
     if (!idev->driver || !idev->identifier) {
@@ -853,7 +854,7 @@ unwind:
 }
 
 void
-DeleteInputDeviceRequest(DeviceIntPtr pDev)
+DeleteInputDeviceRequest(DeviceIntPtr pDev, int flags)
 {
     LocalDevicePtr pInfo = (LocalDevicePtr) pDev->public.devicePrivate;
     InputDriverPtr drv = NULL;
@@ -873,9 +874,9 @@ DeleteInputDeviceRequest(DeviceIntPtr pDev)
     if (!isMaster && pInfo != NULL)
     {
         if(drv->UnInit)
-            drv->UnInit(drv, pInfo, 0);
+            drv->UnInit(drv, pInfo, flags);
         else
-            xf86DeleteInput(pInfo, 0);
+            xf86DeleteInput(pInfo, flags);
 
         /* devices added through HAL aren't in the config layout */
         it = xf86ConfigLayout.inputs;
@@ -1266,7 +1267,7 @@ xf86DisableDevice(DeviceIntPtr dev, Bool panic)
     } else
     {
         SendDevicePresenceEvent(dev->id, DeviceUnrecoverable);
-        DeleteInputDeviceRequest(dev);
+        DeleteInputDeviceRequest(dev, 0);
     }
 }
 
diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.h b/xorg-server/hw/xfree86/common/xf86Xinput.h
index aa9e9d507..d78c22333 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.h
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.h
@@ -1,219 +1,220 @@
-/*
- * Copyright 1995-1999 by Frederic Lepied, France. <Lepied@XFree86.org>
- *                                                                            
- * 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, and that   the  name of  Frederic   Lepied not  be  used  in
- * advertising or publicity pertaining to distribution of the software without
- * specific,  written      prior  permission.     Frederic  Lepied   makes  no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.                   
- *                                                                            
- * FREDERIC  LEPIED DISCLAIMS ALL   WARRANTIES WITH REGARD  TO  THIS SOFTWARE,
- * INCLUDING ALL IMPLIED   WARRANTIES OF MERCHANTABILITY  AND   FITNESS, IN NO
- * EVENT  SHALL FREDERIC  LEPIED 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.
- *
- */
-
-/*
- * Copyright (c) 2000-2002 by The XFree86 Project, Inc.
- *
- * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 copyright holder(s)
- * and author(s) 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 copyright holder(s) and author(s).
- */
-
-
-#ifndef _xf86Xinput_h
-#define _xf86Xinput_h
-
-#include "xf86str.h"
-#include "inputstr.h"
-#include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>
-#include "XIstubs.h"
-
-/* Input device flags */
-#define XI86_OPEN_ON_INIT       0x01 /* open the device at startup time */
-#define XI86_CONFIGURED         0x02 /* the device has been configured */
-#define XI86_ALWAYS_CORE	0x04 /* device always controls the pointer */
-/* the device sends Xinput and core pointer events */
-#define XI86_SEND_CORE_EVENTS	XI86_ALWAYS_CORE
-/* if the device is the core pointer or is sending core events, and
- * SEND_DRAG_EVENTS is false, and a buttons is done, then no motion events
- * (mouse drag action) are sent. This is mainly to allow a touch screen to be
- * used with netscape and other browsers which do strange things if the mouse
- * moves between button down and button up. With a touch screen, this motion
- * is common due to the user's finger moving slightly.
- */
-#define XI86_SEND_DRAG_EVENTS	0x08
-#define XI86_CORE_POINTER	0x10 /* device is the core pointer */
-#define XI86_CORE_KEYBOARD	0x20 /* device is the core keyboard */
-#define XI86_POINTER_CAPABLE	0x40 /* capable of being a core pointer */
-#define XI86_KEYBOARD_CAPABLE	0x80 /* capable of being a core keyboard */
-
-#define XI_PRIVATE(dev) \
-	(((LocalDevicePtr)((dev)->public.devicePrivate))->private)
-
-/* Valuator verification macro */
-#define XI_VERIFY_VALUATORS(num_valuators)					\
-	if (num_valuators > MAX_VALUATORS) {					\
-		xf86Msg(X_ERROR, "%s: num_valuator %d is greater than"		\
-			" MAX_VALUATORS\n", __FUNCTION__, num_valuators);	\
-		return;								\
-	}
-
-/* Stupid API backwards-compatibility. */
-#define TS_Raw 60
-#define TS_Scaled 61
-
-/* This holds the input driver entry and module information. */
-typedef struct _InputDriverRec {
-    int			    driverVersion;
-    char *		    driverName;
-    void		    (*Identify)(int flags);
-    struct _LocalDeviceRec *(*PreInit)(struct _InputDriverRec *drv,
-				       IDevPtr dev, int flags);
-    void		    (*UnInit)(struct _InputDriverRec *drv,
-				      struct _LocalDeviceRec *pInfo,
-				      int flags);
-    pointer		    module;
-    int			    refCount;
-} InputDriverRec, *InputDriverPtr;
-
-/* This is to input devices what the ScrnInfoRec is to screens. */
-
-typedef struct _LocalDeviceRec {
-    struct _LocalDeviceRec *next;
-    char *		    name;
-    int			    flags;
-
-    Bool		    (*device_control)(DeviceIntPtr device, int what);
-    void		    (*read_input)(struct _LocalDeviceRec *local);
-    int			    (*control_proc)(struct _LocalDeviceRec *local,
-					   xDeviceCtl *control);
-    void		    (*close_proc)(struct _LocalDeviceRec *local);
-    int			    (*switch_mode)(ClientPtr client, DeviceIntPtr dev,
-					  int mode);
-    Bool		    (*conversion_proc)(struct _LocalDeviceRec *local,
-					      int first, int num, int v0,
-					      int v1, int v2, int v3, int v4,
-					      int v5, int *x, int *y);
-    Bool		    (*reverse_conversion_proc)(
-					struct _LocalDeviceRec *local,
-					int x, int y, int *valuators);
-    int                     (*set_device_valuators)
-				(struct _LocalDeviceRec *local,
-				 int *valuators, int first_valuator,
-				 int num_valuators);
-
-    int			    fd;
-    Atom		    atom;
-    DeviceIntPtr	    dev;
-    pointer		    private;
-    int			    private_flags;
-    unsigned int	    first;
-    unsigned int	    last;
-    int			    old_x;
-    int			    old_y;
-    char *		    type_name;
-    IntegerFeedbackPtr	    always_core_feedback;
-    IDevPtr		    conf_idev;
-    InputDriverPtr	    drv;
-    pointer		    module;
-    pointer		    options;
-    unsigned int            history_size;
-} LocalDeviceRec, *LocalDevicePtr, InputInfoRec, *InputInfoPtr;
-
-typedef struct _DeviceAssocRec 
-{
-    char *		    config_section_name;
-    LocalDevicePtr	    (*device_allocate)(void);
-} DeviceAssocRec, *DeviceAssocPtr;
-
-/* xf86Globals.c */
-extern _X_EXPORT InputInfoPtr xf86InputDevs;
-
-/* xf86Xinput.c */
-extern _X_EXPORT void xf86PostMotionEvent(DeviceIntPtr device, int is_absolute,
-			 int first_valuator, int num_valuators, ...);
-extern _X_EXPORT void xf86PostMotionEventP(DeviceIntPtr device, int is_absolute,
-			 int first_valuator, int num_valuators, int *valuators);
-extern _X_EXPORT void xf86PostProximityEvent(DeviceIntPtr device, int is_in,
-			    int first_valuator, int num_valuators, ...);
-extern _X_EXPORT void xf86PostProximityEventP(DeviceIntPtr device, int is_in, int first_valuator,
-			     int num_valuators, int *valuators);
-extern _X_EXPORT void xf86PostButtonEvent(DeviceIntPtr device, int is_absolute, int button,
-		    	 int is_down, int first_valuator, int num_valuators,
-			 ...);
-extern _X_EXPORT void xf86PostButtonEventP(DeviceIntPtr device, int is_absolute, int button,
-			  int is_down, int first_valuator, int num_valuators,
-			  int *valuators);
-extern _X_EXPORT void xf86PostKeyEvent(DeviceIntPtr device, unsigned int key_code, int is_down,
-		      int is_absolute, int first_valuator, int num_valuators,
-		      ...);
-extern _X_EXPORT void xf86PostKeyEventP(DeviceIntPtr device, unsigned int key_code, int is_down,
-		       int is_absolute, int first_valuator, int num_valuators,
-		       int *valuators);
-extern _X_EXPORT void xf86PostKeyboardEvent(DeviceIntPtr device, unsigned int key_code,
-                           int is_down);
-extern _X_EXPORT int xf86ActivateDevice(LocalDevicePtr local);
-extern _X_EXPORT LocalDevicePtr xf86FirstLocalDevice(void);
-extern _X_EXPORT int xf86ScaleAxis(int Cx, int Sxhigh, int Sxlow, int Rxhigh, int Rxlow);
-extern _X_EXPORT void xf86XInputSetScreen(LocalDevicePtr local, int screen_number, int x, int y);
-extern _X_EXPORT void xf86ProcessCommonOptions(InputInfoPtr pInfo, pointer options);
-extern _X_EXPORT void xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval,
-				int maxval, int resolution, int min_res,
-				int max_res);
-extern _X_EXPORT void xf86InitValuatorDefaults(DeviceIntPtr dev, int axnum);
-extern _X_EXPORT void xf86AddEnabledDevice(InputInfoPtr pInfo);
-extern _X_EXPORT void xf86RemoveEnabledDevice(InputInfoPtr pInfo);
-extern _X_EXPORT void xf86DisableDevice(DeviceIntPtr dev, Bool panic);
-extern _X_EXPORT void xf86EnableDevice(DeviceIntPtr dev);
-/* not exported */
-int xf86NewInputDevice(IDevPtr idev, DeviceIntPtr *pdev, BOOL is_auto);
-
-/* xf86Helper.c */
-extern _X_EXPORT void xf86AddInputDriver(InputDriverPtr driver, pointer module, int flags);
-extern _X_EXPORT void xf86DeleteInputDriver(int drvIndex);
-extern _X_EXPORT InputInfoPtr xf86AllocateInput(InputDriverPtr drv, int flags);
-extern _X_EXPORT InputDriverPtr xf86LookupInputDriver(const char *name);
-extern _X_EXPORT InputInfoPtr xf86LookupInput(const char *name);
-extern _X_EXPORT void xf86DeleteInput(InputInfoPtr pInp, int flags);
-extern _X_EXPORT void xf86MotionHistoryAllocate(LocalDevicePtr local);
-
-/* xf86Option.c */
-extern _X_EXPORT void xf86CollectInputOptions(InputInfoPtr pInfo, const char **defaultOpts,
-			     pointer extraOpts);
-
-
-/* Legacy hatred */
-#define SendCoreEvents 59
-#define DontSendCoreEvents 60
-
-#endif /* _xf86Xinput_h */
+/*
+ * Copyright 1995-1999 by Frederic Lepied, France. <Lepied@XFree86.org>
+ *                                                                            
+ * 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, and that   the  name of  Frederic   Lepied not  be  used  in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific,  written      prior  permission.     Frederic  Lepied   makes  no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.                   
+ *                                                                            
+ * FREDERIC  LEPIED DISCLAIMS ALL   WARRANTIES WITH REGARD  TO  THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED   WARRANTIES OF MERCHANTABILITY  AND   FITNESS, IN NO
+ * EVENT  SHALL FREDERIC  LEPIED 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.
+ *
+ */
+
+/*
+ * Copyright (c) 2000-2002 by The XFree86 Project, Inc.
+ *
+ * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 copyright holder(s)
+ * and author(s) 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 copyright holder(s) and author(s).
+ */
+
+
+#ifndef _xf86Xinput_h
+#define _xf86Xinput_h
+
+#include "xf86str.h"
+#include "inputstr.h"
+#include <X11/extensions/XI.h>
+#include <X11/extensions/XIproto.h>
+#include "XIstubs.h"
+
+/* Input device flags */
+#define XI86_OPEN_ON_INIT       0x01 /* open the device at startup time */
+#define XI86_CONFIGURED         0x02 /* the device has been configured */
+#define XI86_ALWAYS_CORE	0x04 /* device always controls the pointer */
+/* the device sends Xinput and core pointer events */
+#define XI86_SEND_CORE_EVENTS	XI86_ALWAYS_CORE
+/* if the device is the core pointer or is sending core events, and
+ * SEND_DRAG_EVENTS is false, and a buttons is done, then no motion events
+ * (mouse drag action) are sent. This is mainly to allow a touch screen to be
+ * used with netscape and other browsers which do strange things if the mouse
+ * moves between button down and button up. With a touch screen, this motion
+ * is common due to the user's finger moving slightly.
+ */
+#define XI86_SEND_DRAG_EVENTS	0x08
+#define XI86_CORE_POINTER	0x10 /* device is the core pointer */
+#define XI86_CORE_KEYBOARD	0x20 /* device is the core keyboard */
+#define XI86_POINTER_CAPABLE	0x40 /* capable of being a core pointer */
+#define XI86_KEYBOARD_CAPABLE	0x80 /* capable of being a core keyboard */
+
+#define XI_PRIVATE(dev) \
+	(((LocalDevicePtr)((dev)->public.devicePrivate))->private)
+
+/* Valuator verification macro */
+#define XI_VERIFY_VALUATORS(num_valuators)					\
+	if (num_valuators > MAX_VALUATORS) {					\
+		xf86Msg(X_ERROR, "%s: num_valuator %d is greater than"		\
+			" MAX_VALUATORS\n", __FUNCTION__, num_valuators);	\
+		return;								\
+	}
+
+/* Stupid API backwards-compatibility. */
+#define TS_Raw 60
+#define TS_Scaled 61
+
+/* This holds the input driver entry and module information. */
+typedef struct _InputDriverRec {
+    int			    driverVersion;
+    char *		    driverName;
+    void		    (*Identify)(int flags);
+    struct _LocalDeviceRec *(*PreInit)(struct _InputDriverRec *drv,
+				       IDevPtr dev, int flags);
+    void		    (*UnInit)(struct _InputDriverRec *drv,
+				      struct _LocalDeviceRec *pInfo,
+				      int flags);
+    pointer		    module;
+    int			    refCount;
+} InputDriverRec, *InputDriverPtr;
+
+/* This is to input devices what the ScrnInfoRec is to screens. */
+
+typedef struct _LocalDeviceRec {
+    struct _LocalDeviceRec *next;
+    char *		    name;
+    int			    flags;
+
+    Bool		    (*device_control)(DeviceIntPtr device, int what);
+    void		    (*read_input)(struct _LocalDeviceRec *local);
+    int			    (*control_proc)(struct _LocalDeviceRec *local,
+					   xDeviceCtl *control);
+    void		    (*close_proc)(struct _LocalDeviceRec *local);
+    int			    (*switch_mode)(ClientPtr client, DeviceIntPtr dev,
+					  int mode);
+    Bool		    (*conversion_proc)(struct _LocalDeviceRec *local,
+					      int first, int num, int v0,
+					      int v1, int v2, int v3, int v4,
+					      int v5, int *x, int *y);
+    Bool		    (*reverse_conversion_proc)(
+					struct _LocalDeviceRec *local,
+					int x, int y, int *valuators);
+    int                     (*set_device_valuators)
+				(struct _LocalDeviceRec *local,
+				 int *valuators, int first_valuator,
+				 int num_valuators);
+
+    int			    fd;
+    Atom		    atom;
+    DeviceIntPtr	    dev;
+    pointer		    private;
+    int			    private_flags;
+    unsigned int	    first;
+    unsigned int	    last;
+    int			    old_x;
+    int			    old_y;
+    char *		    type_name;
+    IntegerFeedbackPtr	    always_core_feedback;
+    IDevPtr		    conf_idev;
+    InputDriverPtr	    drv;
+    pointer		    module;
+    pointer		    options;
+    unsigned int            history_size;
+    InputAttributes         *attrs;
+} LocalDeviceRec, *LocalDevicePtr, InputInfoRec, *InputInfoPtr;
+
+typedef struct _DeviceAssocRec 
+{
+    char *		    config_section_name;
+    LocalDevicePtr	    (*device_allocate)(void);
+} DeviceAssocRec, *DeviceAssocPtr;
+
+/* xf86Globals.c */
+extern _X_EXPORT InputInfoPtr xf86InputDevs;
+
+/* xf86Xinput.c */
+extern _X_EXPORT void xf86PostMotionEvent(DeviceIntPtr device, int is_absolute,
+			 int first_valuator, int num_valuators, ...);
+extern _X_EXPORT void xf86PostMotionEventP(DeviceIntPtr device, int is_absolute,
+			 int first_valuator, int num_valuators, int *valuators);
+extern _X_EXPORT void xf86PostProximityEvent(DeviceIntPtr device, int is_in,
+			    int first_valuator, int num_valuators, ...);
+extern _X_EXPORT void xf86PostProximityEventP(DeviceIntPtr device, int is_in, int first_valuator,
+			     int num_valuators, int *valuators);
+extern _X_EXPORT void xf86PostButtonEvent(DeviceIntPtr device, int is_absolute, int button,
+		    	 int is_down, int first_valuator, int num_valuators,
+			 ...);
+extern _X_EXPORT void xf86PostButtonEventP(DeviceIntPtr device, int is_absolute, int button,
+			  int is_down, int first_valuator, int num_valuators,
+			  int *valuators);
+extern _X_EXPORT void xf86PostKeyEvent(DeviceIntPtr device, unsigned int key_code, int is_down,
+		      int is_absolute, int first_valuator, int num_valuators,
+		      ...);
+extern _X_EXPORT void xf86PostKeyEventP(DeviceIntPtr device, unsigned int key_code, int is_down,
+		       int is_absolute, int first_valuator, int num_valuators,
+		       int *valuators);
+extern _X_EXPORT void xf86PostKeyboardEvent(DeviceIntPtr device, unsigned int key_code,
+                           int is_down);
+extern _X_EXPORT int xf86ActivateDevice(LocalDevicePtr local);
+extern _X_EXPORT LocalDevicePtr xf86FirstLocalDevice(void);
+extern _X_EXPORT int xf86ScaleAxis(int Cx, int Sxhigh, int Sxlow, int Rxhigh, int Rxlow);
+extern _X_EXPORT void xf86XInputSetScreen(LocalDevicePtr local, int screen_number, int x, int y);
+extern _X_EXPORT void xf86ProcessCommonOptions(InputInfoPtr pInfo, pointer options);
+extern _X_EXPORT void xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval,
+				int maxval, int resolution, int min_res,
+				int max_res);
+extern _X_EXPORT void xf86InitValuatorDefaults(DeviceIntPtr dev, int axnum);
+extern _X_EXPORT void xf86AddEnabledDevice(InputInfoPtr pInfo);
+extern _X_EXPORT void xf86RemoveEnabledDevice(InputInfoPtr pInfo);
+extern _X_EXPORT void xf86DisableDevice(DeviceIntPtr dev, Bool panic);
+extern _X_EXPORT void xf86EnableDevice(DeviceIntPtr dev);
+/* not exported */
+int xf86NewInputDevice(IDevPtr idev, DeviceIntPtr *pdev, BOOL is_auto);
+
+/* xf86Helper.c */
+extern _X_EXPORT void xf86AddInputDriver(InputDriverPtr driver, pointer module, int flags);
+extern _X_EXPORT void xf86DeleteInputDriver(int drvIndex);
+extern _X_EXPORT InputInfoPtr xf86AllocateInput(InputDriverPtr drv, int flags);
+extern _X_EXPORT InputDriverPtr xf86LookupInputDriver(const char *name);
+extern _X_EXPORT InputInfoPtr xf86LookupInput(const char *name);
+extern _X_EXPORT void xf86DeleteInput(InputInfoPtr pInp, int flags);
+extern _X_EXPORT void xf86MotionHistoryAllocate(LocalDevicePtr local);
+
+/* xf86Option.c */
+extern _X_EXPORT void xf86CollectInputOptions(InputInfoPtr pInfo, const char **defaultOpts,
+			     pointer extraOpts);
+
+
+/* Legacy hatred */
+#define SendCoreEvents 59
+#define DontSendCoreEvents 60
+
+#endif /* _xf86Xinput_h */
diff --git a/xorg-server/hw/xfree86/common/xf86str.h b/xorg-server/hw/xfree86/common/xf86str.h
index c4fbe0403..58438db76 100644
--- a/xorg-server/hw/xfree86/common/xf86str.h
+++ b/xorg-server/hw/xfree86/common/xf86str.h
@@ -406,6 +406,7 @@ typedef struct {
    char *			driver;
    pointer		 	commonOptions;
    pointer			extraOptions;
+   InputAttributes              *attrs;
 } IDevRec, *IDevPtr;
 
 typedef struct {
diff --git a/xorg-server/hw/xnest/Cursor.c b/xorg-server/hw/xnest/Cursor.c
index 290074d4e..f35517abb 100644
--- a/xorg-server/hw/xnest/Cursor.c
+++ b/xorg-server/hw/xnest/Cursor.c
@@ -167,8 +167,7 @@ xnestDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
     pScreenPriv = (xnestCursorFuncPtr)
             dixLookupPrivate(&pScreen->devPrivates, xnestCursorScreenKey);
 
-    pScreenPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);
-    return TRUE;
+    return pScreenPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);
 }
 
 void
diff --git a/xorg-server/hw/xquartz/darwinXinput.c b/xorg-server/hw/xquartz/darwinXinput.c
index 90e440e54..cba2853a3 100644
--- a/xorg-server/hw/xquartz/darwinXinput.c
+++ b/xorg-server/hw/xquartz/darwinXinput.c
@@ -1,257 +1,257 @@
-/*
- * X server support of the XINPUT extension for xquartz
- *
- * This is currently a copy of Xi/stubs.c, but eventually this
- * should include more complete XINPUT support.
- */
-
-/************************************************************
-
-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.
-
-********************************************************/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "inputstr.h"
-#include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>
-#include "XIstubs.h"
-#include "darwin.h"
-
-/***********************************************************************
- *
- * Caller:	ProcXCloseDevice
- *
- * Take care of implementation-dependent details of closing a device.
- * Some implementations may actually close the device, others may just
- * remove this clients interest in that device.
- *
- * The default implementation is to do nothing (assume all input devices
- * are initialized during X server initialization and kept open).
- *
- */
-
-void
-CloseInputDevice(DeviceIntPtr d, ClientPtr client)
-{
-  DEBUG_LOG("CloseInputDevice(%p, %p)\n", d, client);
-}
-
-/***********************************************************************
- *
- * Caller:	ProcXListInputDevices
- *
- * This is the implementation-dependent routine to initialize an input 
- * device to the point that information about it can be listed.
- * Some implementations open all input devices when the server is first
- * initialized, and never close them.  Other implementations open only
- * the X pointer and keyboard devices during server initialization,
- * and only open other input devices when some client makes an
- * XOpenDevice request.  If some other process has the device open, the
- * server may not be able to get information about the device to list it.
- *
- * This procedure should be used by implementations that do not initialize
- * all input devices at server startup.  It should do device-dependent
- * initialization for any devices not previously initialized, and call
- * AddInputDevice for each of those devices so that a DeviceIntRec will be 
- * created for them.
- *
- * The default implementation is to do nothing (assume all input devices
- * are initialized during X server initialization and kept open).
- * The commented-out sample code shows what you might do if you don't want 
- * the default.
- *
- */
-
-void
-AddOtherInputDevices(void)
-{
-    /**********************************************************************
-     for each uninitialized device, do something like: 
-
-    DeviceIntPtr dev;
-    DeviceProc deviceProc;
-    pointer private;
-
-    dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE);
-    dev->public.devicePrivate = private;
-    RegisterOtherDevice(dev);
-    dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
-    ************************************************************************/
-  DEBUG_LOG("AddOtherInputDevices\n");
-}
-
-/***********************************************************************
- *
- * Caller:	ProcXOpenDevice
- *
- * This is the implementation-dependent routine to open an input device.
- * Some implementations open all input devices when the server is first
- * initialized, and never close them.  Other implementations open only
- * the X pointer and keyboard devices during server initialization,
- * and only open other input devices when some client makes an
- * XOpenDevice request.  This entry point is for the latter type of 
- * implementation.
- *
- * If the physical device is not already open, do it here.  In this case,
- * you need to keep track of the fact that one or more clients has the
- * device open, and physically close it when the last client that has
- * it open does an XCloseDevice.
- *
- * The default implementation is to do nothing (assume all input devices
- * are opened during X server initialization and kept open).
- *
- */
-
-void
-OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
-{
-  DEBUG_LOG("OpenInputDevice(%p, %p, %p)\n", dev, client, status);
-}
-
-/****************************************************************************
- *
- * Caller:	ProcXSetDeviceMode
- *
- * Change the mode of an extension device.
- * This function is used to change the mode of a device from reporting
- * relative motion to reporting absolute positional information, and
- * vice versa.
- * The default implementation below is that no such devices are supported.
- *
- */
-
-int
-SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)
-{
-  DEBUG_LOG("SetDeviceMode(%p, %p, %d)\n", client, dev, mode);
-    return BadMatch;
-}
-
-/****************************************************************************
- *
- * Caller:	ProcXSetDeviceValuators
- *
- * Set the value of valuators on an extension input device.
- * This function is used to set the initial value of valuators on
- * those input devices that are capable of reporting either relative
- * motion or an absolute position, and allow an initial position to be set.
- * The default implementation below is that no such devices are supported.
- *
- */
-
-int
-SetDeviceValuators(ClientPtr client, DeviceIntPtr dev,
-		   int *valuators, int first_valuator, int num_valuators)
-{
-  DEBUG_LOG("SetDeviceValuators(%p, %p, %p, %d, %d)\n", client,
-	    dev, valuators, first_valuator, num_valuators);
-  return BadMatch;
-}
-
-/****************************************************************************
- *
- * Caller:	ProcXChangeDeviceControl
- *
- * Change the specified device controls on an extension input device.
- *
- */
-
-int
-ChangeDeviceControl(ClientPtr client, DeviceIntPtr dev,
-		    xDeviceCtl * control)
-{
-
-  DEBUG_LOG("ChangeDeviceControl(%p, %p, %p)\n", client, dev, control);
-    switch (control->control) {
-    case DEVICE_RESOLUTION:
-	return (BadMatch);
-    case DEVICE_ABS_CALIB:
-    case DEVICE_ABS_AREA:
-        return (BadMatch);
-    case DEVICE_CORE:
-        return (BadMatch);
-    default:
-	return (BadMatch);
-    }
-}
-
-
-/****************************************************************************
- *
- * Caller: configAddDevice (and others)
- *
- * Add a new device with the specified options.
- *
- */
-int
-NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
-                      DeviceIntPtr *pdev)
-{
-  DEBUG_LOG("NewInputDeviceRequest(%p, %p)\n", options, pdev);
-  return BadValue;
-}
-
-/****************************************************************************
- *
- * Caller: configRemoveDevice (and others)
- *
- * Remove the specified device previously added.
- *
- */
-void
-DeleteInputDeviceRequest(DeviceIntPtr dev)
-{
-  DEBUG_LOG("DeleteInputDeviceRequest(%p)\n", dev);
-}
-
-void
-CloseInput (void)
-{
-}
-
+/*
+ * X server support of the XINPUT extension for xquartz
+ *
+ * This is currently a copy of Xi/stubs.c, but eventually this
+ * should include more complete XINPUT support.
+ */
+
+/************************************************************
+
+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.
+
+********************************************************/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "inputstr.h"
+#include <X11/extensions/XI.h>
+#include <X11/extensions/XIproto.h>
+#include "XIstubs.h"
+#include "darwin.h"
+
+/***********************************************************************
+ *
+ * Caller:	ProcXCloseDevice
+ *
+ * Take care of implementation-dependent details of closing a device.
+ * Some implementations may actually close the device, others may just
+ * remove this clients interest in that device.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are initialized during X server initialization and kept open).
+ *
+ */
+
+void
+CloseInputDevice(DeviceIntPtr d, ClientPtr client)
+{
+  DEBUG_LOG("CloseInputDevice(%p, %p)\n", d, client);
+}
+
+/***********************************************************************
+ *
+ * Caller:	ProcXListInputDevices
+ *
+ * This is the implementation-dependent routine to initialize an input 
+ * device to the point that information about it can be listed.
+ * Some implementations open all input devices when the server is first
+ * initialized, and never close them.  Other implementations open only
+ * the X pointer and keyboard devices during server initialization,
+ * and only open other input devices when some client makes an
+ * XOpenDevice request.  If some other process has the device open, the
+ * server may not be able to get information about the device to list it.
+ *
+ * This procedure should be used by implementations that do not initialize
+ * all input devices at server startup.  It should do device-dependent
+ * initialization for any devices not previously initialized, and call
+ * AddInputDevice for each of those devices so that a DeviceIntRec will be 
+ * created for them.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are initialized during X server initialization and kept open).
+ * The commented-out sample code shows what you might do if you don't want 
+ * the default.
+ *
+ */
+
+void
+AddOtherInputDevices(void)
+{
+    /**********************************************************************
+     for each uninitialized device, do something like: 
+
+    DeviceIntPtr dev;
+    DeviceProc deviceProc;
+    pointer private;
+
+    dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE);
+    dev->public.devicePrivate = private;
+    RegisterOtherDevice(dev);
+    dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
+    ************************************************************************/
+  DEBUG_LOG("AddOtherInputDevices\n");
+}
+
+/***********************************************************************
+ *
+ * Caller:	ProcXOpenDevice
+ *
+ * This is the implementation-dependent routine to open an input device.
+ * Some implementations open all input devices when the server is first
+ * initialized, and never close them.  Other implementations open only
+ * the X pointer and keyboard devices during server initialization,
+ * and only open other input devices when some client makes an
+ * XOpenDevice request.  This entry point is for the latter type of 
+ * implementation.
+ *
+ * If the physical device is not already open, do it here.  In this case,
+ * you need to keep track of the fact that one or more clients has the
+ * device open, and physically close it when the last client that has
+ * it open does an XCloseDevice.
+ *
+ * The default implementation is to do nothing (assume all input devices
+ * are opened during X server initialization and kept open).
+ *
+ */
+
+void
+OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
+{
+  DEBUG_LOG("OpenInputDevice(%p, %p, %p)\n", dev, client, status);
+}
+
+/****************************************************************************
+ *
+ * Caller:	ProcXSetDeviceMode
+ *
+ * Change the mode of an extension device.
+ * This function is used to change the mode of a device from reporting
+ * relative motion to reporting absolute positional information, and
+ * vice versa.
+ * The default implementation below is that no such devices are supported.
+ *
+ */
+
+int
+SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)
+{
+  DEBUG_LOG("SetDeviceMode(%p, %p, %d)\n", client, dev, mode);
+    return BadMatch;
+}
+
+/****************************************************************************
+ *
+ * Caller:	ProcXSetDeviceValuators
+ *
+ * Set the value of valuators on an extension input device.
+ * This function is used to set the initial value of valuators on
+ * those input devices that are capable of reporting either relative
+ * motion or an absolute position, and allow an initial position to be set.
+ * The default implementation below is that no such devices are supported.
+ *
+ */
+
+int
+SetDeviceValuators(ClientPtr client, DeviceIntPtr dev,
+		   int *valuators, int first_valuator, int num_valuators)
+{
+  DEBUG_LOG("SetDeviceValuators(%p, %p, %p, %d, %d)\n", client,
+	    dev, valuators, first_valuator, num_valuators);
+  return BadMatch;
+}
+
+/****************************************************************************
+ *
+ * Caller:	ProcXChangeDeviceControl
+ *
+ * Change the specified device controls on an extension input device.
+ *
+ */
+
+int
+ChangeDeviceControl(ClientPtr client, DeviceIntPtr dev,
+		    xDeviceCtl * control)
+{
+
+  DEBUG_LOG("ChangeDeviceControl(%p, %p, %p)\n", client, dev, control);
+    switch (control->control) {
+    case DEVICE_RESOLUTION:
+	return (BadMatch);
+    case DEVICE_ABS_CALIB:
+    case DEVICE_ABS_AREA:
+        return (BadMatch);
+    case DEVICE_CORE:
+        return (BadMatch);
+    default:
+	return (BadMatch);
+    }
+}
+
+
+/****************************************************************************
+ *
+ * Caller: configAddDevice (and others)
+ *
+ * Add a new device with the specified options.
+ *
+ */
+int
+NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
+                      DeviceIntPtr *pdev)
+{
+  DEBUG_LOG("NewInputDeviceRequest(%p, %p)\n", options, pdev);
+  return BadValue;
+}
+
+/****************************************************************************
+ *
+ * Caller: configRemoveDevice (and others)
+ *
+ * Remove the specified device previously added.
+ *
+ */
+void
+DeleteInputDeviceRequest(DeviceIntPtr dev, int flags)
+{
+  DEBUG_LOG("DeleteInputDeviceRequest(%p)\n", dev);
+}
+
+void
+CloseInput (void)
+{
+}
+
diff --git a/xorg-server/include/input.h b/xorg-server/include/input.h
index 63f981ef0..de80388fa 100644
--- a/xorg-server/include/input.h
+++ b/xorg-server/include/input.h
@@ -1,548 +1,554 @@
-/************************************************************
-
-Copyright 1987, 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 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
-
-                        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 Digital not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.  
-
-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-DIGITAL 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.
-
-********************************************************/
-
-#ifndef INPUT_H
-#define INPUT_H
-
-#include "misc.h"
-#include "screenint.h"
-#include <X11/Xmd.h>
-#include <X11/Xproto.h>
-#include <stdint.h>
-#include "window.h"     /* for WindowPtr */
-#include "xkbrules.h"
-#include "events.h"
-
-#define DEVICE_INIT	0
-#define DEVICE_ON	1
-#define DEVICE_OFF	2
-#define DEVICE_CLOSE	3
-
-#define POINTER_RELATIVE (1 << 1)
-#define POINTER_ABSOLUTE (1 << 2)
-#define POINTER_ACCELERATE (1 << 3)
-#define POINTER_SCREEN (1 << 4) /* Data in screen coordinates */
-
-/*int constants for pointer acceleration schemes*/
-#define PtrAccelNoOp            0
-#define PtrAccelPredictable     1
-#define PtrAccelLightweight     2
-#define PtrAccelDefault         PtrAccelPredictable
-
-#define MAX_VALUATORS 36
-/* Maximum number of valuators, divided by six, rounded up, to get number
- * of events. */
-#define MAX_VALUATOR_EVENTS 6
-#define MAX_BUTTONS 256 /* completely arbitrarily chosen */
-
-#define NO_AXIS_LIMITS -1
-
-#define MAP_LENGTH	256
-#define DOWN_LENGTH	32	/* 256/8 => number of bytes to hold 256 bits */
-#define NullGrab ((GrabPtr)NULL)
-#define PointerRootWin ((WindowPtr)PointerRoot)
-#define NoneWin ((WindowPtr)None)
-#define NullDevice ((DevicePtr)NULL)
-
-#ifndef FollowKeyboard
-#define FollowKeyboard 		3
-#endif
-#ifndef FollowKeyboardWin
-#define FollowKeyboardWin  ((WindowPtr) FollowKeyboard)
-#endif
-#ifndef RevertToFollowKeyboard
-#define RevertToFollowKeyboard	3
-#endif
-
-typedef unsigned long Leds;
-typedef struct _OtherClients *OtherClientsPtr;
-typedef struct _InputClients *InputClientsPtr;
-typedef struct _DeviceIntRec *DeviceIntPtr;
-typedef struct _ClassesRec *ClassesPtr;
-typedef union _GrabMask GrabMask;
-
-typedef struct _EventList {
-    xEvent* event;
-    int evlen; /* length of allocated memory for event in bytes.  This is not
-                  the actual length of the event. The event's actual length is
-                  32 for standard events or 32 +
-                  ((xGenericEvent*)event)->length * 4 for GenericEvents.
-                  For events in the EQ, the length is
-                  ((InternalEvent*)event)->u.any.length */
-} EventList, *EventListPtr;
-
-/* The DIX stores incoming input events in this list */
-extern EventListPtr InputEventList;
-extern int InputEventListLen;
-
-typedef int (*DeviceProc)(
-    DeviceIntPtr /*device*/,
-    int /*what*/);
-
-typedef void (*ProcessInputProc)(
-    InternalEvent * /*event*/,
-    DeviceIntPtr /*device*/);
-
-typedef Bool (*DeviceHandleProc)(
-    DeviceIntPtr /*device*/,
-    void* /*data*/
-    );
-
-typedef void (*DeviceUnwrapProc)(
-    DeviceIntPtr /*device*/,
-    DeviceHandleProc /*proc*/,
-    void* /*data*/
-    );
-
-/* pointer acceleration handling */
-typedef void (*PointerAccelSchemeProc)(
-    DeviceIntPtr /*pDev*/,
-    int /*first_valuator*/,
-    int /*num_valuators*/,
-    int* /*valuators*/,
-    int /*evtime*/);
-
-typedef void (*DeviceCallbackProc)(
-              DeviceIntPtr /*pDev*/);
-
-typedef struct _DeviceRec {
-    pointer	devicePrivate;
-    ProcessInputProc processInputProc;	/* current */
-    ProcessInputProc realInputProc;	/* deliver */
-    ProcessInputProc enqueueInputProc;	/* enqueue */
-    Bool	on;			/* used by DDX to keep state */
-} DeviceRec, *DevicePtr;
-
-typedef struct {
-    int			click, bell, bell_pitch, bell_duration;
-    Bool		autoRepeat;
-    unsigned char	autoRepeats[32];
-    Leds		leds;
-    unsigned char	id;
-} KeybdCtrl;
-
-typedef struct {
-    KeySym  *map;
-    KeyCode minKeyCode,
-	    maxKeyCode;
-    int     mapWidth;
-} KeySymsRec, *KeySymsPtr;
-
-typedef struct {
-    int		num, den, threshold;
-    unsigned char id;
-} PtrCtrl;
-
-typedef struct {
-    int         resolution, min_value, max_value;
-    int         integer_displayed;
-    unsigned char id;
-} IntegerCtrl;
-
-typedef struct {
-    int         max_symbols, num_symbols_supported;
-    int         num_symbols_displayed;
-    KeySym      *symbols_supported;
-    KeySym      *symbols_displayed;
-    unsigned char id;
-} StringCtrl;
-
-typedef struct {
-    int         percent, pitch, duration;
-    unsigned char id;
-} BellCtrl;
-
-typedef struct {
-    Leds        led_values;
-    Mask        led_mask;
-    unsigned char id;
-} LedCtrl;
-
-extern _X_EXPORT KeybdCtrl	defaultKeyboardControl;
-extern _X_EXPORT PtrCtrl	defaultPointerControl;
-
-typedef struct _InputOption {
-    char                *key;
-    char                *value;
-    struct _InputOption *next;
-} InputOption;
-
-typedef struct _InputAttributes {
-    char                *product;
-    char                *vendor;
-    char                *device;
-    char                **tags; /* null-terminated */
-    uint32_t            flags;
-} InputAttributes;
-
-#define ATTR_KEYBOARD (1<<0)
-#define ATTR_POINTER (1<<1)
-#define ATTR_JOYSTICK (1<<2)
-#define ATTR_TABLET (1<<3)
-#define ATTR_TOUCHPAD (1<<4)
-#define ATTR_TOUCHSCREEN (1<<5)
-
-/* Key has been run through all input processing and events sent to clients. */
-#define KEY_PROCESSED 1
-/* Key has not been fully processed, no events have been sent. */
-#define KEY_POSTED 2
-
-extern void set_key_down(DeviceIntPtr pDev, int key_code, int type);
-extern void set_key_up(DeviceIntPtr pDev, int key_code, int type);
-extern int key_is_down(DeviceIntPtr pDev, int key_code, int type);
-
-extern void InitCoreDevices(void);
-extern void InitXTestDevices(void);
-
-extern _X_EXPORT DeviceIntPtr AddInputDevice(
-    ClientPtr /*client*/,
-    DeviceProc /*deviceProc*/,
-    Bool /*autoStart*/);
-
-extern _X_EXPORT Bool EnableDevice(
-    DeviceIntPtr /*device*/,
-    BOOL /* sendevent */);
-
-extern _X_EXPORT Bool ActivateDevice(
-    DeviceIntPtr /*device*/,
-    BOOL /* sendevent */);
-
-extern _X_EXPORT Bool DisableDevice(
-    DeviceIntPtr /*device*/,
-    BOOL /* sendevent */);
-
-extern int InitAndStartDevices(void);
-
-extern void CloseDownDevices(void);
-
-extern void UndisplayDevices(void);
-
-extern _X_EXPORT int RemoveDevice(
-    DeviceIntPtr /*dev*/,
-    BOOL /* sendevent */);
-
-extern _X_EXPORT int NumMotionEvents(void);
-
-extern void RegisterPointerDevice(
-    DeviceIntPtr /*device*/);
-
-extern void RegisterKeyboardDevice(
-    DeviceIntPtr /*device*/);
-
-extern _X_EXPORT int dixLookupDevice(
-    DeviceIntPtr *         /* dev */,
-    int                    /* id */,
-    ClientPtr              /* client */,
-    Mask                   /* access_mode */);
-
-extern _X_EXPORT void QueryMinMaxKeyCodes(
-    KeyCode* /*minCode*/,
-    KeyCode* /*maxCode*/);
-
-extern _X_EXPORT Bool SetKeySymsMap(
-    KeySymsPtr /*dst*/,
-    KeySymsPtr /*src*/);
-
-extern _X_EXPORT Bool InitButtonClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    int /*numButtons*/,
-    Atom* /* labels */,
-    CARD8* /*map*/);
-
-extern _X_EXPORT Bool InitValuatorClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    int /*numAxes*/,
-    Atom* /* labels */,
-    int /*numMotionEvents*/,
-    int /*mode*/);
-
-extern _X_EXPORT Bool InitPointerAccelerationScheme(
-    DeviceIntPtr /*dev*/,
-    int /*scheme*/);
-
-extern _X_EXPORT Bool InitAbsoluteClassDeviceStruct(
-    DeviceIntPtr /*device*/);
-
-extern _X_EXPORT Bool InitFocusClassDeviceStruct(
-    DeviceIntPtr /*device*/);
-
-typedef void (*BellProcPtr)(
-    int /*percent*/,
-    DeviceIntPtr /*device*/,
-    pointer /*ctrl*/,
-    int);
-
-typedef void (*KbdCtrlProcPtr)(
-    DeviceIntPtr /*device*/,
-    KeybdCtrl * /*ctrl*/);
-
-typedef void (*PtrCtrlProcPtr)(
-    DeviceIntPtr /*device*/,
-    PtrCtrl * /*ctrl*/);
-
-extern _X_EXPORT Bool InitPtrFeedbackClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    PtrCtrlProcPtr /*controlProc*/);
-
-typedef void (*StringCtrlProcPtr)(
-    DeviceIntPtr /*device*/,
-    StringCtrl * /*ctrl*/);
-
-extern _X_EXPORT Bool InitStringFeedbackClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    StringCtrlProcPtr /*controlProc*/,
-    int /*max_symbols*/,
-    int /*num_symbols_supported*/,
-    KeySym* /*symbols*/);
-
-typedef void (*BellCtrlProcPtr)(
-    DeviceIntPtr /*device*/,
-    BellCtrl * /*ctrl*/);
-
-extern _X_EXPORT Bool InitBellFeedbackClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    BellProcPtr /*bellProc*/,
-    BellCtrlProcPtr /*controlProc*/);
-
-typedef void (*LedCtrlProcPtr)(
-    DeviceIntPtr /*device*/,
-    LedCtrl * /*ctrl*/);
-
-extern _X_EXPORT Bool InitLedFeedbackClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    LedCtrlProcPtr /*controlProc*/);
-
-typedef void (*IntegerCtrlProcPtr)(
-    DeviceIntPtr /*device*/,
-    IntegerCtrl * /*ctrl*/);
-
-
-extern _X_EXPORT Bool InitIntegerFeedbackClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    IntegerCtrlProcPtr /*controlProc*/);
-
-extern _X_EXPORT Bool InitPointerDeviceStruct(
-    DevicePtr /*device*/,
-    CARD8* /*map*/,
-    int /*numButtons*/,
-    Atom* /* btn_labels */,
-    PtrCtrlProcPtr /*controlProc*/,
-    int /*numMotionEvents*/,
-    int /*numAxes*/,
-    Atom* /* axes_labels */);
-
-extern _X_EXPORT Bool InitKeyboardDeviceStruct(
-    DeviceIntPtr /*device*/,
-    XkbRMLVOSet * /*rmlvo*/,
-    BellProcPtr /*bellProc*/,
-    KbdCtrlProcPtr /*controlProc*/);
-
-extern int ApplyPointerMapping(
-    DeviceIntPtr /* pDev */,
-    CARD8 *      /* map */,
-    int          /* len */,
-    ClientPtr	/* client */);
-
-extern Bool BadDeviceMap(
-    BYTE* /*buff*/,
-    int /*length*/,
-    unsigned /*low*/,
-    unsigned /*high*/,
-    XID* /*errval*/);
-
-extern void NoteLedState(
-    DeviceIntPtr /*keybd*/,
-    int /*led*/,
-    Bool /*on*/);
-
-extern void MaybeStopHint(
-    DeviceIntPtr /*device*/,
-    ClientPtr /*client*/);
-
-extern void ProcessPointerEvent(
-    InternalEvent* /* ev */,
-    DeviceIntPtr /*mouse*/);
-
-extern void ProcessKeyboardEvent(
-    InternalEvent* /*ev*/,
-    DeviceIntPtr   /*keybd*/);
-
-extern Bool LegalModifier(
-    unsigned int /*key*/, 
-    DeviceIntPtr /*pDev*/);
-
-extern _X_EXPORT void ProcessInputEvents(void);
-
-extern _X_EXPORT void InitInput(
-    int  /*argc*/,
-    char ** /*argv*/);
-extern _X_EXPORT void CloseInput(void);
-
-extern _X_EXPORT int GetMaximumEventsNum(void);
-
-extern _X_EXPORT int GetEventList(EventListPtr* list);
-extern _X_EXPORT EventListPtr InitEventList(int num_events);
-extern _X_EXPORT void FreeEventList(EventListPtr list, int num_events);
-
-extern void CreateClassesChangedEvent(EventListPtr event,
-                                      DeviceIntPtr master,
-                                      DeviceIntPtr slave,
-                                      int type);
-extern _X_EXPORT int GetPointerEvents(
-    EventListPtr events,
-    DeviceIntPtr pDev,
-    int type,
-    int buttons,
-    int flags,
-    int first_valuator,
-    int num_valuators,
-    int *valuators);
-
-extern _X_EXPORT int GetKeyboardEvents(
-    EventListPtr events,
-    DeviceIntPtr pDev,
-    int type,
-    int key_code);
-
-extern int GetKeyboardValuatorEvents(
-    EventListPtr events,
-    DeviceIntPtr pDev,
-    int type,
-    int key_code,
-    int first_valuator,
-    int num_valuator,
-    int *valuators);
-
-extern int GetProximityEvents(
-    EventListPtr events,
-    DeviceIntPtr pDev,
-    int type,
-    int first_valuator,
-    int num_valuators,
-    int *valuators);
-
-extern void PostSyntheticMotion(
-    DeviceIntPtr pDev,
-    int x,
-    int y,
-    int screen,
-    unsigned long time);
-
-extern _X_EXPORT int GetMotionHistorySize(
-    void);
-
-extern _X_EXPORT void AllocateMotionHistory(
-    DeviceIntPtr pDev);
-
-extern _X_EXPORT int GetMotionHistory(
-    DeviceIntPtr pDev,
-    xTimecoord **buff,
-    unsigned long start,
-    unsigned long stop,
-    ScreenPtr pScreen,
-    BOOL core);
-
-extern int AttachDevice(ClientPtr client,
-                        DeviceIntPtr slave,
-                        DeviceIntPtr master);
-
-extern _X_EXPORT DeviceIntPtr GetPairedDevice(DeviceIntPtr kbd);
-extern DeviceIntPtr GetMaster(DeviceIntPtr dev, int type);
-
-extern _X_EXPORT int AllocDevicePair(ClientPtr client,
-                             char* name,
-                             DeviceIntPtr* ptr,
-                             DeviceIntPtr* keybd,
-                             DeviceProc ptr_proc,
-                             DeviceProc keybd_proc,
-                             Bool master);
-extern void DeepCopyDeviceClasses(DeviceIntPtr from,
-                                  DeviceIntPtr to,
-                                  DeviceChangedEvent *dce);
-
-/* Helper functions. */
-extern _X_EXPORT int generate_modkeymap(ClientPtr client, DeviceIntPtr dev,
-                              KeyCode **modkeymap, int *max_keys_per_mod);
-extern int change_modmap(ClientPtr client, DeviceIntPtr dev, KeyCode *map,
-                         int max_keys_per_mod);
-extern int AllocXTestDevice(ClientPtr client,
-                             char* name,
-                             DeviceIntPtr* ptr,
-                             DeviceIntPtr* keybd,
-                             DeviceIntPtr master_ptr,
-                             DeviceIntPtr master_keybd);
-extern BOOL IsXTestDevice(DeviceIntPtr dev, DeviceIntPtr master);
-extern DeviceIntPtr GetXTestDevice(DeviceIntPtr master);
-extern void SendDevicePresenceEvent(int deviceid, int type);
-
-/* misc event helpers */
-extern Mask GetEventFilter(DeviceIntPtr dev, xEvent *event);
-extern Mask GetWindowXI2Mask(DeviceIntPtr dev, WindowPtr win, xEvent* ev);
-void FixUpEventFromWindow(DeviceIntPtr pDev,
-                          xEvent *xE,
-                          WindowPtr pWin,
-                          Window child,
-                          Bool calcChild);
-
-/* Implemented by the DDX. */
-extern _X_EXPORT int NewInputDeviceRequest(
-    InputOption *options,
-    InputAttributes *attrs,
-    DeviceIntPtr *dev);
-extern  _X_EXPORT void DeleteInputDeviceRequest(
-    DeviceIntPtr dev);
-
-extern _X_EXPORT void DDXRingBell(
-    int volume,
-    int pitch,
-    int duration);
-
-/* Set to TRUE by default - os/utils.c sets it to FALSE on user request,
-   xfixes/cursor.c uses it to determine if the cursor is enabled */
-extern Bool EnableCursor;
-
-#endif /* INPUT_H */
+/************************************************************
+
+Copyright 1987, 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 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        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 Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL 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.
+
+********************************************************/
+
+#ifndef INPUT_H
+#define INPUT_H
+
+#include "misc.h"
+#include "screenint.h"
+#include <X11/Xmd.h>
+#include <X11/Xproto.h>
+#include <stdint.h>
+#include "window.h"     /* for WindowPtr */
+#include "xkbrules.h"
+#include "events.h"
+
+#define DEVICE_INIT	0
+#define DEVICE_ON	1
+#define DEVICE_OFF	2
+#define DEVICE_CLOSE	3
+
+/* DeleteInputDeviceRequest flags */
+#define DEVICE_REMOVE_ALL    (1 << 0) /* all devices will be removed */
+
+#define POINTER_RELATIVE (1 << 1)
+#define POINTER_ABSOLUTE (1 << 2)
+#define POINTER_ACCELERATE (1 << 3)
+#define POINTER_SCREEN (1 << 4) /* Data in screen coordinates */
+
+/*int constants for pointer acceleration schemes*/
+#define PtrAccelNoOp            0
+#define PtrAccelPredictable     1
+#define PtrAccelLightweight     2
+#define PtrAccelDefault         PtrAccelPredictable
+
+#define MAX_VALUATORS 36
+/* Maximum number of valuators, divided by six, rounded up, to get number
+ * of events. */
+#define MAX_VALUATOR_EVENTS 6
+#define MAX_BUTTONS 256 /* completely arbitrarily chosen */
+
+#define NO_AXIS_LIMITS -1
+
+#define MAP_LENGTH	256
+#define DOWN_LENGTH	32	/* 256/8 => number of bytes to hold 256 bits */
+#define NullGrab ((GrabPtr)NULL)
+#define PointerRootWin ((WindowPtr)PointerRoot)
+#define NoneWin ((WindowPtr)None)
+#define NullDevice ((DevicePtr)NULL)
+
+#ifndef FollowKeyboard
+#define FollowKeyboard 		3
+#endif
+#ifndef FollowKeyboardWin
+#define FollowKeyboardWin  ((WindowPtr) FollowKeyboard)
+#endif
+#ifndef RevertToFollowKeyboard
+#define RevertToFollowKeyboard	3
+#endif
+
+typedef unsigned long Leds;
+typedef struct _OtherClients *OtherClientsPtr;
+typedef struct _InputClients *InputClientsPtr;
+typedef struct _DeviceIntRec *DeviceIntPtr;
+typedef struct _ClassesRec *ClassesPtr;
+typedef union _GrabMask GrabMask;
+
+typedef struct _EventList {
+    xEvent* event;
+    int evlen; /* length of allocated memory for event in bytes.  This is not
+                  the actual length of the event. The event's actual length is
+                  32 for standard events or 32 +
+                  ((xGenericEvent*)event)->length * 4 for GenericEvents.
+                  For events in the EQ, the length is
+                  ((InternalEvent*)event)->u.any.length */
+} EventList, *EventListPtr;
+
+/* The DIX stores incoming input events in this list */
+extern EventListPtr InputEventList;
+extern int InputEventListLen;
+
+typedef int (*DeviceProc)(
+    DeviceIntPtr /*device*/,
+    int /*what*/);
+
+typedef void (*ProcessInputProc)(
+    InternalEvent * /*event*/,
+    DeviceIntPtr /*device*/);
+
+typedef Bool (*DeviceHandleProc)(
+    DeviceIntPtr /*device*/,
+    void* /*data*/
+    );
+
+typedef void (*DeviceUnwrapProc)(
+    DeviceIntPtr /*device*/,
+    DeviceHandleProc /*proc*/,
+    void* /*data*/
+    );
+
+/* pointer acceleration handling */
+typedef void (*PointerAccelSchemeProc)(
+    DeviceIntPtr /*pDev*/,
+    int /*first_valuator*/,
+    int /*num_valuators*/,
+    int* /*valuators*/,
+    int /*evtime*/);
+
+typedef void (*DeviceCallbackProc)(
+              DeviceIntPtr /*pDev*/);
+
+typedef struct _DeviceRec {
+    pointer	devicePrivate;
+    ProcessInputProc processInputProc;	/* current */
+    ProcessInputProc realInputProc;	/* deliver */
+    ProcessInputProc enqueueInputProc;	/* enqueue */
+    Bool	on;			/* used by DDX to keep state */
+} DeviceRec, *DevicePtr;
+
+typedef struct {
+    int			click, bell, bell_pitch, bell_duration;
+    Bool		autoRepeat;
+    unsigned char	autoRepeats[32];
+    Leds		leds;
+    unsigned char	id;
+} KeybdCtrl;
+
+typedef struct {
+    KeySym  *map;
+    KeyCode minKeyCode,
+	    maxKeyCode;
+    int     mapWidth;
+} KeySymsRec, *KeySymsPtr;
+
+typedef struct {
+    int		num, den, threshold;
+    unsigned char id;
+} PtrCtrl;
+
+typedef struct {
+    int         resolution, min_value, max_value;
+    int         integer_displayed;
+    unsigned char id;
+} IntegerCtrl;
+
+typedef struct {
+    int         max_symbols, num_symbols_supported;
+    int         num_symbols_displayed;
+    KeySym      *symbols_supported;
+    KeySym      *symbols_displayed;
+    unsigned char id;
+} StringCtrl;
+
+typedef struct {
+    int         percent, pitch, duration;
+    unsigned char id;
+} BellCtrl;
+
+typedef struct {
+    Leds        led_values;
+    Mask        led_mask;
+    unsigned char id;
+} LedCtrl;
+
+extern _X_EXPORT KeybdCtrl	defaultKeyboardControl;
+extern _X_EXPORT PtrCtrl	defaultPointerControl;
+
+typedef struct _InputOption {
+    char                *key;
+    char                *value;
+    struct _InputOption *next;
+} InputOption;
+
+typedef struct _InputAttributes {
+    char                *product;
+    char                *vendor;
+    char                *device;
+    char                **tags; /* null-terminated */
+    uint32_t            flags;
+} InputAttributes;
+
+#define ATTR_KEYBOARD (1<<0)
+#define ATTR_POINTER (1<<1)
+#define ATTR_JOYSTICK (1<<2)
+#define ATTR_TABLET (1<<3)
+#define ATTR_TOUCHPAD (1<<4)
+#define ATTR_TOUCHSCREEN (1<<5)
+
+/* Key has been run through all input processing and events sent to clients. */
+#define KEY_PROCESSED 1
+/* Key has not been fully processed, no events have been sent. */
+#define KEY_POSTED 2
+
+extern void set_key_down(DeviceIntPtr pDev, int key_code, int type);
+extern void set_key_up(DeviceIntPtr pDev, int key_code, int type);
+extern int key_is_down(DeviceIntPtr pDev, int key_code, int type);
+
+extern void InitCoreDevices(void);
+extern void InitXTestDevices(void);
+
+extern _X_EXPORT DeviceIntPtr AddInputDevice(
+    ClientPtr /*client*/,
+    DeviceProc /*deviceProc*/,
+    Bool /*autoStart*/);
+
+extern _X_EXPORT Bool EnableDevice(
+    DeviceIntPtr /*device*/,
+    BOOL /* sendevent */);
+
+extern _X_EXPORT Bool ActivateDevice(
+    DeviceIntPtr /*device*/,
+    BOOL /* sendevent */);
+
+extern _X_EXPORT Bool DisableDevice(
+    DeviceIntPtr /*device*/,
+    BOOL /* sendevent */);
+
+extern int InitAndStartDevices(void);
+
+extern void CloseDownDevices(void);
+
+extern void UndisplayDevices(void);
+
+extern _X_EXPORT int RemoveDevice(
+    DeviceIntPtr /*dev*/,
+    BOOL /* sendevent */);
+
+extern _X_EXPORT int NumMotionEvents(void);
+
+extern void RegisterPointerDevice(
+    DeviceIntPtr /*device*/);
+
+extern void RegisterKeyboardDevice(
+    DeviceIntPtr /*device*/);
+
+extern _X_EXPORT int dixLookupDevice(
+    DeviceIntPtr *         /* dev */,
+    int                    /* id */,
+    ClientPtr              /* client */,
+    Mask                   /* access_mode */);
+
+extern _X_EXPORT void QueryMinMaxKeyCodes(
+    KeyCode* /*minCode*/,
+    KeyCode* /*maxCode*/);
+
+extern _X_EXPORT Bool SetKeySymsMap(
+    KeySymsPtr /*dst*/,
+    KeySymsPtr /*src*/);
+
+extern _X_EXPORT Bool InitButtonClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    int /*numButtons*/,
+    Atom* /* labels */,
+    CARD8* /*map*/);
+
+extern _X_EXPORT Bool InitValuatorClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    int /*numAxes*/,
+    Atom* /* labels */,
+    int /*numMotionEvents*/,
+    int /*mode*/);
+
+extern _X_EXPORT Bool InitPointerAccelerationScheme(
+    DeviceIntPtr /*dev*/,
+    int /*scheme*/);
+
+extern _X_EXPORT Bool InitAbsoluteClassDeviceStruct(
+    DeviceIntPtr /*device*/);
+
+extern _X_EXPORT Bool InitFocusClassDeviceStruct(
+    DeviceIntPtr /*device*/);
+
+typedef void (*BellProcPtr)(
+    int /*percent*/,
+    DeviceIntPtr /*device*/,
+    pointer /*ctrl*/,
+    int);
+
+typedef void (*KbdCtrlProcPtr)(
+    DeviceIntPtr /*device*/,
+    KeybdCtrl * /*ctrl*/);
+
+typedef void (*PtrCtrlProcPtr)(
+    DeviceIntPtr /*device*/,
+    PtrCtrl * /*ctrl*/);
+
+extern _X_EXPORT Bool InitPtrFeedbackClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    PtrCtrlProcPtr /*controlProc*/);
+
+typedef void (*StringCtrlProcPtr)(
+    DeviceIntPtr /*device*/,
+    StringCtrl * /*ctrl*/);
+
+extern _X_EXPORT Bool InitStringFeedbackClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    StringCtrlProcPtr /*controlProc*/,
+    int /*max_symbols*/,
+    int /*num_symbols_supported*/,
+    KeySym* /*symbols*/);
+
+typedef void (*BellCtrlProcPtr)(
+    DeviceIntPtr /*device*/,
+    BellCtrl * /*ctrl*/);
+
+extern _X_EXPORT Bool InitBellFeedbackClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    BellProcPtr /*bellProc*/,
+    BellCtrlProcPtr /*controlProc*/);
+
+typedef void (*LedCtrlProcPtr)(
+    DeviceIntPtr /*device*/,
+    LedCtrl * /*ctrl*/);
+
+extern _X_EXPORT Bool InitLedFeedbackClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    LedCtrlProcPtr /*controlProc*/);
+
+typedef void (*IntegerCtrlProcPtr)(
+    DeviceIntPtr /*device*/,
+    IntegerCtrl * /*ctrl*/);
+
+
+extern _X_EXPORT Bool InitIntegerFeedbackClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    IntegerCtrlProcPtr /*controlProc*/);
+
+extern _X_EXPORT Bool InitPointerDeviceStruct(
+    DevicePtr /*device*/,
+    CARD8* /*map*/,
+    int /*numButtons*/,
+    Atom* /* btn_labels */,
+    PtrCtrlProcPtr /*controlProc*/,
+    int /*numMotionEvents*/,
+    int /*numAxes*/,
+    Atom* /* axes_labels */);
+
+extern _X_EXPORT Bool InitKeyboardDeviceStruct(
+    DeviceIntPtr /*device*/,
+    XkbRMLVOSet * /*rmlvo*/,
+    BellProcPtr /*bellProc*/,
+    KbdCtrlProcPtr /*controlProc*/);
+
+extern int ApplyPointerMapping(
+    DeviceIntPtr /* pDev */,
+    CARD8 *      /* map */,
+    int          /* len */,
+    ClientPtr	/* client */);
+
+extern Bool BadDeviceMap(
+    BYTE* /*buff*/,
+    int /*length*/,
+    unsigned /*low*/,
+    unsigned /*high*/,
+    XID* /*errval*/);
+
+extern void NoteLedState(
+    DeviceIntPtr /*keybd*/,
+    int /*led*/,
+    Bool /*on*/);
+
+extern void MaybeStopHint(
+    DeviceIntPtr /*device*/,
+    ClientPtr /*client*/);
+
+extern void ProcessPointerEvent(
+    InternalEvent* /* ev */,
+    DeviceIntPtr /*mouse*/);
+
+extern void ProcessKeyboardEvent(
+    InternalEvent* /*ev*/,
+    DeviceIntPtr   /*keybd*/);
+
+extern Bool LegalModifier(
+    unsigned int /*key*/, 
+    DeviceIntPtr /*pDev*/);
+
+extern _X_EXPORT void ProcessInputEvents(void);
+
+extern _X_EXPORT void InitInput(
+    int  /*argc*/,
+    char ** /*argv*/);
+extern _X_EXPORT void CloseInput(void);
+
+extern _X_EXPORT int GetMaximumEventsNum(void);
+
+extern _X_EXPORT int GetEventList(EventListPtr* list);
+extern _X_EXPORT EventListPtr InitEventList(int num_events);
+extern _X_EXPORT void FreeEventList(EventListPtr list, int num_events);
+
+extern void CreateClassesChangedEvent(EventListPtr event,
+                                      DeviceIntPtr master,
+                                      DeviceIntPtr slave,
+                                      int type);
+extern _X_EXPORT int GetPointerEvents(
+    EventListPtr events,
+    DeviceIntPtr pDev,
+    int type,
+    int buttons,
+    int flags,
+    int first_valuator,
+    int num_valuators,
+    int *valuators);
+
+extern _X_EXPORT int GetKeyboardEvents(
+    EventListPtr events,
+    DeviceIntPtr pDev,
+    int type,
+    int key_code);
+
+extern int GetKeyboardValuatorEvents(
+    EventListPtr events,
+    DeviceIntPtr pDev,
+    int type,
+    int key_code,
+    int first_valuator,
+    int num_valuator,
+    int *valuators);
+
+extern int GetProximityEvents(
+    EventListPtr events,
+    DeviceIntPtr pDev,
+    int type,
+    int first_valuator,
+    int num_valuators,
+    int *valuators);
+
+extern void PostSyntheticMotion(
+    DeviceIntPtr pDev,
+    int x,
+    int y,
+    int screen,
+    unsigned long time);
+
+extern _X_EXPORT int GetMotionHistorySize(
+    void);
+
+extern _X_EXPORT void AllocateMotionHistory(
+    DeviceIntPtr pDev);
+
+extern _X_EXPORT int GetMotionHistory(
+    DeviceIntPtr pDev,
+    xTimecoord **buff,
+    unsigned long start,
+    unsigned long stop,
+    ScreenPtr pScreen,
+    BOOL core);
+
+extern int AttachDevice(ClientPtr client,
+                        DeviceIntPtr slave,
+                        DeviceIntPtr master);
+
+extern _X_EXPORT DeviceIntPtr GetPairedDevice(DeviceIntPtr kbd);
+extern DeviceIntPtr GetMaster(DeviceIntPtr dev, int type);
+
+extern _X_EXPORT int AllocDevicePair(ClientPtr client,
+                             char* name,
+                             DeviceIntPtr* ptr,
+                             DeviceIntPtr* keybd,
+                             DeviceProc ptr_proc,
+                             DeviceProc keybd_proc,
+                             Bool master);
+extern void DeepCopyDeviceClasses(DeviceIntPtr from,
+                                  DeviceIntPtr to,
+                                  DeviceChangedEvent *dce);
+
+/* Helper functions. */
+extern _X_EXPORT int generate_modkeymap(ClientPtr client, DeviceIntPtr dev,
+                              KeyCode **modkeymap, int *max_keys_per_mod);
+extern int change_modmap(ClientPtr client, DeviceIntPtr dev, KeyCode *map,
+                         int max_keys_per_mod);
+extern int AllocXTestDevice(ClientPtr client,
+                             char* name,
+                             DeviceIntPtr* ptr,
+                             DeviceIntPtr* keybd,
+                             DeviceIntPtr master_ptr,
+                             DeviceIntPtr master_keybd);
+extern BOOL IsXTestDevice(DeviceIntPtr dev, DeviceIntPtr master);
+extern DeviceIntPtr GetXTestDevice(DeviceIntPtr master);
+extern void SendDevicePresenceEvent(int deviceid, int type);
+extern _X_EXPORT InputAttributes *DuplicateInputAttributes(InputAttributes *attrs);
+extern _X_EXPORT void FreeInputAttributes(InputAttributes *attrs);
+
+/* misc event helpers */
+extern Mask GetEventFilter(DeviceIntPtr dev, xEvent *event);
+extern Mask GetWindowXI2Mask(DeviceIntPtr dev, WindowPtr win, xEvent* ev);
+void FixUpEventFromWindow(DeviceIntPtr pDev,
+                          xEvent *xE,
+                          WindowPtr pWin,
+                          Window child,
+                          Bool calcChild);
+
+/* Implemented by the DDX. */
+extern _X_EXPORT int NewInputDeviceRequest(
+    InputOption *options,
+    InputAttributes *attrs,
+    DeviceIntPtr *dev);
+extern  _X_EXPORT void DeleteInputDeviceRequest(
+    DeviceIntPtr dev,
+    int flags);
+
+extern _X_EXPORT void DDXRingBell(
+    int volume,
+    int pitch,
+    int duration);
+
+/* Set to TRUE by default - os/utils.c sets it to FALSE on user request,
+   xfixes/cursor.c uses it to determine if the cursor is enabled */
+extern Bool EnableCursor;
+
+#endif /* INPUT_H */
diff --git a/xorg-server/mi/midispcur.c b/xorg-server/mi/midispcur.c
index 8b26765a8..d56080488 100644
--- a/xorg-server/mi/midispcur.c
+++ b/xorg-server/mi/midispcur.c
@@ -141,6 +141,7 @@ miDCRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
 }
 
 #ifdef ARGB_CURSOR
+#define EnsurePicture(picture,draw,win) (picture || miDCMakePicture(&picture,draw,win))
 
 static VisualPtr
 miDCGetWindowVisual (WindowPtr pWin)
@@ -413,6 +414,8 @@ miDCPutUpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor,
 #ifdef ARGB_CURSOR
     if (pPriv->pPicture)
     {
+	if (!EnsurePicture(pBuffer->pRootPicture, &pWin->drawable, pWin))
+	    return FALSE;
 	CompositePicture (PictOpOver,
 			  pPriv->pPicture,
 			  NULL,
@@ -695,9 +698,8 @@ miDCMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor,
 #ifdef ARGB_CURSOR
     if (pPriv->pPicture)
     {
-	if (!pBuffer->pTempPicture)
-            miDCMakePicture(&pBuffer->pTempPicture, &pTemp->drawable, pWin);
-
+	if (!EnsurePicture(pBuffer->pTempPicture, &pTemp->drawable, pWin))
+	    return FALSE;
 	CompositePicture (PictOpOver,
 			  pPriv->pPicture,
 			  NULL,
@@ -781,10 +783,7 @@ miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
             goto failure;
 
 #ifdef ARGB_CURSOR
-        miDCMakePicture(&pBuffer->pRootPicture, &pWin->drawable, pWin);
-        if (!pBuffer->pRootPicture)
-            goto failure;
-
+        pBuffer->pRootPicture = NULL;
         pBuffer->pTempPicture = NULL;
 #endif
 
diff --git a/xorg-server/test/input.c b/xorg-server/test/input.c
index 63d1a1801..1271ee683 100644
--- a/xorg-server/test/input.c
+++ b/xorg-server/test/input.c
@@ -1,788 +1,890 @@
-/**
- * Copyright © 2009 Red Hat, Inc.
- *
- *  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.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <stdint.h>
-#include <X11/X.h>
-#include "misc.h"
-#include "resource.h"
-#include <X11/Xproto.h>
-#include <X11/extensions/XI2proto.h>
-#include <X11/Xatom.h>
-#include "windowstr.h"
-#include "inputstr.h"
-#include "eventconvert.h"
-#include "exevents.h"
-#include "dixgrabs.h"
-#include "eventstr.h"
-#include <glib.h>
-
-/**
- * Init a device with axes.
- * Verify values set on the device.
- *
- * Result: All axes set to default values (usually 0).
- */
-static void dix_init_valuators(void)
-{
-    DeviceIntRec dev;
-    ValuatorClassPtr val;
-    const int num_axes = 2;
-    int i;
-    Atom atoms[MAX_VALUATORS] = { 0 };
-
-
-    memset(&dev, 0, sizeof(DeviceIntRec));
-    dev.type = MASTER_POINTER; /* claim it's a master to stop ptracccel */
-
-    g_assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE);
-    g_assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute));
-
-    val = dev.valuator;
-    g_assert(val);
-    g_assert(val->numAxes == num_axes);
-    g_assert(val->numMotionEvents == 0);
-    g_assert(val->mode == Absolute);
-    g_assert(val->axisVal);
-
-    for (i = 0; i < num_axes; i++)
-    {
-        g_assert(val->axisVal[i] == 0);
-        g_assert(val->axes->min_value == NO_AXIS_LIMITS);
-        g_assert(val->axes->max_value == NO_AXIS_LIMITS);
-    }
-
-    g_assert(dev.last.numValuators == num_axes);
-}
-
-/* just check the known success cases, and that error cases set the client's
- * error value correctly. */
-static void dix_check_grab_values(void)
-{
-    ClientRec client;
-    GrabParameters param;
-    int rc;
-
-    memset(&client, 0, sizeof(client));
-
-    param.grabtype = GRABTYPE_CORE;
-    param.this_device_mode = GrabModeSync;
-    param.other_devices_mode = GrabModeSync;
-    param.modifiers = AnyModifier;
-    param.ownerEvents = FALSE;
-
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == Success);
-
-    param.this_device_mode = GrabModeAsync;
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == Success);
-
-    param.this_device_mode = GrabModeAsync + 1;
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == BadValue);
-    g_assert(client.errorValue == param.this_device_mode);
-    g_assert(client.errorValue == GrabModeAsync + 1);
-
-    param.this_device_mode = GrabModeSync;
-    param.other_devices_mode = GrabModeAsync;
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == Success);
-
-    param.other_devices_mode = GrabModeAsync + 1;
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == BadValue);
-    g_assert(client.errorValue == param.other_devices_mode);
-    g_assert(client.errorValue == GrabModeAsync + 1);
-
-    param.other_devices_mode = GrabModeSync;
-
-    param.modifiers = 1 << 13;
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == BadValue);
-    g_assert(client.errorValue == param.modifiers);
-    g_assert(client.errorValue == (1 << 13));
-
-
-    param.modifiers = AnyModifier;
-    param.ownerEvents = TRUE;
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == Success);
-
-    param.ownerEvents = 3;
-    rc = CheckGrabValues(&client, &param);
-    g_assert(rc == BadValue);
-    g_assert(client.errorValue == param.ownerEvents);
-    g_assert(client.errorValue == 3);
-}
-
-
-/**
- * Convert various internal events to the matching core event and verify the
- * parameters.
- */
-static void dix_event_to_core(int type)
-{
-    DeviceEvent ev;
-    xEvent core;
-    int time;
-    int x, y;
-    int rc;
-    int state;
-    int detail;
-    const int ROOT_WINDOW_ID = 0x100;
-
-    /* EventToCore memsets the event to 0 */
-#define test_event() \
-    g_assert(rc == Success); \
-    g_assert(core.u.u.type == type); \
-    g_assert(core.u.u.detail == detail); \
-    g_assert(core.u.keyButtonPointer.time == time); \
-    g_assert(core.u.keyButtonPointer.rootX == x); \
-    g_assert(core.u.keyButtonPointer.rootY == y); \
-    g_assert(core.u.keyButtonPointer.state == state); \
-    g_assert(core.u.keyButtonPointer.eventX == 0); \
-    g_assert(core.u.keyButtonPointer.eventY == 0); \
-    g_assert(core.u.keyButtonPointer.root == ROOT_WINDOW_ID); \
-    g_assert(core.u.keyButtonPointer.event == 0); \
-    g_assert(core.u.keyButtonPointer.child == 0); \
-    g_assert(core.u.keyButtonPointer.sameScreen == FALSE);
-
-    x = 0;
-    y = 0;
-    time = 12345;
-    state = 0;
-    detail = 0;
-
-    ev.header   = 0xFF;
-    ev.length   = sizeof(DeviceEvent);
-    ev.time     = time;
-    ev.root_y   = x;
-    ev.root_x   = y;
-    ev.root     = ROOT_WINDOW_ID;
-    ev.corestate = state;
-    ev.detail.key = detail;
-
-    ev.type = type;
-    ev.detail.key = 0;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    test_event();
-
-    x = 1;
-    y = 2;
-    ev.root_x = x;
-    ev.root_y = y;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    test_event();
-
-    x = 0x7FFF;
-    y = 0x7FFF;
-    ev.root_x = x;
-    ev.root_y = y;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    test_event();
-
-    x = 0x8000; /* too high */
-    y = 0x8000; /* too high */
-    ev.root_x = x;
-    ev.root_y = y;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(core.u.keyButtonPointer.rootX != x);
-    g_assert(core.u.keyButtonPointer.rootY != y);
-
-    x = 0x7FFF;
-    y = 0x7FFF;
-    ev.root_x = x;
-    ev.root_y = y;
-    time = 0;
-    ev.time = time;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    test_event();
-
-    detail = 1;
-    ev.detail.key = detail;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    test_event();
-
-    detail = 0xFF; /* highest value */
-    ev.detail.key = detail;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    test_event();
-
-    detail = 0xFFF; /* too big */
-    ev.detail.key = detail;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(rc == BadMatch);
-
-    detail = 0xFF; /* too big */
-    ev.detail.key = detail;
-    state = 0xFFFF; /* highest value */
-    ev.corestate = state;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    test_event();
-
-    state = 0x10000; /* too big */
-    ev.corestate = state;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(core.u.keyButtonPointer.state != state);
-    g_assert(core.u.keyButtonPointer.state == (state & 0xFFFF));
-
-#undef test_event
-}
-
-static void dix_event_to_core_conversion(void)
-{
-    DeviceEvent ev;
-    xEvent core;
-    int rc;
-
-    ev.header   = 0xFF;
-    ev.length   = sizeof(DeviceEvent);
-
-    ev.type     = 0;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(rc == BadImplementation);
-
-    ev.type     = 1;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(rc == BadImplementation);
-
-    ev.type     = ET_ProximityOut + 1;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(rc == BadImplementation);
-
-    ev.type     = ET_ProximityIn;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(rc == BadMatch);
-
-    ev.type     = ET_ProximityOut;
-    rc = EventToCore((InternalEvent*)&ev, &core);
-    g_assert(rc == BadMatch);
-
-    dix_event_to_core(ET_KeyPress);
-    dix_event_to_core(ET_KeyRelease);
-    dix_event_to_core(ET_ButtonPress);
-    dix_event_to_core(ET_ButtonRelease);
-    dix_event_to_core(ET_Motion);
-}
-
-static void xi2_struct_sizes(void)
-{
-#define compare(req) \
-    g_assert(sizeof(req) == sz_##req);
-
-    compare(xXIQueryVersionReq);
-    compare(xXIWarpPointerReq);
-    compare(xXIChangeCursorReq);
-    compare(xXIChangeHierarchyReq);
-    compare(xXISetClientPointerReq);
-    compare(xXIGetClientPointerReq);
-    compare(xXISelectEventsReq);
-    compare(xXIQueryVersionReq);
-    compare(xXIQueryDeviceReq);
-    compare(xXISetFocusReq);
-    compare(xXIGetFocusReq);
-    compare(xXIGrabDeviceReq);
-    compare(xXIUngrabDeviceReq);
-    compare(xXIAllowEventsReq);
-    compare(xXIPassiveGrabDeviceReq);
-    compare(xXIPassiveUngrabDeviceReq);
-    compare(xXIListPropertiesReq);
-    compare(xXIChangePropertyReq);
-    compare(xXIDeletePropertyReq);
-    compare(xXIGetPropertyReq);
-    compare(xXIGetSelectedEventsReq);
-#undef compare
-}
-
-
-static void dix_grab_matching(void)
-{
-    DeviceIntRec xi_all_devices, xi_all_master_devices, dev1, dev2;
-    GrabRec a, b;
-    BOOL rc;
-
-    memset(&a, 0, sizeof(a));
-    memset(&b, 0, sizeof(b));
-
-    /* different grabtypes must fail */
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_XI2;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI2;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_CORE;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    /* XI2 grabs for different devices must fail, regardless of ignoreDevice
-     * XI2 grabs for master devices must fail against a slave */
-    memset(&xi_all_devices, 0, sizeof(DeviceIntRec));
-    memset(&xi_all_master_devices, 0, sizeof(DeviceIntRec));
-    memset(&dev1, 0, sizeof(DeviceIntRec));
-    memset(&dev2, 0, sizeof(DeviceIntRec));
-
-    xi_all_devices.id = XIAllDevices;
-    xi_all_master_devices.id = XIAllMasterDevices;
-    dev1.id = 10;
-    dev1.type = SLAVE;
-    dev2.id = 11;
-    dev2.type = SLAVE;
-
-    inputInfo.all_devices = &xi_all_devices;
-    inputInfo.all_master_devices = &xi_all_master_devices;
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.device = &dev1;
-    b.device = &dev2;
-
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-
-    a.device = &dev2;
-    b.device = &dev1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&a, &b, TRUE);
-    g_assert(rc == FALSE);
-
-    a.device = inputInfo.all_master_devices;
-    b.device = &dev1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&a, &b, TRUE);
-    g_assert(rc == FALSE);
-
-    a.device = &dev1;
-    b.device = inputInfo.all_master_devices;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&a, &b, TRUE);
-    g_assert(rc == FALSE);
-
-    /* ignoreDevice FALSE must fail for different devices for CORE and XI */
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    a.device = &dev1;
-    b.device = &dev2;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    a.device = &dev1;
-    b.device = &dev2;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-
-    /* ignoreDevice FALSE must fail for different modifier devices for CORE
-     * and XI */
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    a.device = &dev1;
-    b.device = &dev1;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev2;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    a.device = &dev1;
-    b.device = &dev1;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev2;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-
-    /* different event type must fail */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.device = &dev1;
-    b.device = &dev1;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev1;
-    a.type = XI_KeyPress;
-    b.type = XI_KeyRelease;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&a, &b, TRUE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    a.device = &dev1;
-    b.device = &dev1;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev1;
-    a.type = XI_KeyPress;
-    b.type = XI_KeyRelease;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&a, &b, TRUE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    a.device = &dev1;
-    b.device = &dev1;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev1;
-    a.type = XI_KeyPress;
-    b.type = XI_KeyRelease;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&a, &b, TRUE);
-    g_assert(rc == FALSE);
-
-    /* different modifiers must fail */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.device = &dev1;
-    b.device = &dev1;
-    a.modifierDevice = &dev1;
-    b.modifierDevice = &dev1;
-    a.type = XI_KeyPress;
-    b.type = XI_KeyPress;
-    a.modifiersDetail.exact = 1;
-    b.modifiersDetail.exact = 2;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    /* AnyModifier must fail for XI2 */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.modifiersDetail.exact = AnyModifier;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    /* XIAnyModifier must fail for CORE and XI */
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    a.modifiersDetail.exact = XIAnyModifier;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    a.modifiersDetail.exact = XIAnyModifier;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    /* different detail must fail */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.detail.exact = 1;
-    b.detail.exact = 2;
-    a.modifiersDetail.exact = 1;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    /* detail of AnyModifier must fail */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.detail.exact = AnyModifier;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = 1;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    /* detail of XIAnyModifier must fail */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.detail.exact = XIAnyModifier;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = 1;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == FALSE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == FALSE);
-
-    /* XIAnyModifier or AnyModifer must succeed */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.detail.exact = 1;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = XIAnyModifier;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == TRUE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == TRUE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    a.detail.exact = 1;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = AnyModifier;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == TRUE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == TRUE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    a.detail.exact = 1;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = AnyModifier;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == TRUE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == TRUE);
-
-    /* AnyKey or XIAnyKeycode must succeed */
-    a.grabtype = GRABTYPE_XI2;
-    b.grabtype = GRABTYPE_XI2;
-    a.detail.exact = XIAnyKeycode;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = 1;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == TRUE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == TRUE);
-
-    a.grabtype = GRABTYPE_CORE;
-    b.grabtype = GRABTYPE_CORE;
-    a.detail.exact = AnyKey;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = 1;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == TRUE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == TRUE);
-
-    a.grabtype = GRABTYPE_XI;
-    b.grabtype = GRABTYPE_XI;
-    a.detail.exact = AnyKey;
-    b.detail.exact = 1;
-    a.modifiersDetail.exact = 1;
-    b.modifiersDetail.exact = 1;
-    rc = GrabMatchesSecond(&a, &b, FALSE);
-    g_assert(rc == TRUE);
-    rc = GrabMatchesSecond(&b, &a, FALSE);
-    g_assert(rc == TRUE);
-}
-
-static void include_byte_padding_macros(void)
-{
-    int i;
-    g_test_message("Testing bits_to_bytes()");
-
-    /* the macros don't provide overflow protection */
-    for (i = 0; i < INT_MAX - 7; i++)
-    {
-        int expected_bytes;
-        expected_bytes = (i + 7)/8;
-
-        g_assert(bits_to_bytes(i) >= i/8);
-        g_assert((bits_to_bytes(i) * 8) - i <= 7);
-    }
-
-    g_test_message("Testing bytes_to_int32()");
-    for (i = 0; i < INT_MAX - 3; i++)
-    {
-        int expected_4byte;
-        expected_4byte = (i + 3)/4;
-
-        g_assert(bytes_to_int32(i) <= i);
-        g_assert((bytes_to_int32(i) * 4) - i <= 3);
-    }
-
-    g_test_message("Testing pad_to_int32");
-
-    for (i = 0; i < INT_MAX - 3; i++)
-    {
-        int expected_bytes;
-        expected_bytes = ((i + 3)/4) * 4;
-
-        g_assert(pad_to_int32(i) >= i);
-        g_assert(pad_to_int32(i) - i <= 3);
-    }
-
-}
-
-static void xi_unregister_handlers(void)
-{
-    DeviceIntRec dev;
-    int handler;
-
-    memset(&dev, 0, sizeof(dev));
-
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 1);
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 2);
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 3);
-
-    g_test_message("Unlinking from front.");
-
-    XIUnregisterPropertyHandler(&dev, 4); /* NOOP */
-    g_assert(dev.properties.handlers->id == 3);
-    XIUnregisterPropertyHandler(&dev, 3);
-    g_assert(dev.properties.handlers->id == 2);
-    XIUnregisterPropertyHandler(&dev, 2);
-    g_assert(dev.properties.handlers->id == 1);
-    XIUnregisterPropertyHandler(&dev, 1);
-    g_assert(dev.properties.handlers == NULL);
-
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 4);
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 5);
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 6);
-    XIUnregisterPropertyHandler(&dev, 3); /* NOOP */
-    g_assert(dev.properties.handlers->next->next->next == NULL);
-    XIUnregisterPropertyHandler(&dev, 4);
-    g_assert(dev.properties.handlers->next->next == NULL);
-    XIUnregisterPropertyHandler(&dev, 5);
-    g_assert(dev.properties.handlers->next == NULL);
-    XIUnregisterPropertyHandler(&dev, 6);
-    g_assert(dev.properties.handlers == NULL);
-
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 7);
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 8);
-    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
-    g_assert(handler == 9);
-
-    XIDeleteAllDeviceProperties(&dev);
-    g_assert(dev.properties.handlers == NULL);
-    XIUnregisterPropertyHandler(&dev, 7); /* NOOP */
-
-}
-
-int main(int argc, char** argv)
-{
-    g_test_init(&argc, &argv,NULL);
-    g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
-
-    g_test_add_func("/dix/input/init-valuators", dix_init_valuators);
-    g_test_add_func("/dix/input/event-core-conversion", dix_event_to_core_conversion);
-    g_test_add_func("/dix/input/check-grab-values", dix_check_grab_values);
-    g_test_add_func("/dix/input/xi2-struct-sizes", xi2_struct_sizes);
-    g_test_add_func("/dix/input/grab_matching", dix_grab_matching);
-    g_test_add_func("/include/byte_padding_macros", include_byte_padding_macros);
-    g_test_add_func("/Xi/xiproperty/register-unregister", xi_unregister_handlers);
-
-    return g_test_run();
-}
+/**
+ * Copyright © 2009 Red Hat, Inc.
+ *
+ *  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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <stdint.h>
+#include <X11/X.h>
+#include "misc.h"
+#include "resource.h"
+#include <X11/Xproto.h>
+#include <X11/extensions/XI2proto.h>
+#include <X11/Xatom.h>
+#include "windowstr.h"
+#include "inputstr.h"
+#include "eventconvert.h"
+#include "exevents.h"
+#include "dixgrabs.h"
+#include "eventstr.h"
+#include <glib.h>
+
+/**
+ * Init a device with axes.
+ * Verify values set on the device.
+ *
+ * Result: All axes set to default values (usually 0).
+ */
+static void dix_init_valuators(void)
+{
+    DeviceIntRec dev;
+    ValuatorClassPtr val;
+    const int num_axes = 2;
+    int i;
+    Atom atoms[MAX_VALUATORS] = { 0 };
+
+
+    memset(&dev, 0, sizeof(DeviceIntRec));
+    dev.type = MASTER_POINTER; /* claim it's a master to stop ptracccel */
+
+    g_assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE);
+    g_assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute));
+
+    val = dev.valuator;
+    g_assert(val);
+    g_assert(val->numAxes == num_axes);
+    g_assert(val->numMotionEvents == 0);
+    g_assert(val->mode == Absolute);
+    g_assert(val->axisVal);
+
+    for (i = 0; i < num_axes; i++)
+    {
+        g_assert(val->axisVal[i] == 0);
+        g_assert(val->axes->min_value == NO_AXIS_LIMITS);
+        g_assert(val->axes->max_value == NO_AXIS_LIMITS);
+    }
+
+    g_assert(dev.last.numValuators == num_axes);
+}
+
+/* just check the known success cases, and that error cases set the client's
+ * error value correctly. */
+static void dix_check_grab_values(void)
+{
+    ClientRec client;
+    GrabParameters param;
+    int rc;
+
+    memset(&client, 0, sizeof(client));
+
+    param.grabtype = GRABTYPE_CORE;
+    param.this_device_mode = GrabModeSync;
+    param.other_devices_mode = GrabModeSync;
+    param.modifiers = AnyModifier;
+    param.ownerEvents = FALSE;
+
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == Success);
+
+    param.this_device_mode = GrabModeAsync;
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == Success);
+
+    param.this_device_mode = GrabModeAsync + 1;
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == BadValue);
+    g_assert(client.errorValue == param.this_device_mode);
+    g_assert(client.errorValue == GrabModeAsync + 1);
+
+    param.this_device_mode = GrabModeSync;
+    param.other_devices_mode = GrabModeAsync;
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == Success);
+
+    param.other_devices_mode = GrabModeAsync + 1;
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == BadValue);
+    g_assert(client.errorValue == param.other_devices_mode);
+    g_assert(client.errorValue == GrabModeAsync + 1);
+
+    param.other_devices_mode = GrabModeSync;
+
+    param.modifiers = 1 << 13;
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == BadValue);
+    g_assert(client.errorValue == param.modifiers);
+    g_assert(client.errorValue == (1 << 13));
+
+
+    param.modifiers = AnyModifier;
+    param.ownerEvents = TRUE;
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == Success);
+
+    param.ownerEvents = 3;
+    rc = CheckGrabValues(&client, &param);
+    g_assert(rc == BadValue);
+    g_assert(client.errorValue == param.ownerEvents);
+    g_assert(client.errorValue == 3);
+}
+
+
+/**
+ * Convert various internal events to the matching core event and verify the
+ * parameters.
+ */
+static void dix_event_to_core(int type)
+{
+    DeviceEvent ev;
+    xEvent core;
+    int time;
+    int x, y;
+    int rc;
+    int state;
+    int detail;
+    const int ROOT_WINDOW_ID = 0x100;
+
+    /* EventToCore memsets the event to 0 */
+#define test_event() \
+    g_assert(rc == Success); \
+    g_assert(core.u.u.type == type); \
+    g_assert(core.u.u.detail == detail); \
+    g_assert(core.u.keyButtonPointer.time == time); \
+    g_assert(core.u.keyButtonPointer.rootX == x); \
+    g_assert(core.u.keyButtonPointer.rootY == y); \
+    g_assert(core.u.keyButtonPointer.state == state); \
+    g_assert(core.u.keyButtonPointer.eventX == 0); \
+    g_assert(core.u.keyButtonPointer.eventY == 0); \
+    g_assert(core.u.keyButtonPointer.root == ROOT_WINDOW_ID); \
+    g_assert(core.u.keyButtonPointer.event == 0); \
+    g_assert(core.u.keyButtonPointer.child == 0); \
+    g_assert(core.u.keyButtonPointer.sameScreen == FALSE);
+
+    x = 0;
+    y = 0;
+    time = 12345;
+    state = 0;
+    detail = 0;
+
+    ev.header   = 0xFF;
+    ev.length   = sizeof(DeviceEvent);
+    ev.time     = time;
+    ev.root_y   = x;
+    ev.root_x   = y;
+    ev.root     = ROOT_WINDOW_ID;
+    ev.corestate = state;
+    ev.detail.key = detail;
+
+    ev.type = type;
+    ev.detail.key = 0;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    test_event();
+
+    x = 1;
+    y = 2;
+    ev.root_x = x;
+    ev.root_y = y;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    test_event();
+
+    x = 0x7FFF;
+    y = 0x7FFF;
+    ev.root_x = x;
+    ev.root_y = y;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    test_event();
+
+    x = 0x8000; /* too high */
+    y = 0x8000; /* too high */
+    ev.root_x = x;
+    ev.root_y = y;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(core.u.keyButtonPointer.rootX != x);
+    g_assert(core.u.keyButtonPointer.rootY != y);
+
+    x = 0x7FFF;
+    y = 0x7FFF;
+    ev.root_x = x;
+    ev.root_y = y;
+    time = 0;
+    ev.time = time;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    test_event();
+
+    detail = 1;
+    ev.detail.key = detail;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    test_event();
+
+    detail = 0xFF; /* highest value */
+    ev.detail.key = detail;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    test_event();
+
+    detail = 0xFFF; /* too big */
+    ev.detail.key = detail;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(rc == BadMatch);
+
+    detail = 0xFF; /* too big */
+    ev.detail.key = detail;
+    state = 0xFFFF; /* highest value */
+    ev.corestate = state;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    test_event();
+
+    state = 0x10000; /* too big */
+    ev.corestate = state;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(core.u.keyButtonPointer.state != state);
+    g_assert(core.u.keyButtonPointer.state == (state & 0xFFFF));
+
+#undef test_event
+}
+
+static void dix_event_to_core_conversion(void)
+{
+    DeviceEvent ev;
+    xEvent core;
+    int rc;
+
+    ev.header   = 0xFF;
+    ev.length   = sizeof(DeviceEvent);
+
+    ev.type     = 0;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(rc == BadImplementation);
+
+    ev.type     = 1;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(rc == BadImplementation);
+
+    ev.type     = ET_ProximityOut + 1;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(rc == BadImplementation);
+
+    ev.type     = ET_ProximityIn;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(rc == BadMatch);
+
+    ev.type     = ET_ProximityOut;
+    rc = EventToCore((InternalEvent*)&ev, &core);
+    g_assert(rc == BadMatch);
+
+    dix_event_to_core(ET_KeyPress);
+    dix_event_to_core(ET_KeyRelease);
+    dix_event_to_core(ET_ButtonPress);
+    dix_event_to_core(ET_ButtonRelease);
+    dix_event_to_core(ET_Motion);
+}
+
+static void xi2_struct_sizes(void)
+{
+#define compare(req) \
+    g_assert(sizeof(req) == sz_##req);
+
+    compare(xXIQueryVersionReq);
+    compare(xXIWarpPointerReq);
+    compare(xXIChangeCursorReq);
+    compare(xXIChangeHierarchyReq);
+    compare(xXISetClientPointerReq);
+    compare(xXIGetClientPointerReq);
+    compare(xXISelectEventsReq);
+    compare(xXIQueryVersionReq);
+    compare(xXIQueryDeviceReq);
+    compare(xXISetFocusReq);
+    compare(xXIGetFocusReq);
+    compare(xXIGrabDeviceReq);
+    compare(xXIUngrabDeviceReq);
+    compare(xXIAllowEventsReq);
+    compare(xXIPassiveGrabDeviceReq);
+    compare(xXIPassiveUngrabDeviceReq);
+    compare(xXIListPropertiesReq);
+    compare(xXIChangePropertyReq);
+    compare(xXIDeletePropertyReq);
+    compare(xXIGetPropertyReq);
+    compare(xXIGetSelectedEventsReq);
+#undef compare
+}
+
+
+static void dix_grab_matching(void)
+{
+    DeviceIntRec xi_all_devices, xi_all_master_devices, dev1, dev2;
+    GrabRec a, b;
+    BOOL rc;
+
+    memset(&a, 0, sizeof(a));
+    memset(&b, 0, sizeof(b));
+
+    /* different grabtypes must fail */
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_XI2;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI2;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_CORE;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    /* XI2 grabs for different devices must fail, regardless of ignoreDevice
+     * XI2 grabs for master devices must fail against a slave */
+    memset(&xi_all_devices, 0, sizeof(DeviceIntRec));
+    memset(&xi_all_master_devices, 0, sizeof(DeviceIntRec));
+    memset(&dev1, 0, sizeof(DeviceIntRec));
+    memset(&dev2, 0, sizeof(DeviceIntRec));
+
+    xi_all_devices.id = XIAllDevices;
+    xi_all_master_devices.id = XIAllMasterDevices;
+    dev1.id = 10;
+    dev1.type = SLAVE;
+    dev2.id = 11;
+    dev2.type = SLAVE;
+
+    inputInfo.all_devices = &xi_all_devices;
+    inputInfo.all_master_devices = &xi_all_master_devices;
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.device = &dev1;
+    b.device = &dev2;
+
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+
+    a.device = &dev2;
+    b.device = &dev1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&a, &b, TRUE);
+    g_assert(rc == FALSE);
+
+    a.device = inputInfo.all_master_devices;
+    b.device = &dev1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&a, &b, TRUE);
+    g_assert(rc == FALSE);
+
+    a.device = &dev1;
+    b.device = inputInfo.all_master_devices;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&a, &b, TRUE);
+    g_assert(rc == FALSE);
+
+    /* ignoreDevice FALSE must fail for different devices for CORE and XI */
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    a.device = &dev1;
+    b.device = &dev2;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    a.device = &dev1;
+    b.device = &dev2;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+
+    /* ignoreDevice FALSE must fail for different modifier devices for CORE
+     * and XI */
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    a.device = &dev1;
+    b.device = &dev1;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev2;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    a.device = &dev1;
+    b.device = &dev1;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev2;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+
+    /* different event type must fail */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.device = &dev1;
+    b.device = &dev1;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev1;
+    a.type = XI_KeyPress;
+    b.type = XI_KeyRelease;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&a, &b, TRUE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    a.device = &dev1;
+    b.device = &dev1;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev1;
+    a.type = XI_KeyPress;
+    b.type = XI_KeyRelease;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&a, &b, TRUE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    a.device = &dev1;
+    b.device = &dev1;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev1;
+    a.type = XI_KeyPress;
+    b.type = XI_KeyRelease;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&a, &b, TRUE);
+    g_assert(rc == FALSE);
+
+    /* different modifiers must fail */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.device = &dev1;
+    b.device = &dev1;
+    a.modifierDevice = &dev1;
+    b.modifierDevice = &dev1;
+    a.type = XI_KeyPress;
+    b.type = XI_KeyPress;
+    a.modifiersDetail.exact = 1;
+    b.modifiersDetail.exact = 2;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    /* AnyModifier must fail for XI2 */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.modifiersDetail.exact = AnyModifier;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    /* XIAnyModifier must fail for CORE and XI */
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    a.modifiersDetail.exact = XIAnyModifier;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    a.modifiersDetail.exact = XIAnyModifier;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    /* different detail must fail */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.detail.exact = 1;
+    b.detail.exact = 2;
+    a.modifiersDetail.exact = 1;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    /* detail of AnyModifier must fail */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.detail.exact = AnyModifier;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = 1;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    /* detail of XIAnyModifier must fail */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.detail.exact = XIAnyModifier;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = 1;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == FALSE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == FALSE);
+
+    /* XIAnyModifier or AnyModifer must succeed */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.detail.exact = 1;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = XIAnyModifier;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == TRUE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == TRUE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    a.detail.exact = 1;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = AnyModifier;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == TRUE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == TRUE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    a.detail.exact = 1;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = AnyModifier;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == TRUE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == TRUE);
+
+    /* AnyKey or XIAnyKeycode must succeed */
+    a.grabtype = GRABTYPE_XI2;
+    b.grabtype = GRABTYPE_XI2;
+    a.detail.exact = XIAnyKeycode;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = 1;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == TRUE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == TRUE);
+
+    a.grabtype = GRABTYPE_CORE;
+    b.grabtype = GRABTYPE_CORE;
+    a.detail.exact = AnyKey;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = 1;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == TRUE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == TRUE);
+
+    a.grabtype = GRABTYPE_XI;
+    b.grabtype = GRABTYPE_XI;
+    a.detail.exact = AnyKey;
+    b.detail.exact = 1;
+    a.modifiersDetail.exact = 1;
+    b.modifiersDetail.exact = 1;
+    rc = GrabMatchesSecond(&a, &b, FALSE);
+    g_assert(rc == TRUE);
+    rc = GrabMatchesSecond(&b, &a, FALSE);
+    g_assert(rc == TRUE);
+}
+
+static void include_byte_padding_macros(void)
+{
+    int i;
+    g_test_message("Testing bits_to_bytes()");
+
+    /* the macros don't provide overflow protection */
+    for (i = 0; i < INT_MAX - 7; i++)
+    {
+        int expected_bytes;
+        expected_bytes = (i + 7)/8;
+
+        g_assert(bits_to_bytes(i) >= i/8);
+        g_assert((bits_to_bytes(i) * 8) - i <= 7);
+    }
+
+    g_test_message("Testing bytes_to_int32()");
+    for (i = 0; i < INT_MAX - 3; i++)
+    {
+        int expected_4byte;
+        expected_4byte = (i + 3)/4;
+
+        g_assert(bytes_to_int32(i) <= i);
+        g_assert((bytes_to_int32(i) * 4) - i <= 3);
+    }
+
+    g_test_message("Testing pad_to_int32");
+
+    for (i = 0; i < INT_MAX - 3; i++)
+    {
+        int expected_bytes;
+        expected_bytes = ((i + 3)/4) * 4;
+
+        g_assert(pad_to_int32(i) >= i);
+        g_assert(pad_to_int32(i) - i <= 3);
+    }
+
+}
+
+static void xi_unregister_handlers(void)
+{
+    DeviceIntRec dev;
+    int handler;
+
+    memset(&dev, 0, sizeof(dev));
+
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 1);
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 2);
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 3);
+
+    g_test_message("Unlinking from front.");
+
+    XIUnregisterPropertyHandler(&dev, 4); /* NOOP */
+    g_assert(dev.properties.handlers->id == 3);
+    XIUnregisterPropertyHandler(&dev, 3);
+    g_assert(dev.properties.handlers->id == 2);
+    XIUnregisterPropertyHandler(&dev, 2);
+    g_assert(dev.properties.handlers->id == 1);
+    XIUnregisterPropertyHandler(&dev, 1);
+    g_assert(dev.properties.handlers == NULL);
+
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 4);
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 5);
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 6);
+    XIUnregisterPropertyHandler(&dev, 3); /* NOOP */
+    g_assert(dev.properties.handlers->next->next->next == NULL);
+    XIUnregisterPropertyHandler(&dev, 4);
+    g_assert(dev.properties.handlers->next->next == NULL);
+    XIUnregisterPropertyHandler(&dev, 5);
+    g_assert(dev.properties.handlers->next == NULL);
+    XIUnregisterPropertyHandler(&dev, 6);
+    g_assert(dev.properties.handlers == NULL);
+
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 7);
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 8);
+    handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);
+    g_assert(handler == 9);
+
+    XIDeleteAllDeviceProperties(&dev);
+    g_assert(dev.properties.handlers == NULL);
+    XIUnregisterPropertyHandler(&dev, 7); /* NOOP */
+
+}
+
+static void cmp_attr_fields(InputAttributes *attr1,
+                            InputAttributes *attr2)
+{
+    char **tags1, **tags2;
+
+    g_assert(attr1 && attr2);
+    g_assert(attr1 != attr2);
+    g_assert(attr1->flags == attr2->flags);
+
+    if (attr1->product != NULL)
+    {
+        g_assert(attr1->product != attr2->product);
+        g_assert(strcmp(attr1->product, attr2->product) == 0);
+    } else
+        g_assert(attr2->product == NULL);
+
+    if (attr1->vendor != NULL)
+    {
+        g_assert(attr1->vendor != attr2->vendor);
+        g_assert(strcmp(attr1->vendor, attr2->vendor) == 0);
+    } else
+        g_assert(attr2->vendor == NULL);
+
+    if (attr1->device != NULL)
+    {
+        g_assert(attr1->device != attr2->device);
+        g_assert(strcmp(attr1->device, attr2->device) == 0);
+    } else
+        g_assert(attr2->device == NULL);
+
+    tags1 = attr1->tags;
+    tags2 = attr2->tags;
+    if (!tags1)
+    {
+        g_assert(!tags2);
+        return;
+    }
+
+    /* check for identical content, but duplicated */
+    while (*tags1)
+    {
+        g_assert(*tags1 != *tags2);
+        g_assert(strcmp(*tags1, *tags2) == 0);
+        tags1++;
+        tags2++;
+    }
+
+    g_assert(!*tags2);
+
+    /* check for not sharing memory */
+    tags1 = attr1->tags;
+    while (*tags1)
+    {
+        tags2 = attr2->tags;
+        while (*tags2)
+            g_assert(*tags1 != *tags2++);
+
+        tags1++;
+    }
+}
+
+static void dix_input_attributes(void)
+{
+    InputAttributes orig = {0};
+    InputAttributes *new;
+    char *tags[4] = {"tag1", "tag2", "tag2", NULL};
+
+    new = DuplicateInputAttributes(NULL);
+    g_assert(!new);
+
+    new = DuplicateInputAttributes(&orig);
+    g_assert(memcpy(&orig, new, sizeof(InputAttributes)));
+
+    orig.product = "product name";
+    new = DuplicateInputAttributes(&orig);
+    cmp_attr_fields(&orig, new);
+    FreeInputAttributes(new);
+
+    orig.vendor = "vendor name";
+    new = DuplicateInputAttributes(&orig);
+    cmp_attr_fields(&orig, new);
+    FreeInputAttributes(new);
+
+    orig.device = "device path";
+    new = DuplicateInputAttributes(&orig);
+    cmp_attr_fields(&orig, new);
+    FreeInputAttributes(new);
+
+    orig.flags = 0xF0;
+    new = DuplicateInputAttributes(&orig);
+    cmp_attr_fields(&orig, new);
+    FreeInputAttributes(new);
+
+    orig.tags = tags;
+    new = DuplicateInputAttributes(&orig);
+    cmp_attr_fields(&orig, new);
+    FreeInputAttributes(new);
+}
+
+
+int main(int argc, char** argv)
+{
+    g_test_init(&argc, &argv,NULL);
+    g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
+
+    g_test_add_func("/dix/input/attributes", dix_input_attributes);
+    g_test_add_func("/dix/input/init-valuators", dix_init_valuators);
+    g_test_add_func("/dix/input/event-core-conversion", dix_event_to_core_conversion);
+    g_test_add_func("/dix/input/check-grab-values", dix_check_grab_values);
+    g_test_add_func("/dix/input/xi2-struct-sizes", xi2_struct_sizes);
+    g_test_add_func("/dix/input/grab_matching", dix_grab_matching);
+    g_test_add_func("/include/byte_padding_macros", include_byte_padding_macros);
+    g_test_add_func("/Xi/xiproperty/register-unregister", xi_unregister_handlers);
+
+
+    return g_test_run();
+}
author	marha <marha@users.sourceforge.net>	2010-05-26 07:52:44 +0000
committer	marha <marha@users.sourceforge.net>	2010-05-26 07:52:44 +0000
commit	d2ae79d77679ccfc02ef5b8e42c16d398d874464 (patch)
tree	1d566cb7bc73279e52671d2529bff1905148a32b /xorg-server
parent	74fa9a70a4817660f1c2ec3b3cc2bbe56db4fc58 (diff)
download	vcxsrv-d2ae79d77679ccfc02ef5b8e42c16d398d874464.tar.gz vcxsrv-d2ae79d77679ccfc02ef5b8e42c16d398d874464.tar.bz2 vcxsrv-d2ae79d77679ccfc02ef5b8e42c16d398d874464.zip