xserver pixman libX11 libXext 14/11/2010

7 files changed, 820 insertions, 849 deletions

diff --git a/xorg-server/hw/dmx/doc/dmx.xml b/xorg-server/hw/dmx/doc/dmx.xml
index c7eaf1333..c998485bc 100644
--- a/xorg-server/hw/dmx/doc/dmx.xml
+++ b/xorg-server/hw/dmx/doc/dmx.xml
@@ -817,22 +817,10 @@ is called once for each input device.
 </para>

 

 <para>Once input handles for core keyboard and core pointer devices have

-been obtained from AddInputDevice(), they are registered as core devices

-by calling RegisterPointerDevice() and RegisterKeyboardDevice().  Each

-of these should be called once.  If both core devices are not

+been obtained from AddInputDevice().  If both core devices are not

 registered, then the X server will exit with a fatal error when it

 attempts to start the input devices in InitAndStartDevices(), which is

 called directly after InitInput() (see below).

-

-<variablelist>

-<varlistentry>

-<term>Register{Pointer,Keyboard}Device()</term>

-<listitem><para>These DIX functions take a

-handle returned from AddInputDevice() and initialize the core input

-device fields in inputInfo, and initialize the input processing and grab

-functions for each core input device.

-</para></listitem></varlistentry>

-</variablelist>

 </para>

 

 <para>The core pointer device is then registered with the miPointer code

diff --git a/xorg-server/hw/dmx/glxProxy/glxcmds.c b/xorg-server/hw/dmx/glxProxy/glxcmds.c
index f1893656f..26ffad825 100644
--- a/xorg-server/hw/dmx/glxProxy/glxcmds.c
+++ b/xorg-server/hw/dmx/glxProxy/glxcmds.c
@@ -2565,7 +2565,7 @@ int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
    

     cl->GLClientmajorVersion = req->major;

     cl->GLClientminorVersion = req->minor;

-    if (cl->GLClientextensions) free(cl->GLClientextensions);

+    free(cl->GLClientextensions);

     buf = (const char *)(req+1);

     cl->GLClientextensions = strdup(buf);

 

diff --git a/xorg-server/hw/dmx/glxProxy/glxext.c b/xorg-server/hw/dmx/glxProxy/glxext.c
index 01cbd6e08..a90c14906 100644
--- a/xorg-server/hw/dmx/glxProxy/glxext.c
+++ b/xorg-server/hw/dmx/glxProxy/glxext.c
@@ -77,10 +77,10 @@ static void ResetClientState(int clientIndex)
     Display **keep_be_displays;

     int i;

 

-    if (cl->returnBuf) free(cl->returnBuf);

-    if (cl->currentContexts) free(cl->currentContexts);

-    if (cl->currentDrawables) free(cl->currentDrawables);

-    if (cl->largeCmdBuf) free(cl->largeCmdBuf);

+    free(cl->returnBuf);

+    free(cl->currentContexts);

+    free(cl->currentDrawables);

+    free(cl->largeCmdBuf);

 

     for (i=0; i< screenInfo.numScreens; i++) {

        if (cl->be_displays[i])

@@ -97,7 +97,7 @@ static void ResetClientState(int clientIndex)
     */

     cl->GLClientmajorVersion = 1;

     cl->GLClientminorVersion = 0;

-    if (cl->GLClientextensions) free(cl->GLClientextensions);

+    free(cl->GLClientextensions);

 

     memset(cl->be_displays, 0, screenInfo.numScreens * sizeof(Display *));

 }

