svn merge -r588:HEAD ^/branches/released .

1 files changed, 985 insertions, 985 deletions

diff --git a/xorg-server/hw/dmx/dmxcursor.c b/xorg-server/hw/dmx/dmxcursor.c
index 37e66d758..2d0243343 100644
--- a/xorg-server/hw/dmx/dmxcursor.c
+++ b/xorg-server/hw/dmx/dmxcursor.c
@@ -1,985 +1,985 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   David H. Dawes <dawes@xfree86.org>
- *   Kevin E. Martin <kem@redhat.com>
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- * This file contains code than supports cursor movement, including the
- * code that initializes and reinitializes the screen positions and
- * computes screen overlap.
- *
- * "This code is based very closely on the XFree86 equivalent
- * (xfree86/common/xf86Cursor.c)."  --David Dawes.
- *
- * "This code was then extensively re-written, as explained here."
- * --Rik Faith
- *
- * The code in xf86Cursor.c used edge lists to implement the
- * CursorOffScreen function.  The edge list computation was complex
- * (especially in the face of arbitrarily overlapping screens) compared
- * with the speed savings in the CursorOffScreen function.  The new
- * implementation has erred on the side of correctness, readability, and
- * maintainability over efficiency.  For the common (non-edge) case, the
- * dmxCursorOffScreen function does avoid a loop over all the screens.
- * When the cursor has left the screen, all the screens are searched,
- * and the first screen (in dmxScreens order) containing the cursor will
- * be returned.  If run-time profiling shows that this routing is a
- * performance bottle-neck, then an edge list may have to be
- * reimplemented.  An edge list algorithm is O(edges) whereas the new
- * algorithm is O(dmxNumScreens).  Since edges is usually 1-3 and
- * dmxNumScreens may be 30-60 for large backend walls, this trade off
- * may be compelling.
- *
- * The xf86InitOrigins routine uses bit masks during the computation and
- * is therefore limited to the length of a word (e.g., 32 or 64 bits)
- * screens.  Because Xdmx is expected to be used with a large number of
- * backend displays, this limitation was removed.  The new
- * implementation has erred on the side of readability over efficiency,
- * using the dmxSL* routines to manage a screen list instead of a
- * bitmap, and a function call to decrease the length of the main
- * routine.  Both algorithms are of the same order, and both are called
- * only at server generation time, so trading clarity and long-term
- * maintainability for efficiency does not seem justified in this case.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#define DMX_CURSOR_DEBUG 0
-
-#include "dmx.h"
-#include "dmxsync.h"
-#include "dmxcursor.h"
-#include "dmxlog.h"
-#include "dmxprop.h"
-#include "dmxinput.h"
-
-#include "mipointer.h"
-#include "windowstr.h"
-#include "globals.h"
-#include "cursorstr.h"
-#include "dixevents.h"          /* For GetSpriteCursor() */
-#include "inputstr.h"           /* for inputInfo.pointer */
-
-#if DMX_CURSOR_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 dmxCursorDoMultiCursors = 1;
-
-/** Turn off support for displaying multiple cursors on overlapped
-    back-end displays.  See #dmxCursorDoMultiCursors. */
-void dmxCursorNoMulti(void)
-{
-    dmxCursorDoMultiCursors = 0;
-}
-
-static Bool dmxCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)
-{
-    DMXScreenInfo *dmxScreen;
-    int           i;
-    int           localX = *x;
-    int           localY = *y;
-    int           globalX;
-    int           globalY;
-    
-    if (screenInfo.numScreens == 1)
-        return FALSE;
-
-                                /* On current screen? */
-    dmxScreen = &dmxScreens[(*ppScreen)->myNum];
-    if (localX >= 0
-        && localX < dmxScreen->rootWidth
-        && localY >= 0
-        && localY < dmxScreen->rootHeight)
-        return FALSE;
-
-                                /* Convert to global coordinate space */
-    globalX = dmxScreen->rootXOrigin + localX;
-    globalY = dmxScreen->rootYOrigin + localY;
-
-                                /* Is cursor on the current screen?
-                                 * This efficiently exits this routine
-                                 * for the most common case. */
-    if (ppScreen && *ppScreen) {
-        dmxScreen = &dmxScreens[(*ppScreen)->myNum];
-        if (globalX >= dmxScreen->rootXOrigin
-            && globalX < dmxScreen->rootXOrigin + dmxScreen->rootWidth
-            && globalY >= dmxScreen->rootYOrigin
-            && globalY < dmxScreen->rootYOrigin + dmxScreen->rootHeight)
-            return FALSE;
-    }
-
-                                /* Find first screen cursor is on */
-    for (i = 0; i < dmxNumScreens; i++) {
-        dmxScreen = &dmxScreens[i];
-        if (globalX >= dmxScreen->rootXOrigin
-            && globalX < dmxScreen->rootXOrigin + dmxScreen->rootWidth
-            && globalY >= dmxScreen->rootYOrigin
-            && globalY < dmxScreen->rootYOrigin + dmxScreen->rootHeight) {
-            if (dmxScreen->index == (*ppScreen)->myNum)
-                return FALSE;
-            *ppScreen = screenInfo.screens[dmxScreen->index];
-            *x        = globalX - dmxScreen->rootXOrigin;
-            *y        = globalY - dmxScreen->rootYOrigin;
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
-static void dmxCrossScreen(ScreenPtr pScreen, Bool entering)
-{
-}
-
-static void dmxWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
-{
-    DMXDBG3("dmxWarpCursor(%d,%d,%d)\n", pScreen->myNum, x, y);
-#if 11 /*BP*/
-    /* This call is depracated.  Replace with???? */
-    miPointerWarpCursor(pDev, pScreen, x, y);
-#else
-    pScreen->SetCursorPosition(pDev, pScreen, x, y, FALSE);
-#endif
-}
-
-miPointerScreenFuncRec dmxPointerCursorFuncs =
-{
-    dmxCursorOffScreen,
-    dmxCrossScreen,
-    dmxWarpCursor,
-    NULL,
-    NULL,
-};
-
-
-/** Create a list of screens that we'll manipulate. */
-static int *dmxSLCreate(void)
-{
-    int *list = malloc(dmxNumScreens * sizeof(*list));
-    int i;
-    
-    for (i = 0; i < dmxNumScreens; i++)
-        list[i] = 1;
-    return list;
-}
-
-/** Free list. */
-static void dmxSLFree(int *list)
-{
-    free(list);
-}
-
-/** Find next uninitialized entry in list. */
-static int dmxSLFindNext(int *list)
-{
-    int i;
-    for (i = 0; i < dmxNumScreens; i++)
-        if (list[i])
-            return i;
-    return -1;
-}
-
-/** Make one pass over all the screens and return the number updated. */
-static int dmxTryComputeScreenOrigins(int *screensLeft)
-{
-    ScreenPtr       pScreen;
-    DMXScreenInfo   *screen;
-    int             i, ref;
-    int             changed = 0;
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        if (!screensLeft[i])
-            continue;
-        screen  = &dmxScreens[i];
-        switch (screen->where) {
-        case PosAbsolute:
-            dixScreenOrigins[i].x = screen->whereX;
-            dixScreenOrigins[i].y = screen->whereY;
-            ++changed, screensLeft[i] = 0;
-            break;
-        case PosRelative:
-            ref = screen->whereRefScreen;
-            if (screensLeft[ref])
-                break;
-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->whereX;
-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->whereY;
-            ++changed, screensLeft[i] = 0;
-            break;
-        case PosRightOf:
-            ref = screen->whereRefScreen;
-            if (screensLeft[ref])
-                break;
-            pScreen = screenInfo.screens[ref];
-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x + pScreen->width;
-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
-            ++changed, screensLeft[i] = 0;
-            break;
-        case PosLeftOf:
-            ref = screen->whereRefScreen;
-            if (screensLeft[ref])
-                break;
-            pScreen = screenInfo.screens[i];
-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x - pScreen->width;
-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
-            ++changed, screensLeft[i] = 0;
-            break;
-        case PosBelow:
-            ref = screen->whereRefScreen;
-            if (screensLeft[ref])
-                break;
-            pScreen = screenInfo.screens[ref];
-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y + pScreen->height;
-            ++changed, screensLeft[i] = 0;
-            break;
-        case PosAbove:
-            ref = screen->whereRefScreen;
-            if (screensLeft[ref])
-                break;
-            pScreen = screenInfo.screens[i];
-            dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
-            dixScreenOrigins[i].y = dixScreenOrigins[ref].y - pScreen->height;
-            ++changed, screensLeft[i] = 0;
-            break;
-        case PosNone:
-            dmxLog(dmxFatal, "No position information for screen %d\n", i);
-        }
-    }
-    return changed;
-}
-
-static void dmxComputeScreenOrigins(void)
-{
-    int             *screensLeft;
-    int             i, ref;
-    int             minX, minY;
-
-                                /* Compute origins based on
-                                 * configuration information. */
-    screensLeft = dmxSLCreate();
-    while ((i = dmxSLFindNext(screensLeft)) >= 0) {
-        while (dmxTryComputeScreenOrigins(screensLeft));
-        if ((i = dmxSLFindNext(screensLeft)) >= 0) {
-	    /* All of the remaining screens are referencing each other.
-	     * Assign a value to one of them and go through again.  This
-	     * guarantees that we will eventually terminate.
-	     */
-	    ref                     = dmxScreens[i].whereRefScreen;
-	    dixScreenOrigins[ref].x = dixScreenOrigins[ref].y = 0;
-            screensLeft[ref]        = 0;
-	}
-    }
-    dmxSLFree(screensLeft);
-
-
-                                /* Justify the topmost and leftmost to
-                                 * (0,0). */
-    minX = dixScreenOrigins[0].x;
-    minY = dixScreenOrigins[0].y;
-    for (i = 1; i < dmxNumScreens; i++) { /* Compute minX, minY */
-	if (dixScreenOrigins[i].x < minX)
-            minX = dixScreenOrigins[i].x;
-	if (dixScreenOrigins[i].y < minY)
-            minY = dixScreenOrigins[i].y;
-    }
-    if (minX || minY) {
-	for (i = 0; i < dmxNumScreens; i++) {
-	    dixScreenOrigins[i].x -= minX;
-	    dixScreenOrigins[i].y -= minY;
-	}
-    }
-}
-
-/** Recompute origin information in the #dmxScreens list.  This is
- * called from #dmxInitOrigins. */
-void dmxReInitOrigins(void)
-{
-    int        i;
-
-    if (dmxNumScreens > MAXSCREENS)
-        dmxLog(dmxFatal, "dmxNumScreens = %d > MAXSCREENS = %d\n",
-               dmxNumScreens, MAXSCREENS);
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        DMXScreenInfo    *dmxScreen  = &dmxScreens[i];
-        dmxLogOutput(dmxScreen,
-                     "s=%dx%d%+d%+d r=%dx%d%+d%+d @%d,%d"
-                     " (be=%dx%d depth=%d bpp=%d)\n",
-                     dmxScreen->scrnWidth, dmxScreen->scrnHeight,
-                     dmxScreen->scrnX, dmxScreen->scrnY,
-
-                     dmxScreen->rootWidth, dmxScreen->rootHeight,
-                     dmxScreen->rootX, dmxScreen->rootY,
-                     
-                     dmxScreen->rootXOrigin, dmxScreen->rootYOrigin,
-                     dmxScreen->beWidth, dmxScreen->beHeight,
-                     dmxScreen->beDepth, dmxScreen->beBPP);
-    }
-}
-
-/** Initialize screen origins (and relative position).  This is called
- * for each server generation.  For dynamic reconfiguration, use
- * #dmxReInitOrigins() instead. */
-void dmxInitOrigins(void)
-{
-    int  i;
-
-    if (dmxNumScreens > MAXSCREENS)
-        dmxLog(dmxFatal, "dmxNumScreens = %d > MAXSCREENS = %d\n",
-               dmxNumScreens, MAXSCREENS);
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        DMXScreenInfo    *dmxScreen  = &dmxScreens[i];
-        dmxLogOutput(dmxScreen,
-                     "(request) s=%dx%d%+d%+d r=%dx%d%+d%+d @%d,%d (%d)"
-                     " (be=%dx%d depth=%d bpp=%d)\n",
-                     dmxScreen->scrnWidth, dmxScreen->scrnHeight,
-                     dmxScreen->scrnX, dmxScreen->scrnY,
-
-                     dmxScreen->rootWidth, dmxScreen->rootHeight,
-                     dmxScreen->rootX, dmxScreen->rootY,
-
-                     dmxScreen->whereX, dmxScreen->whereY,
-                     dmxScreen->where,
-
-                     dmxScreen->beWidth, dmxScreen->beHeight,
-                     dmxScreen->beDepth, dmxScreen->beBPP);
-    }
-
-    dmxComputeScreenOrigins();
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        DMXScreenInfo  *dmxScreen = &dmxScreens[i];
-        dmxScreen->rootXOrigin = dixScreenOrigins[i].x;
-        dmxScreen->rootYOrigin = dixScreenOrigins[i].y;
-    }
-
-    dmxReInitOrigins();
-}
-
-/** Returns non-zero if the global \a x, \a y coordinate is on the
- * screen window of the \a dmxScreen. */
-int dmxOnScreen(int x, int y, DMXScreenInfo *dmxScreen)
-{
-#if DMX_CURSOR_DEBUG > 1
-    dmxLog(dmxDebug,
-           "dmxOnScreen %d %d,%d (r=%dx%d%+d%+d@%d,%d s=%dx%d%+d%+d)\n",
-           dmxScreen->index, x, y,
-           dmxScreen->rootWidth, dmxScreen->rootHeight,
-           dmxScreen->rootX, dmxScreen->rootY,
-           dmxScreen->rootXOrigin, dmxScreen->rootYOrigin,
-           dmxScreen->scrnWidth, dmxScreen->scrnHeight,
-           dmxScreen->scrnX, dmxScreen->scrnY);
-#endif
-    if (x >= dmxScreen->rootXOrigin
-        && x < dmxScreen->rootXOrigin + dmxScreen->rootWidth
-        && y >= dmxScreen->rootYOrigin
-        && y < dmxScreen->rootYOrigin + dmxScreen->rootHeight) return 1;
-    return 0;
-}
-
-/** Returns non-zero if \a a overlaps \a b. */
-static int dmxDoesOverlap(DMXScreenInfo *a, DMXScreenInfo *b)
-{
-    if (dmxOnScreen(a->rootXOrigin,
-                    a->rootYOrigin,                 b))
-        return 1;
-
-    if (dmxOnScreen(a->rootXOrigin,
-                    a->rootYOrigin + a->scrnWidth,  b))
-        return 1;
-
-    if (dmxOnScreen(a->rootXOrigin + a->scrnHeight,
-                    a->rootYOrigin,                 b))
-        return 1;
-
-    if (dmxOnScreen(a->rootXOrigin + a->scrnHeight,
-                    a->rootYOrigin + a->scrnWidth,  b))
-        return 1;
-
-    if (dmxOnScreen(b->rootXOrigin,
-                    b->rootYOrigin,                 a))
-        return 1;
-
-    if (dmxOnScreen(b->rootXOrigin,
-                    b->rootYOrigin + b->scrnWidth,  a))
-        return 1;
-
-    if (dmxOnScreen(b->rootXOrigin + b->scrnHeight,
-                    b->rootYOrigin,                 a))
-        return 1;
-
-    if (dmxOnScreen(b->rootXOrigin + b->scrnHeight,
-                    b->rootYOrigin + b->scrnWidth,  a))
-        return 1;
-
-    return 0;
-}
-
-/** Used with \a dmxInterateOverlap to print out a list of screens which
- * overlap each other. */
-static void *dmxPrintOverlap(DMXScreenInfo *dmxScreen, void *closure)
-{
-    DMXScreenInfo *a = closure;
-    if (dmxScreen != a) {
-        if (dmxScreen->cursorNotShared)
-            dmxLogOutputCont(a, " [%d/%s]", dmxScreen->index, dmxScreen->name);
-        else
-            dmxLogOutputCont(a, " %d/%s", dmxScreen->index, dmxScreen->name);
-    }
-    return NULL;
-}
-
-/** Iterate over the screens which overlap with the \a start screen,
- * calling \a f with the \a closure for each argument.  Often used with
- * #dmxPrintOverlap. */
-static void *dmxIterateOverlap(DMXScreenInfo *start,
-                               void *(*f)(DMXScreenInfo *dmxScreen, void *),
-                               void *closure)
-{
-    DMXScreenInfo *pt;
-
-    if (!start->over) return f(start, closure);
-
-    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {
-        void *retval;
-        if ((retval = f(pt, closure))) return retval;
-        if (pt == start) break;
-    }
-    return NULL;
-}
-
-/** Used with #dmxPropertyIterate to determine if screen \a a is the
- * same as the screen \a closure. */
-static void *dmxTestSameDisplay(DMXScreenInfo *a, void *closure)
-{
-    DMXScreenInfo *b = closure;
-
-    if (a == b)
-        return a;
-    return NULL;
-}
-
-/** Detects overlapping dmxScreens and creates circular lists.  This
- * uses an O(dmxNumScreens^2) algorithm, but dmxNumScreens is < 100 and
- * the computation only needs to be performed for every server
- * generation or dynamic reconfiguration . */
-void dmxInitOverlap(void)
-{
-    int           i, j;
-    DMXScreenInfo *a, *b, *pt;
-
-    for (i = 0; i < dmxNumScreens; i++)
-        dmxScreens[i].over = NULL;
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        a = &dmxScreens[i];
-        
-        for (j = i+1; j < dmxNumScreens; j++) {
-            b = &dmxScreens[j];
-            if (b->over)
-                continue;
-            
-            if (dmxDoesOverlap(a, b)) {
-                DMXDBG6("%d overlaps %d: a=%p %p b=%p %p\n",
-                        a->index, b->index, a, a->over, b, b->over);
-                b->over = (a->over ? a->over : a);
-                a->over = b;
-            }
-        }
-    }
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        a = &dmxScreens[i];
-        
-        if (!a->over)
-            continue;
-        
-                                /* Flag all pairs that are on same display */
-        for (pt = a->over; pt != a; pt = pt->over) {
-            if (dmxPropertyIterate(a, dmxTestSameDisplay, pt)) {
-                /* The ->over sets contain the transitive set of screens
-                 * that overlap.  For screens that are on the same
-                 * backend display, we only want to exclude pairs of
-                 * screens that mutually overlap on the backend display,
-                 * so we call dmxDoesOverlap, which is stricter than the
-                 * ->over set. */
-                if (!dmxDoesOverlap(a, pt))
-                    continue;
-                a->cursorNotShared  = 1;
-                pt->cursorNotShared = 1;
-                dmxLog(dmxInfo,
-                       "Screen %d and %d overlap on %s\n",
-                       a->index, pt->index, a->name);
-            }
-        }
-    }
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        a = &dmxScreens[i];
-        
-        if (a->over) {
-            dmxLogOutput(a, "Overlaps");
-            dmxIterateOverlap(a, dmxPrintOverlap, a);
-            dmxLogOutputCont(a, "\n");
-        }
-    }
-}
-
-/** Create \a pCursor on the back-end associated with \a pScreen. */
-void dmxBECreateCursor(ScreenPtr pScreen, CursorPtr pCursor)
-{
-    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
-    dmxCursorPrivPtr  pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);
-    CursorBitsPtr     pBits = pCursor->bits;
-    Pixmap            src, msk;
-    XColor            fg, bg;
-    XImage           *img;
-    XlibGC            gc = NULL;
-    XGCValues         v;
-    unsigned long     m;
-    int               i;
-
-    if (!pCursorPriv)
-	return;
-
-    m = GCFunction | GCPlaneMask | GCForeground | GCBackground | GCClipMask;
-    v.function = GXcopy;
-    v.plane_mask = AllPlanes;
-    v.foreground = 1L;
-    v.background = 0L;
-    v.clip_mask = None;
-
-    for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {
-	if (dmxScreen->bePixmapFormats[i].depth == 1) {
-	    /* Create GC in the back-end servers */
-	    gc = XCreateGC(dmxScreen->beDisplay, dmxScreen->scrnDefDrawables[i],
-			   m, &v);
-	    break;
-	}
-    }
-    if (!gc)
-        dmxLog(dmxFatal, "dmxRealizeCursor: gc not initialized\n");
-
-    src = XCreatePixmap(dmxScreen->beDisplay, dmxScreen->scrnWin,
-			pBits->width, pBits->height, 1);
-    msk = XCreatePixmap(dmxScreen->beDisplay, dmxScreen->scrnWin,
-			pBits->width, pBits->height, 1);
-
-    img = XCreateImage(dmxScreen->beDisplay,
-		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,
-		       1, XYBitmap, 0, (char *)pBits->source,
-		       pBits->width, pBits->height,
-		       BitmapPad(dmxScreen->beDisplay), 0);
-
-    XPutImage(dmxScreen->beDisplay, src, gc, img, 0, 0, 0, 0,
-	      pBits->width, pBits->height);
-
-    XFree(img);
-  
-    img = XCreateImage(dmxScreen->beDisplay,
-		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,
-		       1, XYBitmap, 0, (char *)pBits->mask,
-		       pBits->width, pBits->height,
-		       BitmapPad(dmxScreen->beDisplay), 0);
-
-    XPutImage(dmxScreen->beDisplay, msk, gc, img, 0, 0, 0, 0,
-	      pBits->width, pBits->height);
-
-    XFree(img);
-
-    fg.red   = pCursor->foreRed;
-    fg.green = pCursor->foreGreen;
-    fg.blue  = pCursor->foreBlue;
-
-    bg.red   = pCursor->backRed;
-    bg.green = pCursor->backGreen;
-    bg.blue  = pCursor->backBlue;
-
-    pCursorPriv->cursor = XCreatePixmapCursor(dmxScreen->beDisplay,
-					      src, msk,
-					      &fg, &bg,
-					      pBits->xhot, pBits->yhot);
-
-    XFreePixmap(dmxScreen->beDisplay, src);
-    XFreePixmap(dmxScreen->beDisplay, msk);
-    XFreeGC(dmxScreen->beDisplay, gc);
-
-    dmxSync(dmxScreen, FALSE);
-}
-
-static Bool _dmxRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)
-{
-    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
-    dmxCursorPrivPtr  pCursorPriv;
-
-    DMXDBG2("_dmxRealizeCursor(%d,%p)\n", pScreen->myNum, pCursor);
-
-    DMX_SET_CURSOR_PRIV(pCursor, pScreen, xalloc(sizeof(*pCursorPriv)));
-    if (!DMX_GET_CURSOR_PRIV(pCursor, pScreen))
-	return FALSE;
-
-    pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);
-    pCursorPriv->cursor = (Cursor)0;
-
-    if (!dmxScreen->beDisplay)
-	return TRUE;
-
-    dmxBECreateCursor(pScreen, pCursor);
-    return TRUE;
-}
-
-/** Free \a pCursor on the back-end associated with \a pScreen. */
-Bool dmxBEFreeCursor(ScreenPtr pScreen, CursorPtr pCursor)
-{
-    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
-    dmxCursorPrivPtr  pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);
-
-    if (pCursorPriv) {
-	XFreeCursor(dmxScreen->beDisplay, pCursorPriv->cursor);
-	pCursorPriv->cursor = (Cursor)0;
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-static Bool _dmxUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)
-{
-    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
-
-    DMXDBG2("_dmxUnrealizeCursor(%d,%p)\n",
-            pScreen->myNum, pCursor);
-
-    if (dmxScreen->beDisplay) {
-	if (dmxBEFreeCursor(pScreen, pCursor))
-	    xfree(DMX_GET_CURSOR_PRIV(pCursor, pScreen));
-    }
-    DMX_SET_CURSOR_PRIV(pCursor, pScreen, NULL);
-
-    return TRUE;
-}
-
-static void _dmxMoveCursor(ScreenPtr pScreen, int x, int y)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-    int           newX       = x + dmxScreen->rootX;
-    int           newY       = y + dmxScreen->rootY;
-
-    if (newX < 0) newX = 0;
-    if (newY < 0) newY = 0;
-
-    DMXDBG5("_dmxMoveCursor(%d,%d,%d) -> %d,%d\n",
-            pScreen->myNum, x, y, newX, newY);
-    if (dmxScreen->beDisplay) {
-	XWarpPointer(dmxScreen->beDisplay, None, dmxScreen->scrnWin,
-		     0, 0, 0, 0, newX, newY);
-	dmxSync(dmxScreen, TRUE);
-    }
-}
-
-static void _dmxSetCursor(ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
-{
-    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
-
-    DMXDBG4("_dmxSetCursor(%d,%p,%d,%d)\n", pScreen->myNum, pCursor, x, y);
-
-    if (pCursor) {
-	dmxCursorPrivPtr  pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);
-	if (pCursorPriv && dmxScreen->curCursor != pCursorPriv->cursor) {
-	    if (dmxScreen->beDisplay)
-		XDefineCursor(dmxScreen->beDisplay, dmxScreen->scrnWin,
-			      pCursorPriv->cursor);
-            dmxScreen->cursor        = pCursor;
-	    dmxScreen->curCursor     = pCursorPriv->cursor;
-            dmxScreen->cursorVisible = 1;
-	}
-	_dmxMoveCursor(pScreen, x, y);
-    } else {
-	if (dmxScreen->beDisplay)
-	    XDefineCursor(dmxScreen->beDisplay, dmxScreen->scrnWin,
-			  dmxScreen->noCursor);
-        dmxScreen->cursor        = NULL;
-	dmxScreen->curCursor     = (Cursor)0;
-        dmxScreen->cursorVisible = 0;
-    }
-    if (dmxScreen->beDisplay) dmxSync(dmxScreen, TRUE);
-}
-
-static Bool dmxRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
-{
-    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];
-    DMXScreenInfo *pt;
-
-    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared)
-        return _dmxRealizeCursor(pScreen, pCursor);
-
-    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {
-        if (pt->cursorNotShared)
-            continue;
-        _dmxRealizeCursor(screenInfo.screens[pt->index], pCursor);
-        if (pt == start)
-            break;
-    }
-    return TRUE;
-}
-
-static Bool dmxUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
-{
-    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];
-    DMXScreenInfo *pt;
-
-    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared)
-        return _dmxUnrealizeCursor(pScreen, pCursor);
-
-    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {
-        if (pt->cursorNotShared)
-            continue;
-        _dmxUnrealizeCursor(screenInfo.screens[pt->index], pCursor);
-        if (pt == start)
-            break;
-    }
-    return TRUE;
-}
-
-static CursorPtr dmxFindCursor(DMXScreenInfo *start)
-{
-    DMXScreenInfo *pt;
-
-    if (!start || !start->over)
-        return GetSpriteCursor(inputInfo.pointer);
-    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {
-        if (pt->cursor)
-            return pt->cursor;
-        if (pt == start)
-            break;
-    }
-    return GetSpriteCursor(inputInfo.pointer);
-}
-
-/** Move the cursor to coordinates (\a x, \a y)on \a pScreen.  This
- * function is usually called via #dmxPointerSpriteFuncs, except during
- * reconfiguration when the cursor is repositioned to force an update on
- * newley overlapping screens and on screens that no longer overlap.
- *
- * The coords (x,y) are in global coord space.  We'll loop over the
- * back-end screens and see if they contain the global coord.  If so, call
- * _dmxMoveCursor() (XWarpPointer) to position the pointer on that screen.
- */
-void dmxMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
-{
-    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];
-    DMXScreenInfo *pt;
-
-    DMXDBG3("dmxMoveCursor(%d,%d,%d)\n", pScreen->myNum, x, y);
-
-    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared) {
-        _dmxMoveCursor(pScreen, x, y);
-        return;
-    }
-
-    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {
-        if (pt->cursorNotShared)
-            continue;
-        if (dmxOnScreen(x + start->rootXOrigin, y + start->rootYOrigin, pt)) {
-            if (/* pt != start && */ !pt->cursorVisible) {
-                if (!pt->cursor) {
-                                /* This only happens during
-                                 * reconfiguration when a new overlap
-                                 * occurs. */
-                    CursorPtr pCursor;
-                    
-                    if ((pCursor = dmxFindCursor(start)))
-                        _dmxRealizeCursor(screenInfo.screens[pt->index],
-                                          pt->cursor = pCursor);
-                    
-                }
-                _dmxSetCursor(screenInfo.screens[pt->index],
-                              pt->cursor,
-                              x + start->rootXOrigin - pt->rootXOrigin,
-                              y + start->rootYOrigin - pt->rootYOrigin);
-            }
-            _dmxMoveCursor(screenInfo.screens[pt->index],
-                           x + start->rootXOrigin - pt->rootXOrigin,
-                           y + start->rootYOrigin - pt->rootYOrigin);
-        } else if (/* pt != start && */ pt->cursorVisible) {
-            _dmxSetCursor(screenInfo.screens[pt->index],
-                          NULL,
-                          x + start->rootXOrigin - pt->rootXOrigin,
-                          y + start->rootYOrigin - pt->rootYOrigin);
-        }
-        if (pt == start)
-            break;
-    }
-}
-
-static void dmxSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
-{
-    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];
-    DMXScreenInfo *pt;
-    int           GX, GY, gx, gy;
-
-    DMXDBG5("dmxSetCursor(%d %p, %p,%d,%d)\n",
-            pScreen->myNum, start, pCursor, x, y);
-
-                                /* We do this check here because of two cases:
-                                 *
-                                 * 1) if a client calls XWarpPointer()
-                                 * and Xinerama is not running, we can
-                                 * have mi's notion of the pointer
-                                 * position out of phase with DMX's
-                                 * notion.
-                                 *
-                                 * 2) if a down button is held while the
-                                 * cursor moves outside the root window,
-                                 * mi's notion of the pointer position
-                                 * is out of phase with DMX's notion and
-                                 * the cursor can remain visible when it
-                                 * shouldn't be. */
-
-    dmxGetGlobalPosition(&GX, &GY);
-    gx = start->rootXOrigin + x;
-    gy = start->rootYOrigin + y;
-    if (x && y && (GX != gx || GY != gy))
-        dmxCoreMotion(NULL, gx, gy, 0, DMX_NO_BLOCK);
-    
-    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared) {
-        _dmxSetCursor(pScreen, pCursor, x, y);
-        return;
-    }
-
-    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {
-        if (pt->cursorNotShared)
-            continue;
-        if (dmxOnScreen(x + start->rootXOrigin, y + start->rootYOrigin, pt)) {
-            _dmxSetCursor(screenInfo.screens[pt->index], pCursor,
-                          x + start->rootXOrigin - pt->rootXOrigin,
-                          y + start->rootYOrigin - pt->rootYOrigin);
-        } else {
-            _dmxSetCursor(screenInfo.screens[pt->index], NULL,
-                          x + start->rootXOrigin - pt->rootXOrigin,
-                          y + start->rootYOrigin - pt->rootYOrigin);
-        }
-        if (pt == start)
-            break;
-    }
-}
-
-
-/** This routine is used by the backend input routines to hide the
- * cursor on a screen that is being used for relative input.  \see
- * dmxbackend.c */
-void dmxHideCursor(DMXScreenInfo *dmxScreen)
-{
-    int       x, y;
-    ScreenPtr pScreen = screenInfo.screens[dmxScreen->index];
-
-    dmxGetGlobalPosition(&x, &y);
-    _dmxSetCursor(pScreen, NULL, x, y);
-}
-
-/** This routine is called during reconfiguration to make sure the
- * cursor is visible. */
-void dmxCheckCursor(void)
-{
-    int           i;
-    int           x, y;
-    ScreenPtr     pScreen;
-    DMXScreenInfo *firstScreen;
-
-    dmxGetGlobalPosition(&x, &y);
-    firstScreen = dmxFindFirstScreen(x, y);
-
-    DMXDBG2("dmxCheckCursor %d %d\n", x, y);
-    for (i = 0; i < dmxNumScreens; i++) {
-        DMXScreenInfo *dmxScreen = &dmxScreens[i];
-        pScreen                  = screenInfo.screens[dmxScreen->index];
-
-        if (!dmxOnScreen(x, y, dmxScreen)) {
-            if (firstScreen && i == miPointerGetScreen(inputInfo.pointer)->myNum)
-                miPointerSetScreen(inputInfo.pointer, firstScreen->index, x, y);
-            _dmxSetCursor(pScreen, NULL,
-                          x - dmxScreen->rootXOrigin,
-                          y - dmxScreen->rootYOrigin);
-        } else {
-            if (!dmxScreen->cursor) {
-                CursorPtr pCursor;
-                
-                if ((pCursor = dmxFindCursor(dmxScreen))) {
-                    _dmxRealizeCursor(pScreen, dmxScreen->cursor = pCursor);
-                }
-            }
-            _dmxSetCursor(pScreen, dmxScreen->cursor,
-                          x - dmxScreen->rootXOrigin,
-                          y - dmxScreen->rootYOrigin);
-        }
-    }
-    DMXDBG2("   leave dmxCheckCursor %d %d\n", x, y);
-}
-
-static Bool dmxDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScr)
-{
-    return TRUE;
-}
-
-static void dmxDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScr)
-{
-}
-
-miPointerSpriteFuncRec dmxPointerSpriteFuncs =
-{
-    dmxRealizeCursor,
-    dmxUnrealizeCursor,
-    dmxSetCursor,
-    dmxMoveCursor,
-    dmxDeviceCursorInitialize,
-    dmxDeviceCursorCleanup
-};
+/*

+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.

+ *

+ * All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining

+ * a copy of this software and associated documentation files (the

+ * "Software"), to deal in the Software without restriction, including

+ * without limitation on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS

+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+

+/*

+ * Authors:

+ *   David H. Dawes <dawes@xfree86.org>

+ *   Kevin E. Martin <kem@redhat.com>

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

+ *

+ */

