/*
 * 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
 * This file provides generic input support.  Functions here set up
 * input and lead to the calling of low-level device drivers for
 * input. */

#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif

#define DMX_WINDOW_DEBUG 0

#include "dmxinputinit.h"
#include "dmxextension.h"       /* For dmxInputCount */

#include "dmxdummy.h"
#include "dmxbackend.h"
#include "dmxconsole.h"
#include "dmxcommon.h"
#include "dmxevents.h"
#include "dmxmotion.h"
#include "dmxprop.h"
#include "config/dmxconfig.h"
#include "dmxcursor.h"

#include "usb-keyboard.h"
#include "usb-mouse.h"
#include "usb-other.h"
#include "usb-common.h"

#include "dmxarg.h"

#include "inputstr.h"
#include "input.h"
#include "mipointer.h"
#include "windowstr.h"
#include "mi.h"
#include "xkbsrv.h"

#include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h>
#include "exevents.h"
#include "extinit.h"

DMXLocalInputInfoPtr dmxLocalCorePointer, dmxLocalCoreKeyboard;

static DMXLocalInputInfoRec DMXDummyMou = {
    "dummy-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_LOCAL, 1,
    NULL, NULL, NULL, NULL, NULL, dmxDummyMouGetInfo
};

static DMXLocalInputInfoRec DMXDummyKbd = {
    "dummy-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_LOCAL, 1,
    NULL, NULL, NULL, NULL, NULL, dmxDummyKbdGetInfo
};

static DMXLocalInputInfoRec DMXBackendMou = {
    "backend-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_BACKEND, 2,
    dmxBackendCreatePrivate, dmxBackendDestroyPrivate,
    dmxBackendInit, NULL, dmxBackendLateReInit, dmxBackendMouGetInfo,
    dmxCommonMouOn, dmxCommonMouOff, dmxBackendUpdatePosition,
    NULL, NULL, NULL,
    dmxBackendCollectEvents, dmxBackendProcessInput, dmxBackendFunctions, NULL,
    dmxCommonMouCtrl
};

static DMXLocalInputInfoRec DMXBackendKbd = {
    "backend-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_BACKEND,
    1,                          /* With backend-mou or console-mou */
    dmxCommonCopyPrivate, NULL,
    dmxBackendInit, NULL, NULL, dmxBackendKbdGetInfo,
    dmxCommonKbdOn, dmxCommonKbdOff, NULL,
    NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,
    NULL, dmxCommonKbdCtrl, dmxCommonKbdBell
};

static DMXLocalInputInfoRec DMXConsoleMou = {
    "console-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_CONSOLE, 2,
    dmxConsoleCreatePrivate, dmxConsoleDestroyPrivate,
    dmxConsoleInit, dmxConsoleReInit, NULL, dmxConsoleMouGetInfo,
    dmxCommonMouOn, dmxCommonMouOff, dmxConsoleUpdatePosition,
    NULL, NULL, NULL,
    dmxConsoleCollectEvents, NULL, dmxConsoleFunctions, dmxConsoleUpdateInfo,
    dmxCommonMouCtrl
};

static DMXLocalInputInfoRec DMXConsoleKbd = {
    "console-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_CONSOLE,
    1,                          /* With backend-mou or console-mou */
    dmxCommonCopyPrivate, NULL,
    dmxConsoleInit, dmxConsoleReInit, NULL, dmxConsoleKbdGetInfo,
    dmxCommonKbdOn, dmxCommonKbdOff, NULL,
    NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,
    NULL, dmxCommonKbdCtrl, dmxCommonKbdBell
};

static DMXLocalInputInfoRec DMXLocalDevices[] = {
    /* Dummy drivers that can compile on any OS */
#ifdef __linux__
    /* USB drivers, currently only for
       Linux, but relatively easy to port to
       other OSs */
    {
     "usb-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_LOCAL, 1,
     usbCreatePrivate, usbDestroyPrivate,
     kbdUSBInit, NULL, NULL, kbdUSBGetInfo,
     kbdUSBOn, usbOff, NULL,
     NULL, NULL, NULL,
     kbdUSBRead, NULL, NULL, NULL,
     NULL, kbdUSBCtrl},
    {
     "usb-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_LOCAL, 1,
     usbCreatePrivate, usbDestroyPrivate,
     mouUSBInit, NULL, NULL, mouUSBGetInfo,
     mouUSBOn, usbOff, NULL,
     NULL, NULL, NULL,
     mouUSBRead},
    {
     "usb-oth", DMX_LOCAL_OTHER, DMX_LOCAL_TYPE_LOCAL, 1,
     usbCreatePrivate, usbDestroyPrivate,
     othUSBInit, NULL, NULL, othUSBGetInfo,
     othUSBOn, usbOff, NULL,
     NULL, NULL, NULL,
     othUSBRead},
#endif
    {
     "dummy-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_LOCAL, 1,
     NULL, NULL, NULL, NULL, NULL, dmxDummyMouGetInfo},
    {
     "dummy-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_LOCAL, 1,
     NULL, NULL, NULL, NULL, NULL, dmxDummyKbdGetInfo},
    {NULL}                      /* Must be last */
};

#if 11 /*BP*/
    void
DDXRingBell(int volume, int pitch, int duration)
{
    /* NO-OP */
}

/* taken from kdrive/src/kinput.c: */
static void
dmxKbdCtrl(DeviceIntPtr pDevice, KeybdCtrl * ctrl)
{
#if 0
    KdKeyboardInfo *ki;

    for (ki = kdKeyboards; ki; ki = ki->next) {
        if (ki->dixdev && ki->dixdev->id == pDevice->id)
            break;
    }

    if (!ki || !ki->dixdev || ki->dixdev->id != pDevice->id || !ki->driver)
        return;

    KdSetLeds(ki, ctrl->leds);
    ki->bellPitch = ctrl->bell_pitch;
    ki->bellDuration = ctrl->bell_duration;
#endif
}

