mi: fix some macros to allow multiple cursors for master devices.

Macros defaulted to inputInfo.pointe rfor devices that weren't spriteOwners.
Changed to take the device's master device now.

This includes sticking in a number of checks and warnings that cursor
rendering won't be called for floating devices.

mi/midispcur.c

@@ -85,7 +85,7 @@ typedef struct {
 #define MIDCBUFFER(dev) \
  ((DevHasCursor(dev)) ? \
   (miDCBufferPtr)dev->devPrivates[miDCSpriteIndex].ptr :\
-  (miDCBufferPtr)inputInfo.pointer->devPrivates[miDCSpriteIndex].ptr)
+  (miDCBufferPtr)dev->u.master->devPrivates[miDCSpriteIndex].ptr)
 
 /* 
  * The core pointer buffer will point to the index of the virtual core pointer

mi/mipointer.c

@@ -59,7 +59,7 @@ static int miPointerPrivatesIndex = 0;
 #define MIPOINTER(dev) \
     ((DevHasCursor((dev))) ? \
         (miPointerPtr) dev->devPrivates[miPointerPrivatesIndex].ptr : \
-        (miPointerPtr) inputInfo.pointer->devPrivates[miPointerPrivatesIndex].ptr)
+        (miPointerPtr) dev->u.master->devPrivates[miPointerPrivatesIndex].ptr)
 
 static Bool miPointerRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, 
                                    CursorPtr pCursor);
@@ -210,7 +210,12 @@ miPointerDisplayCursor (pDev, pScreen, pCursor)
     ScreenPtr 	 pScreen;
     CursorPtr	 pCursor;
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+        return FALSE;
+
+    pPointer = MIPOINTER(pDev);
 
     pPointer->pCursor = pCursor;
     pPointer->pScreen = pScreen;
@@ -233,7 +238,12 @@ miPointerConstrainCursor (pDev, pScreen, pBox)
     ScreenPtr	pScreen;
     BoxPtr	pBox;
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
+
+    if (!pDev->isMaster && !pDev->u.master)
+        return;
+    
+    pPointer = MIPOINTER(pDev);
 
     pPointer->limits = *pBox;
     pPointer->confined = PointerConfinedToScreen(pDev);
@@ -347,7 +357,11 @@ miPointerWarpCursor (pDev, pScreen, x, y)
     ScreenPtr	 pScreen;
     int	   	 x, y;
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+        return;
+    pPointer = MIPOINTER(pDev);
     SetupScreen (pScreen);
 
     if (pPointer->pScreen != pScreen)
@@ -399,7 +413,7 @@ miPointerUpdateSprite (DeviceIntPtr pDev)
     int			x, y, devx, devy;
     miPointerPtr        pPointer;
 
-    if (!pDev || !pDev->coreEvents)
+    if (!pDev || !pDev->coreEvents || (!pDev->isMaster && !pDev->u.master))
         return;
 
     pPointer = MIPOINTER(pDev);
@@ -488,7 +502,12 @@ miPointerSetScreen(DeviceIntPtr pDev, int screen_no, int x, int y)
 {
 	miPointerScreenPtr pScreenPriv;
 	ScreenPtr pScreen;
-        miPointerPtr pPointer = MIPOINTER(pDev);
+        miPointerPtr pPointer; 
+        
+        if (!pDev->isMaster && !pDev->u.master)
+            return;
+
+        pPointer = MIPOINTER(pDev);
 
 	pScreen = screenInfo.screens[screen_no];
 	pScreenPriv = GetScreenPrivate (pScreen);
@@ -508,8 +527,10 @@ miPointerCurrentScreen ()
 _X_EXPORT ScreenPtr
 miPointerGetScreen(DeviceIntPtr pDev)
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    if (!pDev->isMaster && !pDev->u.master)
-    return pPointer->pScreen;
+        return NULL;
+
+    return MIPOINTER(pDev)->pScreen;
 }
 
 /* Move the pointer to x, y on the current screen, update the sprite, and
@@ -526,9 +547,13 @@ static void
 miPointerMoved (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y,
                      unsigned long time)
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    miPointerPtr pPointer;
     SetupScreen(pScreen);
 
+    if (!pDev->isMaster && !pDev->u.master) 
+        return;
+
+    pPointer = MIPOINTER(pDev);
 
     if (pDev && pDev->coreEvents 
         && !pScreenPriv->waitForUpdate && pScreen == pPointer->pSpriteScreen)
@@ -551,8 +576,12 @@ miPointerSetPosition(DeviceIntPtr pDev, int *x, int *y, unsigned long time)
     ScreenPtr		pScreen;
     ScreenPtr		newScreen;
 
-    miPointerPtr        pPointer = MIPOINTER(pDev);
+    miPointerPtr        pPointer; 
+    
+    if (!pDev->isMaster && !pDev->u.master)
+        return;
 
+    pPointer = MIPOINTER(pDev);
     pScreen = pPointer->pScreen;
     if (!pScreen)
 	return;	    /* called before ready */