+

+/** \file

+ * This file contains code than supports cursor movement, including the

+ * code that initializes and reinitializes the screen positions and

+ * computes screen overlap.

+ *

+ * "This code is based very closely on the XFree86 equivalent

+ * (xfree86/common/xf86Cursor.c)."  --David Dawes.

+ *

+ * "This code was then extensively re-written, as explained here."

+ * --Rik Faith

+ *

+ * The code in xf86Cursor.c used edge lists to implement the

+ * CursorOffScreen function.  The edge list computation was complex

+ * (especially in the face of arbitrarily overlapping screens) compared

+ * with the speed savings in the CursorOffScreen function.  The new

+ * implementation has erred on the side of correctness, readability, and

+ * maintainability over efficiency.  For the common (non-edge) case, the

+ * dmxCursorOffScreen function does avoid a loop over all the screens.

+ * When the cursor has left the screen, all the screens are searched,

+ * and the first screen (in dmxScreens order) containing the cursor will

+ * be returned.  If run-time profiling shows that this routing is a

+ * performance bottle-neck, then an edge list may have to be

+ * reimplemented.  An edge list algorithm is O(edges) whereas the new

+ * algorithm is O(dmxNumScreens).  Since edges is usually 1-3 and

+ * dmxNumScreens may be 30-60 for large backend walls, this trade off

+ * may be compelling.

+ *

+ * The xf86InitOrigins routine uses bit masks during the computation and

+ * is therefore limited to the length of a word (e.g., 32 or 64 bits)

+ * screens.  Because Xdmx is expected to be used with a large number of

+ * backend displays, this limitation was removed.  The new

+ * implementation has erred on the side of readability over efficiency,

+ * using the dmxSL* routines to manage a screen list instead of a

+ * bitmap, and a function call to decrease the length of the main

+ * routine.  Both algorithms are of the same order, and both are called

+ * only at server generation time, so trading clarity and long-term

+ * maintainability for efficiency does not seem justified in this case.

+ */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#define DMX_CURSOR_DEBUG 0

