frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mi: removing MPX ifdefs 

global sprite renaming in mipointer and misprite
	fixed: multiple remove cursor call in miSpriteInstallColormap
	fixed: wrong core pointer usage in miSpriteStoreColors

dix:    bugfix in CheckCursorConfinement
	removing MPX ifdefs
	removing MPX event generation (using Xi solely now)
This commit is contained in:
Peter Hutterer 2006-12-14 10:50:18 +10:30 committed by Peter Hutterer
parent ae3c24da34
commit a96788058e
8 changed files with 214 additions and 452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Changelog
View File

@ -1,4 +1,22 @@
MPX Changelog file == 14.12.06 ==
mi: removing MPX ifdefs
global sprite renaming in mipointer and misprite
fixed: multiple remove cursor call in miSpriteInstallColormap
fixed: wrong core pointer usage in miSpriteStoreColors
dix: bugfix in CheckCursorConfinement
removing MPX ifdefs
removing MPX event generation (using Xi solely now)
Files:
mi/midispcur.c
mi/misprite.c
mi/mispritest.h
mi/mipointer.c
dix/getevents.c
dix/events.c
dix/cursor.c
== 12.12.06 == == 12.12.06 ==
dix: Moving SpriteRec into DeviceIntRec dix: Moving SpriteRec into DeviceIntRec
removing global sprite structure removing global sprite structure

37
dix/cursor.c
View File

@ -128,16 +128,11 @@ FreeCursor(pointer value, XID cid)
for (nscr = 0; nscr < screenInfo.numScreens; nscr++) for (nscr = 0; nscr < screenInfo.numScreens; nscr++)
{ {
pscr = screenInfo.screens[nscr]; pscr = screenInfo.screens[nscr];
#ifdef MPX for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
#endif if (MPHasCursor(pDev))
(void)( *pscr->UnrealizeCursor)(pDev, pscr, pCurs); (void)( *pscr->UnrealizeCursor)(pDev, pscr, pCurs);
#ifdef MPX
pDev = pDev->next;
} }
#endif
} }
FreeCursorBits(pCurs->bits); FreeCursorBits(pCurs->bits);
xfree( pCurs); xfree( pCurs);
@ -231,16 +226,12 @@ AllocCursorARGB(unsigned char *psrcbits, unsigned char *pmaskbits, CARD32 *argb,
for (nscr = 0; nscr < screenInfo.numScreens; nscr++) for (nscr = 0; nscr < screenInfo.numScreens; nscr++)
{ {
pscr = screenInfo.screens[nscr]; pscr = screenInfo.screens[nscr];
#ifdef MPX for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
#endif
if (!( *pscr->RealizeCursor)(pDev, pscr, pCurs)) if (!( *pscr->RealizeCursor)(pDev, pscr, pCurs))
{ {
#ifdef MPX
/* Realize failed for device pDev on screen pscr. /* Realize failed for device pDev on screen pscr.
* We have to assume that for all devices before, realize * We have to assume that for all devices before, realize
* worked. We need to rollback all devices so far on the * worked. We need to rollback all devices so far on the
@ -254,11 +245,9 @@ AllocCursorARGB(unsigned char *psrcbits, unsigned char *pmaskbits, CARD32 *argb,
( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs); ( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs);
pDevIt = pDevIt->next; pDevIt = pDevIt->next;
} }
#endif
while (--nscr >= 0) while (--nscr >= 0)
{ {
pscr = screenInfo.screens[nscr]; pscr = screenInfo.screens[nscr];
#ifdef MPX
/* now unrealize all devices on previous screens */ /* now unrealize all devices on previous screens */
pDevIt = inputInfo.devices; pDevIt = inputInfo.devices;
while (pDevIt) while (pDevIt)
@ -267,19 +256,14 @@ AllocCursorARGB(unsigned char *psrcbits, unsigned char *pmaskbits, CARD32 *argb,
( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs); ( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs);
pDevIt = pDevIt->next; pDevIt = pDevIt->next;
} }
#else
( *pscr->UnrealizeCursor)(pDev, pscr, pCurs); ( *pscr->UnrealizeCursor)(pDev, pscr, pCurs);
#endif
} }
FreeCursorBits(bits); FreeCursorBits(bits);
xfree(pCurs); xfree(pCurs);
return (CursorPtr)NULL; return (CursorPtr)NULL;
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
} }
return pCurs; return pCurs;
} }
@ -462,16 +446,12 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
for (nscr = 0; nscr < screenInfo.numScreens; nscr++) for (nscr = 0; nscr < screenInfo.numScreens; nscr++)
{ {
pscr = screenInfo.screens[nscr]; pscr = screenInfo.screens[nscr];
#ifdef MPX for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
#endif
if (!( *pscr->RealizeCursor)(pDev, pscr, pCurs)) if (!( *pscr->RealizeCursor)(pDev, pscr, pCurs))
{ {
#ifdef MPX
/* Realize failed for device pDev on screen pscr. /* Realize failed for device pDev on screen pscr.
* We have to assume that for all devices before, realize * We have to assume that for all devices before, realize
* worked. We need to rollback all devices so far on the * worked. We need to rollback all devices so far on the
@ -485,11 +465,9 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs); ( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs);
pDevIt = pDevIt->next; pDevIt = pDevIt->next;
} }
#endif
while (--nscr >= 0) while (--nscr >= 0)
{ {
pscr = screenInfo.screens[nscr]; pscr = screenInfo.screens[nscr];
#ifdef MPX
/* now unrealize all devices on previous screens */ /* now unrealize all devices on previous screens */
pDevIt = inputInfo.devices; pDevIt = inputInfo.devices;
while (pDevIt) while (pDevIt)
@ -498,19 +476,14 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs); ( *pscr->UnrealizeCursor)(pDevIt, pscr, pCurs);
pDevIt = pDevIt->next; pDevIt = pDevIt->next;
} }
#else
( *pscr->UnrealizeCursor)(pDev, pscr, pCurs); ( *pscr->UnrealizeCursor)(pDev, pscr, pCurs);
#endif
} }
FreeCursorBits(bits); FreeCursorBits(bits);
xfree(pCurs); xfree(pCurs);
return BadAlloc; return BadAlloc;
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
} }
*ppCurs = pCurs; *ppCurs = pCurs;
return Success; return Success;