@@ -222,10 +222,10 @@ GLboolean __glXFreeContext(__GLXcontext *cx)
 {

     if (cx->idExists || cx->isCurrent) return GL_FALSE;

     

-    if (cx->feedbackBuf) free(cx->feedbackBuf);

-    if (cx->selectBuf) free(cx->selectBuf);

-    if (cx->real_ids) free(cx->real_ids);

-    if (cx->real_vids) free(cx->real_vids);

+    free(cx->feedbackBuf);

+    free(cx->selectBuf);

+    free(cx->real_ids);

+    free(cx->real_vids);

 

     if (cx->pGlxPixmap) {

        /*

diff --git a/xorg-server/hw/dmx/input/dmxevents.c b/xorg-server/hw/dmx/input/dmxevents.c
index dfa6bdad5..efcd07da3 100644
--- a/xorg-server/hw/dmx/input/dmxevents.c
+++ b/xorg-server/hw/dmx/input/dmxevents.c
@@ -1,795 +1,800 @@
-/*
- * Copyright 2002-2003 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:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- * Provide support and helper functions for enqueing events received by
- * the low-level input drivers. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#define DMX_EVENTS_DEBUG 0
-
-#include "dmxinputinit.h"
-#include "dmxevents.h"
-#include "dmxcb.h"
-#include "dmxcommon.h"
-#include "dmxcursor.h"
-#include "dmxmotion.h"
-#include "dmxsigio.h"
-#include "dmxmap.h"
-
-#include <X11/keysym.h>
-#include "opaque.h"
-#include "inputstr.h"
-#include "mipointer.h"
-#include "mi.h"
-#include "exglobals.h"
-
-#include "xkbsrv.h"
-#include "XIstubs.h"
-
-static int  dmxGlobalX, dmxGlobalY; /* Global cursor position */
-static int  dmxGlobalInvalid;       /* Flag indicating dmxCoreMotion
-                                     * should move the mouse anyway. */
-
-#if DMX_EVENTS_DEBUG
-#define DMXDBG0(f)               dmxLog(dmxDebug,f)
-#define DMXDBG1(f,a)             dmxLog(dmxDebug,f,a)
-#define DMXDBG2(f,a,b)           dmxLog(dmxDebug,f,a,b)
-#define DMXDBG3(f,a,b,c)         dmxLog(dmxDebug,f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)       dmxLog(dmxDebug,f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)     dmxLog(dmxDebug,f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)   dmxLog(dmxDebug,f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h) dmxLog(dmxDebug,f,a,b,c,d,e,g,h)
-#else
-#define DMXDBG0(f)
-#define DMXDBG1(f,a)
-#define DMXDBG2(f,a,b)
-#define DMXDBG3(f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h)
-#endif
-
-static int dmxApplyFunctions(DMXInputInfo *dmxInput, DMXFunctionType f)
-{
-    int i;
-    int rc = 0;
-
-    for (i = 0; i < dmxInput->numDevs; i+= dmxInput->devs[i]->binding)
-        if (dmxInput->devs[i]->functions)
-            rc += dmxInput->devs[i]->functions(dmxInput->devs[i]->private, f);
-    return rc;
-}
-
-static int dmxCheckFunctionKeys(DMXLocalInputInfoPtr dmxLocal,
-                                int type,
-                                KeySym keySym)
-{
-    DMXInputInfo   *dmxInput = &dmxInputs[dmxLocal->inputIdx];
-
-#if 1 /* hack to detect ctrl-alt-q, etc */
-    static int ctrl = 0, alt = 0;
-    /* keep track of ctrl/alt key status */
-    if (type == KeyPress && keySym == 0xffe3) {
-        ctrl = 1;
-    }
-    else if (type == KeyRelease && keySym == 0xffe3) {
-        ctrl = 0;
-    }
-    else if (type == KeyPress && keySym == 0xffe9) {
-        alt = 1;
-    }
-    else if (type == KeyRelease && keySym == 0xffe9) {
-        alt = 0;
-    }
-    if (!ctrl || !alt)
-        return 0;
-#else
-    unsigned short state = 0;
-
-    if (dmxLocal->sendsCore)
-        state = dmxLocalCoreKeyboard->pDevice->key->state;
-    else if (dmxLocal->pDevice->key)
-        state = dmxLocal->pDevice->key->state;
-    
-    DMXDBG3("dmxCheckFunctionKeys: keySym=0x%04x %s state=0x%04x\n",
-            keySym, type == KeyPress ? "press" : "release", state);
-
-    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask))
-        return 0;
-#endif
-
-    switch (keySym) {
-    case XK_g:
-        if (type == KeyPress)
-            dmxApplyFunctions(dmxInput, DMX_FUNCTION_GRAB);
-        return 1;
-    case XK_f:
-        if (type == KeyPress)
-            dmxApplyFunctions(dmxInput, DMX_FUNCTION_FINE);
-        return 1;
-    case XK_q:
-        if (type == KeyPress && dmxLocal->sendsCore)
-            if (dmxApplyFunctions(dmxInput, DMX_FUNCTION_TERMINATE)) {
-                dmxLog(dmxInfo, "User request for termination\n");
-                dispatchException |= DE_TERMINATE;
-            }
-        return 1;
-    }
-    
-    return 0;
-}
-
-
-DMXScreenInfo *dmxFindFirstScreen(int x, int y)
-{
-    int i;
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        DMXScreenInfo *dmxScreen = &dmxScreens[i];
-        if (dmxOnScreen(x, y, dmxScreen))
-            return dmxScreen;
-    }
-    return NULL;
-}
-
-
-/**
- * Enqueue a motion event.
- */
-static void enqueueMotion(DevicePtr pDev, int x, int y)
-{
-    GETDMXLOCALFROMPDEV;
-    DeviceIntPtr p = dmxLocal->pDevice;
-    int i, nevents, valuators[3];
-    EventListPtr events;
-    int detail = 0;  /* XXX should this be mask of pressed buttons? */
-    valuators[0] = x;
-    valuators[1] = y;
-
-    GetEventList(&events);
-    nevents = GetPointerEvents(events, p, MotionNotify, detail,
-                               POINTER_ABSOLUTE | POINTER_SCREEN, 0, 2, valuators);
-    for (i = 0; i < nevents; i++)
-       mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-    return;
-}
-
-
-void
-dmxCoreMotion(DevicePtr pDev, int x, int y, int delta, DMXBlockType block)
-{
-    DMXScreenInfo *dmxScreen;
-    DMXInputInfo  *dmxInput;
-    ScreenPtr     pScreen;
-    int           localX;
-    int           localY;
-    int           i;
-
-    if (!dmxGlobalInvalid && dmxGlobalX == x && dmxGlobalY == y)
-        return;
-    
-    DMXDBG5("dmxCoreMotion(%d,%d,%d) dmxGlobalX=%d dmxGlobalY=%d\n",
-            x, y, delta, dmxGlobalX, dmxGlobalY);
-
-    dmxGlobalInvalid = 0;
-    dmxGlobalX       = x;
-    dmxGlobalY       = y;
-
-    if (dmxGlobalX < 0)
-        dmxGlobalX = 0;
-    if (dmxGlobalY < 0)
-        dmxGlobalY = 0;
-    if (dmxGlobalX >= dmxGlobalWidth)
-        dmxGlobalX = dmxGlobalWidth  + delta -1;
-    if (dmxGlobalY >= dmxGlobalHeight)
-        dmxGlobalY = dmxGlobalHeight + delta -1;
-    
-    if ((dmxScreen = dmxFindFirstScreen(dmxGlobalX, dmxGlobalY))) {
-        localX = dmxGlobalX - dmxScreen->rootXOrigin;
-        localY = dmxGlobalY - dmxScreen->rootYOrigin;
-        if ((pScreen = miPointerGetScreen(inputInfo.pointer))
-            && pScreen->myNum == dmxScreen->index) {
-                                /* Screen is old screen */
-            if (block)
-                dmxSigioBlock();
-            if (pDev)
-               enqueueMotion(pDev, localX, localY);
-            if (block)
-                dmxSigioUnblock();
-        } else {
-                                /* Screen is new */
-            DMXDBG4("   New screen: old=%d new=%d localX=%d localY=%d\n",
-                    pScreen->myNum, dmxScreen->index, localX, localY);
-            if (block)
-                dmxSigioBlock();
-            mieqProcessInputEvents();
-            miPointerSetScreen(inputInfo.pointer, dmxScreen->index,
-                               localX, localY);
-            if (pDev)
-               enqueueMotion(pDev, localX, localY);
-            if (block)
-                dmxSigioUnblock();
-        }
-#if 00
-        miPointerGetPosition(inputInfo.pointer, &localX, &localY);
-
-        if ((pScreen = miPointerGetScreen(inputInfo.pointer))) {
-            dmxGlobalX = localX + dmxScreens[pScreen->myNum].rootXOrigin;
-            dmxGlobalY = localY + dmxScreens[pScreen->myNum].rootYOrigin;
-            ErrorF("Global is now %d, %d  %d, %d\n", dmxGlobalX, dmxGlobalY,
-                   localX, localY);
-            DMXDBG6("   Moved to dmxGlobalX=%d dmxGlobalY=%d"
-                    " on screen index=%d/%d localX=%d localY=%d\n",
-                    dmxGlobalX, dmxGlobalY,
-                    dmxScreen ? dmxScreen->index : -1, pScreen->myNum,
-                    localX, localY);
-        }
-#endif
-    }
-                                /* Send updates down to all core input
-                                 * drivers */
-    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++) {
-        int j;
-        for (j = 0; j < dmxInput->numDevs; j += dmxInput->devs[j]->binding)
-            if (!dmxInput->detached
-                && dmxInput->devs[j]->sendsCore
-                && dmxInput->devs[j]->update_position)
-                dmxInput->devs[j]->update_position(dmxInput->devs[j]->private,
-                                                   dmxGlobalX, dmxGlobalY);
-    }
-    if (!dmxScreen) ProcessInputEvents();
-}
-
-
-
-#define DMX_MAX_AXES 32         /* Max axes reported by this routine */
-static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
-                         int *v, int firstAxis, int axesCount,
-                         DMXMotionType type, DMXBlockType block)
-{
-    DeviceIntPtr           pDevice = dmxLocal->pDevice;
-    xEvent                 xE[2 * DMX_MAX_AXES/6];
-    deviceKeyButtonPointer *xev    = (deviceKeyButtonPointer *)xE;
-    deviceValuator         *xv     = (deviceValuator *)xev+1;
-    int                    thisX   = 0;
-    int                    thisY   = 0;
-    int                    i;
-    int                    count;
-    EventListPtr           events;
-    int                    nevents;
-
-    memset(xE, 0, sizeof(xE));
-
-    if (axesCount > DMX_MAX_AXES) axesCount = DMX_MAX_AXES;
-
-    if (!pDevice->valuator->mode && axesCount == 2) {
-                                /* The dmx console is a relative mode
-                                 * device that sometimes reports
-                                 * absolute motion.  It only has two
-                                 * axes. */
-        if (type == DMX_RELATIVE) {
-            thisX = -v[0];
-            thisY = -v[1];
-            dmxLocal->lastX += thisX;
-            dmxLocal->lastY += thisY;
-            if (dmxLocal->update_position)
-                dmxLocal->update_position(dmxLocal->private,
-                                          dmxLocal->lastX, dmxLocal->lastY);
-        } else {                    /* Convert to relative */
-            if (dmxLocal->lastX || dmxLocal->lastY) {
-                thisX = v[0] - dmxLocal->lastX;
-                thisY = v[1] - dmxLocal->lastY;
-            }
-            dmxLocal->lastX = v[0];
-            dmxLocal->lastY = v[1];
-        }
-        v[0] = thisX;
-        v[1] = thisY;
-    }
-
-    if (axesCount <= 6) {
-                                /* Optimize for the common case when
-                                 * only 1 or 2 axes change. */
-            xev->time          = GetTimeInMillis();
-            xev->type          = DeviceMotionNotify;
-            xev->detail        = 0;
-            xev->deviceid      = pDevice->id | MORE_EVENTS;
-            
-            xv->type           = DeviceValuator;
-            xv->deviceid       = pDevice->id;
-            xv->num_valuators  = axesCount;
-            xv->first_valuator = firstAxis;
-            switch (xv->num_valuators) {
-            case 6: xv->valuator5 = v[5];
-            case 5: xv->valuator4 = v[4];
-            case 4: xv->valuator3 = v[3];
-            case 3: xv->valuator2 = v[2];
-            case 2: xv->valuator1 = v[1];
-            case 1: xv->valuator0 = v[0];
-            }
-            count              = 2;
-    } else {
-        for (i = 0, count = 0; i < axesCount; i += 6) {
-            xev->time          = GetTimeInMillis();
-            xev->type          = DeviceMotionNotify;
-            xev->detail        = 0;
-            xev->deviceid      = pDevice->id | MORE_EVENTS;
-            xev               += 2;
-            
-            xv->type           = DeviceValuator;
-            xv->deviceid       = pDevice->id;
-            xv->num_valuators  = (i+6 >= axesCount ? axesCount - i : 6);
-            xv->first_valuator = firstAxis + i;
-            switch (xv->num_valuators) {
-            case 6: xv->valuator5 = v[i+5];
-            case 5: xv->valuator4 = v[i+4];
-            case 4: xv->valuator3 = v[i+3];
-            case 3: xv->valuator2 = v[i+2];
-            case 2: xv->valuator1 = v[i+1];
-            case 1: xv->valuator0 = v[i+0];
-            }
-            xv                += 2;
-            count             += 2;
-        }
-    }
-
-    if (block)
-        dmxSigioBlock();
-    GetEventList(&events);
-    nevents = GetPointerEvents(events, pDevice, MotionNotify, 0, POINTER_ABSOLUTE,
-                               firstAxis, axesCount, v);
-    for (i = 0; i < nevents; i++)
-        mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-    if (block)
-        dmxSigioUnblock();
-}
-
-static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
-                                          XEvent *e, DMXBlockType block)
-{
-    int                    type;
-    int                    event   = -1;
-    XDeviceKeyEvent        *ke     = (XDeviceKeyEvent *)e;
-    XDeviceMotionEvent     *me     = (XDeviceMotionEvent *)e;
-    DeviceIntPtr           pDevice = dmxLocal->pDevice;
-    int                    valuators[6];
-    EventListPtr           events;
-    int                    nevents, i;
-
-    if (!e)
-        return -1;          /* No extended event passed, cannot handle */
-    
-    if ((XID)dmxLocal->deviceId != ke->deviceid) {
-                                /* Search for the correct dmxLocal,
-                                 * since backend and console events are
-                                 * picked up for the first device on
-                                 * that X server. */
-        int i;
-        DMXInputInfo *dmxInput = &dmxInputs[dmxLocal->inputIdx];
-        for (i = 0; i < dmxInput->numDevs; i++) {
-            dmxLocal = dmxInput->devs[i];
-            if ((XID)dmxLocal->deviceId == ke->deviceid)
-                break;
-        }
-    }
-
-    if ((XID)dmxLocal->deviceId != ke->deviceid
-        || (type = dmxMapLookup(dmxLocal, e->type)) < 0)
-        return -1;    /* No mapping, so this event is unhandled */
-
-    switch (type) {
-    case XI_DeviceValuator:          event = DeviceValuator;          break;
-    case XI_DeviceKeyPress:          event = KeyPress;                break;
-    case XI_DeviceKeyRelease:        event = KeyRelease;              break;
-    case XI_DeviceButtonPress:       event = ButtonPress;             break;
-    case XI_DeviceButtonRelease:     event = ButtonRelease;           break;
-    case XI_DeviceMotionNotify:      event = MotionNotify;            break;
-    case XI_DeviceFocusIn:           event = DeviceFocusIn;           break;
-    case XI_DeviceFocusOut:          event = DeviceFocusOut;          break;
-    case XI_ProximityIn:             event = ProximityIn;             break;
-    case XI_ProximityOut:            event = ProximityOut;            break;
-    case XI_DeviceStateNotify:       event = DeviceStateNotify;       break;
-    case XI_DeviceMappingNotify:     event = DeviceMappingNotify;     break;
-    case XI_ChangeDeviceNotify:      event = ChangeDeviceNotify;      break;
-    case XI_DeviceKeystateNotify:    event = DeviceStateNotify;       break;
-    case XI_DeviceButtonstateNotify: event = DeviceStateNotify;       break;
-    }
-
-#define EXTRACT_VALUATORS(ke, valuators) \
-        valuators[0]       = ke->axis_data[0]; \
-        valuators[1]       = ke->axis_data[1]; \
-        valuators[2]       = ke->axis_data[2]; \
-        valuators[3]       = ke->axis_data[3]; \
-        valuators[4]       = ke->axis_data[4]; \
-        valuators[5]       = ke->axis_data[5]; \
-
-    switch (type) {
-    case XI_DeviceKeyPress:
-    case XI_DeviceKeyRelease:
-        EXTRACT_VALUATORS(ke, valuators);
-        if (block)
-            dmxSigioBlock();
-        GetEventList(&events);
-        nevents = GetKeyboardValuatorEvents(events, pDevice, event,
-                                            ke->keycode, ke->first_axis,
-                                            ke->axes_count, valuators);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-        if (block)
-            dmxSigioUnblock();
-        break;
-    case XI_DeviceButtonPress:
-    case XI_DeviceButtonRelease:
-        EXTRACT_VALUATORS(ke, valuators);
-        if (block)
-            dmxSigioBlock();
-        GetEventList(&events);
-        nevents = GetPointerEvents(events, pDevice, event, ke->keycode,
-                                   POINTER_ABSOLUTE, ke->first_axis,
-                                   ke->axes_count, valuators);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-        if (block)
-            dmxSigioUnblock();
-        break;
-    case XI_ProximityIn:
-    case XI_ProximityOut:
-        EXTRACT_VALUATORS(ke, valuators);
-        if (block)
-            dmxSigioBlock();
-        GetEventList(&events);
-        nevents = GetProximityEvents(events, pDevice, event,
-                                     ke->first_axis, ke->axes_count,
-                                     valuators);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-        if (block)
-            dmxSigioUnblock();
-        break;
-
-        break;
-
-    case XI_DeviceMotionNotify:
-        dmxExtMotion(dmxLocal, me->axis_data, me->first_axis, me->axes_count,
-                     DMX_ABSOLUTE, block);
-        break;
-    case XI_DeviceFocusIn:
-    case XI_DeviceFocusOut:
-    case XI_DeviceStateNotify:
-    case XI_DeviceMappingNotify:
-    case XI_ChangeDeviceNotify:
-    case XI_DeviceKeystateNotify:
-    case XI_DeviceButtonstateNotify:
-                                /* These are ignored, since DMX will
-                                 * generate its own events of these
-                                 * types, as necessary.
-
-                                 * Perhaps ChangeDeviceNotify should
-                                 * generate an error, because it is
-                                 * unexpected? */
-        break;
-    case XI_DeviceValuator:
-    default:
-        dmxLog(dmxWarning,
-               "XInput extension event (remote=%d -> zero-based=%d)"
-               " not supported yet\n", e->type, type);
-        return -1;
-    }
-    return 0;
-}
-
-static int dmxGetButtonMapping(DMXLocalInputInfoPtr dmxLocal, int button)
-{
-    ButtonClassPtr b = dmxLocal->pDevice->button;
-
-    if (button > b->numButtons) { /* This shouldn't happen. */
-        dmxLog(dmxWarning, "Button %d pressed, but only %d buttons?!?\n",
-               button, b->numButtons);
-        return button;
-    }
-    return b->map[button];
-}
-
-/** Return DMX's notion of the pointer position in the global coordinate
- * space. */
-void dmxGetGlobalPosition(int *x, int *y)
-{
-    *x = dmxGlobalX;
-    *y = dmxGlobalY;
-}
-
-/** Invalidate the global position for #dmxCoreMotion. */
-void dmxInvalidateGlobalPosition(void)
-{
-    dmxGlobalInvalid = 1;
-}
-
-/** Enqueue a motion event for \a pDev.  The \a v vector has length \a
- * axesCount, and contains values for each of the axes, starting at \a
- * firstAxes.
- *
- * The \a type of the motion may be \a DMX_RELATIVE, \a DMX_ABSOLUTE, or
- * \a DMX_ABSOLUTE_CONFINED (in the latter case, the pointer will not be
- * allowed to move outside the global boundaires).
- *
- * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
- * blocked around calls to \a enqueueMotion(). */
-void dmxMotion(DevicePtr pDev, int *v, int firstAxes, int axesCount,
-               DMXMotionType type, DMXBlockType block)
-{
-    GETDMXLOCALFROMPDEV;
-
-    if (!dmxLocal->sendsCore) {
-        dmxExtMotion(dmxLocal, v, firstAxes, axesCount, type, block);
-        return;
-    }
-    if (axesCount == 2) {
-        switch (type) {
-        case DMX_RELATIVE:
-            dmxCoreMotion(pDev, dmxGlobalX - v[0], dmxGlobalY - v[1], 0, block);
-            break;
-        case DMX_ABSOLUTE:
-            dmxCoreMotion(pDev, v[0], v[1], 0, block);
-            break;
-        case DMX_ABSOLUTE_CONFINED:
-            dmxCoreMotion(pDev, v[0], v[1], -1, block);
-            break;
-        }
-    }
-}
-
-static KeySym dmxKeyCodeToKeySym(DMXLocalInputInfoPtr dmxLocal,
-                                 KeyCode keyCode)
-{
-    KeySym keysym = NoSymbol;
-    int effectiveGroup;
-    XkbSrvInfoPtr xkbi;
-
-    if (!dmxLocal || !dmxLocal->pDevice || !dmxLocal->pDevice->key)
-        goto out;
-
-    xkbi = dmxLocal->pDevice->key->xkbInfo;
-    effectiveGroup = XkbGetEffectiveGroup(xkbi, &xkbi->state, keyCode);
-
-    if (effectiveGroup == -1)
-        goto out;
-
-    keysym = XkbKeySym(xkbi->desc, keyCode, effectiveGroup);
-    DMXDBG2("dmxKeyCodeToKeySym: Translated keyCode=%d to keySym=0x%04x\n",
-            keyCode, keysym);
-
-out:
-    return keysym;
-}
-
-static KeyCode dmxKeySymToKeyCode(DMXLocalInputInfoPtr dmxLocal, KeySym keySym,
-                                  int tryFirst)
-{
-    /* FIXME: this is quite ineffective, converting to a core map first and
-     * then extracting the info from there. It'd be better to run the actual
-     * xkb map */
-    XkbSrvInfoPtr xkbi = dmxLocal->pDevice->key->xkbInfo;
-    KeySymsPtr pKeySyms = XkbGetCoreMap(dmxLocal->pDevice);
-    int        i;
-
-                                /* Optimize for similar maps */
-    if (XkbKeycodeInRange(xkbi->desc, tryFirst)
-        && pKeySyms->map[(tryFirst - xkbi->desc->min_key_code)
-                         * pKeySyms->mapWidth] == keySym)
-        return tryFirst;
-
-    for (i = pKeySyms->minKeyCode; i <= pKeySyms->maxKeyCode; i++) {
-        if (pKeySyms->map[(i - pKeySyms->minKeyCode)
-                          * pKeySyms->mapWidth] == keySym) {
-            DMXDBG3("dmxKeySymToKeyCode: Translated keySym=0x%04x to"
-                    " keyCode=%d (reverses to core keySym=0x%04x)\n",
-                    keySym, i, dmxKeyCodeToKeySym(dmxLocalCoreKeyboard,i));
-            return i;
-        }
-    }
-    return 0;
-}
-
-static int dmxFixup(DevicePtr pDev, int detail, KeySym keySym)
-{
-    GETDMXLOCALFROMPDEV;
-    int keyCode;
-    
-    if (!dmxLocal->pDevice->key) {
-        dmxLog(dmxWarning, "dmxFixup: not a keyboard device (%s)\n",
-               dmxLocal->pDevice->name);
-        return NoSymbol;
-    }
-    if (!keySym)
-        keySym = dmxKeyCodeToKeySym(dmxLocal, detail);
-    if (keySym == NoSymbol)
-        return detail;
-    keyCode = dmxKeySymToKeyCode(dmxLocalCoreKeyboard, keySym, detail);
-
-    return keyCode ? keyCode : detail;
-}
-
-/** Enqueue an event from the \a pDev device with the
- * specified \a type and \a detail.  If the event is a KeyPress or
- * KeyRelease event, then the \a keySym is also specified.
- *
- * FIXME: make the code do what the comment says, or remove this comment.
- * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
- * blocked around calls to dmxeqEnqueue(). */
-    
-void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
-                XEvent *e, DMXBlockType block)
-{
-    GETDMXINPUTFROMPDEV;
-    xEvent xE;
-    DeviceIntPtr p = dmxLocal->pDevice;
-    int i, nevents, valuators[3];
-    EventListPtr events;
-
-    DMXDBG2("dmxEnqueue: Enqueuing type=%d detail=0x%0x\n", type, detail);
-
-    switch (type) {
-    case KeyPress:
-    case KeyRelease:
-        if (!keySym)
-            keySym = dmxKeyCodeToKeySym(dmxLocal, detail);
-        if (dmxCheckFunctionKeys(dmxLocal, type, keySym))
-            return;
-        if (dmxLocal->sendsCore && dmxLocal != dmxLocalCoreKeyboard)
-            xE.u.u.detail = dmxFixup(pDev, detail, keySym);
-
-        GetEventList(&events);
-        /*ErrorF("KEY %d  sym %d\n", detail, (int) keySym);*/
-        nevents = GetKeyboardEvents(events, p, type, detail);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-        return;
-
-    case ButtonPress:
-    case ButtonRelease:
-        detail = dmxGetButtonMapping(dmxLocal, detail);
-        GetEventList(&events);
-        nevents = GetPointerEvents(events, p, type, detail,
-                                   POINTER_ABSOLUTE | POINTER_SCREEN,
-                                   0,   /* first_valuator = 0 */
-                                   0,   /* num_valuators = 0 */
-                                   valuators);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-        return;
-
-    case MotionNotify:
-        GetEventList(&events);
-        valuators[0] = e->xmotion.x;
-        valuators[1] = e->xmotion.y;
-        valuators[2] = e->xmotion.state; /* FIXME: WTF?? */
-        nevents = GetPointerEvents(events, p, type, detail, 
-                                   POINTER_ABSOLUTE | POINTER_SCREEN, 0, 3, valuators);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-        return;
-
-    case EnterNotify:
-    case LeaveNotify:
-    case KeymapNotify:
-    case MappingNotify:         /* This is sent because we change the
-                                 * modifier map on the backend/console
-                                 * input device so that we have complete
-                                 * control of the input device LEDs. */
-        return;
-    default:
-        if (type == ProximityIn || type == ProximityOut) {
-            if (dmxLocal->sendsCore)
-                return; /* Not a core event */
-            break;
-        }
-        if (type >= LASTEvent) {
-            if (dmxTranslateAndEnqueueExtEvent(dmxLocal, e, block))
-                dmxLogInput(dmxInput, "Unhandled extension event: %d\n", type);
-        } else {
-            dmxLogInput(dmxInput, "Unhandled event: %d (%s)\n",
-                        type, dmxEventName(type));
-        }
-        return;
-    }
-
-}
-
-/** A pointer to this routine is passed to low-level input drivers so
- * that all special keychecking is unified to this file.  This function
- * returns 0 if no special keys have been pressed.  If the user has
- * requested termination of the DMX server, -1 is returned.  If the user
- * has requested a switch to a VT, then the (1-based) number of that VT
- * is returned. */
-int dmxCheckSpecialKeys(DevicePtr pDev, KeySym keySym)
-{
-    GETDMXINPUTFROMPDEV;
-    int            vt    = 0;
-    unsigned short state = 0;
-
-    if (dmxLocal->sendsCore)
-        state = XkbStateFieldFromRec(&dmxLocalCoreKeyboard->pDevice->key->xkbInfo->state);
-    else if (dmxLocal->pDevice->key)
-        state = XkbStateFieldFromRec(&dmxLocal->pDevice->key->xkbInfo->state);
-
-    if (!dmxLocal->sendsCore) return 0; /* Only for core devices */
-
-    DMXDBG2("dmxCheckSpecialKeys: keySym=0x%04x state=0x%04x\n", keySym,state);
-    
-    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask)) return 0;
-    
-    switch (keySym) {
-    case XK_F1:
-    case XK_F2:
-    case XK_F3:
-    case XK_F4:
-    case XK_F5:
-    case XK_F6:
-    case XK_F7:
-    case XK_F8:
-    case XK_F9:
-    case XK_F10:
-        vt = keySym - XK_F1 + 1;
-        break;
-
-    case XK_F11:
-    case XK_F12:
-        vt = keySym - XK_F11 + 11;
-        break;
-
-    case XK_q:                  /* To avoid confusion  */
-    case XK_BackSpace:
-    case XK_Delete:
-    case XK_KP_Delete:
-        dmxLog(dmxInfo, "User request for termination\n");
-        dispatchException |= DE_TERMINATE;
-        return -1;              /* Terminate */
-    }
-
-    if (vt) {
-        dmxLog(dmxInfo, "Request to switch to VT %d\n", vt);
-        dmxInput->vt_switch_pending = vt;
-        return vt;
-    }
-
-    return 0;                   /* Do nothing */
-}
+/*

+ * Copyright 2002-2003 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:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ * Provide support and helper functions for enqueing events received by

+ * the low-level input drivers. */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#define DMX_EVENTS_DEBUG 0

