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

Alloc sprite memory in devices' devPrivates, allow undisplaying cursors. 

Improve memory usage by allocating the sprite's memory only to devices that
actually have a sprite and provide means to remove a device's cursor from the
screen (more hotplugging, yay!).
This commit breaks ScreenRec's ABI.
This commit is contained in:
Peter Hutterer 2007-04-09 19:31:59 +09:30
parent 7cef789fa1
commit f1f8b562aa
12 changed files with 444 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
dix/devices.c
View File

@ -225,12 +225,19 @@ DisableDevice(DeviceIntPtr dev)
return TRUE;
}
/**
* Initialize device through driver, allocate memory for cursor sprite (if
* applicable) and send a PresenceNotify event to all clients.
*
* Must be called before EnableDevice.
*/
int
ActivateDevice(DeviceIntPtr dev)
{
int ret = Success;
devicePresenceNotify ev;
DeviceIntRec dummyDev;
ScreenPtr pScreen = screenInfo.screens[0];
if (!dev || !dev->deviceProc)
return BadImplementation;
@ -238,6 +245,10 @@ ActivateDevice(DeviceIntPtr dev)
ret = (*dev->deviceProc) (dev, DEVICE_INIT);
dev->inited = (ret == Success);
/* Initialize memory for sprites. */
if (IsPointerDevice(dev))
pScreen->DeviceCursorInitialize(dev, pScreen);
ev.type = DevicePresenceNotify;
ev.time = currentTime.milliseconds;
ev.devchange = 0;
@ -497,11 +508,16 @@ CloseDevice(DeviceIntPtr dev)
StringFeedbackPtr s, snext;
BellFeedbackPtr b, bnext;
LedFeedbackPtr l, lnext;
ScreenPtr screen = screenInfo.screens[0];
int j;
if (dev->inited)
(void)(*dev->deviceProc)(dev, DEVICE_CLOSE);
/* free sprite memory */
if (IsPointerDevice(dev))
screen->DeviceCursorCleanup(dev, screen);
xfree(dev->name);
if (dev->key) {
@ -624,6 +640,22 @@ CloseDownDevices()
inputInfo.pointer = NULL;
}
/**
* Remove the cursor sprite for all devices. This needs to be done before any
* resources are freed or any device is deleted.
*/
void
UndisplayDevices()
{
DeviceIntPtr dev;
ScreenPtr screen = screenInfo.screens[0];
for (dev = inputInfo.devices; dev; dev = dev->next)
{
screen->UndisplayCursor(dev, screen);
}
}
int
RemoveDevice(DeviceIntPtr dev)
{
@ -631,23 +663,26 @@ RemoveDevice(DeviceIntPtr dev)
int ret = BadMatch;
devicePresenceNotify ev;
DeviceIntRec dummyDev;
ScreenPtr screen = screenInfo.screens[0];
DebugF("(dix) removing device %d\n", dev->id);
if (!dev || dev == inputInfo.keyboard || dev == inputInfo.pointer)
return BadImplementation;
screen->UndisplayCursor(dev, screen);
prev = NULL;
for (tmp = inputInfo.devices; tmp; (prev = tmp), (tmp = next)) {
next = tmp->next;
if (tmp == dev) {
CloseDevice(tmp);
if (prev==NULL)
inputInfo.devices = next;
else
prev->next = next;
CloseDevice(tmp);
ret = Success;
}
}

2
dix/main.c
View File

@ -466,6 +466,8 @@ main(int argc, char *argv[], char *envp[])
Dispatch();
UndisplayDevices();
/* Now free up whatever must be freed */
if (screenIsSaved == SCREEN_SAVER_ON)
SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);

4
hw/xfree86/common/xf86Events.c
View File

@ -247,10 +247,14 @@ ProcessInputEvents ()
mieqProcessInputEvents();
/* PIE can be called after devices have been shut down. Blame DGA. */
if (inputInfo.pointer)
{
/* FIXME: This is a problem if we have multiple pointers */
miPointerGetPosition(inputInfo.pointer, &x, &y);
xf86SetViewport(xf86Info.currentScreen, x, y);
}
}
void
xf86GrabServerCallback(CallbackListPtr *callbacks, pointer data, pointer args)

4
include/dix.h
View File

