path: root/xc/programs/Xserver/hw/dmx/input/dmxbackend.c

/* $XFree86$ */
/*
 * Copyright 2001,2002 Red Hat Inc., Durham, North Carolina.
 *
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation on the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*
 * Authors:
 *   David H. Dawes <dawes@xfree86.org>
 *   Kevin E. Martin <kem@redhat.com>
 *   Rickard E. (Rik) Faith <faith@redhat.com>
 */

#define DMX_BACKEND_DEBUG 0

/* Core devices on the back end X server -- like Xnest. */

#include "inputstr.h"
#include "input.h"
#include "keysym.h"
#include "mipointer.h"
#include "mi.h"
#include "scrnintstr.h"

#include "dmxinputinit.h"
#include "dmxevents.h"
#include "dmxbackend.h"
#include "dmxcommon.h"
#include "dmxcursor.h"
#include "dmxprop.h"

#include "globals.h"

#include "XInput.h"

typedef struct _myPrivate {
    DMX_COMMON_PRIVATE;
    int                     myScreen;
    
    int                     lastX;
    int                     lastY;
    int                     screen;
} myPrivate;

pointer dmxBackendCreatePrivate(DMXInputInfo *dmxInput)
{
    myPrivate *priv = xalloc(sizeof(*priv));
    memset(priv, 0, sizeof(*priv));
    priv->dmxInput  = dmxInput;
    return priv;
}

void dmxBackendDestroyPrivate(pointer private)
{
    if (private) xfree(private);
}

static void *dmxBackendTestScreen(DMXScreenInfo *dmxScreen, void *closure)
{
    int target = (int)closure;

    if (dmxScreen->index == target) return dmxScreen;
    return NULL;
}

/* Return non-zero if priv->screen and priv->myScreen are on the same
 * physical backend display. */
static int dmxBackendSameDisplay(myPrivate *priv)
{
    DMXScreenInfo *dmxScreen;

    if (priv->screen == priv->myScreen) return 1;
    if (priv->screen < 0 || priv->screen >= dmxNumScreens) return 0;
    if ((dmxScreen = dmxPropertyIterate(priv->backendScreen,
                                        dmxBackendTestScreen,
                                        (void *)priv->screen))) {
        return 1;
    }
    return 0;
}

static void *dmxBackendTestEvents(DMXScreenInfo *dmxScreen, void *closure)
{
    if (XPending(dmxScreen->display)) return dmxScreen;
    return NULL;
}

static void *dmxBackendTestMotionEvent(DMXScreenInfo *dmxScreen, void *closure)
{
    XEvent N;
    
    if (XPending(dmxScreen->display)) {
        XPeekEvent(dmxScreen->display, &N);
        if (N.type == MotionNotify) return dmxScreen;
    }
    return NULL;
}

static DMXScreenInfo *dmxBackendGetEvent(myPrivate *priv, XEvent *X)
{
    DMXScreenInfo *dmxScreen;

    if ((dmxScreen = dmxPropertyIterate(priv->backendScreen,
                                        dmxBackendTestEvents, NULL))) {
        XNextEvent(dmxScreen->display, X);
        return dmxScreen;
    }
    return NULL;
}

static DMXScreenInfo *dmxBackendPendingMotionEvent(myPrivate *priv)
{
    DMXScreenInfo *dmxScreen;

    if ((dmxScreen = dmxPropertyIterate(priv->backendScreen,
                                        dmxBackendTestMotionEvent, NULL))) {
            return dmxScreen;
    }
    return NULL;
}

static void *dmxBackendTestWindow(DMXScreenInfo *dmxScreen, void *closure)
{
    Window win = (Window)closure;
    if (dmxScreen->window == win) return dmxScreen;
    return NULL;
}

static DMXScreenInfo *dmxBackendFindWindow(myPrivate *priv, Window win)
{
    return dmxPropertyIterate(priv->backendScreen,
                              dmxBackendTestWindow, (void *)win);
}

/* This routine is called from dmxAbsoluteMotion for each motion event. */
void dmxBackendUpdatePosition(pointer private, int x, int y)
{
    GETONLYPRIVFROMPRIVATE;
    int           screen;
    DMXScreenInfo *dmxScreen;

#if DMX_BACKEND_DEBUG
    dmxLog(dmxDebug, "dmxBackendUpdatePosition(,%d,%d)\n", x, y);
#endif
    if (priv->screen != (screen = miPointerCurrentScreen()->myNum)) {
#if DMX_BACKEND_DEBUG
        dmxLog(dmxDebug,
               "dmxBackendUpdatePostion: Moved from screen %d to %d\n",
               priv->screen, screen);
#endif
        priv->screen = screen;
        dmxScreen    = &dmxScreens[priv->screen];

        if (dmxBackendSameDisplay(priv)) {
            priv->myScreen = priv->screen;
        } else {
            priv->lastX = priv->width / 2;
            priv->lastY = priv->height / 2;
            XWarpPointer(priv->display, None, priv->window,
                         0, 0, 0, 0, priv->lastX, priv->lastY);
            XSync(priv->display, False);
        }
    }
}