/* taken from kdrive/src/kinput.c: */
static void
dmxBell(int volume, DeviceIntPtr pDev, void *arg, int something)
{
#if 0
    KeybdCtrl *ctrl = arg;
    KdKeyboardInfo *ki = NULL;

    for (ki = kdKeyboards; ki; ki = ki->next) {
        if (ki->dixdev && ki->dixdev->id == pDev->id)
            break;
    }

    if (!ki || !ki->dixdev || ki->dixdev->id != pDev->id || !ki->driver)
        return;

    KdRingBell(ki, volume, ctrl->bell_pitch, ctrl->bell_duration);
#endif
}

#endif /*BP*/
    static void
_dmxChangePointerControl(DMXLocalInputInfoPtr dmxLocal, PtrCtrl * ctrl)
{
    if (!dmxLocal)
        return;
    dmxLocal->mctrl = *ctrl;
    if (dmxLocal->mCtrl)
        dmxLocal->mCtrl(&dmxLocal->pDevice->public, ctrl);
}

/** Change the pointer control information for the \a pDevice.  If the
 * device sends core events, then also change the control information
 * for all of the pointer devices that send core events. */
void
dmxChangePointerControl(DeviceIntPtr pDevice, PtrCtrl * ctrl)
{
    GETDMXLOCALFROMPDEVICE;
    int i, j;

    if (dmxLocal->sendsCore) {  /* Do for all core devices */
        for (i = 0; i < dmxNumInputs; i++) {
            DMXInputInfo *dmxInput = &dmxInputs[i];

            if (dmxInput->detached)
                continue;
            for (j = 0; j < dmxInput->numDevs; j++)
                if (dmxInput->devs[j]->sendsCore)
                    _dmxChangePointerControl(dmxInput->devs[j], ctrl);
        }
    }
    else {                      /* Do for this device only */
        _dmxChangePointerControl(dmxLocal, ctrl);
    }
}

static void
_dmxKeyboardKbdCtrlProc(DMXLocalInputInfoPtr dmxLocal, KeybdCtrl * ctrl)
{
    dmxLocal->kctrl = *ctrl;
    if (dmxLocal->kCtrl) {
        dmxLocal->kCtrl(&dmxLocal->pDevice->public, ctrl);
        if (dmxLocal->pDevice->kbdfeed) {
            XkbEventCauseRec cause;

            XkbSetCauseUnknown(&cause);
            /* Generate XKB events, as necessary */
            XkbUpdateIndicators(dmxLocal->pDevice, XkbAllIndicatorsMask, False,
                                NULL, &cause);
        }
    }
}

/** Change the keyboard control information for the \a pDevice.  If the
 * device sends core events, then also change the control information
 * for all of the keyboard devices that send core events. */
void
dmxKeyboardKbdCtrlProc(DeviceIntPtr pDevice, KeybdCtrl * ctrl)
{
    GETDMXLOCALFROMPDEVICE;
    int i, j;

    if (dmxLocal->sendsCore) {  /* Do for all core devices */
        for (i = 0; i < dmxNumInputs; i++) {
            DMXInputInfo *dmxInput = &dmxInputs[i];

            if (dmxInput->detached)
                continue;
            for (j = 0; j < dmxInput->numDevs; j++)
                if (dmxInput->devs[j]->sendsCore)
                    _dmxKeyboardKbdCtrlProc(dmxInput->devs[j], ctrl);
        }
    }
    else {                      /* Do for this device only */
        _dmxKeyboardKbdCtrlProc(dmxLocal, ctrl);
    }
}

static void
_dmxKeyboardBellProc(DMXLocalInputInfoPtr dmxLocal, int percent)
{
    if (dmxLocal->kBell)
        dmxLocal->kBell(&dmxLocal->pDevice->public,
                        percent,
                        dmxLocal->kctrl.bell,
                        dmxLocal->kctrl.bell_pitch,
                        dmxLocal->kctrl.bell_duration);
}

/** Sound the bell on the device.  If the device send core events, then
 * sound the bell on all of the devices that send core events. */
void
dmxKeyboardBellProc(int percent, DeviceIntPtr pDevice,
                    void *ctrl, int unknown)
{
    GETDMXLOCALFROMPDEVICE;
    int i, j;

    if (dmxLocal->sendsCore) {  /* Do for all core devices */
        for (i = 0; i < dmxNumInputs; i++) {
            DMXInputInfo *dmxInput = &dmxInputs[i];

            if (dmxInput->detached)
                continue;
            for (j = 0; j < dmxInput->numDevs; j++)
                if (dmxInput->devs[j]->sendsCore)
                    _dmxKeyboardBellProc(dmxInput->devs[j], percent);
        }
    }
    else {                      /* Do for this device only */
        _dmxKeyboardBellProc(dmxLocal, percent);
    }
}

static void
dmxKeyboardFreeNames(XkbComponentNamesPtr names)
{
    if (names->keycodes)
        XFree(names->keycodes);
    if (names->types)
        XFree(names->types);
    if (names->compat)
        XFree(names->compat);
    if (names->symbols)
        XFree(names->symbols);
    if (names->geometry)
        XFree(names->geometry);
}

