path: root/hw/dmx/input/dmxevents.c

/*
 * 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 "dmxeq.h"
#include "dmxsigio.h"
#include "dmxmap.h"

#include <X11/keysym.h>
#include "opaque.h"
#include "inputstr.h"
#include "mipointer.h"
#include "mi.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];
    unsigned short state = 0;

#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
    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;
}

static void dmxEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal, xEvent *e,
                               DMXBlockType block)
{
    xEvent                 xE[2];
    deviceKeyButtonPointer *xev      = (deviceKeyButtonPointer *)xE;
    deviceValuator         *xv       = (deviceValuator *)xev+1;
    DeviceIntPtr           pDevice   = dmxLocal->pDevice;
    DMXInputInfo           *dmxInput = &dmxInputs[dmxLocal->inputIdx];
    int                    type      = e->u.u.type;

    switch (e->u.u.type) {
    case KeyPress:
        type = DeviceKeyPress;
        break;
    case KeyRelease:
        type = DeviceKeyRelease;
        break;
    case ButtonPress:
        type = DeviceButtonPress;
        break;
    case ButtonRelease:
        type = DeviceButtonRelease;
        break;
    case MotionNotify:
        dmxLog(dmxError,
               "dmxEnqueueExtEvent: MotionNotify not allowed here\n");
        return;
    default:
        if (e->u.u.type == ProximityIn || e->u.u.type == ProximityOut)
            break;
        dmxLogInput(dmxInput,
                    "dmxEnqueueExtEvent: Unhandled %s event (%d)\n",
                    e->u.u.type >= LASTEvent ? "extension" : "non-extension",
                    e->u.u.type);
        return;
    }

    xev->type          = type;
    xev->detail        = e->u.u.detail;
    xev->deviceid      = pDevice->id | MORE_EVENTS;
    xev->time          = e->u.keyButtonPointer.time;

    xv->type           = DeviceValuator;
    xv->deviceid       = pDevice->id;
    xv->num_valuators  = 0;
    xv->first_valuator = 0;

    if (block)
        dmxSigioBlock();
    dmxeqEnqueue(pDevice, xE);
    if (block)
        dmxSigioUnblock();
}

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, 0, 2, valuators);
    for (i = 0; i < nevents; i++)
       mieqEnqueue(p, (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();
            dmxeqProcessInputEvents();
            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;

    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();
    dmxPointerPutMotionEvent(pDevice, firstAxis, axesCount, v, xev->time);
    dmxeqEnqueue(pDevice, xE);
    if (block)
        dmxSigioUnblock();
}

static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
                                          XEvent *e, DMXBlockType block)
{
    xEvent                 xE[2];
    deviceKeyButtonPointer *xev    = (deviceKeyButtonPointer *)xE;
    deviceValuator         *xv     = (deviceValuator *)xev+1;
    int                    type;
    int                    event   = -1;
    XDeviceKeyEvent        *ke     = (XDeviceKeyEvent *)e;
    XDeviceMotionEvent     *me     = (XDeviceMotionEvent *)e;
    DeviceIntPtr           pDevice = dmxLocal->pDevice;

    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 = DeviceKeyPress;          break;
    case XI_DeviceKeyRelease:        event = DeviceKeyRelease;        break;
    case XI_DeviceButtonPress:       event = DeviceButtonPress;       break;
    case XI_DeviceButtonRelease:     event = DeviceButtonRelease;     break;
    case XI_DeviceMotionNotify:      event = DeviceMotionNotify;      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;
    }

    switch (type) {
    case XI_DeviceKeyPress: 
    case XI_DeviceKeyRelease:
    case XI_DeviceButtonPress:
    case XI_DeviceButtonRelease:
    case XI_ProximityIn:
    case XI_ProximityOut:
        xev->type          = event;
        xev->detail        = ke->keycode; /* same as ->button */
        xev->deviceid      = dmxLocal->pDevice->id | MORE_EVENTS;
        xev->time          = GetTimeInMillis();

        xv->type           = DeviceValuator;
        xv->deviceid       = dmxLocal->pDevice->id;
        xv->num_valuators  = ke->axes_count;
        xv->first_valuator = ke->first_axis;
        xv->valuator0      = ke->axis_data[0];
        xv->valuator1      = ke->axis_data[1];
        xv->valuator2      = ke->axis_data[2];
        xv->valuator3      = ke->axis_data[3];
        xv->valuator4      = ke->axis_data[4];
        xv->valuator5      = ke->axis_data[5];

        if (block)
            dmxSigioBlock();
        dmxeqEnqueue(pDevice, xE);
        if (block)
            dmxSigioUnblock();
        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 #dmxeqEnqueue(). */
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)
{
    KeySymsPtr pKeySyms = NULL;

    if (!dmxLocal || !dmxLocal->pDevice || !dmxLocal->pDevice->key)
        return NoSymbol;
    pKeySyms = &dmxLocal->pDevice->key->curKeySyms;
    if (!pKeySyms)
        return NoSymbol;
    
    if (keyCode > pKeySyms->minKeyCode && keyCode <= pKeySyms->maxKeyCode) {
        DMXDBG2("dmxKeyCodeToKeySym: Translated keyCode=%d to keySym=0x%04x\n",
                keyCode,
                pKeySyms->map[(keyCode - pKeySyms->minKeyCode)
                              * pKeySyms->mapWidth]);
               
        return pKeySyms->map[(keyCode - pKeySyms->minKeyCode)
                             * pKeySyms->mapWidth];
    }
    return NoSymbol;
}

static KeyCode dmxKeySymToKeyCode(DMXLocalInputInfoPtr dmxLocal, KeySym keySym,
                                  int tryFirst)
{
    KeySymsPtr pKeySyms = &dmxLocal->pDevice->key->curKeySyms;
    int        i;

                                /* Optimize for similar maps */
    if (tryFirst >= pKeySyms->minKeyCode
        && tryFirst <= pKeySyms->maxKeyCode
        && pKeySyms->map[(tryFirst - pKeySyms->minKeyCode)
                         * 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.
 *
 * 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, (events + i)->event);
        return;

    case ButtonPress:
    case ButtonRelease:
        detail = dmxGetButtonMapping(dmxLocal, detail);
        GetEventList(&events);
        nevents = GetPointerEvents(events, p, type, detail,
                                   POINTER_ABSOLUTE,
                                   0,   /* first_valuator = 0 */
                                   0,   /* num_valuators = 0 */
                                   valuators);
        for (i = 0; i < nevents; i++)
            mieqEnqueue(p, (events + i)->event);
        return;

    case MotionNotify:
        GetEventList(&events);
        valuators[0] = e->xmotion.x;
        valuators[1] = e->xmotion.y;
        valuators[2] = e->xmotion.state;
        nevents = GetPointerEvents(events, p, type, detail, 
                                   POINTER_ABSOLUTE, 0, 3, valuators);
        for (i = 0; i < nevents; i++)
            mieqEnqueue(p, (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;
    }

#if 00 /* dead code? */
    memset(&xE, 0, sizeof(xE));
    xE.u.u.type                = type;
    xE.u.u.detail              = detail;
    xE.u.keyButtonPointer.time = GetTimeInMillis();

    if (!dmxLocal->sendsCore)
        dmxEnqueueExtEvent(dmxLocal, &xE, block);
    else
        dmxeqEnqueue(&xE);
#endif /*00*/
}

/** 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 = dmxLocalCoreKeyboard->pDevice->key->state;
    else if (dmxLocal->pDevice->key)
        state = dmxLocal->pDevice->key->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 */
}