+

+#include "dmxinputinit.h"

+#include "dmxevents.h"

+#include "dmxcb.h"

+#include "dmxcommon.h"

+#include "dmxcursor.h"

+#include "dmxmotion.h"

+#include "dmxsigio.h"

+#include "dmxmap.h"

+

+#include <X11/keysym.h>

+#include "opaque.h"

+#include "inputstr.h"

+#include "inpututils.h"

+#include "mipointer.h"

+#include "mi.h"

+#include "exglobals.h"

+

+#include "xkbsrv.h"

+#include "XIstubs.h"

+

+static int  dmxGlobalX, dmxGlobalY; /* Global cursor position */

+static int  dmxGlobalInvalid;       /* Flag indicating dmxCoreMotion

+                                     * should move the mouse anyway. */

+

+#if DMX_EVENTS_DEBUG

+#define DMXDBG0(f)               dmxLog(dmxDebug,f)

+#define DMXDBG1(f,a)             dmxLog(dmxDebug,f,a)

+#define DMXDBG2(f,a,b)           dmxLog(dmxDebug,f,a,b)

+#define DMXDBG3(f,a,b,c)         dmxLog(dmxDebug,f,a,b,c)

+#define DMXDBG4(f,a,b,c,d)       dmxLog(dmxDebug,f,a,b,c,d)