static int
dmxKeyboardOn(DeviceIntPtr pDevice, DMXLocalInitInfo * info)
{
    GETDMXINPUTFROMPDEVICE;
    XkbRMLVOSet rmlvo;

    rmlvo.rules = dmxConfigGetXkbRules();
    rmlvo.model = dmxConfigGetXkbModel();
    rmlvo.layout = dmxConfigGetXkbLayout();
    rmlvo.variant = dmxConfigGetXkbVariant();
    rmlvo.options = dmxConfigGetXkbOptions();

    XkbSetRulesDflts(&rmlvo);
    if (!info->force && (dmxInput->keycodes
                         || dmxInput->symbols || dmxInput->geometry)) {
        if (info->freenames)
            dmxKeyboardFreeNames(&info->names);
        info->freenames = 0;
        info->names.keycodes = dmxInput->keycodes;
        info->names.types = NULL;
        info->names.compat = NULL;
        info->names.symbols = dmxInput->symbols;
        info->names.geometry = dmxInput->geometry;

        dmxLogInput(dmxInput, "XKEYBOARD: From command line: %s",
                    info->names.keycodes);
        if (info->names.symbols && *info->names.symbols)
            dmxLogInputCont(dmxInput, " %s", info->names.symbols);
        if (info->names.geometry && *info->names.geometry)
            dmxLogInputCont(dmxInput, " %s", info->names.geometry);
        dmxLogInputCont(dmxInput, "\n");
    }
    else if (info->names.keycodes) {
        dmxLogInput(dmxInput, "XKEYBOARD: From device: %s",
                    info->names.keycodes);
        if (info->names.symbols && *info->names.symbols)
            dmxLogInputCont(dmxInput, " %s", info->names.symbols);
        if (info->names.geometry && *info->names.geometry)
            dmxLogInputCont(dmxInput, " %s", info->names.geometry);
        dmxLogInputCont(dmxInput, "\n");
    }
    else {
        dmxLogInput(dmxInput, "XKEYBOARD: Defaults: %s %s %s %s %s\n",
                    dmxConfigGetXkbRules(),
                    dmxConfigGetXkbLayout(),
                    dmxConfigGetXkbModel(), dmxConfigGetXkbVariant()
                    ? dmxConfigGetXkbVariant() : "", dmxConfigGetXkbOptions()
                    ? dmxConfigGetXkbOptions() : "");
    }
    InitKeyboardDeviceStruct(pDevice, &rmlvo,
                             dmxKeyboardBellProc, dmxKeyboardKbdCtrlProc);

    if (info->freenames)
        dmxKeyboardFreeNames(&info->names);

    return Success;
}

static int
dmxDeviceOnOff(DeviceIntPtr pDevice, int what)
{
    GETDMXINPUTFROMPDEVICE;
    DMXLocalInitInfo info;
    int i;
    Atom btn_labels[MAX_BUTTONS] = { 0 };       /* FIXME */
    Atom axis_labels[MAX_VALUATORS] = { 0 };    /* FIXME */

    if (dmxInput->detached)
        return Success;

    memset(&info, 0, sizeof(info));
    switch (what) {
    case DEVICE_INIT:
        if (dmxLocal->init)
            dmxLocal->init(pDev);
        if (dmxLocal->get_info)
            dmxLocal->get_info(pDev, &info);
        if (info.keyboard) {    /* XKEYBOARD makes this a special case */
            dmxKeyboardOn(pDevice, &info);
            break;
        }
        if (info.keyClass) {
            XkbRMLVOSet rmlvo;

            rmlvo.rules = dmxConfigGetXkbRules();
            rmlvo.model = dmxConfigGetXkbModel();
            rmlvo.layout = dmxConfigGetXkbLayout();
            rmlvo.variant = dmxConfigGetXkbVariant();
            rmlvo.options = dmxConfigGetXkbOptions();

            InitKeyboardDeviceStruct(pDevice, &rmlvo, dmxBell, dmxKbdCtrl);
        }
        if (info.buttonClass) {
            InitButtonClassDeviceStruct(pDevice, info.numButtons,
                                        btn_labels, info.map);
        }
        if (info.valuatorClass) {
            if (info.numRelAxes && dmxLocal->sendsCore) {
                InitValuatorClassDeviceStruct(pDevice, info.numRelAxes,
                                              axis_labels,
                                              GetMaximumEventsNum(), Relative);
                for (i = 0; i < info.numRelAxes; i++)
                    InitValuatorAxisStruct(pDevice, i, axis_labels[i],
                                           info.minval[i], info.maxval[i],
                                           info.res[i],
                                           info.minres[i], info.maxres[i],
                                           Relative);
            }
            else if (info.numRelAxes) {
                InitValuatorClassDeviceStruct(pDevice, info.numRelAxes,
                                              axis_labels,
                                              dmxPointerGetMotionBufferSize(),
                                              Relative);
                for (i = 0; i < info.numRelAxes; i++)
                    InitValuatorAxisStruct(pDevice, i, axis_labels[i],
                                           info.minval[i],
                                           info.maxval[i], info.res[i],
                                           info.minres[i], info.maxres[i],
                                           Relative);
            }
            else if (info.numAbsAxes) {
                InitValuatorClassDeviceStruct(pDevice, info.numAbsAxes,
                                              axis_labels,
                                              dmxPointerGetMotionBufferSize(),
                                              Absolute);
                for (i = 0; i < info.numAbsAxes; i++)
                    InitValuatorAxisStruct(pDevice, i,
                                           axis_labels[i],
                                           info.minval[i], info.maxval[i],
                                           info.res[i], info.minres[i],
                                           info.maxres[i], Absolute);
            }
        }
        if (info.focusClass)
            InitFocusClassDeviceStruct(pDevice);
        if (info.proximityClass)
            InitProximityClassDeviceStruct(pDevice);
        if (info.ptrFeedbackClass)
            InitPtrFeedbackClassDeviceStruct(pDevice, dmxChangePointerControl);
        if (info.intFeedbackClass || info.strFeedbackClass)
            dmxLog(dmxWarning,
                   "Integer and string feedback not supported for %s\n",
                   pDevice->name);
        if (!info.keyboard && (info.ledFeedbackClass || info.belFeedbackClass))
            dmxLog(dmxWarning,
                   "Led and bel feedback not supported for non-keyboard %s\n",
                   pDevice->name);
        break;
    case DEVICE_ON:
        if (!pDev->on) {
            if (dmxLocal->on)
		dmxLocal->on(pDev);
            pDev->on = TRUE;
        }
        break;
    case DEVICE_OFF:
    case DEVICE_CLOSE:
        /* This can get called twice consecutively: once for a
         * detached screen (DEVICE_OFF), and then again at server
         * generation time (DEVICE_CLOSE). */
        if (pDev->on) {
            if (dmxLocal->off)
                dmxLocal->off(pDev);
            pDev->on = FALSE;
        }
        break;
    }
    if (info.keySyms.map && info.freemap) {
        XFree(info.keySyms.map);
        info.keySyms.map = NULL;
    }
    if (info.xkb)
        XkbFreeKeyboard(info.xkb, 0, True);
    return Success;
}