+

+#include "dmx.h"

+#include "dmxsync.h"

+#include "dmxcursor.h"

+#include "dmxlog.h"

+#include "dmxprop.h"

+#include "dmxinput.h"

+

+#include "mipointer.h"

+#include "windowstr.h"

+#include "globals.h"

+#include "cursorstr.h"

+#include "dixevents.h"          /* For GetSpriteCursor() */

+#include "inputstr.h"           /* for inputInfo.pointer */

+

+#if DMX_CURSOR_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 dmxCursorDoMultiCursors = 1;

+

+/** Turn off support for displaying multiple cursors on overlapped

+    back-end displays.  See #dmxCursorDoMultiCursors. */

+void dmxCursorNoMulti(void)

+{

+    dmxCursorDoMultiCursors = 0;

+}

+

+static Bool dmxCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)

+{

+    DMXScreenInfo *dmxScreen;

+    int           i;

+    int           localX = *x;

+    int           localY = *y;

+    int           globalX;

+    int           globalY;

+    

+    if (screenInfo.numScreens == 1)

+        return FALSE;

+

+                                /* On current screen? */

+    dmxScreen = &dmxScreens[(*ppScreen)->myNum];

+    if (localX >= 0

+        && localX < dmxScreen->rootWidth

+        && localY >= 0

+        && localY < dmxScreen->rootHeight)

+        return FALSE;

+

+                                /* Convert to global coordinate space */

+    globalX = dmxScreen->rootXOrigin + localX;

+    globalY = dmxScreen->rootYOrigin + localY;

+

+                                /* Is cursor on the current screen?

+                                 * This efficiently exits this routine

+                                 * for the most common case. */

+    if (ppScreen && *ppScreen) {

+        dmxScreen = &dmxScreens[(*ppScreen)->myNum];

+        if (globalX >= dmxScreen->rootXOrigin

+            && globalX < dmxScreen->rootXOrigin + dmxScreen->rootWidth

+            && globalY >= dmxScreen->rootYOrigin

+            && globalY < dmxScreen->rootYOrigin + dmxScreen->rootHeight)

+            return FALSE;

+    }

+

+                                /* Find first screen cursor is on */

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

+        dmxScreen = &dmxScreens[i];

+        if (globalX >= dmxScreen->rootXOrigin

+            && globalX < dmxScreen->rootXOrigin + dmxScreen->rootWidth

+            && globalY >= dmxScreen->rootYOrigin

+            && globalY < dmxScreen->rootYOrigin + dmxScreen->rootHeight) {

+            if (dmxScreen->index == (*ppScreen)->myNum)

+                return FALSE;

+            *ppScreen = screenInfo.screens[dmxScreen->index];

+            *x        = globalX - dmxScreen->rootXOrigin;

+            *y        = globalY - dmxScreen->rootYOrigin;

+            return TRUE;

+        }

+    }