@@ -605,9 +634,14 @@ miPointerPosition (int *x, int *y)
 _X_EXPORT void
 miPointerGetPosition(DeviceIntPtr pDev, int *x, int *y)
 {
-    miPointerPtr pPointer = MIPOINTER(pDev);
+    if (!pDev->isMaster && !pDev->u.master)
-    *x = pPointer->x;
+    {
-    *y = pPointer->y;
+        ErrorF("[mi] miPointerGetPosition called for floating device.\n");
+        return;
+    }
+
+    *x = MIPOINTER(pDev)->x;
+    *y = MIPOINTER(pDev)->y;
 }
 
 void

mi/misprite.c

@@ -77,7 +77,7 @@ static int miSpriteDevPrivatesIndex;
 #define MISPRITE(dev) \
     ((DevHasCursor(dev)) ? \
        (miCursorInfoPtr) dev->devPrivates[miSpriteDevPrivatesIndex].ptr : \
-       (miCursorInfoPtr) inputInfo.pointer->devPrivates[miSpriteDevPrivatesIndex].ptr)
+       (miCursorInfoPtr) dev->u.master->devPrivates[miSpriteDevPrivatesIndex].ptr)
 
 
 /*
@@ -759,6 +759,12 @@ miSpriteRealizeCursor (pDev, pScreen, pCursor)
     miCursorInfoPtr pCursorInfo;
 
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
+
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteRealizeCursor called for floating device.\n");
+        return FALSE;
+    }
     pCursorInfo = MISPRITE(pDev);
 
     if (pCursor == pCursorInfo->pCursor)
@@ -790,7 +796,14 @@ miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
     miSpriteScreenPtr	pScreenPriv;
 
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
-    miCursorInfoPtr pPointer = MISPRITE(pDev);
+    miCursorInfoPtr pPointer;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteSetCursor called for floating device.\n");
+        return;
+    }
+    pPointer = MISPRITE(pDev);
 
     if (!pCursor)
     {
@@ -905,6 +918,11 @@ miSpriteMoveCursor (pDev, pScreen, x, y)
     CursorPtr pCursor;
 
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteMoveCursor called for floating device.\n");
+        return;
+    }
     pCursor = MISPRITE(pDev)->pCursor;
 
     miSpriteSetCursor (pDev, pScreen, pCursor, x, y);
@@ -972,6 +990,11 @@ miSpriteUndisplayCursor(pDev, pScreen)
     DeviceIntPtr pDev;
     ScreenPtr    pScreen;
 {
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteUndisplayCursor called for floating device.\n");
+        return;
+    }
     if (MISPRITE(pDev)->isUp)
         miSpriteRemoveCursor(pDev, pScreen);
 }
@@ -989,6 +1012,11 @@ miSpriteRemoveCursor (pDev, pScreen)
     miCursorInfoPtr     pCursorInfo;
 
 
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteRemoveCursor called for floating device.\n");
+        return;
+    }
     DamageDrawInternal (pScreen, TRUE);
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
     pCursorInfo = MISPRITE(pDev);
@@ -1026,6 +1054,11 @@ miSpriteSaveUnderCursor(pDev, pScreen)
     CursorPtr		pCursor;
     miCursorInfoPtr     pCursorInfo;
 
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteSaveUnderCursor called for floating device.\n");
+        return;
+    }
     DamageDrawInternal (pScreen, TRUE);
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
     pCursorInfo = MISPRITE(pDev);
@@ -1065,6 +1098,12 @@ miSpriteRestoreCursor (pDev, pScreen)
     int			x, y;
     CursorPtr		pCursor;
     miCursorInfoPtr     pCursorInfo;
+    
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteRestoreCursor called for floating device.\n");
+        return;
+    }
 
     DamageDrawInternal (pScreen, TRUE);
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
@@ -1106,6 +1145,11 @@ miSpriteComputeSaved (pDev, pScreen)
     CursorPtr	    pCursor;
     miCursorInfoPtr pCursorInfo;
 
+    if (!pDev->isMaster && !pDev->u.master)
+    {
+        ErrorF("[mi] miSpriteComputeSaved called for floating device.\n");
+        return;
+    }
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
     pCursorInfo = MISPRITE(pDev);