static void
dmxProcessInputEvents(DMXInputInfo * dmxInput)
{
    int i;

    mieqProcessInputEvents();
#if 00 /*BP*/
        miPointerUpdate();
#endif
    if (dmxInput->detached)
        return;
    for (i = 0; i < dmxInput->numDevs; i += dmxInput->devs[i]->binding)
        if (dmxInput->devs[i]->process_input) {
            dmxInput->devs[i]->process_input(dmxInput->devs[i]->private);
        }

#if 11 /*BP*/
        mieqProcessInputEvents();
#endif
}

static void
dmxUpdateWindowInformation(DMXInputInfo * dmxInput,
                           DMXUpdateType type, WindowPtr pWindow)
{
    int i;

#ifdef PANORAMIX
    if (!noPanoramiXExtension && pWindow &&
        pWindow->parent != screenInfo.screens[0]->root)
        return;
#endif
#if DMX_WINDOW_DEBUG
    {
        const char *name = "Unknown";

        switch (type) {
        case DMX_UPDATE_REALIZE:
            name = "Realize";
            break;
        case DMX_UPDATE_UNREALIZE:
            name = "Unrealize";
            break;
        case DMX_UPDATE_RESTACK:
            name = "Restack";
            break;
        case DMX_UPDATE_COPY:
            name = "Copy";
            break;
        case DMX_UPDATE_RESIZE:
            name = "Resize";
            break;
        case DMX_UPDATE_REPARENT:
            name = "Repaint";
            break;
        }
        dmxLog(dmxDebug, "Window %p changed: %s\n", pWindow, name);
    }
#endif

    if (dmxInput->detached)
        return;
    for (i = 0; i < dmxInput->numDevs; i += dmxInput->devs[i]->binding)
        if (dmxInput->devs[i]->update_info)
            dmxInput->devs[i]->update_info(dmxInput->devs[i]->private,
                                           type, pWindow);
}

static void
dmxCollectAll(DMXInputInfo * dmxInput)
{
    int i;

    if (dmxInput->detached)
        return;
    for (i = 0; i < dmxInput->numDevs; i += dmxInput->devs[i]->binding)
        if (dmxInput->devs[i]->collect_events)
            dmxInput->devs[i]->collect_events(&dmxInput->devs[i]->pDevice->
                                              public, dmxMotion, dmxEnqueue,
                                              dmxCheckSpecialKeys, DMX_BLOCK);
}

static void
dmxBlockHandler(void *blockData, void *timeout)
{
    DMXInputInfo *dmxInput = &dmxInputs[(uintptr_t) blockData];
    static unsigned long generation = 0;

    if (generation != serverGeneration) {
        generation = serverGeneration;
        dmxCollectAll(dmxInput);
    }
}

static void
dmxSwitchReturn(void *p)
{
    DMXInputInfo *dmxInput = p;
    int i;

    dmxLog(dmxInfo, "Returning from VT %d\n", dmxInput->vt_switched);

    if (!dmxInput->vt_switched)
        dmxLog(dmxFatal, "dmxSwitchReturn called, but not switched\n");
    for (i = 0; i < dmxInput->numDevs; i++)
        if (dmxInput->devs[i]->vt_post_switch)
            dmxInput->devs[i]->vt_post_switch(dmxInput->devs[i]->private);
    dmxInput->vt_switched = 0;
}

static void
dmxWakeupHandler(void *blockData, int result)
{
    DMXInputInfo *dmxInput = &dmxInputs[(uintptr_t) blockData];
    int i;

    if (dmxInput->vt_switch_pending) {
        dmxLog(dmxInfo, "Switching to VT %d\n", dmxInput->vt_switch_pending);
        for (i = 0; i < dmxInput->numDevs; i++)
            if (dmxInput->devs[i]->vt_pre_switch)
                dmxInput->devs[i]->vt_pre_switch(dmxInput->devs[i]->private);
        dmxInput->vt_switched = dmxInput->vt_switch_pending;
        dmxInput->vt_switch_pending = 0;
        for (i = 0; i < dmxInput->numDevs; i++) {
            if (dmxInput->devs[i]->vt_switch) {
                if (!dmxInput->devs[i]->vt_switch(dmxInput->devs[i]->private,
                                                  dmxInput->vt_switched,
                                                  dmxSwitchReturn, dmxInput))
                    dmxSwitchReturn(dmxInput);
                break;          /* Only call one vt_switch routine */
            }
        }
    }
    dmxCollectAll(dmxInput);
}

