andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mi: free allocated memory in miDCCloseScreen and in miDCInitialize in case

Browse Source 
of errors.
	Some copyright notices.
	misprite.c passes DeviceIntPtr around and down to DC (previously
	miCursorInfoPtr and the plain device id).
	Large cleanup in misprite.c to avoid code duplication.
This commit is contained in:
Peter Hutterer 2006-11-27 14:47:23 +10:30 committed by Peter Hutterer
parent 1c7568b8a1
commit a2340a7368
4 changed files with 332 additions and 362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Changelog
View File

@ -1,4 +1,17 @@
MPX Changelog file MPX Changelog file
== 27.11.06 ==
mi: free allocated memory in miDCCloseScreen and in miDCInitialize in case
of errors.
Some copyright notices.
misprite.c passes DeviceIntPtr around and down to DC (previously
miCursorInfoPtr and the plain device id).
Large cleanup in misprite.c to avoid code duplication.
Files:
mi/midispcur.c
mi/misprite.c
mi/misprite.h
== 23.11.06 == == 23.11.06 ==
mi: closing memory leak, miPointer is freed in miPointerCloseScreen mi: closing memory leak, miPointer is freed in miPointerCloseScreen
bugfix: uninitialized pPointer in miPointerGetPosition ifndef MPX bugfix: uninitialized pPointer in miPointerGetPosition ifndef MPX

70
mi/midispcur.c
View File