+    return FALSE;

+}

+

+static void dmxCrossScreen(ScreenPtr pScreen, Bool entering)

+{

+}

+

+static void dmxWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

+{

+    DMXDBG3("dmxWarpCursor(%d,%d,%d)\n", pScreen->myNum, x, y);

+#if 11 /*BP*/

+    /* This call is depracated.  Replace with???? */

+    miPointerWarpCursor(pDev, pScreen, x, y);

+#else

+    pScreen->SetCursorPosition(pDev, pScreen, x, y, FALSE);

+#endif

+}

+

+miPointerScreenFuncRec dmxPointerCursorFuncs =

+{

+    dmxCursorOffScreen,

+    dmxCrossScreen,

+    dmxWarpCursor,

+    NULL,

+    NULL,

+};

+

+

+/** Create a list of screens that we'll manipulate. */

+static int *dmxSLCreate(void)

+{

+    int *list = malloc(dmxNumScreens * sizeof(*list));

+    int i;

+    

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

+        list[i] = 1;

+    return list;

+}

+

+/** Free list. */

+static void dmxSLFree(int *list)

+{

+    free(list);

+}

+

+/** Find next uninitialized entry in list. */

+static int dmxSLFindNext(int *list)

+{

+    int i;

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

+        if (list[i])

+            return i;

+    return -1;

+}