static char *
dmxMakeUniqueDeviceName(DMXLocalInputInfoPtr dmxLocal)
{
    static int k = 0;
    static int m = 0;
    static int o = 0;
    static unsigned long dmxGeneration = 0;

#define LEN  32
    char *buf = malloc(LEN);

    if (dmxGeneration != serverGeneration) {
        k = m = o = 0;
        dmxGeneration = serverGeneration;
    }

    switch (dmxLocal->type) {
    case DMX_LOCAL_KEYBOARD:
        snprintf(buf, LEN, "Keyboard%d", k++);
        break;
    case DMX_LOCAL_MOUSE:
        snprintf(buf, LEN, "Mouse%d", m++);
        break;
    default:
        snprintf(buf, LEN, "Other%d", o++);
        break;
    }

    return buf;
}

static DeviceIntPtr
dmxAddDevice(DMXLocalInputInfoPtr dmxLocal)
{
    DeviceIntPtr pDevice;
    Atom atom;
    const char *name = NULL;
    char *devname;
    DMXInputInfo *dmxInput;

    if (!dmxLocal)
        return NULL;
    dmxInput = &dmxInputs[dmxLocal->inputIdx];

    if (dmxLocal->sendsCore) {
        if (dmxLocal->type == DMX_LOCAL_KEYBOARD && !dmxLocalCoreKeyboard) {
            dmxLocal->isCore = 1;
            dmxLocalCoreKeyboard = dmxLocal;
            name = "keyboard";
        }
        if (dmxLocal->type == DMX_LOCAL_MOUSE && !dmxLocalCorePointer) {
            dmxLocal->isCore = 1;
            dmxLocalCorePointer = dmxLocal;
            name = "pointer";
        }
    }

    if (!name) {
        name = "extension";
    }

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

    pDevice = AddInputDevice(serverClient, dmxDeviceOnOff, TRUE);
    if (!pDevice) {
        dmxLog(dmxError, "Too many devices -- cannot add device %s\n",
               dmxLocal->name);
        return NULL;
    }
    pDevice->public.devicePrivate = dmxLocal;
    dmxLocal->pDevice = pDevice;

    devname = dmxMakeUniqueDeviceName(dmxLocal);
    atom = MakeAtom((char *) devname, strlen(devname), TRUE);
    pDevice->type = atom;
    pDevice->name = devname;

    if (dmxLocal->isCore && dmxLocal->type == DMX_LOCAL_MOUSE) {
#if 00   /*BP*/
            miRegisterPointerDevice(screenInfo.screens[0], pDevice);
#else
        /* Nothing? dmxDeviceOnOff() should get called to init, right? */
#endif
    }

    if (dmxLocal->create_private)
        dmxLocal->private = dmxLocal->create_private(pDevice);

    dmxLogInput(dmxInput, "Added %s as %s device called %s%s\n",
                dmxLocal->name, name, devname,
                dmxLocal->isCore
                ? " [core]"
                : (dmxLocal->sendsCore ? " [sends core events]" : ""));

    return pDevice;
}

static DMXLocalInputInfoPtr
dmxLookupLocal(const char *name)
{
    DMXLocalInputInfoPtr pt;

    for (pt = &DMXLocalDevices[0]; pt->name; ++pt)
        if (!strcmp(pt->name, name))
            return pt;          /* search for device name */
    return NULL;
}

/** Copy the local input information from \a s into a new \a devs slot
 * in \a dmxInput. */
DMXLocalInputInfoPtr
dmxInputCopyLocal(DMXInputInfo * dmxInput, DMXLocalInputInfoPtr s)
{
    DMXLocalInputInfoPtr dmxLocal = malloc(sizeof(*dmxLocal));

    if (!dmxLocal)
        dmxLog(dmxFatal, "DMXLocalInputInfoPtr: out of memory\n");

    memcpy(dmxLocal, s, sizeof(*dmxLocal));
    dmxLocal->inputIdx = dmxInput->inputIdx;
    dmxLocal->sendsCore = dmxInput->core;
    dmxLocal->savedSendsCore = dmxInput->core;
    dmxLocal->deviceId = -1;

    ++dmxInput->numDevs;
    dmxInput->devs = reallocarray(dmxInput->devs,
                                  dmxInput->numDevs, sizeof(*dmxInput->devs));
    dmxInput->devs[dmxInput->numDevs - 1] = dmxLocal;

    return dmxLocal;
}

static void
dmxPopulateLocal(DMXInputInfo * dmxInput, dmxArg a)
{
    int i;
    int help = 0;
    DMXLocalInputInfoRec *pt;

    for (i = 1; i < dmxArgC(a); i++) {
        const char *name = dmxArgV(a, i);

        if ((pt = dmxLookupLocal(name))) {
            dmxInputCopyLocal(dmxInput, pt);
        }
        else {
            if (strlen(name))
                dmxLog(dmxWarning, "Could not find a driver called %s\n", name);
            ++help;
        }
    }
    if (help) {
        dmxLog(dmxInfo, "Available local device drivers:\n");
        for (pt = &DMXLocalDevices[0]; pt->name; ++pt) {
            const char *type;

            switch (pt->type) {
            case DMX_LOCAL_KEYBOARD:
                type = "keyboard";
                break;
            case DMX_LOCAL_MOUSE:
                type = "pointer";
                break;
            default:
                type = "unknown";
                break;
            }
            dmxLog(dmxInfo, "   %s (%s)\n", pt->name, type);
        }
        dmxLog(dmxFatal, "Must have valid local device driver\n");
    }
}