void dmxBackendCollectEvents(pointer private)
{
    GETPRIVFROMPRIVATE;
    XEvent        X;
    DMXScreenInfo *dmxScreen;
    int           enterred = 0;
    int           left     = 0;

    while ((dmxScreen = dmxBackendGetEvent(priv, &X))) {
	switch (X.type) {
        case EnterNotify:
            if (enterred++) continue;
#if DMX_BACKEND_DEBUG
            dmxLog(dmxDebug,
                   "dmxBackendCollectEvents: Enter %lu\n", dmxScreen->window);
#endif
            XRaiseWindow(dmxScreen->display, dmxScreen->window);
            XGrabPointer(dmxScreen->display, dmxScreen->window,
                         True, 0, GrabModeAsync, GrabModeAsync, None,
                         None, CurrentTime);
            break;
        case LeaveNotify:
            if (left++) continue;
#if DMX_BACKEND_DEBUG
            dmxLog(dmxDebug,
                   "dmxBackendCollectEvents: Leave %lu\n", dmxScreen->window);
#endif
            XUngrabPointer(dmxScreen->display, CurrentTime);
            break;
	case MotionNotify:
#if DMX_BACKEND_DEBUG
            dmxLog(dmxDebug,
                   "dmxBackendCollectEvents: MotionNotify from screen %d:"
                   " %d %d win=%lu/%lu\n",
                   dmxScreen->index, X.xmotion.x, X.xmotion.y,
                   X.xmotion.window, dmxScreen->window);
#endif

            if (dmxBackendPendingMotionEvent(priv)) continue;
            if (!(dmxScreen = dmxBackendFindWindow(priv, X.xmotion.window)))
                dmxLog(dmxFatal,
                       "Event on non-existant window %lu\n", X.xmotion.window);
            if (priv->screen == priv->myScreen) {
                int newX = X.xmotion.x;
                int newY = X.xmotion.y;

                if (!newX)                    newX = -1;
                if (newX == priv->width - 1)  newX = priv->width;
                if (!newY)                    newY = -1;
                if (newY == priv->height - 1) newY = priv->height;
                dmxAbsoluteMotion(dmxScreen->originX + newX,
                                  dmxScreen->originY + newY);
            } else {
                dmxRelativeMotion(dmxScreen->originX
                                  + priv->lastX - X.xmotion.x,
                                  dmxScreen->originY
                                  + priv->lastY - X.xmotion.y);
                priv->lastX = X.xmotion.x;
                priv->lastY = X.xmotion.y;
            }
	    break;

	default:
            dmxEnqueueXEvent(dmxInput, &X);
	    break;
	}
    }
}

void dmxBackendProcessInput(pointer private)
{
    GETONLYPRIVFROMPRIVATE;

    if (!dmxBackendSameDisplay(priv)
        && (priv->lastX != priv->width / 2
            || priv->lastY != priv->height / 2)) {
	priv->lastX = priv->width / 2;
	priv->lastY = priv->height / 2;
        XWarpPointer(priv->display, None, priv->window,
                     0, 0, 0, 0, priv->lastX, priv->lastY);
        XSync(priv->display, False);
    }
}

void dmxBackendInitialize(pointer private)
{
    GETPRIVFROMPRIVATE;
    XExtensionVersion *ext;
    XDeviceInfo       *devices;
    DMXScreenInfo     *dmxScreen;
    int               num;
    int               i;

    /* Fill in myPrivate */
    for (i = 0,dmxScreen = &dmxScreens[0]; i<dmxNumScreens; i++,dmxScreen++) {
        if (!strcmp(dmxInput->name, dmxScreen->name)) {
            priv->display            = dmxScreen->display;
            priv->window             = dmxScreen->window;
            priv->width              = dmxScreen->width;
            priv->height             = dmxScreen->height;
            priv->backendScreen      = dmxScreen;
            break;
        }
    }
    if (i >= dmxNumScreens)
        dmxLog(dmxFatal,
               "%s is not an existing backend display - cannot initialize\n",
               dmxInput->name);

    /* Finish dmxInput initialization using computed values or constants. */
    priv->initPointerX       = priv->width / 2;
    priv->initPointerY       = priv->height / 2;
    priv->eventMask          = (EnterWindowMask|LeaveWindowMask);
    priv->myScreen           = dmxScreen->index;
    priv->lastX              = priv->width / 2; /* FIXME? put cursor here? */
    priv->lastY              = priv->height / 2;
    priv->screen             = priv->myScreen;

    /* Print out information about the XInput Extension. */
    ext = XGetExtensionVersion(priv->display, INAME);
    if (ext && ext != (XExtensionVersion *)NoSuchExtension) {
        dmxLogInput(dmxInput, "%s version %d.%d\n",
                    INAME, ext->major_version, ext->minor_version);
        devices = XListInputDevices(priv->display, &num);
        if (num)
            dmxLogInput(dmxInput, "Extended devices:\n");
        for (i = 0; i < num; i++) {
            const char *kind = "Unknown";
            switch (devices[i].use) {
            case IsXPointer:         kind = "XPointer";         break;
            case IsXKeyboard:        kind = "XKeyboard";        break;
            case IsXExtensionDevice: kind = "XExtensionDevice"; break;
            }
            dmxLogInput(dmxInput, "  \"%s\": %s\n",
                        devices[i].name ? devices[i].name : "<noname>", kind);
        }
        XFreeDeviceList(devices);
    }
}

int dmxBackendFunctions(pointer private, DMXFunctionType function)
{
    switch (function) {
    case DMX_FUNCTION_TERMINATE:
        return 1;
    default:
        return 0;
    }
}