+

+/** Make one pass over all the screens and return the number updated. */

+static int dmxTryComputeScreenOrigins(int *screensLeft)

+{

+    ScreenPtr       pScreen;

+    DMXScreenInfo   *screen;

+    int             i, ref;

+    int             changed = 0;

+

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

+        if (!screensLeft[i])

+            continue;

+        screen  = &dmxScreens[i];

+        switch (screen->where) {

+        case PosAbsolute:

+            dixScreenOrigins[i].x = screen->whereX;

+            dixScreenOrigins[i].y = screen->whereY;

+            ++changed, screensLeft[i] = 0;

+            break;

+        case PosRelative:

+            ref = screen->whereRefScreen;

+            if (screensLeft[ref])

+                break;

+            dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->whereX;

+            dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->whereY;

+            ++changed, screensLeft[i] = 0;

+            break;

+        case PosRightOf:

+            ref = screen->whereRefScreen;

+            if (screensLeft[ref])

+                break;

+            pScreen = screenInfo.screens[ref];

+            dixScreenOrigins[i].x = dixScreenOrigins[ref].x + pScreen->width;

+            dixScreenOrigins[i].y = dixScreenOrigins[ref].y;

+            ++changed, screensLeft[i] = 0;

+            break;

+        case PosLeftOf:

+            ref = screen->whereRefScreen;

+            if (screensLeft[ref])

+                break;

+            pScreen = screenInfo.screens[i];

+            dixScreenOrigins[i].x = dixScreenOrigins[ref].x - pScreen->width;

+            dixScreenOrigins[i].y = dixScreenOrigins[ref].y;

+            ++changed, screensLeft[i] = 0;

+            break;

+        case PosBelow:

+            ref = screen->whereRefScreen;

+            if (screensLeft[ref])

+                break;

+            pScreen = screenInfo.screens[ref];

+            dixScreenOrigins[i].x = dixScreenOrigins[ref].x;

+            dixScreenOrigins[i].y = dixScreenOrigins[ref].y + pScreen->height;

+            ++changed, screensLeft[i] = 0;

+            break;

+        case PosAbove:

+            ref = screen->whereRefScreen;

+            if (screensLeft[ref])

+                break;

+            pScreen = screenInfo.screens[i];

+            dixScreenOrigins[i].x = dixScreenOrigins[ref].x;

+            dixScreenOrigins[i].y = dixScreenOrigins[ref].y - pScreen->height;

+            ++changed, screensLeft[i] = 0;

+            break;

+        case PosNone:

+            dmxLog(dmxFatal, "No position information for screen %d\n", i);

+        }

+    }