int
dmxInputExtensionErrorHandler(Display * dsp, _Xconst char *name,
                              _Xconst char *reason)
{
    return 0;
}

static void
dmxInputScanForExtensions(DMXInputInfo * dmxInput, int doXI)
{
    XExtensionVersion *ext;
    XDeviceInfo *devices;
    Display *dsp;
    int num;
    int i, j;
    XextErrorHandler handler;

    if (!(dsp = XOpenDisplay(dmxInput->name)))
        return;

    /* Print out information about the XInput Extension. */
    handler = XSetExtensionErrorHandler(dmxInputExtensionErrorHandler);
    ext = XGetExtensionVersion(dsp, INAME);
    XSetExtensionErrorHandler(handler);

    if (!ext || ext == (XExtensionVersion *) NoSuchExtension) {
        dmxLogInput(dmxInput, "%s is not available\n", INAME);
    }
    else {
        dmxLogInput(dmxInput, "Locating devices on %s (%s version %d.%d)\n",
                    dmxInput->name, INAME,
                    ext->major_version, ext->minor_version);
        devices = XListInputDevices(dsp, &num);

        XFree(ext);
        ext = NULL;

        /* Print a list of all devices */
        for (i = 0; i < num; i++) {
            const char *use = "Unknown";

            switch (devices[i].use) {
            case IsXPointer:
                use = "XPointer";
                break;
            case IsXKeyboard:
                use = "XKeyboard";
                break;
            case IsXExtensionDevice:
                use = "XExtensionDevice";
                break;
            case IsXExtensionPointer:
                use = "XExtensionPointer";
                break;
            case IsXExtensionKeyboard:
                use = "XExtensionKeyboard";
                break;
            }
            dmxLogInput(dmxInput, "  %2d %-10.10s %-16.16s\n",
                        (int) devices[i].id,
                        devices[i].name ? devices[i].name : "", use);
        }

        /* Search for extensions */
        for (i = 0; i < num; i++) {
            switch (devices[i].use) {
            case IsXKeyboard:
                for (j = 0; j < dmxInput->numDevs; j++) {
                    DMXLocalInputInfoPtr dmxL = dmxInput->devs[j];

                    if (dmxL->type == DMX_LOCAL_KEYBOARD && dmxL->deviceId < 0) {
                        dmxL->deviceId = devices[i].id;
                        dmxL->deviceName = (devices[i].name
                                            ? strdup(devices[i].name)
                                            : NULL);
                    }
                }
                break;
            case IsXPointer:
                for (j = 0; j < dmxInput->numDevs; j++) {
                    DMXLocalInputInfoPtr dmxL = dmxInput->devs[j];

                    if (dmxL->type == DMX_LOCAL_MOUSE && dmxL->deviceId < 0) {
                        dmxL->deviceId = devices[i].id;
                        dmxL->deviceName = (devices[i].name
                                            ? xstrdup(devices[i].name)
                                            : NULL);
                    }
                }
                break;
            }
        }
        XFreeDeviceList(devices);
    }
    XCloseDisplay(dsp);
}

/** Re-initialize all the devices described in \a dmxInput.  Called from
    #dmxAdjustCursorBoundaries before the cursor is redisplayed. */
void
dmxInputReInit(DMXInputInfo * dmxInput)
{
    int i;

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

        if (dmxLocal->reinit)
            dmxLocal->reinit(&dmxLocal->pDevice->public);
    }
}

/** Re-initialize all the devices described in \a dmxInput.  Called from
    #dmxAdjustCursorBoundaries after the cursor is redisplayed. */
void
dmxInputLateReInit(DMXInputInfo * dmxInput)
{
    int i;

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

        if (dmxLocal->latereinit)
            dmxLocal->latereinit(&dmxLocal->pDevice->public);
    }
}