@ -29,6 +29,12 @@ Except as contained in this notice, the name of The Open Group shall not be
used in advertising or otherwise to promote the sale, use or other dealings used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group. in this Software without prior written authorization from The Open Group.
*/ */
/*
* MPX additions:
* Copyright © 2006 Peter Hutterer
* Author: Peter Hutterer <peter@cs.unisa.edu.au>
*
*/
#ifdef HAVE_DIX_CONFIG_H #ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h> #include <dix-config.h>
@ -55,9 +61,7 @@ in this Software without prior written authorization from The Open Group.
#ifdef MPX #ifdef MPX
# include "inputstr.h" # include "inputstr.h"
#define SaneID(a) (a >= 0 && a < MAX_DEVICES) #define SaneID(a) (a >= 0 && a < MAX_DEVICES)
#endif #endif
/* per-screen private data */ /* per-screen private data */
@ -102,20 +106,20 @@ typedef struct {
static Bool miDCRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor); static Bool miDCRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor);
static Bool miDCUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCursor); static Bool miDCUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCursor);
static Bool miDCPutUpCursor(int deviceid, ScreenPtr pScreen, static Bool miDCPutUpCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor, int x, int y, CursorPtr pCursor, int x, int y,
unsigned long source, unsigned long mask); unsigned long source, unsigned long mask);
static Bool miDCSaveUnderCursor(int deviceid, ScreenPtr pScreen, static Bool miDCSaveUnderCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int x, int y,
int w, int h); int w, int h);
static Bool miDCRestoreUnderCursor(int deviceid, ScreenPtr pScreen, static Bool miDCRestoreUnderCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int x, int y,
int w, int h); int w, int h);
static Bool miDCMoveCursor(int deviceid, ScreenPtr pScreen, static Bool miDCMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor, int x, int y, CursorPtr pCursor, int x, int y,
int w, int h, int dx, int dy, int w, int h, int dx, int dy,
unsigned long source, unsigned long mask); unsigned long source, unsigned long mask);
static Bool miDCChangeSave(int deviceid, ScreenPtr pScreen, static Bool miDCChangeSave(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h, int x, int y, int w, int h,
int dx, int dy); int dx, int dy);
@ -173,7 +177,7 @@ miDCInitialize (pScreen, screenFuncs)
pScreenPriv->pMPBuffers = (miDCBufferPtr)xalloc(MAX_DEVICES * pScreenPriv->pMPBuffers = (miDCBufferPtr)xalloc(MAX_DEVICES *
sizeof(miDCBufferRec)); sizeof(miDCBufferRec));
/* virtual core pointer ID is 1, we might as well use the array */ /* virtual core pointer ID is 1 */
xfree(pScreenPriv->pCoreBuffer); xfree(pScreenPriv->pCoreBuffer);
pScreenPriv->pCoreBuffer = &pScreenPriv->pMPBuffers[1]; pScreenPriv->pCoreBuffer = &pScreenPriv->pMPBuffers[1];
@ -206,6 +210,11 @@ miDCInitialize (pScreen, screenFuncs)
if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs)) if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs))
{ {
#ifdef MPX
xfree((pointer)pScreenPriv->pMPBuffers);
#else
xfree((pointer)pScreenPriv->pCoreBuffer);
#endif
xfree ((pointer) pScreenPriv); xfree ((pointer) pScreenPriv);
return FALSE; return FALSE;
} }
@ -256,6 +265,11 @@ miDCCloseScreen (index, pScreen)
mpBufferIdx++; mpBufferIdx++;
} }
} }
xfree((pointer) pScreenPriv->pMPBuffers);
#else
xfree((pointer) pScreenPriv->pCoreBuffer);
#endif #endif
xfree ((pointer) pScreenPriv); xfree ((pointer) pScreenPriv);
@ -530,8 +544,8 @@ miDCMakeGC(
static Bool static Bool
miDCPutUpCursor (deviceid, pScreen, pCursor, x, y, source, mask) miDCPutUpCursor (pDev, pScreen, pCursor, x, y, source, mask)
int deviceid; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
CursorPtr pCursor; CursorPtr pCursor;
int x, y; int x, y;
@ -554,8 +568,8 @@ miDCPutUpCursor (deviceid, pScreen, pCursor, x, y, source, mask)
pBuffer = pScreenPriv->pCoreBuffer; pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX #ifdef MPX
if (SaneID(deviceid)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[deviceid]; pBuffer = &pScreenPriv->pMPBuffers[pDev->id];
#endif #endif
#ifdef ARGB_CURSOR #ifdef ARGB_CURSOR
@ -592,8 +606,8 @@ miDCPutUpCursor (deviceid, pScreen, pCursor, x, y, source, mask)
} }
static Bool static Bool
miDCSaveUnderCursor (deviceid, pScreen, x, y, w, h) miDCSaveUnderCursor (pDev, pScreen, x, y, w, h)
int deviceid; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
int x, y, w, h; int x, y, w, h;
{ {
@ -606,8 +620,8 @@ miDCSaveUnderCursor (deviceid, pScreen, x, y, w, h)
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr; pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pBuffer = pScreenPriv->pCoreBuffer; pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX #ifdef MPX
if (SaneID(deviceid)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[deviceid]; pBuffer = &pScreenPriv->pMPBuffers[pDev->id];
#endif #endif
pSave = pBuffer->pSave; pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
@ -631,8 +645,8 @@ miDCSaveUnderCursor (deviceid, pScreen, x, y, w, h)
} }
static Bool static Bool
miDCRestoreUnderCursor (deviceid, pScreen, x, y, w, h) miDCRestoreUnderCursor (pDev, pScreen, x, y, w, h)
int deviceid; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
int x, y, w, h; int x, y, w, h;
{ {
@ -645,8 +659,8 @@ miDCRestoreUnderCursor (deviceid, pScreen, x, y, w, h)
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr; pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pBuffer = pScreenPriv->pCoreBuffer; pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX #ifdef MPX
if (SaneID(deviceid)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[deviceid]; pBuffer = &pScreenPriv->pMPBuffers[pDev->id];
#endif #endif
pSave = pBuffer->pSave; pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
@ -663,8 +677,8 @@ miDCRestoreUnderCursor (deviceid, pScreen, x, y, w, h)
} }
static Bool static Bool
miDCChangeSave (deviceid, pScreen, x, y, w, h, dx, dy) miDCChangeSave (pDev, pScreen, x, y, w, h, dx, dy)
int deviceid; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
int x, y, w, h, dx, dy; int x, y, w, h, dx, dy;
{ {
@ -678,8 +692,8 @@ miDCChangeSave (deviceid, pScreen, x, y, w, h, dx, dy)
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr; pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pBuffer = pScreenPriv->pCoreBuffer; pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX #ifdef MPX
if (SaneID(deviceid)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[deviceid]; pBuffer = &pScreenPriv->pMPBuffers[pDev->id];
#endif #endif
pSave = pBuffer->pSave; pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
@ -802,8 +816,8 @@ miDCChangeSave (deviceid, pScreen, x, y, w, h, dx, dy)
} }
static Bool static Bool
miDCMoveCursor (deviceid, pScreen, pCursor, x, y, w, h, dx, dy, source, mask) miDCMoveCursor (pDev, pScreen, pCursor, x, y, w, h, dx, dy, source, mask)
int deviceid; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
CursorPtr pCursor; CursorPtr pCursor;
int x, y, w, h, dx, dy; int x, y, w, h, dx, dy;
@ -829,8 +843,8 @@ miDCMoveCursor (deviceid, pScreen, pCursor, x, y, w, h, dx, dy, source, mask)
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
pBuffer = pScreenPriv->pCoreBuffer; pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX #ifdef MPX
if (SaneID(deviceid)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[deviceid]; pBuffer = &pScreenPriv->pMPBuffers[pDev->id];
#endif #endif
pTemp = pBuffer->pTemp; pTemp = pBuffer->pTemp;
if (!pTemp || if (!pTemp ||

545
mi/misprite.c
View File

@ -29,15 +29,12 @@ Except as contained in this notice, the name of The Open Group shall not be
used in advertising or otherwise to promote the sale, use or other dealings used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group. in this Software without prior written authorization from The Open Group.
*/ */
#ifdef MPX /*
/*
* MPX additions: * MPX additions:
* Copyright © 2006 Peter Hutterer * Copyright © 2006 Peter Hutterer
* License see above.
* Author: Peter Hutterer <peter@cs.unisa.edu.au> * Author: Peter Hutterer <peter@cs.unisa.edu.au>
* *
*/ */
#endif
#ifdef HAVE_DIX_CONFIG_H #ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h> #include <dix-config.h>
@ -66,9 +63,7 @@ in this Software without prior written authorization from The Open Group.
# include "damage.h" # include "damage.h"
#ifdef MPX #ifdef MPX
# include "inputstr.h" /* for MAX_DEVICES */ # include "inputstr.h"
static miCursorInfoPtr DevToSprite(DeviceIntPtr pDev, ScreenPtr pScreen);
#endif #endif
@ -108,7 +103,7 @@ static void miSpriteStoreColors(ColormapPtr pMap, int ndef,
static void miSpriteSaveDoomedAreas(WindowPtr pWin, static void miSpriteSaveDoomedAreas(WindowPtr pWin,
RegionPtr pObscured, int dx, RegionPtr pObscured, int dx,
int dy); int dy);
static void miSpriteComputeSaved(miCursorInfoPtr pDevCursor, static void miSpriteComputeSaved(DeviceIntPtr pDev,
ScreenPtr pScreen); ScreenPtr pScreen);
#define SCREEN_PROLOGUE(pScreen, field)\ #define SCREEN_PROLOGUE(pScreen, field)\
@ -142,9 +137,9 @@ _X_EXPORT miPointerSpriteFuncRec miSpritePointerFuncs = {
* other misc functions * other misc functions
*/ */
static void miSpriteRemoveCursor(miCursorInfoPtr pDevCursor, static void miSpriteRemoveCursor(DeviceIntPtr pDev,
ScreenPtr pScreen); ScreenPtr pScreen);
static void miSpriteRestoreCursor(miCursorInfoPtr pDevCursor, static void miSpriteRestoreCursor(DeviceIntPtr pDev,
ScreenPtr pScreen); ScreenPtr pScreen);
static void static void
@ -152,32 +147,30 @@ miSpriteReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
{ {
ScreenPtr pScreen = closure; ScreenPtr pScreen = closure;
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo;
DeviceIntPtr pDev = inputInfo.pointer;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX #ifdef MPX
pDev = inputInfo.devices;
while(pDev)
{ {
int mpCursorIdx = 0; if (MPHasCursor(pDev))
while (mpCursorIdx < MAX_DEVICES)
{ {
miCursorInfoPtr pMPCursor = &pScreenPriv->mpCursors[mpCursorIdx]; pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
if (pMPCursor->isUp && if (pCursorInfo->isUp &&
RECT_IN_REGION (pScreen, pRegion, &pMPCursor->saved) != rgnOUT) RECT_IN_REGION (pScreen, pRegion, &pCursorInfo->saved)
{ != rgnOUT)
SPRITE_DEBUG(("Damage remove MPX\n"));
miSpriteRemoveCursor(pMPCursor, pScreen);
}
mpCursorIdx++;
}
}
#else
if (pScreenPriv->cp->isUp &&
RECT_IN_REGION (pScreen, pRegion, &pScreenPriv->cp->saved) != rgnOUT)
{ {
SPRITE_DEBUG(("Damage remove\n")); SPRITE_DEBUG(("Damage remove\n"));
miSpriteRemoveCursor (pScreenPriv->cp, pScreen); miSpriteRemoveCursor (pDev, pScreen);
}
#ifdef MPX
}
pDev = pDev->next;
} }
#endif #endif
} }
@ -351,6 +344,8 @@ miSpriteCloseScreen (i, pScreen)
#ifdef MPX #ifdef MPX
xfree((pointer)(pScreenPriv->mpCursors)); xfree((pointer)(pScreenPriv->mpCursors));
#else
xfree((pointer)(pScreenPriv->cp));
#endif #endif
xfree ((pointer) pScreenPriv); xfree ((pointer) pScreenPriv);
@ -368,37 +363,33 @@ miSpriteGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
{ {
ScreenPtr pScreen = pDrawable->pScreen; ScreenPtr pScreen = pDrawable->pScreen;
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
SCREEN_PROLOGUE (pScreen, GetImage); SCREEN_PROLOGUE (pScreen, GetImage);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX
pDev = inputInfo.devices;
while (pDev)
{
if (MPHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
if (pDrawable->type == DRAWABLE_WINDOW && if (pDrawable->type == DRAWABLE_WINDOW &&
pScreenPriv->cp->isUp && pCursorInfo->isUp &&
ORG_OVERLAP(&pScreenPriv->cp->saved,pDrawable->x,pDrawable->y, ORG_OVERLAP(&pCursorInfo->saved,pDrawable->x,pDrawable->y,
sx, sy, w, h)) sx, sy, w, h))
{ {
SPRITE_DEBUG (("GetImage remove\n")); SPRITE_DEBUG (("GetImage remove\n"));
miSpriteRemoveCursor (pScreenPriv->cp, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX #ifdef MPX
/* check for MPX cursors in the target region */
if (pDrawable->type == DRAWABLE_WINDOW)
{
int mpCursorIdx = 0;
while (mpCursorIdx < MAX_DEVICES)
{
miCursorInfoPtr pMPCursor = &pScreenPriv->mpCursors[mpCursorIdx];
if (pMPCursor->isUp &&
ORG_OVERLAP(&pMPCursor->saved,pDrawable->x,pDrawable->y,
sx, sy, w, h))
{
SPRITE_DEBUG(("GetImage remove MPX\n"));
}
miSpriteRemoveCursor(pMPCursor, pScreen);
mpCursorIdx++;
} }
pDev = pDev->next;
} }
#endif #endif
@ -419,50 +410,31 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
{ {
ScreenPtr pScreen = pDrawable->pScreen; ScreenPtr pScreen = pDrawable->pScreen;
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
SCREEN_PROLOGUE (pScreen, GetSpans); SCREEN_PROLOGUE (pScreen, GetSpans);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
if (pDrawable->type == DRAWABLE_WINDOW && pScreenPriv->cp->isUp)
{
register DDXPointPtr pts;
register int *widths;
register int nPts;
register int xorg,
yorg;
xorg = pDrawable->x;
yorg = pDrawable->y;
for (pts = ppt, widths = pwidth, nPts = nspans;
nPts--;
pts++, widths++)
{
if (SPN_OVERLAP(&pScreenPriv->cp->saved,pts->y+yorg,
pts->x+xorg,*widths))
{
SPRITE_DEBUG (("GetSpans remove\n"));
miSpriteRemoveCursor (pScreenPriv->cp, pScreen);
break;
}
}
}
#ifdef MPX #ifdef MPX
if (pDrawable->type == DRAWABLE_WINDOW) pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev))
int mpCursorIdx = 0; {
pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
while(mpCursorIdx < MAX_DEVICES) #endif
if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp)
{ {
miCursorInfoPtr pMPCursor = &pScreenPriv->mpCursors[mpCursorIdx];
register DDXPointPtr pts; register DDXPointPtr pts;
register int *widths; register int *widths;
register int nPts; register int nPts;
register int xorg, register int xorg,
yorg; yorg;
xorg = pDrawable->x; xorg = pDrawable->x;
yorg = pDrawable->y; yorg = pDrawable->y;
@ -470,18 +442,19 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
nPts--; nPts--;
pts++, widths++) pts++, widths++)
{ {
if (SPN_OVERLAP(&pMPCursor->saved,pts->y+yorg, if (SPN_OVERLAP(&pCursorInfo->saved,pts->y+yorg,
pts->x+xorg,*widths)) pts->x+xorg,*widths))
{ {
SPRITE_DEBUG (("GetSpans remove\n")); SPRITE_DEBUG (("GetSpans remove\n"));
miSpriteRemoveCursor (pMPCursor, pScreen); miSpriteRemoveCursor (pDev, pScreen);
break; break;
} }
} }
mpCursorIdx++;
} }
#ifdef MPX
}
pDev = pDev->next;
} }
#endif #endif
(*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart); (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
@ -496,38 +469,36 @@ miSpriteSourceValidate (pDrawable, x, y, width, height)
{ {
ScreenPtr pScreen = pDrawable->pScreen; ScreenPtr pScreen = pDrawable->pScreen;
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
SCREEN_PROLOGUE (pScreen, SourceValidate); SCREEN_PROLOGUE (pScreen, SourceValidate);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
if (pDrawable->type == DRAWABLE_WINDOW && pScreenPriv->cp->isUp && #ifdef MPX
ORG_OVERLAP(&pScreenPriv->cp->saved, pDrawable->x, pDrawable->y, pDev = inputInfo.devices;
while(pDev)
{
if (MPHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp &&
ORG_OVERLAP(&pCursorInfo->saved, pDrawable->x, pDrawable->y,
x, y, width, height)) x, y, width, height))
{ {
SPRITE_DEBUG (("SourceValidate remove\n")); SPRITE_DEBUG (("SourceValidate remove\n"));
miSpriteRemoveCursor (pScreenPriv->cp, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX #ifdef MPX
if (pDrawable->type == DRAWABLE_WINDOW)
{
int mpCursorIdx = 0;
while (mpCursorIdx < MAX_DEVICES)
{
miCursorInfoPtr pMPCursor = &pScreenPriv->mpCursors[mpCursorIdx];
if (pMPCursor->isUp && ORG_OVERLAP(&pMPCursor->saved,
pDrawable->x, pDrawable->y, x, y, width, height))
{
SPRITE_DEBUG(("SourceValidate remove MPX\n"));
miSpriteRemoveCursor(pMPCursor, pScreen);
} }
mpCursorIdx++; pDev = pDev->next;
}
} }
#endif #endif
if (pScreen->SourceValidate) if (pScreen->SourceValidate)
(*pScreen->SourceValidate) (pDrawable, x, y, width, height); (*pScreen->SourceValidate) (pDrawable, x, y, width, height);
@ -539,36 +510,34 @@ miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{ {
ScreenPtr pScreen = pWindow->drawable.pScreen; ScreenPtr pScreen = pWindow->drawable.pScreen;
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
SCREEN_PROLOGUE (pScreen, CopyWindow); SCREEN_PROLOGUE (pScreen, CopyWindow);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX
pDev = inputInfo.devices;
while(pDev)
{
if (MPHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
/* /*
* Damage will take care of destination check * Damage will take care of destination check
*/ */
if (pScreenPriv->cp->isUp && if (pCursorInfo->isUp &&
RECT_IN_REGION (pScreen, prgnSrc, &pScreenPriv->cp->saved) != rgnOUT) RECT_IN_REGION (pScreen, prgnSrc, &pCursorInfo->saved) != rgnOUT)
{ {
SPRITE_DEBUG (("CopyWindow remove\n")); SPRITE_DEBUG (("CopyWindow remove\n"));
miSpriteRemoveCursor (pScreenPriv->cp, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX #ifdef MPX
{
int mpCursorIdx = 0;
while (mpCursorIdx < MAX_DEVICES)
{
miCursorInfoPtr pMPCursor = &pScreenPriv->mpCursors[mpCursorIdx];
if (pMPCursor->isUp && RECT_IN_REGION (pScreen, prgnSrc,
&pMPCursor->saved) != rgnOUT)
{
SPRITE_DEBUG(("CopyWindow remove MPX\n"));
miSpriteRemoveCursor(pMPCursor, pScreen);
} }
mpCursorIdx++; pDev = pDev->next;
}
} }
#endif #endif
@ -585,8 +554,11 @@ miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
{ {
ScreenPtr pScreen = screenInfo.screens[i]; ScreenPtr pScreen = screenInfo.screens[i];
miSpriteScreenPtr pPriv; miSpriteScreenPtr pPriv;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
pPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pPriv->cp;
SCREEN_PROLOGUE(pScreen, BlockHandler); SCREEN_PROLOGUE(pScreen, BlockHandler);
@ -595,28 +567,24 @@ miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
SCREEN_EPILOGUE(pScreen, BlockHandler); SCREEN_EPILOGUE(pScreen, BlockHandler);
#ifdef MPX #ifdef MPX
pDev = inputInfo.devices;
while(pDev)
{ {
int mpCursorIdx = 0; if (MPHasCursor(pDev))
while (mpCursorIdx < MAX_DEVICES)
{ {
miCursorInfoPtr pMPCursor = &pPriv->mpCursors[mpCursorIdx]; pCursorInfo = &pPriv->mpCursors[pDev->id];
if (!pMPCursor->isUp && pMPCursor->shouldBeUp) #endif
{ if (!pCursorInfo->isUp && pCursorInfo->shouldBeUp)
SPRITE_DEBUG (("BlockHandler restore MPX\n"));
miSpriteRestoreCursor (pMPCursor, pScreen);
}
mpCursorIdx++;
}
}
#else
if (!pPriv->cp->isUp && pPriv->cp->shouldBeUp)
{ {
SPRITE_DEBUG (("BlockHandler restore\n")); SPRITE_DEBUG (("BlockHandler restore\n"));
miSpriteRestoreCursor (pPriv->cp, pScreen); miSpriteRestoreCursor (pDev, pScreen);
}
#ifdef MPX
}
pDev = pDev->next;
} }
#endif #endif
} }
static void static void
@ -625,8 +593,12 @@ miSpriteInstallColormap (pMap)
{ {
ScreenPtr pScreen = pMap->pScreen; ScreenPtr pScreen = pMap->pScreen;
miSpriteScreenPtr pPriv; miSpriteScreenPtr pPriv;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
int cursorIdx;
pPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pPriv->cp;
SCREEN_PROLOGUE(pScreen, InstallColormap); SCREEN_PROLOGUE(pScreen, InstallColormap);
@ -634,30 +606,34 @@ miSpriteInstallColormap (pMap)
SCREEN_EPILOGUE(pScreen, InstallColormap); SCREEN_EPILOGUE(pScreen, InstallColormap);
#ifdef MPX #ifdef MPX
/* InstallColormap is called before devices are initialized. We cannot
* just run through the device list, we need to go through all possible
* sprite structs.*/
cursorIdx = 0;
while(cursorIdx < MAX_DEVICES)
{ {
int mpCursorIdx = 0; pCursorInfo = &pPriv->mpCursors[cursorIdx];
while (mpCursorIdx < MAX_DEVICES) #endif
pCursorInfo->pInstalledMap = pMap;
if (pCursorInfo->pColormap != pMap)
{ {
miCursorInfoPtr pMPCursor = &pPriv->mpCursors[mpCursorIdx]; pCursorInfo->checkPixels = TRUE;
pMPCursor->pInstalledMap = pMap; if (pCursorInfo->isUp)
if (pMPCursor->pColormap != pMap)
{ {
pMPCursor->checkPixels = TRUE; #ifdef MPX
if (pMPCursor->isUp) /* find matching device */
miSpriteRemoveCursor(pMPCursor, pScreen); pDev = inputInfo.devices;
} while(pDev && pDev->id != cursorIdx)
mpCursorIdx++; pDev = pDev->next;
if (!pDev)
pDev = inputInfo.pointer;
#endif
miSpriteRemoveCursor (pDev, pScreen);
} }
} }
#else #ifdef MPX
pPriv->cp->pInstalledMap = pMap; cursorIdx++;
if (pPriv->cp->pColormap != pMap)
{
pPriv->cp->checkPixels = TRUE;
if (pPriv->cp->isUp)
miSpriteRemoveCursor (pPriv->cp, pScreen);
} }
#endif #endif
@ -674,10 +650,13 @@ miSpriteStoreColors (pMap, ndef, pdef)
int i; int i;
int updated; int updated;
VisualPtr pVisual; VisualPtr pVisual;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
pPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
SCREEN_PROLOGUE(pScreen, StoreColors); SCREEN_PROLOGUE(pScreen, StoreColors);
pCursorInfo = pPriv->cp;
(*pScreen->StoreColors) (pMap, ndef, pdef); (*pScreen->StoreColors) (pMap, ndef, pdef);
@ -698,58 +677,14 @@ miSpriteStoreColors (pMap, ndef, pdef)
UpdateDAC(dev, plane,blue,blueMask) UpdateDAC(dev, plane,blue,blueMask)
#ifdef MPX #ifdef MPX
pDev = inputInfo.devices;
while(pDev)
{ {
int mpCursorIdx = 0; if (MPHasCursor(pDev))
while (mpCursorIdx < MAX_DEVICES)
{ {
miCursorInfoPtr pMPCursor = &pPriv->mpCursors[mpCursorIdx]; pCursorInfo = &pPriv->mpCursors[pDev->id];
#endif
if (pPriv->cp->pColormap == pMap) if (pCursorInfo->pColormap == pMap)
{
updated = 0;
pVisual = pMap->pVisual;
if (pVisual->class == DirectColor)
{
for (i = 0; i < ndef; i++)
{
CheckDirect (pMPCursor, SOURCE_COLOR)
CheckDirect (pMPCursor, MASK_COLOR)
}
}
else
{
/* PseudoColor/GrayScale - match on exact pixel */
for (i = 0; i < ndef; i++)
{
if (pdef[i].pixel ==
pMPCursor->colors[SOURCE_COLOR].pixel)
{
pMPCursor->colors[SOURCE_COLOR] = pdef[i];
if (++updated == 2)
break;
}
if (pdef[i].pixel ==
pMPCursor->colors[MASK_COLOR].pixel)
{
pMPCursor->colors[MASK_COLOR] = pdef[i];
if (++updated == 2)
break;
}
}
}
if (updated)
{
pMPCursor->checkPixels = TRUE;
if (pMPCursor->isUp)
miSpriteRemoveCursor (pMPCursor, pScreen);
}
}
mpCursorIdx++;
}
}
#else
if (pPriv->cp->pColormap == pMap)
{ {
updated = 0; updated = 0;
pVisual = pMap->pVisual; pVisual = pMap->pVisual;
@ -768,15 +703,17 @@ miSpriteStoreColors (pMap, ndef, pdef)
/* PseudoColor/GrayScale - match on exact pixel */ /* PseudoColor/GrayScale - match on exact pixel */
for (i = 0; i < ndef; i++) for (i = 0; i < ndef; i++)
{ {
if (pdef[i].pixel == pPriv->cp->colors[SOURCE_COLOR].pixel) if (pdef[i].pixel ==
pCursorInfo->colors[SOURCE_COLOR].pixel)
{ {
pPriv->cp->colors[SOURCE_COLOR] = pdef[i]; pCursorInfo->colors[SOURCE_COLOR] = pdef[i];
if (++updated == 2) if (++updated == 2)
break; break;
} }
if (pdef[i].pixel == pPriv->cp->colors[MASK_COLOR].pixel) if (pdef[i].pixel ==
pCursorInfo->colors[MASK_COLOR].pixel)
{ {
pPriv->cp->colors[MASK_COLOR] = pdef[i]; pCursorInfo->colors[MASK_COLOR] = pdef[i];
if (++updated == 2) if (++updated == 2)
break; break;
} }
@ -784,11 +721,15 @@ miSpriteStoreColors (pMap, ndef, pdef)
} }
if (updated) if (updated)
{ {
pPriv->cp->checkPixels = TRUE; pCursorInfo->checkPixels = TRUE;
if (pPriv->cp->isUp) if (pCursorInfo->isUp)
miSpriteRemoveCursor (pPriv->cp, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
} }
#ifdef MPX
}
pDev = pDev->next;
}
#endif #endif
} }
@ -841,22 +782,27 @@ miSpriteSaveDoomedAreas (pWin, pObscured, dx, dy)
ScreenPtr pScreen; ScreenPtr pScreen;
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
BoxRec cursorBox; BoxRec cursorBox;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
pScreen = pWin->drawable.pScreen; pScreen = pWin->drawable.pScreen;
SCREEN_PROLOGUE (pScreen, SaveDoomedAreas); SCREEN_PROLOGUE (pScreen, SaveDoomedAreas);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX #ifdef MPX
pDev = inputInfo.devices;
while(pDev)
{ {
int mpCursorIdx = 0; if(MPHasCursor(pDev))
while (mpCursorIdx < MAX_DEVICES)
{ {
miCursorInfoPtr pMPCursor = &pScreenPriv->mpCursors[mpCursorIdx]; pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
if (pMPCursor->isUp) if (pCursorInfo->isUp)
{ {
cursorBox = pMPCursor->saved; cursorBox = pCursorInfo->saved;
if (dx || dy) if (dx || dy)
{ {
@ -866,25 +812,12 @@ miSpriteSaveDoomedAreas (pWin, pObscured, dx, dy)
cursorBox.y2 += dy; cursorBox.y2 += dy;
} }
if (RECT_IN_REGION( pScreen, pObscured, &cursorBox) != rgnOUT) if (RECT_IN_REGION( pScreen, pObscured, &cursorBox) != rgnOUT)
miSpriteRemoveCursor (pMPCursor, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
mpCursorIdx++;
}
}
#else
if (pScreenPriv->cp->isUp)
{
cursorBox = pScreenPriv->cp->saved;
if (dx || dy) #ifdef MPX
{
cursorBox.x1 += dx;
cursorBox.y1 += dy;
cursorBox.x2 += dx;
cursorBox.y2 += dy;
} }
if (RECT_IN_REGION( pScreen, pObscured, &cursorBox) != rgnOUT) pDev = pDev->next;
miSpriteRemoveCursor (pScreenPriv->cp, pScreen);
} }
#endif #endif
@ -906,19 +839,19 @@ miSpriteRealizeCursor (pDev, pScreen, pCursor)
CursorPtr pCursor; CursorPtr pCursor;
{ {
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX #ifdef MPX
{ if (MPHasCursor(pDev))
miCursorInfoPtr pMPCursor = DevToSprite(pDev, pScreen); pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
if (pCursor == pMPCursor->pCursor)
pMPCursor->checkPixels = TRUE;
}
#else
if (pCursor == pScreenPriv->cp->pCursor)
pScreenPriv->cp->checkPixels = TRUE;
#endif #endif
if (pCursor == pCursorInfo->pCursor)
pCursorInfo->checkPixels = TRUE;
return (*pScreenPriv->funcs->RealizeCursor) (pScreen, pCursor); return (*pScreenPriv->funcs->RealizeCursor) (pScreen, pCursor);
} }
@ -947,7 +880,7 @@ miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
miCursorInfoPtr pPointer = pScreenPriv->cp; miCursorInfoPtr pPointer = pScreenPriv->cp;
#ifdef MPX #ifdef MPX
if (IsMPDev(pDev)) if (MPHasCursor(pDev))
pPointer = &pScreenPriv->mpCursors[pDev->id]; pPointer = &pScreenPriv->mpCursors[pDev->id];
#endif #endif
@ -955,7 +888,7 @@ miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
{ {
pPointer->shouldBeUp = FALSE; pPointer->shouldBeUp = FALSE;
if (pPointer->isUp) if (pPointer->isUp)
miSpriteRemoveCursor (pPointer, pScreen); miSpriteRemoveCursor (pDev, pScreen);
pPointer->pCursor = 0; pPointer->pCursor = 0;
return; return;
} }
@ -1041,14 +974,14 @@ miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
#endif #endif
{ {
SPRITE_DEBUG (("SetCursor remove\n")); SPRITE_DEBUG (("SetCursor remove\n"));
miSpriteRemoveCursor (pPointer, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
} }
if (!pPointer->isUp && pPointer->pCursor) if (!pPointer->isUp && pPointer->pCursor)
{ {
SPRITE_DEBUG (("SetCursor restore\n")); SPRITE_DEBUG (("SetCursor restore\n"));
miSpriteRestoreCursor (pPointer, pScreen); miSpriteRestoreCursor (pDev, pScreen);
} }
} }
@ -1066,7 +999,7 @@ miSpriteMoveCursor (pDev, pScreen, x, y)
pCursor = pScreenPriv->cp->pCursor; pCursor = pScreenPriv->cp->pCursor;
#ifdef MPX #ifdef MPX
if (IsMPDev(pDev)) if (MPHasCursor(pDev))
pCursor = pScreenPriv->mpCursors[pDev->id].pCursor; pCursor = pScreenPriv->mpCursors[pDev->id].pCursor;
#endif #endif
miSpriteSetCursor (pDev, pScreen, pCursor, x, y); miSpriteSetCursor (pDev, pScreen, pCursor, x, y);
@ -1077,26 +1010,35 @@ miSpriteMoveCursor (pDev, pScreen, x, y)
*/ */
static void static void
miSpriteRemoveCursor (pDevCursor, pScreen) miSpriteRemoveCursor (pDev, pScreen)
miCursorInfoPtr pDevCursor; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
{ {
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo;
DamageDrawInternal (pScreen, TRUE); DamageDrawInternal (pScreen, TRUE);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
miSpriteIsUpFALSE (pDevCursor, pScreen, pScreenPriv); pCursorInfo = pScreenPriv->cp;
pDevCursor->pCacheWin = NullWindow;
if (!(*pScreenPriv->funcs->RestoreUnderCursor) (pDevCursor->id, #ifdef MPX
if (MPHasCursor(pDev))
pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
miSpriteIsUpFALSE (pCursorInfo, pScreen, pScreenPriv);
pCursorInfo->pCacheWin = NullWindow;
if (!(*pScreenPriv->funcs->RestoreUnderCursor) (pDev,
pScreen, pScreen,
pDevCursor->saved.x1, pCursorInfo->saved.x1,
pDevCursor->saved.y1, pCursorInfo->saved.y1,
pDevCursor->saved.x2 - pCursorInfo->saved.x2 -
pDevCursor->saved.x1, pCursorInfo->saved.x1,
pDevCursor->saved.y2 - pCursorInfo->saved.y2 -
pDevCursor->saved.y1)) pCursorInfo->saved.y1))
{ {
miSpriteIsUpTRUE (pDevCursor, pScreen, pScreenPriv); miSpriteIsUpTRUE (pCursorInfo, pScreen, pScreenPriv);
} }
DamageDrawInternal (pScreen, FALSE); DamageDrawInternal (pScreen, FALSE);
} }
@ -1107,37 +1049,46 @@ miSpriteRemoveCursor (pDevCursor, pScreen)
*/ */
static void static void
miSpriteRestoreCursor (pDevCursor, pScreen) miSpriteRestoreCursor (pDev, pScreen)
miCursorInfoPtr pDevCursor; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
{ {
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
int x, y; int x, y;
CursorPtr pCursor; CursorPtr pCursor;
miCursorInfoPtr pCursorInfo;
DamageDrawInternal (pScreen, TRUE); DamageDrawInternal (pScreen, TRUE);
miSpriteComputeSaved (pDevCursor, pScreen);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursor = pDevCursor->pCursor; pCursorInfo = pScreenPriv->cp;
x = pDevCursor->x - (int)pCursor->bits->xhot;
y = pDevCursor->y - (int)pCursor->bits->yhot; #ifdef MPX
if ((*pScreenPriv->funcs->SaveUnderCursor) (pDevCursor->id, if (MPHasCursor(pDev))
pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
miSpriteComputeSaved (pDev, pScreen);
pCursor = pCursorInfo->pCursor;
x = pCursorInfo->x - (int)pCursor->bits->xhot;
y = pCursorInfo->y - (int)pCursor->bits->yhot;
if ((*pScreenPriv->funcs->SaveUnderCursor) (pDev,
pScreen, pScreen,
pDevCursor->saved.x1, pCursorInfo->saved.x1,
pDevCursor->saved.y1, pCursorInfo->saved.y1,
pDevCursor->saved.x2 - pCursorInfo->saved.x2 -
pDevCursor->saved.x1, pCursorInfo->saved.x1,
pDevCursor->saved.y2 - pCursorInfo->saved.y2 -
pDevCursor->saved.y1)) pCursorInfo->saved.y1))
{ {
if (pDevCursor->checkPixels) if (pCursorInfo->checkPixels)
miSpriteFindColors (pDevCursor, pScreen); miSpriteFindColors (pCursorInfo, pScreen);
if ((*pScreenPriv->funcs->PutUpCursor) (pDevCursor->id, pScreen, if ((*pScreenPriv->funcs->PutUpCursor) (pDev, pScreen,
pCursor, x, y, pCursor, x, y,
pDevCursor->colors[SOURCE_COLOR].pixel, pCursorInfo->colors[SOURCE_COLOR].pixel,
pDevCursor->colors[MASK_COLOR].pixel)) pCursorInfo->colors[MASK_COLOR].pixel))
{ {
miSpriteIsUpTRUE (pDevCursor, pScreen, pScreenPriv); miSpriteIsUpTRUE (pCursorInfo, pScreen, pScreenPriv);
} }
} }
DamageDrawInternal (pScreen, FALSE); DamageDrawInternal (pScreen, FALSE);
@ -1148,43 +1099,35 @@ miSpriteRestoreCursor (pDevCursor, pScreen)
*/ */
static void static void
miSpriteComputeSaved (pDevCursor, pScreen) miSpriteComputeSaved (pDev, pScreen)
miCursorInfoPtr pDevCursor; DeviceIntPtr pDev;
ScreenPtr pScreen; ScreenPtr pScreen;
{ {
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
int x, y, w, h; int x, y, w, h;
int wpad, hpad; int wpad, hpad;
CursorPtr pCursor; CursorPtr pCursor;
miCursorInfoPtr pCursorInfo;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursor = pDevCursor->pCursor; pCursorInfo = pScreenPriv->cp;
x = pDevCursor->x - (int)pCursor->bits->xhot;
y = pDevCursor->y - (int)pCursor->bits->yhot; #ifdef MPX
if (MPHasCursor(pDev))
pCursorInfo = &pScreenPriv->mpCursors[pDev->id];
#endif
pCursor = pCursorInfo->pCursor;
x = pCursorInfo->x - (int)pCursor->bits->xhot;
y = pCursorInfo->y - (int)pCursor->bits->yhot;
w = pCursor->bits->width; w = pCursor->bits->width;
h = pCursor->bits->height; h = pCursor->bits->height;
wpad = SPRITE_PAD; wpad = SPRITE_PAD;
hpad = SPRITE_PAD; hpad = SPRITE_PAD;
pDevCursor->saved.x1 = x - wpad; pCursorInfo->saved.x1 = x - wpad;
pDevCursor->saved.y1 = y - hpad; pCursorInfo->saved.y1 = y - hpad;
pDevCursor->saved.x2 = pDevCursor->saved.x1 + w + wpad * 2; pCursorInfo->saved.x2 = pCursorInfo->saved.x1 + w + wpad * 2;
pDevCursor->saved.y2 = pDevCursor->saved.y1 + h + hpad * 2; pCursorInfo->saved.y2 = pCursorInfo->saved.y1 + h + hpad * 2;
} }
#ifdef MPX
static miCursorInfoPtr DevToSprite(DeviceIntPtr pDev, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
int mpCursorIdx = 0;
while(mpCursorIdx < MAX_DEVICES)
{
miCursorInfoPtr pMPCursor = &pScreenPriv->mpCursors[mpCursorIdx];
if (pMPCursor->id == pDev->id)
return pMPCursor;
mpCursorIdx++;
}
return pScreenPriv->cp;
}
#endif

10
mi/misprite.h
View File

@ -42,7 +42,7 @@ typedef struct {
CursorPtr /*pCursor*/ CursorPtr /*pCursor*/
); );
Bool (*PutUpCursor)( Bool (*PutUpCursor)(
int /* deviceid */, DeviceIntPtr /*pDev*/,
ScreenPtr /*pScreen*/, ScreenPtr /*pScreen*/,
CursorPtr /*pCursor*/, CursorPtr /*pCursor*/,
int /*x*/, int /*x*/,
@ -51,7 +51,7 @@ typedef struct {
unsigned long /*mask*/ unsigned long /*mask*/
); );
Bool (*SaveUnderCursor)( Bool (*SaveUnderCursor)(
int /* deviceid */, DeviceIntPtr /*pDev*/,
ScreenPtr /*pScreen*/, ScreenPtr /*pScreen*/,
int /*x*/, int /*x*/,
int /*y*/, int /*y*/,
@ -59,7 +59,7 @@ typedef struct {
int /*h*/ int /*h*/
); );
Bool (*RestoreUnderCursor)( Bool (*RestoreUnderCursor)(
int /* deviceid */, DeviceIntPtr /*pDev*/,
ScreenPtr /*pScreen*/, ScreenPtr /*pScreen*/,
int /*x*/, int /*x*/,
int /*y*/, int /*y*/,
@ -67,7 +67,7 @@ typedef struct {
int /*h*/ int /*h*/
); );
Bool (*MoveCursor)( Bool (*MoveCursor)(
int /* deviceid */, DeviceIntPtr /*pDev*/,
ScreenPtr /*pScreen*/, ScreenPtr /*pScreen*/,
CursorPtr /*pCursor*/, CursorPtr /*pCursor*/,
int /*x*/, int /*x*/,
@ -80,7 +80,7 @@ typedef struct {
unsigned long /*mask*/ unsigned long /*mask*/
); );
Bool (*ChangeSave)( Bool (*ChangeSave)(
int /* deviceid */, DeviceIntPtr /*pDev*/,
ScreenPtr /*pScreen*/, ScreenPtr /*pScreen*/,
int /*x*/, int /*x*/,
int /*y*/, int /*y*/,