+    return changed;

+}

+

+static void dmxComputeScreenOrigins(void)

+{

+    int             *screensLeft;

+    int             i, ref;

+    int             minX, minY;

+

+                                /* Compute origins based on

+                                 * configuration information. */

+    screensLeft = dmxSLCreate();

+    while ((i = dmxSLFindNext(screensLeft)) >= 0) {

+        while (dmxTryComputeScreenOrigins(screensLeft));

+        if ((i = dmxSLFindNext(screensLeft)) >= 0) {

+	    /* All of the remaining screens are referencing each other.

+	     * Assign a value to one of them and go through again.  This

+	     * guarantees that we will eventually terminate.

+	     */

+	    ref                     = dmxScreens[i].whereRefScreen;

+	    dixScreenOrigins[ref].x = dixScreenOrigins[ref].y = 0;

+            screensLeft[ref]        = 0;

+	}

+    }

+    dmxSLFree(screensLeft);

+

+

+                                /* Justify the topmost and leftmost to

+                                 * (0,0). */

+    minX = dixScreenOrigins[0].x;

+    minY = dixScreenOrigins[0].y;

+    for (i = 1; i < dmxNumScreens; i++) { /* Compute minX, minY */

+	if (dixScreenOrigins[i].x < minX)

+            minX = dixScreenOrigins[i].x;

+	if (dixScreenOrigins[i].y < minY)

+            minY = dixScreenOrigins[i].y;

+    }

+    if (minX || minY) {

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

+	    dixScreenOrigins[i].x -= minX;

+	    dixScreenOrigins[i].y -= minY;

+	}

+    }

+}

+

+/** Recompute origin information in the #dmxScreens list.  This is

+ * called from #dmxInitOrigins. */

+void dmxReInitOrigins(void)

+{

+    int        i;

+

+    if (dmxNumScreens > MAXSCREENS)

+        dmxLog(dmxFatal, "dmxNumScreens = %d > MAXSCREENS = %d\n",

+               dmxNumScreens, MAXSCREENS);

+

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

+        DMXScreenInfo    *dmxScreen  = &dmxScreens[i];

+        dmxLogOutput(dmxScreen,

+                     "s=%dx%d%+d%+d r=%dx%d%+d%+d @%d,%d"

+                     " (be=%dx%d depth=%d bpp=%d)\n",

+                     dmxScreen->scrnWidth, dmxScreen->scrnHeight,

+                     dmxScreen->scrnX, dmxScreen->scrnY,

+

+                     dmxScreen->rootWidth, dmxScreen->rootHeight,

+                     dmxScreen->rootX, dmxScreen->rootY,

+                     

+                     dmxScreen->rootXOrigin, dmxScreen->rootYOrigin,

+                     dmxScreen->beWidth, dmxScreen->beHeight,

+                     dmxScreen->beDepth, dmxScreen->beBPP);

+    }

+}

+

+/** Initialize screen origins (and relative position).  This is called

+ * for each server generation.  For dynamic reconfiguration, use

+ * #dmxReInitOrigins() instead. */

+void dmxInitOrigins(void)

+{

+    int  i;

+

+    if (dmxNumScreens > MAXSCREENS)

+        dmxLog(dmxFatal, "dmxNumScreens = %d > MAXSCREENS = %d\n",

+               dmxNumScreens, MAXSCREENS);

+

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

+        DMXScreenInfo    *dmxScreen  = &dmxScreens[i];

+        dmxLogOutput(dmxScreen,

+                     "(request) s=%dx%d%+d%+d r=%dx%d%+d%+d @%d,%d (%d)"

+                     " (be=%dx%d depth=%d bpp=%d)\n",

+                     dmxScreen->scrnWidth, dmxScreen->scrnHeight,

+                     dmxScreen->scrnX, dmxScreen->scrnY,

+

+                     dmxScreen->rootWidth, dmxScreen->rootHeight,

+                     dmxScreen->rootX, dmxScreen->rootY,

+

+                     dmxScreen->whereX, dmxScreen->whereY,

+                     dmxScreen->where,

+

+                     dmxScreen->beWidth, dmxScreen->beHeight,

+                     dmxScreen->beDepth, dmxScreen->beBPP);

+    }

+

+    dmxComputeScreenOrigins();

+

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

+        DMXScreenInfo  *dmxScreen = &dmxScreens[i];

+        dmxScreen->rootXOrigin = dixScreenOrigins[i].x;

+        dmxScreen->rootYOrigin = dixScreenOrigins[i].y;

+    }

+

+    dmxReInitOrigins();

+}

+

+/** Returns non-zero if the global \a x, \a y coordinate is on the

+ * screen window of the \a dmxScreen. */

+int dmxOnScreen(int x, int y, DMXScreenInfo *dmxScreen)

+{

+#if DMX_CURSOR_DEBUG > 1

+    dmxLog(dmxDebug,

+           "dmxOnScreen %d %d,%d (r=%dx%d%+d%+d@%d,%d s=%dx%d%+d%+d)\n",

+           dmxScreen->index, x, y,

+           dmxScreen->rootWidth, dmxScreen->rootHeight,

+           dmxScreen->rootX, dmxScreen->rootY,

+           dmxScreen->rootXOrigin, dmxScreen->rootYOrigin,

+           dmxScreen->scrnWidth, dmxScreen->scrnHeight,

+           dmxScreen->scrnX, dmxScreen->scrnY);

+#endif

+    if (x >= dmxScreen->rootXOrigin

+        && x < dmxScreen->rootXOrigin + dmxScreen->rootWidth

+        && y >= dmxScreen->rootYOrigin

+        && y < dmxScreen->rootYOrigin + dmxScreen->rootHeight) return 1;

+    return 0;

+}

+

+/** Returns non-zero if \a a overlaps \a b. */

+static int dmxDoesOverlap(DMXScreenInfo *a, DMXScreenInfo *b)

+{

+    if (dmxOnScreen(a->rootXOrigin,

+                    a->rootYOrigin,                 b))

+        return 1;

+

+    if (dmxOnScreen(a->rootXOrigin,

+                    a->rootYOrigin + a->scrnWidth,  b))

+        return 1;

+

+    if (dmxOnScreen(a->rootXOrigin + a->scrnHeight,

+                    a->rootYOrigin,                 b))

+        return 1;

+

+    if (dmxOnScreen(a->rootXOrigin + a->scrnHeight,

+                    a->rootYOrigin + a->scrnWidth,  b))

+        return 1;

+

+    if (dmxOnScreen(b->rootXOrigin,

+                    b->rootYOrigin,                 a))

+        return 1;

+

+    if (dmxOnScreen(b->rootXOrigin,

+                    b->rootYOrigin + b->scrnWidth,  a))

+        return 1;

+

+    if (dmxOnScreen(b->rootXOrigin + b->scrnHeight,

+                    b->rootYOrigin,                 a))

+        return 1;

+

+    if (dmxOnScreen(b->rootXOrigin + b->scrnHeight,

+                    b->rootYOrigin + b->scrnWidth,  a))

+        return 1;

+

+    return 0;

+}

+

+/** Used with \a dmxInterateOverlap to print out a list of screens which

+ * overlap each other. */

+static void *dmxPrintOverlap(DMXScreenInfo *dmxScreen, void *closure)

+{

+    DMXScreenInfo *a = closure;

+    if (dmxScreen != a) {

+        if (dmxScreen->cursorNotShared)

+            dmxLogOutputCont(a, " [%d/%s]", dmxScreen->index, dmxScreen->name);

+        else

+            dmxLogOutputCont(a, " %d/%s", dmxScreen->index, dmxScreen->name);

+    }

+    return NULL;

+}

+

+/** Iterate over the screens which overlap with the \a start screen,

+ * calling \a f with the \a closure for each argument.  Often used with

+ * #dmxPrintOverlap. */

+static void *dmxIterateOverlap(DMXScreenInfo *start,

+                               void *(*f)(DMXScreenInfo *dmxScreen, void *),

+                               void *closure)

+{

+    DMXScreenInfo *pt;

+

+    if (!start->over) return f(start, closure);

+

+    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {

+        void *retval;

+        if ((retval = f(pt, closure))) return retval;

+        if (pt == start) break;

+    }

+    return NULL;

+}

+

+/** Used with #dmxPropertyIterate to determine if screen \a a is the

+ * same as the screen \a closure. */

+static void *dmxTestSameDisplay(DMXScreenInfo *a, void *closure)

+{

+    DMXScreenInfo *b = closure;

+

+    if (a == b)

+        return a;

+    return NULL;

+}