/** Initialize all of the devices described in \a dmxInput. */
void
dmxInputInit(DMXInputInfo * dmxInput)
{
    dmxArg a;
    const char *name;
    int i;
    int doXI = 1;               /* Include by default */
    int forceConsole = 0;
    int doWindows = 1;          /* On by default */
    int hasXkb = 0;

    a = dmxArgParse(dmxInput->name);

    name = dmxArgV(a, 0);

    if (!strcmp(name, "local")) {
        dmxPopulateLocal(dmxInput, a);
    }
    else if (!strcmp(name, "dummy")) {
        dmxInputCopyLocal(dmxInput, &DMXDummyMou);
        dmxInputCopyLocal(dmxInput, &DMXDummyKbd);
        dmxLogInput(dmxInput, "Using dummy input\n");
    }
    else {
        int found;

        for (i = 1; i < dmxArgC(a); i++) {
            switch (hasXkb) {
            case 1:
                dmxInput->keycodes = xstrdup(dmxArgV(a, i));
                ++hasXkb;
                break;
            case 2:
                dmxInput->symbols = xstrdup(dmxArgV(a, i));
                ++hasXkb;
                break;
            case 3:
                dmxInput->geometry = xstrdup(dmxArgV(a, i));
                hasXkb = 0;
                break;
            case 0:
                if (!strcmp(dmxArgV(a, i), "noxi"))
                    doXI = 0;
                else if (!strcmp(dmxArgV(a, i), "xi"))
                    doXI = 1;
                else if (!strcmp(dmxArgV(a, i), "console"))
                    forceConsole = 1;
                else if (!strcmp(dmxArgV(a, i), "noconsole"))
                    forceConsole = 0;
                else if (!strcmp(dmxArgV(a, i), "windows"))
                    doWindows = 1;
                else if (!strcmp(dmxArgV(a, i), "nowindows"))
                    doWindows = 0;
                else if (!strcmp(dmxArgV(a, i), "xkb"))
                    hasXkb = 1;
                else {
                    dmxLog(dmxFatal, "Unknown input argument: %s\n", dmxArgV(a, i));
                }
            }
        }

        for (found = 0, i = 0; i < dmxNumScreens; i++) {
            if (dmxPropertySameDisplay(&dmxScreens[i], name)) {
                if (dmxScreens[i].shared)
                    dmxLog(dmxFatal,
                           "Cannot take input from shared backend (%s)\n",
                           name);
                if (!dmxInput->core) {
                    dmxLog(dmxWarning,
                           "Cannot use core devices on a backend (%s)"
                           " as XInput devices\n", name);
                }
                else {
                    char *pt;

                    for (pt = (char *) dmxInput->name; pt && *pt; pt++)
                        if (*pt == ',')
                            *pt = '\0';
                    dmxInputCopyLocal(dmxInput, &DMXBackendMou);
                    dmxInputCopyLocal(dmxInput, &DMXBackendKbd);
                    dmxInput->scrnIdx = i;
                    dmxLogInput(dmxInput,
                                "Using backend input from %s\n", name);
                }
                ++found;
                break;
            }
        }
        if (!found || forceConsole) {
            char *pt;

            if (found)
                dmxInput->console = TRUE;
            for (pt = (char *) dmxInput->name; pt && *pt; pt++)
                if (*pt == ',')
                    *pt = '\0';
            dmxInputCopyLocal(dmxInput, &DMXConsoleMou);
            dmxInputCopyLocal(dmxInput, &DMXConsoleKbd);
            if (doWindows) {
                dmxInput->windows = TRUE;
                dmxInput->updateWindowInfo = dmxUpdateWindowInformation;
            }
            dmxLogInput(dmxInput,
                        "Using console input from %s (%s windows)\n",
                        name, doWindows ? "with" : "without");
        }
    }

    dmxArgFree(a);

    /* Locate extensions we may be interested in */
    dmxInputScanForExtensions(dmxInput, doXI);

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

        dmxLocal->pDevice = dmxAddDevice(dmxLocal);
    }

    dmxInput->processInputEvents = dmxProcessInputEvents;
    dmxInput->detached = False;

    RegisterBlockAndWakeupHandlers(dmxBlockHandler, dmxWakeupHandler,
                                   (void *) (uintptr_t) dmxInput->inputIdx);
}

static void
dmxInputFreeLocal(DMXLocalInputInfoRec * local)
{
    if (!local)
        return;
    if (local->isCore && local->type == DMX_LOCAL_MOUSE)
        dmxLocalCorePointer = NULL;
    if (local->isCore && local->type == DMX_LOCAL_KEYBOARD)
        dmxLocalCoreKeyboard = NULL;
    if (local->destroy_private)
        local->destroy_private(local->private);
    free(local->history);
    free(local->valuators);
    free((void *) local->deviceName);
    local->private = NULL;
    local->history = NULL;
    local->deviceName = NULL;
    free(local);
}

/** Free all of the memory associated with \a dmxInput */
void
dmxInputFree(DMXInputInfo * dmxInput)
{
    int i;

    if (!dmxInput)
        return;

    free(dmxInput->keycodes);
    free(dmxInput->symbols);
    free(dmxInput->geometry);

    for (i = 0; i < dmxInput->numDevs; i++) {
        dmxInputFreeLocal(dmxInput->devs[i]);
        dmxInput->devs[i] = NULL;
    }
    free(dmxInput->devs);
    dmxInput->devs = NULL;
    dmxInput->numDevs = 0;
    if (dmxInput->freename)
        free((void *) dmxInput->name);
    dmxInput->name = NULL;
}

/** Log information about all of the known devices using #dmxLog(). */
void
dmxInputLogDevices(void)
{
    int i, j;

    dmxLog(dmxInfo, "%d devices:\n", dmxGetInputCount());
    dmxLog(dmxInfo, "  Id  Name                 Classes\n");
    for (j = 0; j < dmxNumInputs; j++) {
        DMXInputInfo *dmxInput = &dmxInputs[j];
        const char *pt = strchr(dmxInput->name, ',');
        int len = (pt ? (size_t) (pt - dmxInput->name)
                   : strlen(dmxInput->name));

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

            if (pDevice) {
                dmxLog(dmxInfo, "  %2d%c %-20.20s",
                       pDevice->id,
                       dmxInput->detached ? 'D' : ' ', pDevice->name);
                if (pDevice->key)
                    dmxLogCont(dmxInfo, " key");
                if (pDevice->valuator)
                    dmxLogCont(dmxInfo, " val");
                if (pDevice->button)
                    dmxLogCont(dmxInfo, " btn");
                if (pDevice->focus)
                    dmxLogCont(dmxInfo, " foc");
                if (pDevice->kbdfeed)
                    dmxLogCont(dmxInfo, " fb/kbd");
                if (pDevice->ptrfeed)
                    dmxLogCont(dmxInfo, " fb/ptr");
                if (pDevice->intfeed)
                    dmxLogCont(dmxInfo, " fb/int");
                if (pDevice->stringfeed)
                    dmxLogCont(dmxInfo, " fb/str");
                if (pDevice->bell)
                    dmxLogCont(dmxInfo, " fb/bel");
                if (pDevice->leds)
                    dmxLogCont(dmxInfo, " fb/led");
                if (!pDevice->key && !pDevice->valuator && !pDevice->button
                    && !pDevice->focus && !pDevice->kbdfeed
                    && !pDevice->ptrfeed && !pDevice->intfeed
                    && !pDevice->stringfeed && !pDevice->bell && !pDevice->leds)
                    dmxLogCont(dmxInfo, " (none)");

                dmxLogCont(dmxInfo, "\t[i%d/%*.*s",
                           dmxInput->inputIdx, len, len, dmxInput->name);
                if (dmxInput->devs[i]->deviceId >= 0)
                    dmxLogCont(dmxInfo, "/id%d", (int) dmxInput->devs[i]->deviceId);
                if (dmxInput->devs[i]->deviceName)
                    dmxLogCont(dmxInfo, "=%s", dmxInput->devs[i]->deviceName);
                dmxLogCont(dmxInfo, "] %s\n",
                           dmxInput->devs[i]->isCore
                           ? "core"
                           : (dmxInput->devs[i]->sendsCore
                              ? "extension (sends core events)" : "extension"));
            }
        }
    }
}