@ -424,6 +424,10 @@ extern int DeliverDeviceEvents(
extern void DefineInitialRootWindow(
WindowPtr /* win */);
extern void SetupSprite(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScreen */);
extern void InitializeSprite(
DeviceIntPtr /* pDev */,
WindowPtr /* pWin */);

2
include/input.h
View File

@ -190,6 +190,8 @@ extern int InitAndStartDevices(void);
extern void CloseDownDevices(void);
extern void UndisplayDevices(void);
extern int RemoveDevice(
DeviceIntPtr /*dev*/);

16
include/scrnintstr.h
View File

@ -431,6 +431,18 @@ typedef void (* MarkUnrealizedWindowProcPtr)(
WindowPtr /*pWin*/,
Bool /*fromConfigure*/);
typedef void (* UndisplayCursorProcPtr)(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScreen */);
typedef Bool (* DeviceCursorInitializeProcPtr)(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScreen */);
typedef void (* DeviceCursorCleanupProcPtr)(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScreen */);
typedef struct _Screen {
int myNum; /* index of this instance in Screens[] */
ATOM id;
@ -587,6 +599,10 @@ typedef struct _Screen {
ChangeBorderWidthProcPtr ChangeBorderWidth;
MarkUnrealizedWindowProcPtr MarkUnrealizedWindow;
/* Device cursor procedures */
UndisplayCursorProcPtr UndisplayCursor;
DeviceCursorInitializeProcPtr DeviceCursorInitialize;
DeviceCursorCleanupProcPtr DeviceCursorCleanup;
} ScreenRec;
typedef struct _ScreenInfo {

165
mi/midispcur.c
View File

@ -67,6 +67,9 @@ static unsigned long miDCGeneration = 0;
static Bool miDCCloseScreen(int index, ScreenPtr pScreen);
/* per device private data */
static int miDCSpriteIndex;
typedef struct {
GCPtr pSourceGC, pMaskGC;
GCPtr pSaveGC, pRestoreGC;
@ -79,13 +82,16 @@ typedef struct {
#endif
} miDCBufferRec, *miDCBufferPtr;
#define MIDCBUFFER(dev) \
((DevHasCursor(dev)) ? \
(miDCBufferPtr)dev->devPrivates[miDCSpriteIndex].ptr :\
(miDCBufferPtr)inputInfo.pointer->devPrivates[miDCSpriteIndex].ptr)
/*
* The core pointer buffer will point to the index of the virtual core pointer
* in the pCursorBuffers array.
*/
typedef struct {
miDCBufferPtr pCoreBuffer; /* for core pointer */
miDCBufferPtr pCursorBuffers; /* one for each device */
CloseScreenProcPtr CloseScreen;
} miDCScreenRec, *miDCScreenPtr;
@ -121,6 +127,9 @@ static Bool miDCChangeSave(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h,
int dx, int dy);
static Bool miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen);
static void miDCDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen);
static miSpriteCursorFuncRec miDCFuncs = {
miDCRealizeCursor,
miDCUnrealizeCursor,
@ -129,6 +138,8 @@ static miSpriteCursorFuncRec miDCFuncs = {
miDCRestoreUnderCursor,
miDCMoveCursor,
miDCChangeSave,
miDCDeviceInitialize,
miDCDeviceCleanup
};
_X_EXPORT Bool
@ -137,8 +148,6 @@ miDCInitialize (pScreen, screenFuncs)
miPointerScreenFuncPtr screenFuncs;
{
miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer;
int mpBufferIdx;
if (miDCGeneration != serverGeneration)
{
@ -151,41 +160,8 @@ miDCInitialize (pScreen, screenFuncs)
if (!pScreenPriv)
return FALSE;
/*
* initialize the entire private structure to zeros
*/
pScreenPriv->pCursorBuffers = (miDCBufferPtr)xalloc(MAX_DEVICES *
sizeof(miDCBufferRec));
if (!pScreenPriv->pCursorBuffers)
{
xfree((pointer)pScreenPriv);
return FALSE;
}
/* virtual core pointer ID is 1 */
pScreenPriv->pCoreBuffer = &pScreenPriv->pCursorBuffers[1];
mpBufferIdx = 0;
while(mpBufferIdx < MAX_DEVICES)
{
pBuffer = &pScreenPriv->pCursorBuffers[mpBufferIdx];
pBuffer->pSourceGC =
pBuffer->pMaskGC =
pBuffer->pSaveGC =
pBuffer->pRestoreGC =
pBuffer->pMoveGC =
pBuffer->pPixSourceGC =
pBuffer->pPixMaskGC = NULL;
#ifdef ARGB_CURSOR
pBuffer->pRootPicture = NULL;
pBuffer->pTempPicture = NULL;
#endif
pBuffer->pSave = pBuffer->pTemp = NULL;
mpBufferIdx++;
}
miDCSpriteIndex = AllocateDevicePrivateIndex();
pScreenPriv->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = miDCCloseScreen;
@ -194,7 +170,6 @@ miDCInitialize (pScreen, screenFuncs)
if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs))
{
xfree ((pointer) pScreenPriv->pCursorBuffers);
xfree ((pointer) pScreenPriv);
return FALSE;
}
@ -211,38 +186,10 @@ miDCCloseScreen (index, pScreen)
ScreenPtr pScreen;
{
miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer;
int mpBufferIdx;
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pScreen->CloseScreen = pScreenPriv->CloseScreen;
mpBufferIdx = 0;
while (mpBufferIdx < MAX_DEVICES)
{
pBuffer = &pScreenPriv->pCursorBuffers[mpBufferIdx];
tossGC (pBuffer->pSourceGC);
tossGC (pBuffer->pMaskGC);
tossGC (pBuffer->pSaveGC);
tossGC (pBuffer->pRestoreGC);
tossGC (pBuffer->pMoveGC);
tossGC (pBuffer->pPixSourceGC);
tossGC (pBuffer->pPixMaskGC);
tossPix (pBuffer->pSave);
tossPix (pBuffer->pTemp);
#ifdef ARGB_CURSOR
#if 0 /* This has been free()d before */
tossPict (pScreenPriv->pRootPicture);
#endif
tossPict (pBuffer->pTempPicture);
#endif
mpBufferIdx++;
}
xfree((pointer) pScreenPriv->pCursorBuffers);
xfree ((pointer) pScreenPriv);
return (*pScreen->CloseScreen) (index, pScreen);
}
@ -536,10 +483,7 @@ miDCPutUpCursor (pDev, pScreen, pCursor, x, y, source, mask)
}
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pWin = WindowTable[pScreen->myNum];
pBuffer = pScreenPriv->pCoreBuffer;
if (DevHasCursor(pDev))
pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
pBuffer = MIDCBUFFER(pDev);
#ifdef ARGB_CURSOR
if (pPriv->pPicture)
@ -587,10 +531,7 @@ miDCSaveUnderCursor (pDev, pScreen, x, y, w, h)
GCPtr pGC;
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pBuffer = pScreenPriv->pCoreBuffer;
if (DevHasCursor(pDev))
pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
pBuffer = MIDCBUFFER(pDev);
pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum];
@ -626,10 +567,7 @@ miDCRestoreUnderCursor (pDev, pScreen, x, y, w, h)
GCPtr pGC;
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pBuffer = pScreenPriv->pCoreBuffer;
if (DevHasCursor(pDev))
pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
pBuffer = MIDCBUFFER(pDev);
pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum];
@ -659,10 +597,7 @@ miDCChangeSave (pDev, pScreen, x, y, w, h, dx, dy)
int sourcex, sourcey, destx, desty, copyw, copyh;
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pBuffer = pScreenPriv->pCoreBuffer;
if (DevHasCursor(pDev))
pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
pBuffer = MIDCBUFFER(pDev);
pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum];
@ -810,10 +745,7 @@ miDCMoveCursor (pDev, pScreen, pCursor, x, y, w, h, dx, dy, source, mask)
}
pScreenPriv = (miDCScreenPtr) pScreen->devPrivates[miDCScreenIndex].ptr;
pWin = WindowTable[pScreen->myNum];
pBuffer = pScreenPriv->pCoreBuffer;
if (DevHasCursor(pDev))
pBuffer = &pScreenPriv->pCursorBuffers[pDev->id];
pBuffer = MIDCBUFFER(pDev);
pTemp = pBuffer->pTemp;
if (!pTemp ||
@ -905,3 +837,62 @@ miDCMoveCursor (pDev, pScreen, pCursor, x, y, w, h, dx, dy, source, mask)
0, 0, w, h, x, y);
return TRUE;
}
static Bool
miDCDeviceInitialize(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
miDCBufferPtr pBuffer;
if (!AllocateDevicePrivate(pDev, miDCSpriteIndex))
return FALSE;
pBuffer =
pDev->devPrivates[miDCSpriteIndex].ptr = xalloc(sizeof(miDCBufferRec));
pBuffer->pSourceGC =
pBuffer->pMaskGC =
pBuffer->pSaveGC =
pBuffer->pRestoreGC =
pBuffer->pMoveGC =
pBuffer->pPixSourceGC =
pBuffer->pPixMaskGC = NULL;
#ifdef ARGB_CURSOR
pBuffer->pRootPicture = NULL;
pBuffer->pTempPicture = NULL;
#endif
pBuffer->pSave = pBuffer->pTemp = NULL;
return TRUE;
}
static void
miDCDeviceCleanup(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
miDCBufferPtr pBuffer;
if (DevHasCursor(pDev))
{
pBuffer = MIDCBUFFER(pDev);
tossGC (pBuffer->pSourceGC);
tossGC (pBuffer->pMaskGC);
tossGC (pBuffer->pSaveGC);
tossGC (pBuffer->pRestoreGC);
tossGC (pBuffer->pMoveGC);
tossGC (pBuffer->pPixSourceGC);
tossGC (pBuffer->pPixMaskGC);
tossPix (pBuffer->pSave);
tossPix (pBuffer->pTemp);
#ifdef ARGB_CURSOR
#if 0 /* This has been free()d before */
tossPict (pScreenPriv->pRootPicture);
#endif
tossPict (pBuffer->pTempPicture);
#endif
xfree(pDev->devPrivates[miDCSpriteIndex].ptr);
pDev->devPrivates[miDCSpriteIndex].ptr = NULL;
}
}