+#define DMXDBG5(f,a,b,c,d,e)     dmxLog(dmxDebug,f,a,b,c,d,e)

+#define DMXDBG6(f,a,b,c,d,e,g)   dmxLog(dmxDebug,f,a,b,c,d,e,g)

+#define DMXDBG7(f,a,b,c,d,e,g,h) dmxLog(dmxDebug,f,a,b,c,d,e,g,h)

+#else

+#define DMXDBG0(f)

+#define DMXDBG1(f,a)

+#define DMXDBG2(f,a,b)

+#define DMXDBG3(f,a,b,c)

+#define DMXDBG4(f,a,b,c,d)

+#define DMXDBG5(f,a,b,c,d,e)

+#define DMXDBG6(f,a,b,c,d,e,g)

+#define DMXDBG7(f,a,b,c,d,e,g,h)

+#endif

+

+static int dmxApplyFunctions(DMXInputInfo *dmxInput, DMXFunctionType f)

+{

+    int i;

+    int rc = 0;

+

+    for (i = 0; i < dmxInput->numDevs; i+= dmxInput->devs[i]->binding)

+        if (dmxInput->devs[i]->functions)

+            rc += dmxInput->devs[i]->functions(dmxInput->devs[i]->private, f);

+    return rc;

+}

+

+static int dmxCheckFunctionKeys(DMXLocalInputInfoPtr dmxLocal,

+                                int type,

+                                KeySym keySym)