/** Detach an input */
int
dmxInputDetach(DMXInputInfo * dmxInput)
{
    int i;

    if (dmxInput->detached)
        return BadAccess;

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

        dmxLogInput(dmxInput, "Detaching device id %d: %s%s\n",
                    dmxLocal->pDevice->id,
                    dmxLocal->pDevice->name,
                    dmxLocal->isCore
                    ? " [core]"
                    : (dmxLocal->sendsCore ? " [sends core events]" : ""));
        DisableDevice(dmxLocal->pDevice, TRUE);
    }
    dmxInput->detached = True;
    dmxInputLogDevices();
    return 0;
}

/** Search for input associated with \a dmxScreen, and detach. */
void
dmxInputDetachAll(DMXScreenInfo * dmxScreen)
{
    int i;

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

        if (dmxInput->scrnIdx == dmxScreen->index)
            dmxInputDetach(dmxInput);
    }
}

/** Search for input associated with \a deviceId, and detach. */
int
dmxInputDetachId(int id)
{
    DMXInputInfo *dmxInput = dmxInputLocateId(id);

    if (!dmxInput)
        return BadValue;

    return dmxInputDetach(dmxInput);
}

DMXInputInfo *
dmxInputLocateId(int id)
{
    int i, j;

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

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

            if (dmxLocal->pDevice->id == id)
                return dmxInput;
        }
    }
    return NULL;
}

static int
dmxInputAttachNew(DMXInputInfo * dmxInput, int *id)
{
    dmxInputInit(dmxInput);
    InitAndStartDevices();
    if (id && dmxInput->devs)
        *id = dmxInput->devs[0]->pDevice->id;
    dmxInputLogDevices();
    return 0;
}

static int
dmxInputAttachOld(DMXInputInfo * dmxInput, int *id)
{
    int i;

    dmxInput->detached = False;
    for (i = 0; i < dmxInput->numDevs; i++) {
        DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[i];

        if (id)
            *id = dmxLocal->pDevice->id;
        dmxLogInput(dmxInput,
                    "Attaching device id %d: %s%s\n",
                    dmxLocal->pDevice->id,
                    dmxLocal->pDevice->name,
                    dmxLocal->isCore
                    ? " [core]"
                    : (dmxLocal->sendsCore ? " [sends core events]" : ""));
        EnableDevice(dmxLocal->pDevice, TRUE);
    }
    dmxInputLogDevices();
    return 0;
}

int
dmxInputAttachConsole(const char *name, int isCore, int *id)
{
    DMXInputInfo *dmxInput;
    int i;

    for (i = 0; i < dmxNumInputs; i++) {
        dmxInput = &dmxInputs[i];
        if (dmxInput->scrnIdx == -1
            && dmxInput->detached && !strcmp(dmxInput->name, name)) {
            /* Found match */
            dmxLogInput(dmxInput, "Reattaching detached console input\n");
            return dmxInputAttachOld(dmxInput, id);
        }
    }

    /* No match found */
    dmxInput = dmxConfigAddInput(xstrdup(name), isCore);
    dmxInput->freename = TRUE;
    dmxLogInput(dmxInput, "Attaching new console input\n");
    return dmxInputAttachNew(dmxInput, id);
}

int
dmxInputAttachBackend(int physicalScreen, int isCore, int *id)
{
    DMXInputInfo *dmxInput;
    DMXScreenInfo *dmxScreen;
    int i;

    if (physicalScreen < 0 || physicalScreen >= dmxNumScreens)
        return BadValue;
    for (i = 0; i < dmxNumInputs; i++) {
        dmxInput = &dmxInputs[i];
        if (dmxInput->scrnIdx != -1 && dmxInput->scrnIdx == physicalScreen) {
            /* Found match */
            if (!dmxInput->detached)
                return BadAccess;       /* Already attached */
            dmxScreen = &dmxScreens[physicalScreen];
            if (!dmxScreen->beDisplay)
                return BadAccess;       /* Screen detached */
            dmxLogInput(dmxInput, "Reattaching detached backend input\n");
            return dmxInputAttachOld(dmxInput, id);
        }
    }
    /* No match found */
    dmxScreen = &dmxScreens[physicalScreen];
    if (!dmxScreen->beDisplay)
        return BadAccess;       /* Screen detached */
    dmxInput = dmxConfigAddInput(dmxScreen->name, isCore);
    dmxLogInput(dmxInput, "Attaching new backend input\n");
    return dmxInputAttachNew(dmxInput, id);
}