+

+/** Detects overlapping dmxScreens and creates circular lists.  This

+ * uses an O(dmxNumScreens^2) algorithm, but dmxNumScreens is < 100 and

+ * the computation only needs to be performed for every server

+ * generation or dynamic reconfiguration . */

+void dmxInitOverlap(void)

+{

+    int           i, j;

+    DMXScreenInfo *a, *b, *pt;

+

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

+        dmxScreens[i].over = NULL;

+

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

+        a = &dmxScreens[i];

+        

+        for (j = i+1; j < dmxNumScreens; j++) {

+            b = &dmxScreens[j];

+            if (b->over)

+                continue;

+            

+            if (dmxDoesOverlap(a, b)) {

+                DMXDBG6("%d overlaps %d: a=%p %p b=%p %p\n",

+                        a->index, b->index, a, a->over, b, b->over);

+                b->over = (a->over ? a->over : a);

+                a->over = b;

+            }

+        }

+    }

+

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

+        a = &dmxScreens[i];

+        

+        if (!a->over)

+            continue;

+        

+                                /* Flag all pairs that are on same display */

+        for (pt = a->over; pt != a; pt = pt->over) {

+            if (dmxPropertyIterate(a, dmxTestSameDisplay, pt)) {

+                /* The ->over sets contain the transitive set of screens

+                 * that overlap.  For screens that are on the same

+                 * backend display, we only want to exclude pairs of

+                 * screens that mutually overlap on the backend display,

+                 * so we call dmxDoesOverlap, which is stricter than the

+                 * ->over set. */

+                if (!dmxDoesOverlap(a, pt))

+                    continue;

+                a->cursorNotShared  = 1;

+                pt->cursorNotShared = 1;

+                dmxLog(dmxInfo,

+                       "Screen %d and %d overlap on %s\n",

+                       a->index, pt->index, a->name);

+            }

+        }

+    }

+

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

+        a = &dmxScreens[i];

+        

+        if (a->over) {

+            dmxLogOutput(a, "Overlaps");

+            dmxIterateOverlap(a, dmxPrintOverlap, a);

+            dmxLogOutputCont(a, "\n");

+        }

+    }

+}

+

+/** Create \a pCursor on the back-end associated with \a pScreen. */

+void dmxBECreateCursor(ScreenPtr pScreen, CursorPtr pCursor)

+{

+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];

+    dmxCursorPrivPtr  pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);

+    CursorBitsPtr     pBits = pCursor->bits;

+    Pixmap            src, msk;

+    XColor            fg, bg;

+    XImage           *img;

+    XlibGC            gc = NULL;

+    XGCValues         v;

+    unsigned long     m;

+    int               i;

+

+    if (!pCursorPriv)

+	return;

+

+    m = GCFunction | GCPlaneMask | GCForeground | GCBackground | GCClipMask;

+    v.function = GXcopy;

+    v.plane_mask = AllPlanes;

+    v.foreground = 1L;

+    v.background = 0L;

+    v.clip_mask = None;

+

+    for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {

+	if (dmxScreen->bePixmapFormats[i].depth == 1) {

+	    /* Create GC in the back-end servers */

+	    gc = XCreateGC(dmxScreen->beDisplay, dmxScreen->scrnDefDrawables[i],

+			   m, &v);

+	    break;

+	}

+    }

+    if (!gc)

+        dmxLog(dmxFatal, "dmxRealizeCursor: gc not initialized\n");

+

+    src = XCreatePixmap(dmxScreen->beDisplay, dmxScreen->scrnWin,

+			pBits->width, pBits->height, 1);

+    msk = XCreatePixmap(dmxScreen->beDisplay, dmxScreen->scrnWin,

+			pBits->width, pBits->height, 1);

+

+    img = XCreateImage(dmxScreen->beDisplay,

+		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,

+		       1, XYBitmap, 0, (char *)pBits->source,

+		       pBits->width, pBits->height,

+		       BitmapPad(dmxScreen->beDisplay), 0);

+

+    XPutImage(dmxScreen->beDisplay, src, gc, img, 0, 0, 0, 0,

+	      pBits->width, pBits->height);

+

+    XFree(img);

+  

+    img = XCreateImage(dmxScreen->beDisplay,

+		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,

+		       1, XYBitmap, 0, (char *)pBits->mask,

+		       pBits->width, pBits->height,

+		       BitmapPad(dmxScreen->beDisplay), 0);

+

+    XPutImage(dmxScreen->beDisplay, msk, gc, img, 0, 0, 0, 0,

+	      pBits->width, pBits->height);

+

+    XFree(img);

+

+    fg.red   = pCursor->foreRed;

+    fg.green = pCursor->foreGreen;

+    fg.blue  = pCursor->foreBlue;

+

+    bg.red   = pCursor->backRed;

+    bg.green = pCursor->backGreen;

+    bg.blue  = pCursor->backBlue;

+

+    pCursorPriv->cursor = XCreatePixmapCursor(dmxScreen->beDisplay,

+					      src, msk,

+					      &fg, &bg,

+					      pBits->xhot, pBits->yhot);

+

+    XFreePixmap(dmxScreen->beDisplay, src);

+    XFreePixmap(dmxScreen->beDisplay, msk);

+    XFreeGC(dmxScreen->beDisplay, gc);

+

+    dmxSync(dmxScreen, FALSE);

+}

+

+static Bool _dmxRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)

+{

+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];

+    dmxCursorPrivPtr  pCursorPriv;

+

+    DMXDBG2("_dmxRealizeCursor(%d,%p)\n", pScreen->myNum, pCursor);

+

+    DMX_SET_CURSOR_PRIV(pCursor, pScreen, malloc(sizeof(*pCursorPriv)));

+    if (!DMX_GET_CURSOR_PRIV(pCursor, pScreen))

+	return FALSE;

+

+    pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);

+    pCursorPriv->cursor = (Cursor)0;

+

+    if (!dmxScreen->beDisplay)

+	return TRUE;

+

+    dmxBECreateCursor(pScreen, pCursor);

+    return TRUE;

+}

+

+/** Free \a pCursor on the back-end associated with \a pScreen. */

+Bool dmxBEFreeCursor(ScreenPtr pScreen, CursorPtr pCursor)

+{

+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];

+    dmxCursorPrivPtr  pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);

+

+    if (pCursorPriv) {

+	XFreeCursor(dmxScreen->beDisplay, pCursorPriv->cursor);

+	pCursorPriv->cursor = (Cursor)0;

+	return TRUE;

+    }

+

+    return FALSE;

+}

+

+static Bool _dmxUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)

+{

+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];

+

+    DMXDBG2("_dmxUnrealizeCursor(%d,%p)\n",

+            pScreen->myNum, pCursor);

+

+    if (dmxScreen->beDisplay) {

+	if (dmxBEFreeCursor(pScreen, pCursor))

+	    free(DMX_GET_CURSOR_PRIV(pCursor, pScreen));

+    }

+    DMX_SET_CURSOR_PRIV(pCursor, pScreen, NULL);

+

+    return TRUE;

+}

+

+static void _dmxMoveCursor(ScreenPtr pScreen, int x, int y)

+{

+    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];

+    int           newX       = x + dmxScreen->rootX;

+    int           newY       = y + dmxScreen->rootY;

+

+    if (newX < 0) newX = 0;

+    if (newY < 0) newY = 0;

+

+    DMXDBG5("_dmxMoveCursor(%d,%d,%d) -> %d,%d\n",

+            pScreen->myNum, x, y, newX, newY);

+    if (dmxScreen->beDisplay) {

+	XWarpPointer(dmxScreen->beDisplay, None, dmxScreen->scrnWin,

+		     0, 0, 0, 0, newX, newY);

+	dmxSync(dmxScreen, TRUE);

+    }

+}

+

+static void _dmxSetCursor(ScreenPtr pScreen, CursorPtr pCursor, int x, int y)

+{

+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];

+

+    DMXDBG4("_dmxSetCursor(%d,%p,%d,%d)\n", pScreen->myNum, pCursor, x, y);

+

+    if (pCursor) {

+	dmxCursorPrivPtr  pCursorPriv = DMX_GET_CURSOR_PRIV(pCursor, pScreen);

+	if (pCursorPriv && dmxScreen->curCursor != pCursorPriv->cursor) {

+	    if (dmxScreen->beDisplay)

+		XDefineCursor(dmxScreen->beDisplay, dmxScreen->scrnWin,

+			      pCursorPriv->cursor);

+            dmxScreen->cursor        = pCursor;

+	    dmxScreen->curCursor     = pCursorPriv->cursor;

+            dmxScreen->cursorVisible = 1;

+	}

+	_dmxMoveCursor(pScreen, x, y);

+    } else {

+	if (dmxScreen->beDisplay)

+	    XDefineCursor(dmxScreen->beDisplay, dmxScreen->scrnWin,

+			  dmxScreen->noCursor);

+        dmxScreen->cursor        = NULL;

+	dmxScreen->curCursor     = (Cursor)0;

+        dmxScreen->cursorVisible = 0;

+    }