+{

+    DMXInputInfo   *dmxInput = &dmxInputs[dmxLocal->inputIdx];

+

+#if 1 /* hack to detect ctrl-alt-q, etc */

+    static int ctrl = 0, alt = 0;

+    /* keep track of ctrl/alt key status */

+    if (type == KeyPress && keySym == 0xffe3) {

+        ctrl = 1;

+    }

+    else if (type == KeyRelease && keySym == 0xffe3) {

+        ctrl = 0;

+    }

+    else if (type == KeyPress && keySym == 0xffe9) {

+        alt = 1;

+    }

+    else if (type == KeyRelease && keySym == 0xffe9) {

+        alt = 0;

+    }

+    if (!ctrl || !alt)

+        return 0;

+#else

+    unsigned short state = 0;

+

+    if (dmxLocal->sendsCore)

+        state = dmxLocalCoreKeyboard->pDevice->key->state;

+    else if (dmxLocal->pDevice->key)

+        state = dmxLocal->pDevice->key->state;

+    

+    DMXDBG3("dmxCheckFunctionKeys: keySym=0x%04x %s state=0x%04x\n",

+            keySym, type == KeyPress ? "press" : "release", state);

+

+    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask))

+        return 0;

+#endif

+

+    switch (keySym) {

+    case XK_g:

+        if (type == KeyPress)

+            dmxApplyFunctions(dmxInput, DMX_FUNCTION_GRAB);

+        return 1;

+    case XK_f:

+        if (type == KeyPress)

+            dmxApplyFunctions(dmxInput, DMX_FUNCTION_FINE);

+        return 1;

+    case XK_q:

+        if (type == KeyPress && dmxLocal->sendsCore)

+            if (dmxApplyFunctions(dmxInput, DMX_FUNCTION_TERMINATE)) {

+                dmxLog(dmxInfo, "User request for termination\n");

+                dispatchException |= DE_TERMINATE;

+            }

+        return 1;

+    }

+    

+    return 0;

+}

+

+

+DMXScreenInfo *dmxFindFirstScreen(int x, int y)

+{

+    int i;

+

+    for (i = 0; i < dmxNumScreens; i++) {

+        DMXScreenInfo *dmxScreen = &dmxScreens[i];

+        if (dmxOnScreen(x, y, dmxScreen))

+            return dmxScreen;

+    }

+    return NULL;

+}

+

+

+/**

+ * Enqueue a motion event.

+ */

+static void enqueueMotion(DevicePtr pDev, int x, int y)

+{

+    GETDMXLOCALFROMPDEV;

+    DeviceIntPtr p = dmxLocal->pDevice;

+    int i, nevents, valuators[3];

+    EventListPtr events;

+    int detail = 0;  /* XXX should this be mask of pressed buttons? */

+    ValuatorMask mask;

+    valuators[0] = x;

+    valuators[1] = y;

+

+    valuator_mask_set_range(&mask, 0, 2, valuators);

+    GetEventList(&events);

+    nevents = GetPointerEvents(events, p, MotionNotify, detail,

+                               POINTER_ABSOLUTE | POINTER_SCREEN, &mask);

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

+       mieqEnqueue(p, (InternalEvent*)(events + i)->event);

+    return;

+}

+

+

+void

+dmxCoreMotion(DevicePtr pDev, int x, int y, int delta, DMXBlockType block)

+{

+    DMXScreenInfo *dmxScreen;

+    DMXInputInfo  *dmxInput;

+    ScreenPtr     pScreen;

+    int           localX;

+    int           localY;

+    int           i;

+

+    if (!dmxGlobalInvalid && dmxGlobalX == x && dmxGlobalY == y)

+        return;

+    

+    DMXDBG5("dmxCoreMotion(%d,%d,%d) dmxGlobalX=%d dmxGlobalY=%d\n",

+            x, y, delta, dmxGlobalX, dmxGlobalY);

+

+    dmxGlobalInvalid = 0;

+    dmxGlobalX       = x;

+    dmxGlobalY       = y;

+

+    if (dmxGlobalX < 0)

+        dmxGlobalX = 0;

+    if (dmxGlobalY < 0)

+        dmxGlobalY = 0;

+    if (dmxGlobalX >= dmxGlobalWidth)

+        dmxGlobalX = dmxGlobalWidth  + delta -1;

+    if (dmxGlobalY >= dmxGlobalHeight)

+        dmxGlobalY = dmxGlobalHeight + delta -1;

+    

+    if ((dmxScreen = dmxFindFirstScreen(dmxGlobalX, dmxGlobalY))) {

+        localX = dmxGlobalX - dmxScreen->rootXOrigin;

+        localY = dmxGlobalY - dmxScreen->rootYOrigin;

+        if ((pScreen = miPointerGetScreen(inputInfo.pointer))

+            && pScreen->myNum == dmxScreen->index) {

+                                /* Screen is old screen */

+            if (block)

+                dmxSigioBlock();

+            if (pDev)

+               enqueueMotion(pDev, localX, localY);

+            if (block)

+                dmxSigioUnblock();

+        } else {

+                                /* Screen is new */

+            DMXDBG4("   New screen: old=%d new=%d localX=%d localY=%d\n",

+                    pScreen->myNum, dmxScreen->index, localX, localY);

+            if (block)

+                dmxSigioBlock();

+            mieqProcessInputEvents();

+            miPointerSetScreen(inputInfo.pointer, dmxScreen->index,

+                               localX, localY);

+            if (pDev)

+               enqueueMotion(pDev, localX, localY);

+            if (block)

+                dmxSigioUnblock();

+        }

+#if 00

+        miPointerGetPosition(inputInfo.pointer, &localX, &localY);

+

+        if ((pScreen = miPointerGetScreen(inputInfo.pointer))) {

+            dmxGlobalX = localX + dmxScreens[pScreen->myNum].rootXOrigin;

+            dmxGlobalY = localY + dmxScreens[pScreen->myNum].rootYOrigin;

+            ErrorF("Global is now %d, %d  %d, %d\n", dmxGlobalX, dmxGlobalY,

+                   localX, localY);

+            DMXDBG6("   Moved to dmxGlobalX=%d dmxGlobalY=%d"

+                    " on screen index=%d/%d localX=%d localY=%d\n",

+                    dmxGlobalX, dmxGlobalY,

+                    dmxScreen ? dmxScreen->index : -1, pScreen->myNum,

+                    localX, localY);

+        }

+#endif

+    }

+                                /* Send updates down to all core input

+                                 * drivers */

+    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++) {

+        int j;

+        for (j = 0; j < dmxInput->numDevs; j += dmxInput->devs[j]->binding)

+            if (!dmxInput->detached

+                && dmxInput->devs[j]->sendsCore

+                && dmxInput->devs[j]->update_position)

+                dmxInput->devs[j]->update_position(dmxInput->devs[j]->private,

+                                                   dmxGlobalX, dmxGlobalY);

+    }

+    if (!dmxScreen) ProcessInputEvents();

+}

+

+

+

+#define DMX_MAX_AXES 32         /* Max axes reported by this routine */