15
dix/events.c
View File

@ -4589,13 +4589,16 @@ CheckCursorConfinement(WindowPtr pWin)
for (pDev = inputInfo.devices; pDev; pDev = pDev->next) for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
{ {
grab = pDev->grab; if (MPHasCursor(pDev))
if (grab && (confineTo = grab->confineTo))
{ {
if (!BorderSizeNotEmpty(pDev, confineTo)) grab = pDev->grab;
(*inputInfo.pointer->DeactivateGrab)(pDev); if (grab && (confineTo = grab->confineTo))
else if ((pWin == confineTo) || IsParent(pWin, confineTo)) {
ConfineCursorToWindow(pDev, confineTo, TRUE, TRUE); if (!BorderSizeNotEmpty(pDev, confineTo))
(*inputInfo.pointer->DeactivateGrab)(pDev);
else if ((pWin == confineTo) || IsParent(pWin, confineTo))
ConfineCursorToWindow(pDev, confineTo, TRUE, TRUE);
}
} }
} }
} }

58
dix/getevents.c
View File

@ -66,12 +66,6 @@ extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
#include "exglobals.h" #include "exglobals.h"
#include "extnsionst.h" #include "extnsionst.h"
#ifdef MPX
#include <X11/extensions/MPXconst.h>
#include <X11/extensions/MPXproto.h>
#include "mpxglobals.h"
#endif
/* Maximum number of valuators, divided by six, rounded up, to get number /* Maximum number of valuators, divided by six, rounded up, to get number
* of events. */ * of events. */
#define MAX_VALUATOR_EVENTS 6 #define MAX_VALUATOR_EVENTS 6
@ -505,12 +499,8 @@ GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
if ((type == ButtonPress || type == ButtonRelease) && !pDev->button) if ((type == ButtonPress || type == ButtonRelease) && !pDev->button)
return 0; return 0;
#ifdef MPX
if (pDev->isMPDev) if (pDev->coreEvents || pDev->isMPDev)
num_events = 3;
else
#endif
if (pDev->coreEvents)
num_events = 2; num_events = 2;
else else
num_events = 1; num_events = 1;
@ -537,15 +527,10 @@ GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
kbp->time = ms; kbp->time = ms;
kbp->deviceid = pDev->id; kbp->deviceid = pDev->id;
#ifdef MPX if (!pDev->coreEvents || pDev->isMPDev)
if (pDev->isMPDev)
pointer = pDev; pointer = pDev;
else else
#endif
if (pDev->coreEvents)
pointer = inputInfo.pointer; pointer = inputInfo.pointer;
else
pointer = pDev;
/* Set x and y based on whether this is absolute or relative, and /* Set x and y based on whether this is absolute or relative, and
* accelerate if we need to. */ * accelerate if we need to. */
@ -598,16 +583,10 @@ GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
updateMotionHistory(pDev, ms, first_valuator, num_valuators, valuators); updateMotionHistory(pDev, ms, first_valuator, num_valuators, valuators);
#ifdef MPX if (pDev->coreEvents && !pDev->isMPDev) {
if (pDev->isMPDev)
{
// noop, just less intrusive to fit MPX in like that
} else
#endif
if (pDev->coreEvents) {
/* set the virtual core pointer's coordinates */ /* set the virtual core pointer's coordinates */
pointer->valuator->lastx = x; inputInfo.pointer->valuator->lastx = x;
pointer->valuator->lasty = y; inputInfo.pointer->valuator->lasty = y;
} }
pDev->valuator->lastx = x; pDev->valuator->lastx = x;
pDev->valuator->lasty = y; pDev->valuator->lasty = y;
@ -634,31 +613,8 @@ GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
num_valuators, valuators); num_valuators, valuators);
} }
#ifdef MPX
if (pDev->isMPDev)
{
/* MPX events are the same as XI events but without valuators. */
memcpy(events, kbp, sizeof(deviceKeyButtonPointer));
switch(type)
{
case ButtonPress:
events->u.u.type = MPXButtonPress;
break;
case ButtonRelease:
events->u.u.type = MPXButtonRelease;
break;
case MotionNotify:
events->u.u.type = MPXMotionNotify;
break;
}
events++;
}
/* MPX devices always send core events */ /* MPX devices always send core events */
if (pDev->coreEvents || pDev->isMPDev) { if (pDev->coreEvents || pDev->isMPDev) {
#else
if (pDev->coreEvents) {
#endif
events->u.u.type = type; events->u.u.type = type;
events->u.keyButtonPointer.time = ms; events->u.keyButtonPointer.time = ms;
events->u.keyButtonPointer.rootX = x; events->u.keyButtonPointer.rootX = x;

141
mi/midispcur.c
View File

@ -58,11 +58,7 @@ in this Software without prior written authorization from The Open Group.
# include "picturestr.h" # include "picturestr.h"
#endif #endif
#ifdef MPX # include "inputstr.h" /* for MAX_DEVICES */
# include "inputstr.h"
#define SaneID(a) (a >= 0 && a < MAX_DEVICES)
#endif
/* per-screen private data */ /* per-screen private data */
@ -83,11 +79,13 @@ typedef struct {
#endif #endif
} miDCBufferRec, *miDCBufferPtr; } miDCBufferRec, *miDCBufferPtr;
/*
* The core pointer buffer will point to the index of the virtual core pointer
* in the pCursorBuffers array.
*/
typedef struct { typedef struct {
miDCBufferPtr pCoreBuffer; /* for core pointer */ miDCBufferPtr pCoreBuffer; /* for core pointer */
#ifdef MPX miDCBufferPtr pCursorBuffers; /* one for each device */
miDCBufferPtr pMPBuffers; /* for MPX pointers */
#endif
CloseScreenProcPtr CloseScreen; CloseScreenProcPtr CloseScreen;
} miDCScreenRec, *miDCScreenPtr; } miDCScreenRec, *miDCScreenPtr;
@ -140,6 +138,7 @@ miDCInitialize (pScreen, screenFuncs)
{ {
miDCScreenPtr pScreenPriv; miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer; miDCBufferPtr pBuffer;
int mpBufferIdx;
if (miDCGeneration != serverGeneration) if (miDCGeneration != serverGeneration)
{ {
@ -155,52 +154,37 @@ miDCInitialize (pScreen, screenFuncs)
/* /*
* initialize the entire private structure to zeros * initialize the entire private structure to zeros
*/ */
#if !defined MPX
pScreenPriv->pCoreBuffer = (miDCBufferPtr)xalloc(sizeof(miDCBufferRec)); pScreenPriv->pCursorBuffers = (miDCBufferPtr)xalloc(MAX_DEVICES *
if (!pScreenPriv->pCoreBuffer) sizeof(miDCBufferRec));
if (!pScreenPriv->pCursorBuffers)
{ {
xfree((pointer)pScreenPriv); xfree((pointer)pScreenPriv);
return FALSE; return FALSE;
} }
pBuffer = pScreenPriv->pCoreBuffer;
#else /* ifdef MPX */ /* virtual core pointer ID is 1 */
pScreenPriv->pCoreBuffer = &pScreenPriv->pCursorBuffers[1];
mpBufferIdx = 0;
while(mpBufferIdx < MAX_DEVICES)
{ {
int mpBufferIdx = 0; pBuffer = &pScreenPriv->pCursorBuffers[mpBufferIdx];
pBuffer->pSourceGC =
pScreenPriv->pMPBuffers = (miDCBufferPtr)xalloc(MAX_DEVICES * pBuffer->pMaskGC =
sizeof(miDCBufferRec)); pBuffer->pSaveGC =
if (!pScreenPriv->pMPBuffers) pBuffer->pRestoreGC =
{ pBuffer->pMoveGC =
xfree((pointer)pScreenPriv); pBuffer->pPixSourceGC =
return FALSE; pBuffer->pPixMaskGC = NULL;
}
/* virtual core pointer ID is 1 */
pScreenPriv->pCoreBuffer = &pScreenPriv->pMPBuffers[1];
while(mpBufferIdx < MAX_DEVICES)
{
pBuffer = &pScreenPriv->pMPBuffers[mpBufferIdx];
#endif
pBuffer->pSourceGC =
pBuffer->pMaskGC =
pBuffer->pSaveGC =
pBuffer->pRestoreGC =
pBuffer->pMoveGC =
pBuffer->pPixSourceGC =
pBuffer->pPixMaskGC = NULL;
#ifdef ARGB_CURSOR #ifdef ARGB_CURSOR
pBuffer->pRootPicture = NULL; pBuffer->pRootPicture = NULL;
pBuffer->pTempPicture = NULL; pBuffer->pTempPicture = NULL;
#endif #endif
pBuffer->pSave = pBuffer->pTemp = NULL;
pBuffer->pSave = pBuffer->pTemp = NULL; mpBufferIdx++;
#ifdef MPX
mpBufferIdx++;
}
} }
#endif
pScreenPriv->CloseScreen = pScreen->CloseScreen; pScreenPriv->CloseScreen = pScreen->CloseScreen;
@ -210,11 +194,7 @@ miDCInitialize (pScreen, screenFuncs)
if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs)) if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs))
{ {
#ifdef MPX xfree ((pointer) pScreenPriv->pCursorBuffers);
xfree((pointer)pScreenPriv->pMPBuffers);
#else
xfree((pointer)pScreenPriv->pCoreBuffer);
#endif
xfree ((pointer) pScreenPriv); xfree ((pointer) pScreenPriv);
return FALSE; return FALSE;
} }
@ -232,28 +212,25 @@ miDCCloseScreen (index, pScreen)
{ {
miDCScreenPtr pScreenPriv; miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer; miDCBufferPtr pBuffer;
int mpBufferIdx;
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr; pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pScreen->CloseScreen = pScreenPriv->CloseScreen; pScreen->CloseScreen = pScreenPriv->CloseScreen;
pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX mpBufferIdx = 0;
while (mpBufferIdx < MAX_DEVICES)
{ {
int mpBufferIdx = 0; pBuffer = &pScreenPriv->pCursorBuffers[mpBufferIdx];
while (mpBufferIdx < MAX_DEVICES)
{
pBuffer = &pScreenPriv->pMPBuffers[mpBufferIdx];
#endif tossGC (pBuffer->pSourceGC);
tossGC (pBuffer->pSourceGC); tossGC (pBuffer->pMaskGC);
tossGC (pBuffer->pMaskGC); tossGC (pBuffer->pSaveGC);
tossGC (pBuffer->pSaveGC); tossGC (pBuffer->pRestoreGC);
tossGC (pBuffer->pRestoreGC); tossGC (pBuffer->pMoveGC);
tossGC (pBuffer->pMoveGC); tossGC (pBuffer->pPixSourceGC);
tossGC (pBuffer->pPixSourceGC); tossGC (pBuffer->pPixMaskGC);
tossGC (pBuffer->pPixMaskGC); tossPix (pBuffer->pSave);
tossPix (pBuffer->pSave); tossPix (pBuffer->pTemp);
tossPix (pBuffer->pTemp);
#ifdef ARGB_CURSOR #ifdef ARGB_CURSOR
#if 0 /* This has been free()d before */ #if 0 /* This has been free()d before */
tossPict (pScreenPriv->pRootPicture); tossPict (pScreenPriv->pRootPicture);
@ -261,16 +238,10 @@ miDCCloseScreen (index, pScreen)
tossPict (pBuffer->pTempPicture); tossPict (pBuffer->pTempPicture);
#endif #endif
#ifdef MPX
mpBufferIdx++; mpBufferIdx++;
}
} }
xfree((pointer) pScreenPriv->pMPBuffers); xfree((pointer) pScreenPriv->pCursorBuffers);
#else
xfree((pointer) pScreenPriv->pCoreBuffer);
#endif
xfree ((pointer) pScreenPriv); xfree ((pointer) pScreenPriv);
return (*pScreen->CloseScreen) (index, pScreen); return (*pScreen->CloseScreen) (index, pScreen);
@ -567,10 +538,8 @@ miDCPutUpCursor (pDev, pScreen, pCursor, x, y, source, mask)
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
pBuffer = pScreenPriv->pCoreBuffer; pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[pDev->id]; pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
#endif
#ifdef ARGB_CURSOR #ifdef ARGB_CURSOR
if (pPriv->pPicture) if (pPriv->pPicture)
@ -619,10 +588,10 @@ miDCSaveUnderCursor (pDev, 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
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[pDev->id]; pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
#endif
pSave = pBuffer->pSave; pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
if (!pSave || pSave->drawable.width < w || pSave->drawable.height < h) if (!pSave || pSave->drawable.width < w || pSave->drawable.height < h)
@ -658,10 +627,10 @@ miDCRestoreUnderCursor (pDev, 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
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[pDev->id]; pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
#endif
pSave = pBuffer->pSave; pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
if (!pSave) if (!pSave)
@ -691,10 +660,10 @@ miDCChangeSave (pDev, 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
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[pDev->id]; pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
#endif
pSave = pBuffer->pSave; pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
/* /*
@ -842,10 +811,10 @@ miDCMoveCursor (pDev, pScreen, pCursor, x, y, w, h, dx, dy, source, mask)
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr; pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pWin = WindowTable[pScreen->myNum]; pWin = WindowTable[pScreen->myNum];
pBuffer = pScreenPriv->pCoreBuffer; pBuffer = pScreenPriv->pCoreBuffer;
#ifdef MPX
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pBuffer = &pScreenPriv->pMPBuffers[pDev->id]; pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
#endif
pTemp = pBuffer->pTemp; pTemp = pBuffer->pTemp;
if (!pTemp || if (!pTemp ||
pTemp->drawable.width != pBuffer->pSave->drawable.width || pTemp->drawable.width != pBuffer->pSave->drawable.width ||

143
mi/mipointer.c
View File

@ -1,5 +1,5 @@
/* /*
* miPointer->c * mipointer.c
*/ */
@ -63,15 +63,14 @@ static unsigned long miPointerGeneration = 0;
* until more than one pointer device exists. * until more than one pointer device exists.
*/ */
static miPointerPtr miPointer; static miPointerPtr miCorePointer;
#ifdef MPX
/* Multipointers /* Multipointers
* ID of a device == index in this array. * ID of a device == index in this array.
*/ */
static miPointerRec miMPPointers[MAX_DEVICES]; static miPointerRec miPointers[MAX_DEVICES];
#define MIPOINTER(dev) \
#endif (MPHasCursor((dev))) ? &miPointers[(dev)->id] : miCorePointer
static Bool miPointerRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, static Bool miPointerRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor); CursorPtr pCursor);
@ -103,6 +102,7 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
{ {
miPointerScreenPtr pScreenPriv; miPointerScreenPtr pScreenPriv;
miPointerPtr pPointer; miPointerPtr pPointer;
int ptrIdx;
if (miPointerGeneration != serverGeneration) if (miPointerGeneration != serverGeneration)
{ {
@ -139,29 +139,16 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
pScreen->SetCursorPosition = miPointerSetCursorPosition; pScreen->SetCursorPosition = miPointerSetCursorPosition;
pScreen->RecolorCursor = miRecolorCursor; pScreen->RecolorCursor = miRecolorCursor;
pScreen->PointerNonInterestBox = miPointerPointerNonInterestBox; pScreen->PointerNonInterestBox = miPointerPointerNonInterestBox;
/* /*
* set up the pointer object * set up the pointer object
* virtual core pointer ID is always 1, so we let it point to the matching
* index in the array.
*/ */
#if !defined MPX miCorePointer = &miPointers[1];
miPointer = (miPointerPtr)xalloc(sizeof(miPointerRec)); for(ptrIdx = 0; ptrIdx < MAX_DEVICES; ptrIdx++)
if (!miPointer)
{ {
xfree((pointer)pScreenPriv); pPointer = &miPointers[ptrIdx];
return FALSE;
}
pPointer = miPointer;
#else /* ifdef MPX */
miPointer = &miMPPointers[1];
{
int mpPtrIdx = 0; /* loop counter */
/*
* Set up pointer objects for multipointer devices.
*/
while(mpPtrIdx < MAX_DEVICES)
{
pPointer = &miMPPointers[mpPtrIdx];
#endif
pPointer->pScreen = NULL; pPointer->pScreen = NULL;
pPointer->pSpriteScreen = NULL; pPointer->pSpriteScreen = NULL;
pPointer->pCursor = NULL; pPointer->pCursor = NULL;
@ -173,11 +160,7 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
pPointer->confined = FALSE; pPointer->confined = FALSE;
pPointer->x = 0; pPointer->x = 0;
pPointer->y = 0; pPointer->y = 0;
#ifdef MPX
mpPtrIdx++;
}
} }
#endif
return TRUE; return TRUE;
} }
@ -187,28 +170,21 @@ miPointerCloseScreen (index, pScreen)
int index; int index;
ScreenPtr pScreen; ScreenPtr pScreen;
{ {
miPointerPtr pPointer;
int ptrIdx;
SetupScreen(pScreen); SetupScreen(pScreen);
miPointerPtr pPointer = miPointer;
#ifdef MPX for(ptrIdx = 0; ptrIdx < MAX_DEVICES; ptrIdx++)
int mpPointerIdx = 0;
while(mpPointerIdx < MAX_DEVICES)
{ {
pPointer = &miMPPointers[mpPointerIdx]; pPointer = &miPointers[ptrIdx];
#endif
if (pScreen == pPointer->pScreen) if (pScreen == pPointer->pScreen)
pPointer->pScreen = 0; pPointer->pScreen = 0;
if (pScreen == pPointer->pSpriteScreen) if (pScreen == pPointer->pSpriteScreen)
pPointer->pSpriteScreen = 0; pPointer->pSpriteScreen = 0;
#ifdef MPX
mpPointerIdx++;
} }
#endif
#if !defined MPX
xfree((pointer)miPointer);
#endif
pScreen->CloseScreen = pScreenPriv->CloseScreen; pScreen->CloseScreen = pScreenPriv->CloseScreen;
xfree ((pointer) pScreenPriv); xfree ((pointer) pScreenPriv);
return (*pScreen->CloseScreen) (index, pScreen); return (*pScreen->CloseScreen) (index, pScreen);
@ -244,12 +220,8 @@ miPointerDisplayCursor (pDev, pScreen, pCursor)
ScreenPtr pScreen; ScreenPtr pScreen;
CursorPtr pCursor; CursorPtr pCursor;
{ {
miPointerPtr pPointer = miPointer; miPointerPtr pPointer = MIPOINTER(pDev);
#ifdef MPX
/* use core pointer for non MPX devices */
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
pPointer->pCursor = pCursor; pPointer->pCursor = pCursor;
pPointer->pScreen = pScreen; pPointer->pScreen = pScreen;
miPointerUpdateSprite(pDev); miPointerUpdateSprite(pDev);
@ -262,11 +234,8 @@ miPointerConstrainCursor (pDev, pScreen, pBox)
ScreenPtr pScreen; ScreenPtr pScreen;
BoxPtr pBox; BoxPtr pBox;
{ {
miPointerPtr pPointer = miPointer; miPointerPtr pPointer = MIPOINTER(pDev);
#ifdef MPX
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
pPointer->limits = *pBox; pPointer->limits = *pBox;
pPointer->confined = PointerConfinedToScreen(pDev); pPointer->confined = PointerConfinedToScreen(pDev);
} }
@ -320,15 +289,9 @@ miPointerWarpCursor (pDev, pScreen, x, y)
ScreenPtr pScreen; ScreenPtr pScreen;
int x, y; int x, y;
{ {
miPointerPtr pPointer = miPointer; miPointerPtr pPointer = MIPOINTER(pDev);
SetupScreen (pScreen); SetupScreen (pScreen);
#ifdef MPX
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
if (pPointer->pScreen != pScreen) if (pPointer->pScreen != pScreen)
(*pScreenPriv->screenFuncs->NewEventScreen) (pScreen, TRUE); (*pScreenPriv->screenFuncs->NewEventScreen) (pScreen, TRUE);
@ -376,20 +339,13 @@ miPointerUpdateSprite (DeviceIntPtr pDev)
miPointerScreenPtr pScreenPriv; miPointerScreenPtr pScreenPriv;
CursorPtr pCursor; CursorPtr pCursor;
int x, y, devx, devy; int x, y, devx, devy;
miPointerPtr pPointer = miPointer; miPointerPtr pPointer;
if (!pDev || if (!pDev ||
!(pDev->coreEvents || pDev == inputInfo.pointer !(pDev->coreEvents || pDev == inputInfo.pointer || pDev->isMPDev))
#ifdef MPX
|| pDev->isMPDev
#endif
))
return; return;
#ifdef MPX pPointer = MIPOINTER(pDev);
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
pScreen = pPointer->pScreen; pScreen = pPointer->pScreen;
if (!pScreen) if (!pScreen)
@ -458,7 +414,7 @@ miPointerUpdateSprite (DeviceIntPtr pDev)
void void
miPointerDeltaCursor (int dx, int dy, unsigned long time) miPointerDeltaCursor (int dx, int dy, unsigned long time)
{ {
int x = miPointer->x + dx, y = miPointer->y + dy; int x = miCorePointer->x + dx, y = miCorePointer->y + dy;
miPointerSetPosition(inputInfo.pointer, &x, &y, time); miPointerSetPosition(inputInfo.pointer, &x, &y, time);
} }
@ -474,16 +430,13 @@ miPointerSetScreen(DeviceIntPtr pDev, int screen_no, int x, int y)
{ {
miPointerScreenPtr pScreenPriv; miPointerScreenPtr pScreenPriv;
ScreenPtr pScreen; ScreenPtr pScreen;
miPointerPtr pPointer = miPointer; miPointerPtr pPointer = MIPOINTER(pDev);
pScreen = screenInfo.screens[screen_no]; pScreen = screenInfo.screens[screen_no];
pScreenPriv = GetScreenPrivate (pScreen); pScreenPriv = GetScreenPrivate (pScreen);
(*pScreenPriv->screenFuncs->NewEventScreen) (pScreen, FALSE); (*pScreenPriv->screenFuncs->NewEventScreen) (pScreen, FALSE);
NewCurrentScreen (pDev, pScreen, x, y); NewCurrentScreen (pDev, pScreen, x, y);
#ifdef MPX
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
pPointer->limits.x2 = pScreen->width; pPointer->limits.x2 = pScreen->width;
pPointer->limits.y2 = pScreen->height; pPointer->limits.y2 = pScreen->height;
} }
@ -497,11 +450,7 @@ miPointerCurrentScreen ()
_X_EXPORT ScreenPtr _X_EXPORT ScreenPtr
miPointerGetScreen(DeviceIntPtr pDev) miPointerGetScreen(DeviceIntPtr pDev)
{ {
miPointerPtr pPointer; miPointerPtr pPointer = MIPOINTER(pDev);
#ifdef MPX
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
return pPointer->pScreen; return pPointer->pScreen;
} }
@ -521,22 +470,14 @@ miPointerSetPosition(DeviceIntPtr pDev, int *x, int *y, unsigned long time)
ScreenPtr pScreen; ScreenPtr pScreen;
ScreenPtr newScreen; ScreenPtr newScreen;
miPointerPtr pPointer = miPointer; miPointerPtr pPointer = MIPOINTER(pDev);
#ifdef MPX
if (MPHasCursor(pDev))
pPointer = &(miMPPointers[pDev->id]);
#endif
pScreen = pPointer->pScreen; pScreen = pPointer->pScreen;
if (!pScreen) if (!pScreen)
return; /* called before ready */ return; /* called before ready */
if (!pDev || if (!pDev ||
!(pDev->coreEvents || pDev == inputInfo.pointer !(pDev->coreEvents || pDev == inputInfo.pointer || pDev->isMPDev))
#ifdef MPX
|| pDev->isMPDev
#endif
))
return; return;
if (*x < 0 || *x >= pScreen->width || *y < 0 || *y >= pScreen->height) if (*x < 0 || *x >= pScreen->width || *y < 0 || *y >= pScreen->height)
@ -583,11 +524,7 @@ miPointerPosition (int *x, int *y)
_X_EXPORT void _X_EXPORT void
miPointerGetPosition(DeviceIntPtr pDev, int *x, int *y) miPointerGetPosition(DeviceIntPtr pDev, int *x, int *y)
{ {
miPointerPtr pPointer = miPointer; miPointerPtr pPointer = MIPOINTER(pDev);
#ifdef MPX
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
*x = pPointer->x; *x = pPointer->x;
*y = pPointer->y; *y = pPointer->y;
} }
@ -603,20 +540,12 @@ void
miPointerMoved (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y, miPointerMoved (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y,
unsigned long time) unsigned long time)
{ {
miPointerPtr pPointer = miPointer; miPointerPtr pPointer = MIPOINTER(pDev);
SetupScreen(pScreen); SetupScreen(pScreen);
#ifdef MPX
if (MPHasCursor(pDev))
pPointer = &miMPPointers[pDev->id];
#endif
if (pDev && (pDev->coreEvents || pDev == inputInfo.pointer if (pDev && (pDev->coreEvents || pDev == inputInfo.pointer || pDev->isMPDev)
#ifdef MPX && !pScreenPriv->waitForUpdate && pScreen == pPointer->pSpriteScreen)
|| pDev->isMPDev
#endif
) &&
!pScreenPriv->waitForUpdate && pScreen == pPointer->pSpriteScreen)
{ {
pPointer->devx = x; pPointer->devx = x;
pPointer->devy = y; pPointer->devy = y;

248
mi/misprite.c
View File

@ -146,31 +146,25 @@ miSpriteReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
ScreenPtr pScreen = closure; ScreenPtr pScreen = closure;
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo; miCursorInfoPtr pCursorInfo;
DeviceIntPtr pDev = inputInfo.pointer; DeviceIntPtr pDev;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
if (pCursorInfo->isUp && if (pCursorInfo->isUp &&
RECT_IN_REGION (pScreen, pRegion, &pCursorInfo->saved) RECT_IN_REGION (pScreen, pRegion, &pCursorInfo->saved)
!= rgnOUT) != rgnOUT)
{ {
SPRITE_DEBUG(("Damage remove\n")); SPRITE_DEBUG(("Damage remove\n"));
miSpriteRemoveCursor (pDev, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
} }
/* /*
@ -188,6 +182,7 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
VisualPtr pVisual; VisualPtr pVisual;
miCursorInfoPtr pCursorInfo; miCursorInfoPtr pCursorInfo;
int cursorIdx;
if (!DamageSetup (pScreen)) if (!DamageSetup (pScreen))
return FALSE; return FALSE;
@ -235,54 +230,41 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
pScreenPriv->BlockHandler = pScreen->BlockHandler; pScreenPriv->BlockHandler = pScreen->BlockHandler;
#if !defined MPX /* alloc and zero memory for all cursors */
pScreenPriv->cp = (miCursorInfoPtr)xalloc(sizeof(miCursorInfoRec)); pScreenPriv->pDevCursors =
if (!pScreenPriv->cp) (miCursorInfoPtr)xalloc(MAX_DEVICES * sizeof(miCursorInfoRec));
if (!pScreenPriv->pDevCursors)
{ {
xfree((pointer)pScreenPriv); xfree((pointer)pScreenPriv);
return FALSE; return FALSE;
} }
pCursorInfo = pScreenPriv->cp; /* virtual core pointer's ID is 1 */
#else pScreenPriv->cp = &(pScreenPriv->pDevCursors[1]);
/* alloc and zero memory for all MPX cursors */
pScreenPriv->mpCursors = (miCursorInfoPtr)xalloc(MAX_DEVICES * sizeof(miCursorInfoRec)); cursorIdx = 0;
if (!pScreenPriv->mpCursors) while (cursorIdx < MAX_DEVICES)
{ {
xfree((pointer)pScreenPriv->cp); pCursorInfo = &(pScreenPriv->pDevCursors[cursorIdx]);
xfree((pointer)pScreenPriv); pCursorInfo->pCursor = NULL;
return FALSE; pCursorInfo->x = 0;
pCursorInfo->y = 0;
pCursorInfo->isUp = FALSE;
pCursorInfo->shouldBeUp = FALSE;
pCursorInfo->pCacheWin = NullWindow;
pCursorInfo->isInCacheWin = FALSE;
pCursorInfo->checkPixels = TRUE;
pCursorInfo->pInstalledMap = NULL;
pCursorInfo->pColormap = NULL;
pCursorInfo->colors[SOURCE_COLOR].red = 0;
pCursorInfo->colors[SOURCE_COLOR].green = 0;
pCursorInfo->colors[SOURCE_COLOR].blue = 0;
pCursorInfo->colors[MASK_COLOR].red = 0;
pCursorInfo->colors[MASK_COLOR].green = 0;
pCursorInfo->colors[MASK_COLOR].blue = 0;
cursorIdx++;
} }
pScreenPriv->cp = &(pScreenPriv->mpCursors[1]);
{
int mpCursorIdx = 0;
while (mpCursorIdx < MAX_DEVICES)
{
pCursorInfo = &(pScreenPriv->mpCursors[mpCursorIdx]);
#endif
pCursorInfo->pCursor = NULL;
pCursorInfo->x = 0;
pCursorInfo->y = 0;
pCursorInfo->isUp = FALSE;
pCursorInfo->shouldBeUp = FALSE;
pCursorInfo->pCacheWin = NullWindow;
pCursorInfo->isInCacheWin = FALSE;
pCursorInfo->checkPixels = TRUE;
pCursorInfo->pInstalledMap = NULL;
pCursorInfo->pColormap = NULL;
pCursorInfo->colors[SOURCE_COLOR].red = 0;
pCursorInfo->colors[SOURCE_COLOR].green = 0;
pCursorInfo->colors[SOURCE_COLOR].blue = 0;
pCursorInfo->colors[MASK_COLOR].red = 0;
pCursorInfo->colors[MASK_COLOR].green = 0;
pCursorInfo->colors[MASK_COLOR].blue = 0;
#ifdef MPX
mpCursorIdx++;
}
}
#endif
pScreenPriv->funcs = cursorFuncs; pScreenPriv->funcs = cursorFuncs;
pScreen->devPrivates[miSpriteScreenIndex].ptr = (pointer) pScreenPriv; pScreen->devPrivates[miSpriteScreenIndex].ptr = (pointer) pScreenPriv;
@ -321,6 +303,7 @@ miSpriteCloseScreen (i, pScreen)
ScreenPtr pScreen; ScreenPtr pScreen;
{ {
miSpriteScreenPtr pScreenPriv; miSpriteScreenPtr pScreenPriv;
DeviceIntPtr pDev;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
@ -333,15 +316,18 @@ miSpriteCloseScreen (i, pScreen)
pScreen->StoreColors = pScreenPriv->StoreColors; pScreen->StoreColors = pScreenPriv->StoreColors;
pScreen->SaveDoomedAreas = pScreenPriv->SaveDoomedAreas; pScreen->SaveDoomedAreas = pScreenPriv->SaveDoomedAreas;
miSpriteIsUpFALSE (pScreenPriv->cp, pScreen, pScreenPriv); for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
{
if (MPHasCursor(pDev))
{
miCursorInfoPtr pCursor;
pCursor = &pScreenPriv->pDevCursors[pDev->id];
miSpriteIsUpFALSE (pCursor, pScreen, pScreenPriv);
}
}
DamageDestroy (pScreenPriv->pDamage); DamageDestroy (pScreenPriv->pDamage);
#ifdef MPX xfree ((pointer)(pScreenPriv->pDevCursors));
xfree((pointer)(pScreenPriv->mpCursors));
#else
xfree((pointer)(pScreenPriv->cp));
#endif
xfree ((pointer) pScreenPriv); xfree ((pointer) pScreenPriv);
return (*pScreen->CloseScreen) (i, pScreen); return (*pScreen->CloseScreen) (i, pScreen);
@ -363,16 +349,12 @@ miSpriteGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
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 for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while (pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
if (pDrawable->type == DRAWABLE_WINDOW && if (pDrawable->type == DRAWABLE_WINDOW &&
pCursorInfo->isUp && pCursorInfo->isUp &&
ORG_OVERLAP(&pCursorInfo->saved,pDrawable->x,pDrawable->y, ORG_OVERLAP(&pCursorInfo->saved,pDrawable->x,pDrawable->y,
@ -381,11 +363,8 @@ miSpriteGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
SPRITE_DEBUG (("GetImage remove\n")); SPRITE_DEBUG (("GetImage remove\n"));
miSpriteRemoveCursor (pDev, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
(*pScreen->GetImage) (pDrawable, sx, sy, w, h, (*pScreen->GetImage) (pDrawable, sx, sy, w, h,
format, planemask, pdstLine); format, planemask, pdstLine);
@ -410,16 +389,12 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
SCREEN_PROLOGUE (pScreen, GetSpans); SCREEN_PROLOGUE (pScreen, GetSpans);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp) if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp)
{ {
@ -445,11 +420,8 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
} }
} }
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
(*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart); (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
@ -469,16 +441,12 @@ miSpriteSourceValidate (pDrawable, x, y, width, height)
SCREEN_PROLOGUE (pScreen, SourceValidate); SCREEN_PROLOGUE (pScreen, SourceValidate);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
#ifdef MPX for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp && if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp &&
ORG_OVERLAP(&pCursorInfo->saved, pDrawable->x, pDrawable->y, ORG_OVERLAP(&pCursorInfo->saved, pDrawable->x, pDrawable->y,
x, y, width, height)) x, y, width, height))
@ -486,12 +454,8 @@ miSpriteSourceValidate (pDrawable, x, y, width, height)
SPRITE_DEBUG (("SourceValidate remove\n")); SPRITE_DEBUG (("SourceValidate remove\n"));
miSpriteRemoveCursor (pDev, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
if (pScreen->SourceValidate) if (pScreen->SourceValidate)
(*pScreen->SourceValidate) (pDrawable, x, y, width, height); (*pScreen->SourceValidate) (pDrawable, x, y, width, height);
@ -510,16 +474,12 @@ miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
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 for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
/* /*
* Damage will take care of destination check * Damage will take care of destination check
*/ */
@ -529,11 +489,8 @@ miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
SPRITE_DEBUG (("CopyWindow remove\n")); SPRITE_DEBUG (("CopyWindow remove\n"));
miSpriteRemoveCursor (pDev, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
(*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc); (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
SCREEN_EPILOGUE (pScreen, CopyWindow); SCREEN_EPILOGUE (pScreen, CopyWindow);
@ -552,7 +509,6 @@ miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
miCursorInfoPtr pCursorInfo; 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);
@ -560,25 +516,18 @@ miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
SCREEN_EPILOGUE(pScreen, BlockHandler); SCREEN_EPILOGUE(pScreen, BlockHandler);
#ifdef MPX for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
pCursorInfo = &pPriv->mpCursors[pDev->id]; pCursorInfo = &pPriv->pDevCursors[pDev->id];
#endif
if (!pCursorInfo->isUp && pCursorInfo->shouldBeUp) if (!pCursorInfo->isUp && pCursorInfo->shouldBeUp)
{ {
SPRITE_DEBUG (("BlockHandler restore\n")); SPRITE_DEBUG (("BlockHandler restore\n"));
miSpriteRestoreCursor (pDev, pScreen); miSpriteRestoreCursor (pDev, pScreen);
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
} }
static void static void
@ -592,7 +541,6 @@ miSpriteInstallColormap (pMap)
int cursorIdx; 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);
@ -600,37 +548,30 @@ miSpriteInstallColormap (pMap)
SCREEN_EPILOGUE(pScreen, InstallColormap); SCREEN_EPILOGUE(pScreen, InstallColormap);
#ifdef MPX
/* InstallColormap is called before devices are initialized. We cannot /* InstallColormap is called before devices are initialized. We cannot
* just run through the device list, we need to go through all possible * just run through the device list, we need to go through all possible
* sprite structs.*/ * sprite structs.*/
cursorIdx = 0; for (cursorIdx = 0; cursorIdx < MAX_DEVICES; cursorIdx++)
while(cursorIdx < MAX_DEVICES)
{ {
pCursorInfo = &pPriv->mpCursors[cursorIdx]; pCursorInfo = &pPriv->pDevCursors[cursorIdx];
#endif
pCursorInfo->pInstalledMap = pMap; pCursorInfo->pInstalledMap = pMap;
if (pCursorInfo->pColormap != pMap) if (pCursorInfo->pColormap != pMap)
{ {
pCursorInfo->checkPixels = TRUE; pCursorInfo->checkPixels = TRUE;
if (pCursorInfo->isUp) if (pCursorInfo->isUp)
{ {
#ifdef MPX
/* find matching device */ /* find matching device */
pDev = inputInfo.devices; for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
while(pDev && pDev->id != cursorIdx) {
pDev = pDev->next; if (pDev->id == cursorIdx)
if (!pDev) {
pDev = inputInfo.pointer; miSpriteRemoveCursor(pDev, pScreen);
#endif break;
miSpriteRemoveCursor (pDev, pScreen); }
} }
} }
#ifdef MPX }
cursorIdx++;
} }
#endif
} }
static void static void
@ -650,7 +591,6 @@ miSpriteStoreColors (pMap, ndef, pdef)
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);
@ -670,14 +610,11 @@ miSpriteStoreColors (pMap, ndef, pdef)
UpdateDAC(dev, plane,green,greenMask) \ UpdateDAC(dev, plane,green,greenMask) \
UpdateDAC(dev, plane,blue,blueMask) UpdateDAC(dev, plane,blue,blueMask)
#ifdef MPX for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
{ {
pCursorInfo = &pPriv->mpCursors[pDev->id]; pCursorInfo = &pPriv->pDevCursors[pDev->id];
#endif
if (pCursorInfo->pColormap == pMap) if (pCursorInfo->pColormap == pMap)
{ {
updated = 0; updated = 0;
@ -688,8 +625,8 @@ miSpriteStoreColors (pMap, ndef, pdef)
for (i = 0; i < ndef; i++) for (i = 0; i < ndef; i++)
{ {
CheckDirect (pPriv->cp, SOURCE_COLOR) CheckDirect (pCursorInfo, SOURCE_COLOR)
CheckDirect (pPriv->cp, MASK_COLOR) CheckDirect (pCursorInfo, MASK_COLOR)
} }
} }
else else
@ -720,11 +657,8 @@ miSpriteStoreColors (pMap, ndef, pdef)
miSpriteRemoveCursor (pDev, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
} }
@ -784,16 +718,12 @@ miSpriteSaveDoomedAreas (pWin, pObscured, dx, dy)
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 for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
pDev = inputInfo.devices;
while(pDev)
{ {
if(MPHasCursor(pDev)) if(MPHasCursor(pDev))
{ {
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
if (pCursorInfo->isUp) if (pCursorInfo->isUp)
{ {
cursorBox = pCursorInfo->saved; cursorBox = pCursorInfo->saved;
@ -809,11 +739,8 @@ miSpriteSaveDoomedAreas (pWin, pObscured, dx, dy)
miSpriteRemoveCursor (pDev, pScreen); miSpriteRemoveCursor (pDev, pScreen);
} }
#ifdef MPX
} }
pDev = pDev->next;
} }
#endif
(*pScreen->SaveDoomedAreas) (pWin, pObscured, dx, dy); (*pScreen->SaveDoomedAreas) (pWin, pObscured, dx, dy);
@ -838,10 +765,8 @@ miSpriteRealizeCursor (pDev, pScreen, pCursor)
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp; pCursorInfo = pScreenPriv->cp;
#ifdef MPX
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
if (pCursor == pCursorInfo->pCursor) if (pCursor == pCursorInfo->pCursor)
pCursorInfo->checkPixels = TRUE; pCursorInfo->checkPixels = TRUE;
@ -873,10 +798,9 @@ 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
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pPointer = &pScreenPriv->mpCursors[pDev->id]; pPointer = &pScreenPriv->pDevCursors[pDev->id];
#endif
if (!pCursor) if (!pCursor)
{ {
@ -992,10 +916,9 @@ miSpriteMoveCursor (pDev, pScreen, x, y)
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursor = pScreenPriv->cp->pCursor; pCursor = pScreenPriv->cp->pCursor;
#ifdef MPX
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pCursor = pScreenPriv->mpCursors[pDev->id].pCursor; pCursor = pScreenPriv->pDevCursors[pDev->id].pCursor;
#endif
miSpriteSetCursor (pDev, pScreen, pCursor, x, y); miSpriteSetCursor (pDev, pScreen, pCursor, x, y);
} }
@ -1016,10 +939,8 @@ miSpriteRemoveCursor (pDev, pScreen)
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp; pCursorInfo = pScreenPriv->cp;
#ifdef MPX
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
miSpriteIsUpFALSE (pCursorInfo, pScreen, pScreenPriv); miSpriteIsUpFALSE (pCursorInfo, pScreen, pScreenPriv);
pCursorInfo->pCacheWin = NullWindow; pCursorInfo->pCacheWin = NullWindow;
@ -1056,10 +977,8 @@ miSpriteRestoreCursor (pDev, pScreen)
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp; pCursorInfo = pScreenPriv->cp;
#ifdef MPX
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
miSpriteComputeSaved (pDev, pScreen); miSpriteComputeSaved (pDev, pScreen);
pCursor = pCursorInfo->pCursor; pCursor = pCursorInfo->pCursor;
@ -1106,11 +1025,8 @@ miSpriteComputeSaved (pDev, pScreen)
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr; pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp; pCursorInfo = pScreenPriv->cp;
#ifdef MPX
if (MPHasCursor(pDev)) if (MPHasCursor(pDev))
pCursorInfo = &pScreenPriv->mpCursors[pDev->id]; pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
#endif
pCursor = pCursorInfo->pCursor; pCursor = pCursorInfo->pCursor;
x = pCursorInfo->x - (int)pCursor->bits->xhot; x = pCursorInfo->x - (int)pCursor->bits->xhot;

4
mi/mispritest.h
View File

@ -88,9 +88,7 @@ typedef struct {
VisualPtr pVisual; VisualPtr pVisual;
miSpriteCursorFuncPtr funcs; miSpriteCursorFuncPtr funcs;
DamagePtr pDamage; /* damage tracking structure */ DamagePtr pDamage; /* damage tracking structure */
#ifdef MPX miCursorInfoPtr pDevCursors; /* all cursors' info */
miCursorInfoPtr mpCursors; /* all cursor's info */
#endif
} miSpriteScreenRec, *miSpriteScreenPtr; } miSpriteScreenRec, *miSpriteScreenPtr;
#define SOURCE_COLOR 0 #define SOURCE_COLOR 0