133
mi/mipointer.c
View File

@ -54,18 +54,12 @@ static unsigned long miPointerGeneration = 0;
#define GetScreenPrivate(s) ((miPointerScreenPtr) ((s)->devPrivates[miPointerScreenIndex].ptr))
#define SetupScreen(s) miPointerScreenPtr pScreenPriv = GetScreenPrivate(s)
/*
* until more than one pointer device exists.
*/
static int miPointerPrivatesIndex = 0;
static miPointerPtr miCorePointer;
/* Multipointers
* ID of a device == index in this array.
*/
static miPointerRec miPointers[MAX_DEVICES];
#define MIPOINTER(dev) \
(DevHasCursor((dev))) ? &miPointers[(dev)->id] : miCorePointer
((DevHasCursor((dev))) ? \
(miPointerPtr) dev->devPrivates[miPointerPrivatesIndex].ptr : \
(miPointerPtr) inputInfo.pointer->devPrivates[miPointerPrivatesIndex].ptr)
static Bool miPointerRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor);
@ -73,6 +67,7 @@ static Bool miPointerUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor);
static Bool miPointerDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor);
static void miPointerUndisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen);
static void miPointerConstrainCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
BoxPtr pBox);
static void miPointerPointerNonInterestBox(DeviceIntPtr pDev,
@ -87,6 +82,9 @@ static Bool miPointerCloseScreen(int index, ScreenPtr pScreen);
static void miPointerMove(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y,
unsigned long time);
static Bool miPointerDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen);
static void miPointerDeviceCleanup(DeviceIntPtr pDev,
ScreenPtr pScreen);
static xEvent* events; /* for WarpPointer MotionNotifies */
@ -98,8 +96,6 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
Bool waitForUpdate;
{
miPointerScreenPtr pScreenPriv;
miPointerPtr pPointer;
int ptrIdx;
if (miPointerGeneration != serverGeneration)
{
@ -131,33 +127,17 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
pScreen->ConstrainCursor = miPointerConstrainCursor;
pScreen->CursorLimits = miPointerCursorLimits;
pScreen->DisplayCursor = miPointerDisplayCursor;
pScreen->UndisplayCursor = miPointerUndisplayCursor;
pScreen->UndisplayCursor = miPointerUndisplayCursor;
pScreen->RealizeCursor = miPointerRealizeCursor;
pScreen->UnrealizeCursor = miPointerUnrealizeCursor;
pScreen->SetCursorPosition = miPointerSetCursorPosition;
pScreen->RecolorCursor = miRecolorCursor;
pScreen->PointerNonInterestBox = miPointerPointerNonInterestBox;
pScreen->DeviceCursorInitialize = miPointerDeviceInitialize;
pScreen->DeviceCursorCleanup = miPointerDeviceCleanup;
/*
* set up the pointer object
* virtual core pointer ID is always 1, so we let it point to the matching
* index in the array.
*/
miCorePointer = &miPointers[1];
for(ptrIdx = 0; ptrIdx < MAX_DEVICES; ptrIdx++)
{
pPointer = &miPointers[ptrIdx];
pPointer->pScreen = NULL;
pPointer->pSpriteScreen = NULL;
pPointer->pCursor = NULL;
pPointer->pSpriteCursor = NULL;
pPointer->limits.x1 = 0;
pPointer->limits.x2 = 32767;
pPointer->limits.y1 = 0;
pPointer->limits.y2 = 32767;
pPointer->confined = FALSE;
pPointer->x = 0;
pPointer->y = 0;
}
miPointerPrivatesIndex = AllocateDevicePrivateIndex();
events = NULL;
return TRUE;
@ -169,19 +149,29 @@ miPointerCloseScreen (index, pScreen)
ScreenPtr pScreen;
{
miPointerPtr pPointer;
int ptrIdx;
DeviceIntPtr pDev;
SetupScreen(pScreen);
for(ptrIdx = 0; ptrIdx < MAX_DEVICES; ptrIdx++)
#if 0
for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
{
pPointer = &miPointers[ptrIdx];
if (DevHasCursor(pDev))
{
pPointer = MIPOINTER(pDev);
if (pScreen == pPointer->pScreen)
pPointer->pScreen = 0;
if (pScreen == pPointer->pSpriteScreen)
pPointer->pSpriteScreen = 0;
}
}
if (MIPOINTER(inputInfo.pointer)->pScreen == pScreen)
MIPOINTER(inputInfo.pointer)->pScreen = 0;
if (MIPOINTER(inputInfo.pointer)->pSpriteScreen == pScreen)
MIPOINTER(inputInfo.pointer)->pSpriteScreen = 0;
#endif
pScreen->CloseScreen = pScreenPriv->CloseScreen;
xfree ((pointer) pScreenPriv);
@ -228,6 +218,15 @@ miPointerDisplayCursor (pDev, pScreen, pCursor)
return TRUE;
}
static void
miPointerUndisplayCursor(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
SetupScreen(pScreen);
(*pScreenPriv->spriteFuncs->UndisplayCursor)(pDev, pScreen);
}
static void
miPointerConstrainCursor (pDev, pScreen, pBox)
DeviceIntPtr pDev;
@ -281,6 +280,65 @@ miPointerSetCursorPosition(pDev, pScreen, x, y, generateEvent)
return TRUE;
}
/* Set up sprite information for the device.
This function will be called once for each device after it is initialized
in the DIX.
*/
static Bool
miPointerDeviceInitialize(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
miPointerPtr pPointer;
SetupScreen (pScreen);
if (!AllocateDevicePrivate(pDev, miPointerPrivatesIndex))
return FALSE;
pPointer = xalloc(sizeof(miPointerRec));
if (!pPointer)
return FALSE;
pPointer->pScreen = NULL;
pPointer->pSpriteScreen = NULL;
pPointer->pCursor = NULL;
pPointer->pSpriteCursor = NULL;
pPointer->limits.x1 = 0;
pPointer->limits.x2 = 32767;
pPointer->limits.y1 = 0;
pPointer->limits.y2 = 32767;
pPointer->confined = FALSE;
pPointer->x = 0;
pPointer->y = 0;
if (!((*pScreenPriv->spriteFuncs->DeviceCursorInitialize)(pDev, pScreen)))
{
xfree(pPointer);
return FALSE;
}
pDev->devPrivates[miPointerPrivatesIndex].ptr = pPointer;
return TRUE;
}
/* Clean up after device.
This function will be called once before the device is freed in the DIX
*/
static void
miPointerDeviceCleanup(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
if (DevHasCursor(pDev))
{
SetupScreen(pScreen);
(*pScreenPriv->spriteFuncs->DeviceCursorCleanup)(pDev, pScreen);
xfree(pDev->devPrivates[miPointerPrivatesIndex].ptr);
pDev->devPrivates[miPointerPrivatesIndex].ptr = NULL;
}
}
/* Once signals are ignored, the WarpCursor function can call this */
_X_EXPORT void
@ -413,7 +471,8 @@ miPointerUpdateSprite (DeviceIntPtr pDev)
void
miPointerDeltaCursor (int dx, int dy, unsigned long time)
{
int x = miCorePointer->x + dx, y = miCorePointer->y + dy;
int x = MIPOINTER(inputInfo.pointer)->x = dx;
int y = MIPOINTER(inputInfo.pointer)->y = dy;
miPointerSetPosition(inputInfo.pointer, &x, &y, time);
}

12
mi/mipointer.h
View File

@ -53,6 +53,18 @@ typedef struct _miPointerSpriteFuncRec {
int /* x */,
int /* y */
);
Bool (*DeviceCursorInitialize)(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScr */
);
void (*DeviceCursorCleanup)(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScr */
);
void (*UndisplayCursor)(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScr */
);
} miPointerSpriteFuncRec, *miPointerSpriteFuncPtr;
typedef struct _miPointerScreenFuncRec {

281
mi/misprite.c
View File

@ -72,6 +72,13 @@ in this Software without prior written authorization from The Open Group.
#define SPRITE_DEBUG(x)
#endif
static int miSpriteDevPrivatesIndex;
#define MISPRITE(dev) \
((DevHasCursor(dev)) ? \
(miCursorInfoPtr) dev->devPrivates[miSpriteDevPrivatesIndex].ptr : \
(miCursorInfoPtr) inputInfo.pointer->devPrivates[miSpriteDevPrivatesIndex].ptr)
/*
* screen wrappers
*/
@ -104,6 +111,11 @@ static void miSpriteSaveDoomedAreas(WindowPtr pWin,
static void miSpriteComputeSaved(DeviceIntPtr pDev,
ScreenPtr pScreen);
static Bool miSpriteDeviceCursorInitialize(DeviceIntPtr pDev,
ScreenPtr pScreen);
static void miSpriteDeviceCursorCleanup(DeviceIntPtr pDev,
ScreenPtr pScreen);
#define SCREEN_PROLOGUE(pScreen, field)\
((pScreen)->field = \
((miSpriteScreenPtr) (pScreen)->devPrivates[miSpriteScreenIndex].ptr)->field)
@ -123,12 +135,16 @@ static void miSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor, int x, int y);
static void miSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y);
static void miSpriteUndisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen);
_X_EXPORT miPointerSpriteFuncRec miSpritePointerFuncs = {
miSpriteRealizeCursor,
miSpriteUnrealizeCursor,
miSpriteSetCursor,
miSpriteMoveCursor,
miSpriteDeviceCursorInitialize,
miSpriteDeviceCursorCleanup,
miSpriteUndisplayCursor
};
/*
@ -156,7 +172,7 @@ miSpriteReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (pCursorInfo->isUp &&
RECT_IN_REGION (pScreen, pRegion, &pCursorInfo->saved)
@ -183,8 +199,6 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
{
miSpriteScreenPtr pScreenPriv;
VisualPtr pVisual;
miCursorInfoPtr pCursorInfo;
int cursorIdx;
if (!DamageSetup (pScreen))
return FALSE;
@ -232,43 +246,18 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
pScreenPriv->BlockHandler = pScreen->BlockHandler;
/* alloc and zero memory for all cursors */
pScreenPriv->pDevCursors =
(miCursorInfoPtr)xalloc(MAX_DEVICES * sizeof(miCursorInfoRec));
if (!pScreenPriv->pDevCursors)
{
xfree((pointer)pScreenPriv);
return FALSE;
}
/* virtual core pointer's ID is 1 */
pScreenPriv->cp = &(pScreenPriv->pDevCursors[1]);
cursorIdx = 0;
while (cursorIdx < MAX_DEVICES)
{
pCursorInfo = &(pScreenPriv->pDevCursors[cursorIdx]);
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;
cursorIdx++;
}
pScreenPriv->DeviceCursorInitialize = pScreen->DeviceCursorInitialize;
pScreenPriv->DeviceCursorCleanup = pScreen->DeviceCursorCleanup;
pScreenPriv->pInstalledMap = NULL;
pScreenPriv->pColormap = NULL;
pScreenPriv->funcs = cursorFuncs;
pScreenPriv->colors[SOURCE_COLOR].red = 0;
pScreenPriv->colors[SOURCE_COLOR].green = 0;
pScreenPriv->colors[SOURCE_COLOR].blue = 0;
pScreenPriv->colors[MASK_COLOR].red = 0;
pScreenPriv->colors[MASK_COLOR].green = 0;
pScreenPriv->colors[MASK_COLOR].blue = 0;
pScreen->devPrivates[miSpriteScreenIndex].ptr = (pointer) pScreenPriv;
pScreen->CloseScreen = miSpriteCloseScreen;
@ -286,6 +275,8 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
pScreen->BlockHandler = miSpriteBlockHandler;
damageRegister = 0;
miSpriteDevPrivatesIndex = AllocateDevicePrivateIndex();
return TRUE;
}
@ -318,18 +309,8 @@ miSpriteCloseScreen (i, pScreen)
pScreen->StoreColors = pScreenPriv->StoreColors;
pScreen->SaveDoomedAreas = pScreenPriv->SaveDoomedAreas;
for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
{
if (DevHasCursor(pDev))
{
miCursorInfoPtr pCursor;
pCursor = &pScreenPriv->pDevCursors[pDev->id];
miSpriteIsUpFALSE (pCursor, pScreen, pScreenPriv);
}
}
DamageDestroy (pScreenPriv->pDamage);
xfree ((pointer)(pScreenPriv->pDevCursors));
xfree ((pointer) pScreenPriv);
return (*pScreen->CloseScreen) (i, pScreen);
@ -356,7 +337,7 @@ miSpriteGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (pDrawable->type == DRAWABLE_WINDOW &&
pCursorInfo->isUp &&
ORG_OVERLAP(&pCursorInfo->saved,pDrawable->x,pDrawable->y,
@ -396,7 +377,7 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp)
{
@ -448,7 +429,7 @@ miSpriteSourceValidate (pDrawable, x, y, width, height)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (pDrawable->type == DRAWABLE_WINDOW && pCursorInfo->isUp &&
ORG_OVERLAP(&pCursorInfo->saved, pDrawable->x, pDrawable->y,
x, y, width, height))
@ -481,7 +462,7 @@ miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
/*
* Damage will take care of destination check
*/
@ -522,7 +503,7 @@ miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (!pCursorInfo->isUp && pCursorInfo->shouldBeUp)
{
SPRITE_DEBUG (("BlockHandler restore\n"));
@ -534,7 +515,7 @@ miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (!pCursorInfo->isUp && pCursorInfo->shouldBeUp)
{
SPRITE_DEBUG (("BlockHandler restore\n"));
@ -550,9 +531,6 @@ miSpriteInstallColormap (pMap)
{
ScreenPtr pScreen = pMap->pScreen;
miSpriteScreenPtr pPriv;
DeviceIntPtr pDev = inputInfo.pointer;
miCursorInfoPtr pCursorInfo;
int cursorIdx;
pPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
@ -562,29 +540,23 @@ miSpriteInstallColormap (pMap)
SCREEN_EPILOGUE(pScreen, InstallColormap);
/* InstallColormap is called before devices are initialized. We cannot
* just run through the device list, we need to go through all possible
* sprite structs.*/
for (cursorIdx = 0; cursorIdx < MAX_DEVICES; cursorIdx++)
/* InstallColormap can be called before devices are initialized. */
pPriv->pInstalledMap = pMap;
if (pPriv->pColormap != pMap)
{
pCursorInfo = &pPriv->pDevCursors[cursorIdx];
pCursorInfo->pInstalledMap = pMap;
if (pCursorInfo->pColormap != pMap)
{
pCursorInfo->checkPixels = TRUE;
if (pCursorInfo->isUp)
{
/* find matching device */
DeviceIntPtr pDev;
miCursorInfoPtr pCursorInfo;
for (pDev = inputInfo.devices; pDev; pDev = pDev->next)
{
if (pDev->id == cursorIdx)
if (DevHasCursor(pDev))
{
pCursorInfo = MISPRITE(pDev);
pCursorInfo->checkPixels = TRUE;
if (pCursorInfo->isUp)
miSpriteRemoveCursor(pDev, pScreen);
break;
}
}
}
}
}
}
@ -610,6 +582,14 @@ miSpriteStoreColors (pMap, ndef, pdef)
SCREEN_EPILOGUE(pScreen, StoreColors);
if (pPriv->pColormap == pMap)
{
updated = 0;
pVisual = pMap->pVisual;
if (pVisual->class == DirectColor)
{
/* Direct color - match on any of the subfields */
#define MaskMatch(a,b,mask) (((a) & (pVisual->mask)) == ((b) & (pVisual->mask)))
#define UpdateDAC(dev, plane,dac,mask) {\
@ -624,23 +604,10 @@ miSpriteStoreColors (pMap, ndef, pdef)
UpdateDAC(dev, plane,green,greenMask) \
UpdateDAC(dev, plane,blue,blueMask)
for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
{
if (DevHasCursor(pDev))
{
pCursorInfo = &pPriv->pDevCursors[pDev->id];
if (pCursorInfo->pColormap == pMap)
{
updated = 0;
pVisual = pMap->pVisual;
if (pVisual->class == DirectColor)
{
/* Direct color - match on any of the subfields */
for (i = 0; i < ndef; i++)
{
CheckDirect (pCursorInfo, SOURCE_COLOR)
CheckDirect (pCursorInfo, MASK_COLOR)
CheckDirect (pPriv, SOURCE_COLOR)
CheckDirect (pPriv, MASK_COLOR)
}
}
else
@ -649,16 +616,16 @@ miSpriteStoreColors (pMap, ndef, pdef)
for (i = 0; i < ndef; i++)
{
if (pdef[i].pixel ==
pCursorInfo->colors[SOURCE_COLOR].pixel)
pPriv->colors[SOURCE_COLOR].pixel)
{
pCursorInfo->colors[SOURCE_COLOR] = pdef[i];
pPriv->colors[SOURCE_COLOR] = pdef[i];
if (++updated == 2)
break;
}
if (pdef[i].pixel ==
pCursorInfo->colors[MASK_COLOR].pixel)
pPriv->colors[MASK_COLOR].pixel)
{
pCursorInfo->colors[MASK_COLOR] = pdef[i];
pPriv->colors[MASK_COLOR] = pdef[i];
if (++updated == 2)
break;
}
@ -666,6 +633,11 @@ miSpriteStoreColors (pMap, ndef, pdef)
}
if (updated)
{
for(pDev = inputInfo.devices; pDev; pDev = pDev->next)
{
if (DevHasCursor(pDev))
{
pCursorInfo = MISPRITE(pDev);
pCursorInfo->checkPixels = TRUE;
if (pCursorInfo->isUp)
miSpriteRemoveCursor (pDev, pScreen);
@ -673,19 +645,20 @@ miSpriteStoreColors (pMap, ndef, pdef)
}
}
}
}
static void
miSpriteFindColors (miCursorInfoPtr pDevCursor, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv = (miSpriteScreenPtr)
pScreen->devPrivates[miSpriteScreenIndex].ptr;
CursorPtr pCursor;
xColorItem *sourceColor, *maskColor;
pCursor = pDevCursor->pCursor;
sourceColor = &pDevCursor->colors[SOURCE_COLOR];
maskColor = &pDevCursor->colors[MASK_COLOR];
if (pDevCursor->pColormap != pDevCursor->pInstalledMap ||
sourceColor = &pScreenPriv->colors[SOURCE_COLOR];
maskColor = &pScreenPriv->colors[MASK_COLOR];
if (pScreenPriv->pColormap != pScreenPriv->pInstalledMap ||
!(pCursor->foreRed == sourceColor->red &&
pCursor->foreGreen == sourceColor->green &&
pCursor->foreBlue == sourceColor->blue &&
@ -693,18 +666,18 @@ miSpriteFindColors (miCursorInfoPtr pDevCursor, ScreenPtr pScreen)
pCursor->backGreen == maskColor->green &&
pCursor->backBlue == maskColor->blue))
{
pDevCursor->pColormap = pDevCursor->pInstalledMap;
pScreenPriv->pColormap = pScreenPriv->pInstalledMap;
sourceColor->red = pCursor->foreRed;
sourceColor->green = pCursor->foreGreen;
sourceColor->blue = pCursor->foreBlue;
FakeAllocColor (pDevCursor->pColormap, sourceColor);
FakeAllocColor (pScreenPriv->pColormap, sourceColor);
maskColor->red = pCursor->backRed;
maskColor->green = pCursor->backGreen;
maskColor->blue = pCursor->backBlue;
FakeAllocColor (pDevCursor->pColormap, maskColor);
FakeAllocColor (pScreenPriv->pColormap, maskColor);
/* "free" the pixels right away, don't let this confuse you */
FakeFreeColor(pDevCursor->pColormap, sourceColor->pixel);
FakeFreeColor(pDevCursor->pColormap, maskColor->pixel);
FakeFreeColor(pScreenPriv->pColormap, sourceColor->pixel);
FakeFreeColor(pScreenPriv->pColormap, maskColor->pixel);
}
pDevCursor->checkPixels = FALSE;
@ -737,7 +710,7 @@ miSpriteSaveDoomedAreas (pWin, pObscured, dx, dy)
{
if(DevHasCursor(pDev))
{
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (pCursorInfo->isUp)
{
cursorBox = pCursorInfo->saved;
@ -777,10 +750,7 @@ miSpriteRealizeCursor (pDev, pScreen, pCursor)
miCursorInfoPtr pCursorInfo;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
if (DevHasCursor(pDev))
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
if (pCursor == pCursorInfo->pCursor)
pCursorInfo->checkPixels = TRUE;
@ -811,10 +781,7 @@ miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
miSpriteScreenPtr pScreenPriv;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
miCursorInfoPtr pPointer = pScreenPriv->cp;
if (DevHasCursor(pDev))
pPointer = &pScreenPriv->pDevCursors[pDev->id];
miCursorInfoPtr pPointer = MISPRITE(pDev);
if (!pCursor)
{
@ -929,14 +896,76 @@ miSpriteMoveCursor (pDev, pScreen, x, y)
CursorPtr pCursor;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursor = pScreenPriv->cp->pCursor;
if (DevHasCursor(pDev))
pCursor = pScreenPriv->pDevCursors[pDev->id].pCursor;
pCursor = MISPRITE(pDev)->pCursor;
miSpriteSetCursor (pDev, pScreen, pCursor, x, y);
}
static Bool
miSpriteDeviceCursorInitialize(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo;
int ret = FALSE;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
if (!AllocateDevicePrivate(pDev, miSpriteDevPrivatesIndex))
return FALSE;
pCursorInfo =
pDev->devPrivates[miSpriteDevPrivatesIndex].ptr =
xalloc(sizeof(miCursorInfoRec));
if (!pCursorInfo)
return FALSE;
pCursorInfo->pCursor = NULL;
pCursorInfo->x = 0;
pCursorInfo->y = 0;
pCursorInfo->isUp = FALSE;
pCursorInfo->shouldBeUp = FALSE;
pCursorInfo->pCacheWin = NullWindow;
pCursorInfo->isInCacheWin = FALSE;
pCursorInfo->checkPixels = TRUE;
ret = (*pScreenPriv->funcs->DeviceCursorInitialize)(pDev, pScreen);
if (!ret)
{
xfree(pCursorInfo);
pDev->devPrivates[miSpriteDevPrivatesIndex].ptr = NULL;
}
return ret;
}
static void
miSpriteDeviceCursorCleanup(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
if (DevHasCursor(pDev))
{
miSpriteScreenPtr pScreenPriv;
pScreenPriv =
(miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
(*pScreenPriv->funcs->DeviceCursorCleanup)(pDev, pScreen);
pDev->devPrivates[miSpriteDevPrivatesIndex].ptr = NULL;
xfree(MISPRITE(pDev));
}
}
static void
miSpriteUndisplayCursor(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
{
if (MISPRITE(pDev)->isUp)
miSpriteRemoveCursor(pDev, pScreen);
}
/*
* undraw/draw cursor
*/
@ -952,10 +981,7 @@ miSpriteRemoveCursor (pDev, pScreen)
DamageDrawInternal (pScreen, TRUE);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
if (DevHasCursor(pDev))
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
miSpriteIsUpFALSE (pCursorInfo, pScreen, pScreenPriv);
pCursorInfo->pCacheWin = NullWindow;
@ -992,10 +1018,7 @@ miSpriteSaveUnderCursor(pDev, pScreen)
DamageDrawInternal (pScreen, TRUE);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
if (DevHasCursor(pDev))
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
miSpriteComputeSaved (pDev, pScreen);
pCursor = pCursorInfo->pCursor;
@ -1035,10 +1058,7 @@ miSpriteRestoreCursor (pDev, pScreen)
DamageDrawInternal (pScreen, TRUE);
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
if (DevHasCursor(pDev))
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
miSpriteComputeSaved (pDev, pScreen);
pCursor = pCursorInfo->pCursor;
@ -1051,8 +1071,8 @@ miSpriteRestoreCursor (pDev, pScreen)
miSpriteFindColors (pCursorInfo, pScreen);
if ((*pScreenPriv->funcs->PutUpCursor) (pDev, pScreen,
pCursor, x, y,
pCursorInfo->colors[SOURCE_COLOR].pixel,
pCursorInfo->colors[MASK_COLOR].pixel))
pScreenPriv->colors[SOURCE_COLOR].pixel,
pScreenPriv->colors[MASK_COLOR].pixel))
{
miSpriteIsUpTRUE (pCursorInfo, pScreen, pScreenPriv);
}
@ -1076,10 +1096,7 @@ miSpriteComputeSaved (pDev, pScreen)
miCursorInfoPtr pCursorInfo;
pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
pCursorInfo = pScreenPriv->cp;
if (DevHasCursor(pDev))
pCursorInfo = &pScreenPriv->pDevCursors[pDev->id];
pCursorInfo = MISPRITE(pDev);
pCursor = pCursorInfo->pCursor;
x = pCursorInfo->x - (int)pCursor->bits->xhot;

8
mi/misprite.h
View File

@ -89,6 +89,14 @@ typedef struct {
int /*dx*/,
int /*dy*/
);
Bool (*DeviceCursorInitialize)(
DeviceIntPtr /*pDev*/,
ScreenPtr /*pScreen*/
);
void (*DeviceCursorCleanup)(
DeviceIntPtr /*pDev*/,
ScreenPtr /*pScreen*/
);
} miSpriteCursorFuncRec, *miSpriteCursorFuncPtr;

11
mi/mispritest.h
View File

@ -53,9 +53,6 @@ typedef struct {
WindowPtr pCacheWin; /* window the cursor last seen in */
Bool isInCacheWin;
Bool checkPixels; /* check colormap collision */
xColorItem colors[2];
ColormapPtr pInstalledMap;
ColormapPtr pColormap;
} miCursorInfoRec, *miCursorInfoPtr;
/*
@ -82,12 +79,16 @@ typedef struct {
/* os layer procedures */
ScreenBlockHandlerProcPtr BlockHandler;
miCursorInfoPtr cp; /* core pointer */
/* device cursor procedures */
DeviceCursorInitializeProcPtr DeviceCursorInitialize;
DeviceCursorCleanupProcPtr DeviceCursorCleanup;
xColorItem colors[2];
ColormapPtr pInstalledMap;
ColormapPtr pColormap;
VisualPtr pVisual;
miSpriteCursorFuncPtr funcs;
DamagePtr pDamage; /* damage tracking structure */
miCursorInfoPtr pDevCursors; /* all cursors' info */
} miSpriteScreenRec, *miSpriteScreenPtr;
#define SOURCE_COLOR 0