+static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,

+                         int *v, int firstAxis, int axesCount,

+                         DMXMotionType type, DMXBlockType block)

+{

+    DeviceIntPtr           pDevice = dmxLocal->pDevice;

+    xEvent                 xE[2 * DMX_MAX_AXES/6];

+    deviceKeyButtonPointer *xev    = (deviceKeyButtonPointer *)xE;

+    deviceValuator         *xv     = (deviceValuator *)xev+1;

+    int                    thisX   = 0;

+    int                    thisY   = 0;

+    int                    i;

+    int                    count;

+    EventListPtr           events;

+    int                    nevents;

+    ValuatorMask           mask;

+

+    memset(xE, 0, sizeof(xE));

+

+    if (axesCount > DMX_MAX_AXES) axesCount = DMX_MAX_AXES;

+

+    if ((valuator_get_mode(pDevice,0) == Relative) && axesCount == 2) {

+                                /* The dmx console is a relative mode

+                                 * device that sometimes reports

+                                 * absolute motion.  It only has two

+                                 * axes. */

+        if (type == DMX_RELATIVE) {

+            thisX = -v[0];

+            thisY = -v[1];

+            dmxLocal->lastX += thisX;

+            dmxLocal->lastY += thisY;

+            if (dmxLocal->update_position)

+                dmxLocal->update_position(dmxLocal->private,

+                                          dmxLocal->lastX, dmxLocal->lastY);

+        } else {                    /* Convert to relative */

+            if (dmxLocal->lastX || dmxLocal->lastY) {

+                thisX = v[0] - dmxLocal->lastX;

+                thisY = v[1] - dmxLocal->lastY;

+            }

+            dmxLocal->lastX = v[0];

+            dmxLocal->lastY = v[1];

+        }

+        v[0] = thisX;

+        v[1] = thisY;

+    }

+

+    if (axesCount <= 6) {

+                                /* Optimize for the common case when

+                                 * only 1 or 2 axes change. */

+            xev->time          = GetTimeInMillis();

+            xev->type          = DeviceMotionNotify;

+            xev->detail        = 0;

+            xev->deviceid      = pDevice->id | MORE_EVENTS;

+            

+            xv->type           = DeviceValuator;

+            xv->deviceid       = pDevice->id;

+            xv->num_valuators  = axesCount;

+            xv->first_valuator = firstAxis;

+            switch (xv->num_valuators) {

+            case 6: xv->valuator5 = v[5];

+            case 5: xv->valuator4 = v[4];

+            case 4: xv->valuator3 = v[3];

+            case 3: xv->valuator2 = v[2];

+            case 2: xv->valuator1 = v[1];

+            case 1: xv->valuator0 = v[0];

+            }

+            count              = 2;

+    } else {

+        for (i = 0, count = 0; i < axesCount; i += 6) {

+            xev->time          = GetTimeInMillis();

+            xev->type          = DeviceMotionNotify;

+            xev->detail        = 0;

+            xev->deviceid      = pDevice->id | MORE_EVENTS;

+            xev               += 2;

+            

+            xv->type           = DeviceValuator;

+            xv->deviceid       = pDevice->id;

+            xv->num_valuators  = (i+6 >= axesCount ? axesCount - i : 6);

+            xv->first_valuator = firstAxis + i;

+            switch (xv->num_valuators) {

+            case 6: xv->valuator5 = v[i+5];

+            case 5: xv->valuator4 = v[i+4];

+            case 4: xv->valuator3 = v[i+3];

+            case 3: xv->valuator2 = v[i+2];

+            case 2: xv->valuator1 = v[i+1];

+            case 1: xv->valuator0 = v[i+0];

+            }

+            xv                += 2;

+            count             += 2;

+        }

+    }

+

+    if (block)

+        dmxSigioBlock();

+    valuator_mask_set_range(&mask, firstAxis, axesCount, v);

+    GetEventList(&events);

+    nevents = GetPointerEvents(events, pDevice, MotionNotify, 0,

+                               POINTER_ABSOLUTE, &mask);

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

+        mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);

+

+    if (block)

+        dmxSigioUnblock();

+}

+

+static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,

+                                          XEvent *e, DMXBlockType block)

+{

+    int                    type;

+    int                    event   = -1;

+    XDeviceKeyEvent        *ke     = (XDeviceKeyEvent *)e;

+    XDeviceMotionEvent     *me     = (XDeviceMotionEvent *)e;

+    DeviceIntPtr           pDevice = dmxLocal->pDevice;

+    int                    valuators[MAX_VALUATORS];

+    EventListPtr           events;

+    int                    nevents, i;

+    ValuatorMask           mask;

+

+    if (!e)

+        return -1;          /* No extended event passed, cannot handle */

+

+    if ((XID)dmxLocal->deviceId != ke->deviceid) {

+                                /* Search for the correct dmxLocal,

+                                 * since backend and console events are

+                                 * picked up for the first device on

+                                 * that X server. */

+        int i;

+        DMXInputInfo *dmxInput = &dmxInputs[dmxLocal->inputIdx];

+        for (i = 0; i < dmxInput->numDevs; i++) {

+            dmxLocal = dmxInput->devs[i];

+            if ((XID)dmxLocal->deviceId == ke->deviceid)

+                break;

+        }

+    }

+

+    if ((XID)dmxLocal->deviceId != ke->deviceid

+        || (type = dmxMapLookup(dmxLocal, e->type)) < 0)

+        return -1;    /* No mapping, so this event is unhandled */

+

+    switch (type) {

+    case XI_DeviceValuator:          event = DeviceValuator;          break;

+    case XI_DeviceKeyPress:          event = KeyPress;                break;

+    case XI_DeviceKeyRelease:        event = KeyRelease;              break;

+    case XI_DeviceButtonPress:       event = ButtonPress;             break;

+    case XI_DeviceButtonRelease:     event = ButtonRelease;           break;

+    case XI_DeviceMotionNotify:      event = MotionNotify;            break;

+    case XI_DeviceFocusIn:           event = DeviceFocusIn;           break;

+    case XI_DeviceFocusOut:          event = DeviceFocusOut;          break;

+    case XI_ProximityIn:             event = ProximityIn;             break;

+    case XI_ProximityOut:            event = ProximityOut;            break;

+    case XI_DeviceStateNotify:       event = DeviceStateNotify;       break;

+    case XI_DeviceMappingNotify:     event = DeviceMappingNotify;     break;

+    case XI_ChangeDeviceNotify:      event = ChangeDeviceNotify;      break;

+    case XI_DeviceKeystateNotify:    event = DeviceStateNotify;       break;

+    case XI_DeviceButtonstateNotify: event = DeviceStateNotify;       break;

+    }

+

+#define EXTRACT_VALUATORS(ke, valuators) \

+        valuators[0] = ke->axis_data[0]; \

+        valuators[1] = ke->axis_data[1]; \

+        valuators[2] = ke->axis_data[2]; \

+        valuators[3] = ke->axis_data[3]; \

+        valuators[4] = ke->axis_data[4]; \

+        valuators[5] = ke->axis_data[5]; \

+

+    switch (type) {

+    case XI_DeviceKeyPress:

+    case XI_DeviceKeyRelease:

+        EXTRACT_VALUATORS(ke, valuators);

+        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);

+        if (block)

+            dmxSigioBlock();

+        GetEventList(&events);

+        nevents = GetKeyboardValuatorEvents(events, pDevice, event,

+                                            ke->keycode, &mask);

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

+            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);

+

+        if (block)

+            dmxSigioUnblock();

+        break;

+    case XI_DeviceButtonPress:

+    case XI_DeviceButtonRelease:

+        EXTRACT_VALUATORS(ke, valuators);

+        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);

+        if (block)

+            dmxSigioBlock();

+        GetEventList(&events);

+        nevents = GetPointerEvents(events, pDevice, event, ke->keycode,

+                                   POINTER_ABSOLUTE, &mask);

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

+            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);

+

+        if (block)

+            dmxSigioUnblock();

+        break;

+    case XI_ProximityIn:

+    case XI_ProximityOut:

+        EXTRACT_VALUATORS(ke, valuators);

+        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);

+        if (block)

+            dmxSigioBlock();

+        GetEventList(&events);

+        nevents = GetProximityEvents(events, pDevice, event, &mask);

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

+            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);

+

+        if (block)

+            dmxSigioUnblock();

+        break;

+

+        break;

+

+    case XI_DeviceMotionNotify:

+        dmxExtMotion(dmxLocal, me->axis_data, me->first_axis, me->axes_count,

+                     DMX_ABSOLUTE, block);

+        break;

+    case XI_DeviceFocusIn:

+    case XI_DeviceFocusOut:

+    case XI_DeviceStateNotify:

+    case XI_DeviceMappingNotify:

+    case XI_ChangeDeviceNotify:

+    case XI_DeviceKeystateNotify:

+    case XI_DeviceButtonstateNotify:

+                                /* These are ignored, since DMX will

+                                 * generate its own events of these

+                                 * types, as necessary.

+

+                                 * Perhaps ChangeDeviceNotify should

+                                 * generate an error, because it is

+                                 * unexpected? */

+        break;

+    case XI_DeviceValuator:

+    default:

+        dmxLog(dmxWarning,

+               "XInput extension event (remote=%d -> zero-based=%d)"

+               " not supported yet\n", e->type, type);

+        return -1;

+    }

+    return 0;

+}

+

+static int dmxGetButtonMapping(DMXLocalInputInfoPtr dmxLocal, int button)

+{

+    ButtonClassPtr b = dmxLocal->pDevice->button;

+

+    if (button > b->numButtons) { /* This shouldn't happen. */

+        dmxLog(dmxWarning, "Button %d pressed, but only %d buttons?!?\n",

+               button, b->numButtons);

+        return button;

+    }

+    return b->map[button];

+}

+

+/** Return DMX's notion of the pointer position in the global coordinate

+ * space. */

+void dmxGetGlobalPosition(int *x, int *y)

+{

+    *x = dmxGlobalX;

+    *y = dmxGlobalY;

+}

+

+/** Invalidate the global position for #dmxCoreMotion. */

+void dmxInvalidateGlobalPosition(void)

+{

+    dmxGlobalInvalid = 1;

+}

+

+/** Enqueue a motion event for \a pDev.  The \a v vector has length \a

+ * axesCount, and contains values for each of the axes, starting at \a

+ * firstAxes.

+ *

+ * The \a type of the motion may be \a DMX_RELATIVE, \a DMX_ABSOLUTE, or

+ * \a DMX_ABSOLUTE_CONFINED (in the latter case, the pointer will not be

+ * allowed to move outside the global boundaires).

+ *

+ * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be

+ * blocked around calls to \a enqueueMotion(). */

+void dmxMotion(DevicePtr pDev, int *v, int firstAxes, int axesCount,

+               DMXMotionType type, DMXBlockType block)

+{

+    GETDMXLOCALFROMPDEV;

+

+    if (!dmxLocal->sendsCore) {

+        dmxExtMotion(dmxLocal, v, firstAxes, axesCount, type, block);

+        return;

+    }

+    if (axesCount == 2) {

+        switch (type) {

+        case DMX_RELATIVE:

+            dmxCoreMotion(pDev, dmxGlobalX - v[0], dmxGlobalY - v[1], 0, block);

+            break;

+        case DMX_ABSOLUTE:

+            dmxCoreMotion(pDev, v[0], v[1], 0, block);

+            break;

+        case DMX_ABSOLUTE_CONFINED:

+            dmxCoreMotion(pDev, v[0], v[1], -1, block);

+            break;

+        }

+    }

+}

+

+static KeySym dmxKeyCodeToKeySym(DMXLocalInputInfoPtr dmxLocal,

+                                 KeyCode keyCode)

+{

+    KeySym keysym = NoSymbol;

+    int effectiveGroup;

+    XkbSrvInfoPtr xkbi;

+

+    if (!dmxLocal || !dmxLocal->pDevice || !dmxLocal->pDevice->key)

+        goto out;

+

+    xkbi = dmxLocal->pDevice->key->xkbInfo;

+    effectiveGroup = XkbGetEffectiveGroup(xkbi, &xkbi->state, keyCode);

+

+    if (effectiveGroup == -1)

+        goto out;

+

+    keysym = XkbKeySym(xkbi->desc, keyCode, effectiveGroup);

+    DMXDBG2("dmxKeyCodeToKeySym: Translated keyCode=%d to keySym=0x%04x\n",

+            keyCode, keysym);

+

+out:

+    return keysym;

+}

+

+static KeyCode dmxKeySymToKeyCode(DMXLocalInputInfoPtr dmxLocal, KeySym keySym,

+                                  int tryFirst)

+{

+    /* FIXME: this is quite ineffective, converting to a core map first and

+     * then extracting the info from there. It'd be better to run the actual

+     * xkb map */

+    XkbSrvInfoPtr xkbi = dmxLocal->pDevice->key->xkbInfo;

+    KeySymsPtr pKeySyms = XkbGetCoreMap(dmxLocal->pDevice);

+    int        i;

+

+                                /* Optimize for similar maps */

+    if (XkbKeycodeInRange(xkbi->desc, tryFirst)

+        && pKeySyms->map[(tryFirst - xkbi->desc->min_key_code)

+                         * pKeySyms->mapWidth] == keySym)

+        return tryFirst;

+

+    for (i = pKeySyms->minKeyCode; i <= pKeySyms->maxKeyCode; i++) {

+        if (pKeySyms->map[(i - pKeySyms->minKeyCode)

+                          * pKeySyms->mapWidth] == keySym) {

+            DMXDBG3("dmxKeySymToKeyCode: Translated keySym=0x%04x to"

+                    " keyCode=%d (reverses to core keySym=0x%04x)\n",

+                    keySym, i, dmxKeyCodeToKeySym(dmxLocalCoreKeyboard,i));

+            return i;

+        }

+    }

+    return 0;

+}

+

+static int dmxFixup(DevicePtr pDev, int detail, KeySym keySym)

+{

+    GETDMXLOCALFROMPDEV;

+    int keyCode;

+    

+    if (!dmxLocal->pDevice->key) {

+        dmxLog(dmxWarning, "dmxFixup: not a keyboard device (%s)\n",

+               dmxLocal->pDevice->name);

+        return NoSymbol;

+    }

+    if (!keySym)

+        keySym = dmxKeyCodeToKeySym(dmxLocal, detail);

+    if (keySym == NoSymbol)

+        return detail;

+    keyCode = dmxKeySymToKeyCode(dmxLocalCoreKeyboard, keySym, detail);

+

+    return keyCode ? keyCode : detail;

+}

+

+/** Enqueue an event from the \a pDev device with the

+ * specified \a type and \a detail.  If the event is a KeyPress or

+ * KeyRelease event, then the \a keySym is also specified.

+ *

+ * FIXME: make the code do what the comment says, or remove this comment.

+ * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be

+ * blocked around calls to dmxeqEnqueue(). */

+    

+void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,

+                XEvent *e, DMXBlockType block)

+{

+    GETDMXINPUTFROMPDEV;

+    xEvent xE;

+    DeviceIntPtr p = dmxLocal->pDevice;

+    int i, nevents, valuators[3];

+    EventListPtr events;

+    ValuatorMask mask;

+

+    DMXDBG2("dmxEnqueue: Enqueuing type=%d detail=0x%0x\n", type, detail);

+

+    switch (type) {

+    case KeyPress:

+    case KeyRelease:

+        if (!keySym)

+            keySym = dmxKeyCodeToKeySym(dmxLocal, detail);

+        if (dmxCheckFunctionKeys(dmxLocal, type, keySym))

+            return;

+        if (dmxLocal->sendsCore && dmxLocal != dmxLocalCoreKeyboard)

+            xE.u.u.detail = dmxFixup(pDev, detail, keySym);

+

+        GetEventList(&events);

+        /*ErrorF("KEY %d  sym %d\n", detail, (int) keySym);*/

+        nevents = GetKeyboardEvents(events, p, type, detail);

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

+            mieqEnqueue(p, (InternalEvent*)(events + i)->event);

+        return;

+

+    case ButtonPress:

+    case ButtonRelease:

+        detail = dmxGetButtonMapping(dmxLocal, detail);

+        valuator_mask_zero(&mask);

+        GetEventList(&events);

+        nevents = GetPointerEvents(events, p, type, detail,

+                                   POINTER_ABSOLUTE | POINTER_SCREEN, &mask);

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

+            mieqEnqueue(p, (InternalEvent*)(events + i)->event);

+        return;

+

+    case MotionNotify:

+        GetEventList(&events);

+        valuators[0] = e->xmotion.x;

+        valuators[1] = e->xmotion.y;

+        valuators[2] = e->xmotion.state; /* FIXME: WTF?? */

+        valuator_mask_set_range(&mask, 0, 3, valuators);

+        nevents = GetPointerEvents(events, p, type, detail, 

+                                   POINTER_ABSOLUTE | POINTER_SCREEN, &mask);

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

+            mieqEnqueue(p, (InternalEvent*)(events + i)->event);

+        return;

+

+    case EnterNotify:

+    case LeaveNotify:

+    case KeymapNotify:

+    case MappingNotify:         /* This is sent because we change the

+                                 * modifier map on the backend/console

+                                 * input device so that we have complete

+                                 * control of the input device LEDs. */

+        return;

+    default:

+        if (type == ProximityIn || type == ProximityOut) {

+            if (dmxLocal->sendsCore)

+                return; /* Not a core event */

+            break;

+        }

+        if (type >= LASTEvent) {

+            if (dmxTranslateAndEnqueueExtEvent(dmxLocal, e, block))

+                dmxLogInput(dmxInput, "Unhandled extension event: %d\n", type);

+        } else {

+            dmxLogInput(dmxInput, "Unhandled event: %d (%s)\n",

+                        type, dmxEventName(type));

+        }

+        return;

+    }

+

+}