+    if (dmxScreen->beDisplay) dmxSync(dmxScreen, TRUE);

+}

+

+static Bool dmxRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

+{

+    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];

+    DMXScreenInfo *pt;

+

+    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared)

+        return _dmxRealizeCursor(pScreen, pCursor);

+

+    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {

+        if (pt->cursorNotShared)

+            continue;

+        _dmxRealizeCursor(screenInfo.screens[pt->index], pCursor);

+        if (pt == start)

+            break;

+    }

+    return TRUE;

+}

+

+static Bool dmxUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

+{

+    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];

+    DMXScreenInfo *pt;

+

+    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared)

+        return _dmxUnrealizeCursor(pScreen, pCursor);

+

+    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {

+        if (pt->cursorNotShared)

+            continue;

+        _dmxUnrealizeCursor(screenInfo.screens[pt->index], pCursor);

+        if (pt == start)

+            break;

+    }

+    return TRUE;

+}

+

+static CursorPtr dmxFindCursor(DMXScreenInfo *start)

+{

+    DMXScreenInfo *pt;

+

+    if (!start || !start->over)

+        return GetSpriteCursor(inputInfo.pointer);

+    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {

+        if (pt->cursor)

+            return pt->cursor;

+        if (pt == start)

+            break;

+    }

+    return GetSpriteCursor(inputInfo.pointer);

+}

+

+/** Move the cursor to coordinates (\a x, \a y)on \a pScreen.  This

+ * function is usually called via #dmxPointerSpriteFuncs, except during

+ * reconfiguration when the cursor is repositioned to force an update on

+ * newley overlapping screens and on screens that no longer overlap.

+ *

+ * The coords (x,y) are in global coord space.  We'll loop over the

+ * back-end screens and see if they contain the global coord.  If so, call

+ * _dmxMoveCursor() (XWarpPointer) to position the pointer on that screen.

+ */

+void dmxMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

+{

+    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];

+    DMXScreenInfo *pt;

+

+    DMXDBG3("dmxMoveCursor(%d,%d,%d)\n", pScreen->myNum, x, y);

+

+    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared) {

+        _dmxMoveCursor(pScreen, x, y);

+        return;

+    }

+

+    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {

+        if (pt->cursorNotShared)

+            continue;

+        if (dmxOnScreen(x + start->rootXOrigin, y + start->rootYOrigin, pt)) {

+            if (/* pt != start && */ !pt->cursorVisible) {

+                if (!pt->cursor) {

+                                /* This only happens during

+                                 * reconfiguration when a new overlap

+                                 * occurs. */

+                    CursorPtr pCursor;

+                    

+                    if ((pCursor = dmxFindCursor(start)))

+                        _dmxRealizeCursor(screenInfo.screens[pt->index],

+                                          pt->cursor = pCursor);

+                    

+                }

+                _dmxSetCursor(screenInfo.screens[pt->index],

+                              pt->cursor,

+                              x + start->rootXOrigin - pt->rootXOrigin,

+                              y + start->rootYOrigin - pt->rootYOrigin);

+            }

+            _dmxMoveCursor(screenInfo.screens[pt->index],

+                           x + start->rootXOrigin - pt->rootXOrigin,

+                           y + start->rootYOrigin - pt->rootYOrigin);

+        } else if (/* pt != start && */ pt->cursorVisible) {

+            _dmxSetCursor(screenInfo.screens[pt->index],

+                          NULL,

+                          x + start->rootXOrigin - pt->rootXOrigin,

+                          y + start->rootYOrigin - pt->rootYOrigin);

+        }

+        if (pt == start)

+            break;

+    }

+}

+

+static void dmxSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)

+{

+    DMXScreenInfo *start = &dmxScreens[pScreen->myNum];

+    DMXScreenInfo *pt;

+    int           GX, GY, gx, gy;

+

+    DMXDBG5("dmxSetCursor(%d %p, %p,%d,%d)\n",

+            pScreen->myNum, start, pCursor, x, y);

+

+                                /* We do this check here because of two cases:

+                                 *

+                                 * 1) if a client calls XWarpPointer()

+                                 * and Xinerama is not running, we can

+                                 * have mi's notion of the pointer

+                                 * position out of phase with DMX's

+                                 * notion.

+                                 *

+                                 * 2) if a down button is held while the

+                                 * cursor moves outside the root window,

+                                 * mi's notion of the pointer position

+                                 * is out of phase with DMX's notion and

+                                 * the cursor can remain visible when it

+                                 * shouldn't be. */

+

+    dmxGetGlobalPosition(&GX, &GY);

+    gx = start->rootXOrigin + x;

+    gy = start->rootYOrigin + y;

+    if (x && y && (GX != gx || GY != gy))

+        dmxCoreMotion(NULL, gx, gy, 0, DMX_NO_BLOCK);

+    

+    if (!start->over || !dmxCursorDoMultiCursors || start->cursorNotShared) {

+        _dmxSetCursor(pScreen, pCursor, x, y);

+        return;

+    }

+

+    for (pt = start->over; /* condition at end of loop */; pt = pt->over) {

+        if (pt->cursorNotShared)

+            continue;

+        if (dmxOnScreen(x + start->rootXOrigin, y + start->rootYOrigin, pt)) {

+            _dmxSetCursor(screenInfo.screens[pt->index], pCursor,

+                          x + start->rootXOrigin - pt->rootXOrigin,

+                          y + start->rootYOrigin - pt->rootYOrigin);

+        } else {

+            _dmxSetCursor(screenInfo.screens[pt->index], NULL,

+                          x + start->rootXOrigin - pt->rootXOrigin,

+                          y + start->rootYOrigin - pt->rootYOrigin);

+        }

+        if (pt == start)

+            break;

+    }

+}

+

+

+/** This routine is used by the backend input routines to hide the

+ * cursor on a screen that is being used for relative input.  \see

+ * dmxbackend.c */

+void dmxHideCursor(DMXScreenInfo *dmxScreen)

+{

+    int       x, y;

+    ScreenPtr pScreen = screenInfo.screens[dmxScreen->index];

+

+    dmxGetGlobalPosition(&x, &y);

+    _dmxSetCursor(pScreen, NULL, x, y);

+}

+

+/** This routine is called during reconfiguration to make sure the

+ * cursor is visible. */

+void dmxCheckCursor(void)

+{

+    int           i;

+    int           x, y;

+    ScreenPtr     pScreen;

+    DMXScreenInfo *firstScreen;

+

+    dmxGetGlobalPosition(&x, &y);

+    firstScreen = dmxFindFirstScreen(x, y);

+

+    DMXDBG2("dmxCheckCursor %d %d\n", x, y);

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

+        DMXScreenInfo *dmxScreen = &dmxScreens[i];

+        pScreen                  = screenInfo.screens[dmxScreen->index];

+

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

+            if (firstScreen && i == miPointerGetScreen(inputInfo.pointer)->myNum)

+                miPointerSetScreen(inputInfo.pointer, firstScreen->index, x, y);

+            _dmxSetCursor(pScreen, NULL,

+                          x - dmxScreen->rootXOrigin,

+                          y - dmxScreen->rootYOrigin);

+        } else {

+            if (!dmxScreen->cursor) {

+                CursorPtr pCursor;

+                

+                if ((pCursor = dmxFindCursor(dmxScreen))) {

+                    _dmxRealizeCursor(pScreen, dmxScreen->cursor = pCursor);

+                }

+            }

+            _dmxSetCursor(pScreen, dmxScreen->cursor,

+                          x - dmxScreen->rootXOrigin,

+                          y - dmxScreen->rootYOrigin);

+        }

+    }

+    DMXDBG2("   leave dmxCheckCursor %d %d\n", x, y);

+}

+

+static Bool dmxDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScr)

+{

+    return TRUE;

+}

+

+static void dmxDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScr)

+{

+}

+

+miPointerSpriteFuncRec dmxPointerSpriteFuncs =

+{

+    dmxRealizeCursor,

+    dmxUnrealizeCursor,

+    dmxSetCursor,

+    dmxMoveCursor,

+    dmxDeviceCursorInitialize,

+    dmxDeviceCursorCleanup

+};