+

+/** A pointer to this routine is passed to low-level input drivers so

+ * that all special keychecking is unified to this file.  This function

+ * returns 0 if no special keys have been pressed.  If the user has

+ * requested termination of the DMX server, -1 is returned.  If the user

+ * has requested a switch to a VT, then the (1-based) number of that VT

+ * is returned. */

+int dmxCheckSpecialKeys(DevicePtr pDev, KeySym keySym)

+{

+    GETDMXINPUTFROMPDEV;

+    int            vt    = 0;

+    unsigned short state = 0;

+

+    if (dmxLocal->sendsCore)

+        state = XkbStateFieldFromRec(&dmxLocalCoreKeyboard->pDevice->key->xkbInfo->state);

+    else if (dmxLocal->pDevice->key)

+        state = XkbStateFieldFromRec(&dmxLocal->pDevice->key->xkbInfo->state);

+

+    if (!dmxLocal->sendsCore) return 0; /* Only for core devices */

+

+    DMXDBG2("dmxCheckSpecialKeys: keySym=0x%04x state=0x%04x\n", keySym,state);

+    

+    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask)) return 0;

+    

+    switch (keySym) {

+    case XK_F1:

+    case XK_F2:

+    case XK_F3:

+    case XK_F4:

+    case XK_F5:

+    case XK_F6:

+    case XK_F7:

+    case XK_F8:

+    case XK_F9:

+    case XK_F10:

+        vt = keySym - XK_F1 + 1;

+        break;

+

+    case XK_F11:

+    case XK_F12:

+        vt = keySym - XK_F11 + 11;

+        break;

+

+    case XK_q:                  /* To avoid confusion  */

+    case XK_BackSpace:

+    case XK_Delete:

+    case XK_KP_Delete:

+        dmxLog(dmxInfo, "User request for termination\n");

+        dispatchException |= DE_TERMINATE;

+        return -1;              /* Terminate */

+    }

+

+    if (vt) {

+        dmxLog(dmxInfo, "Request to switch to VT %d\n", vt);

+        dmxInput->vt_switch_pending = vt;

+        return vt;

+    }

+

+    return 0;                   /* Do nothing */

+}

diff --git a/xorg-server/hw/dmx/input/dmxinputinit.c b/xorg-server/hw/dmx/input/dmxinputinit.c
index 0ea3e0953..4b10ecb17 100644
--- a/xorg-server/hw/dmx/input/dmxinputinit.c
+++ b/xorg-server/hw/dmx/input/dmxinputinit.c
@@ -476,7 +476,8 @@ static int dmxDeviceOnOff(DeviceIntPtr pDevice, int what)
                     InitValuatorAxisStruct(pDevice, i, axis_labels[i],

                                            info.minval[i], info.maxval[i],

                                            info.res[i],

-                                           info.minres[i], info.maxres[i]);

+                                           info.minres[i], info.maxres[i],

+                                           Relative);

             } else if (info.numRelAxes) {

                 InitValuatorClassDeviceStruct(pDevice, info.numRelAxes,

                                               axis_labels,

@@ -486,7 +487,8 @@ static int dmxDeviceOnOff(DeviceIntPtr pDevice, int what)
                     InitValuatorAxisStruct(pDevice, i, axis_labels[i],

                                            info.minval[i],

                                            info.maxval[i], info.res[i],

-                                           info.minres[i], info.maxres[i]);

+                                           info.minres[i], info.maxres[i],

+                                           Relative);

             } else if (info.numAbsAxes) {

                 InitValuatorClassDeviceStruct(pDevice, info.numAbsAxes,

                                               axis_labels,

@@ -497,7 +499,7 @@ static int dmxDeviceOnOff(DeviceIntPtr pDevice, int what)
                                            axis_labels[i],

                                            info.minval[i], info.maxval[i],

                                            info.res[i], info.minres[i],

-                                           info.maxres[i]);

+                                           info.maxres[i], Absolute);

             }

         }

         if (info.focusClass)       InitFocusClassDeviceStruct(pDevice);

@@ -693,7 +695,6 @@ static DeviceIntPtr dmxAddDevice(DMXLocalInputInfoPtr dmxLocal)
     DeviceIntPtr pDevice;

     Atom         atom;

     const char   *name = NULL;

-    void         (*registerProcPtr)(DeviceIntPtr)   = NULL;

     char         *devname;

     DMXInputInfo *dmxInput;

 

@@ -706,22 +707,19 @@ static DeviceIntPtr dmxAddDevice(DMXLocalInputInfoPtr dmxLocal)
             dmxLocal->isCore     = 1;

             dmxLocalCoreKeyboard = dmxLocal;

             name                 = "keyboard";

-            registerProcPtr      = RegisterKeyboardDevice;

         }

         if (dmxLocal->type == DMX_LOCAL_MOUSE && !dmxLocalCorePointer) {

             dmxLocal->isCore     = 1;

             dmxLocalCorePointer  = dmxLocal;

             name                 = "pointer";

-            registerProcPtr      = RegisterPointerDevice;

         }

     }

 

     if (!name) {

         name            = "extension";

-        registerProcPtr = RegisterOtherDevice;

     }

 

-    if (!name || !registerProcPtr)

+    if (!name)

         dmxLog(dmxFatal, "Cannot add device %s\n", dmxLocal->name);

 

     pDevice                       = AddInputDevice(serverClient, dmxDeviceOnOff, TRUE);

@@ -738,8 +736,6 @@ static DeviceIntPtr dmxAddDevice(DMXLocalInputInfoPtr dmxLocal)
     pDevice->type = atom;

     pDevice->name = devname;

 

-    registerProcPtr(pDevice);

-

     if (dmxLocal->isCore && dmxLocal->type == DMX_LOCAL_MOUSE) {

 #if 00 /*BP*/

         miRegisterPointerDevice(screenInfo.screens[0], pDevice);

diff --git a/xorg-server/hw/dmx/input/dmxmotion.c b/xorg-server/hw/dmx/input/dmxmotion.c
index d1c79f126..7a4b8a0dc 100644
--- a/xorg-server/hw/dmx/input/dmxmotion.c
+++ b/xorg-server/hw/dmx/input/dmxmotion.c
@@ -125,12 +125,11 @@ void dmxPointerPutMotionEvent(DeviceIntPtr pDevice,
                                 /* Initialize the data from the known

                                  * values (if Absolute) or to zero (if

                                  * Relative) */

-    if (pDevice->valuator->mode == Absolute) {

-        for (i = 0; i < numAxes; i++) 

+    for (i = 0; i < numAxes; i++) {

+        if (pDevice->valuator->axes[i].mode == Absolute)

             dmxLocal->history[OFFSET(dmxLocal->tail,i+1)]

                 = dmxLocal->valuators[i];

-    } else {

-        for (i = 0; i < numAxes; i++) 

+        else

             dmxLocal->history[OFFSET(dmxLocal->tail,i+1)] = 0;

     }

     

diff --git a/xorg-server/hw/dmx/input/dmxxinput.c b/xorg-server/hw/dmx/input/dmxxinput.c
index 3d5f32775..b28a80d4d 100644
--- a/xorg-server/hw/dmx/input/dmxxinput.c
+++ b/xorg-server/hw/dmx/input/dmxxinput.c
@@ -51,23 +51,6 @@
 #include "dmxinputinit.h"

 #include "exevents.h"

 

-/** Close the input device.  This is not required by the XINPUT model

- * that DMX uses. */

-void CloseInputDevice (DeviceIntPtr d, ClientPtr client)

-{

-}

-

-/** This is not required by the XINPUT model that DMX uses. */

-void AddOtherInputDevices(void)

-{

-}

-

-/** Open an input device.  This is not required by the XINPUT model that

- * DMX uses. */

-void OpenInputDevice (DeviceIntPtr dev, ClientPtr client, int *status)

-{

-}

-

 /** Set device mode to \a mode.  This is not implemented. */

 int SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)

 {