#include <CoreGraphics/CoreGraphics.h>
#include "quartz.h"
#include "quartz-cursor.h"
#include "Xplugin.h"
#include "mi.h"
#include "scrnintstr.h"
#include "cursorstr.h"
#include "mipointrst.h"
#include "windowstr.h"
#include "globals.h"
#include "servermd.h"
#include "dixevents.h"
typedef struct {
int CursorVisible;
QueryBestSizeProcPtr QueryBestSize;
miPointerSpriteFuncPtr spriteFuncs;
} QuartzCursorScreenRec, *QuartzCursorScreenPtr;
static int darwinCursorScreenIndex = -1;
static unsigned long darwinCursorGeneration = 0;
static Bool movedCursor = FALSE;
#define CURSOR_PRIV(pScreen) \
((QuartzCursorScreenPtr)pScreen->devPrivates[darwinCursorScreenIndex].ptr)
static Bool
load_cursor (CursorPtr src, int screen)
{
uint32_t *data;
uint32_t rowbytes;
int width, height;
int hot_x, hot_y;
uint32_t fg_color, bg_color;
uint8_t *srow, *sptr;
uint8_t *mrow, *mptr;
uint32_t *drow, *dptr;
unsigned xcount, ycount;
xp_error err;
width = src->bits->width;
height = src->bits->height;
hot_x = src->bits->xhot;
hot_y = src->bits->yhot;
#ifdef ARGB_CURSOR
if (src->bits->argb != NULL)
{
rowbytes = src->bits->width * sizeof (CARD32);
data = (uint32_t *) src->bits->argb;
}
else
#endif
{
fg_color = 0xFF00 | (src->foreRed >> 8);
fg_color <<= 16;
fg_color |= src->foreGreen & 0xFF00;
fg_color |= src->foreBlue >> 8;
bg_color = 0xFF00 | (src->backRed >> 8);
bg_color <<= 16;
bg_color |= src->backGreen & 0xFF00;
bg_color |= src->backBlue >> 8;
fg_color = htonl (fg_color);
bg_color = htonl (bg_color);
rowbytes = ((src->bits->width * 4) + 31) & ~31;
data = alloca (rowbytes * src->bits->height);
if (!src->bits->emptyMask)
{
ycount = src->bits->height;
srow = src->bits->source; mrow = src->bits->mask;
drow = data;
while (ycount-- > 0)
{
xcount = (src->bits->width + 7) / 8;
sptr = srow; mptr = mrow;
dptr = drow;
while (xcount-- > 0)
{
uint8_t s, m;
int i;
s = *sptr++; m = *mptr++;
for (i = 0; i < 8; i++)
{
#if BITMAP_BIT_ORDER == MSBFirst
if (m & 128)
*dptr++ = (s & 128) ? fg_color : bg_color;
else
*dptr++ = 0;
s <<= 1; m <<= 1;
#else
if (m & 1)
*dptr++ = (s & 1) ? fg_color : bg_color;
else
*dptr++ = 0;
s >>= 1; m >>= 1;
#endif
}
}
srow += BitmapBytePad (src->bits->width);
mrow += BitmapBytePad (src->bits->width);
drow = (uint32_t *) ((char *) drow + rowbytes);
}
}
else
{
memset (data, 0, src->bits->height * rowbytes);
}
}
err = xp_set_cursor (width, height, hot_x, hot_y, data, rowbytes);
return err == Success;
}
static Bool
QuartzRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
{
if(pCursor == NULL || pCursor->bits == NULL)
return FALSE;
return TRUE;
}
static Bool
QuartzUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
{
return TRUE;
}
static void
QuartzSetCursor (ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
{
QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
if (!quartzServerVisible)
return;
if (pCursor == NULL)
{
if (ScreenPriv->CursorVisible)
{
xp_hide_cursor ();
ScreenPriv->CursorVisible = FALSE;
}
}
else
{
load_cursor (pCursor, pScreen->myNum);
if (!ScreenPriv->CursorVisible)
{
xp_show_cursor ();
ScreenPriv->CursorVisible = TRUE;
}
}
}
static void
QuartzMoveCursor (ScreenPtr pScreen, int x, int y)
{
}
static miPointerSpriteFuncRec quartzSpriteFuncsRec = {
QuartzRealizeCursor,
QuartzUnrealizeCursor,
QuartzSetCursor,
QuartzMoveCursor
};
static Bool
QuartzCursorOffScreen (ScreenPtr *pScreen, int *x, int *y)
{
return FALSE;
}
static void
QuartzCrossScreen (ScreenPtr pScreen, Bool entering)
{
return;
}
static void
QuartzWarpCursor (ScreenPtr pScreen, int x, int y)
{
if (!movedCursor)
{
movedCursor = TRUE;
return;
}
if (quartzServerVisible)
{
int sx, sy;
sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
CGWarpMouseCursorPosition (CGPointMake (sx + x, sy + y));
}
miPointerWarpCursor (pScreen, x, y);
}
void
QuartzIgnoreNextWarpCursor (void)
{
movedCursor = FALSE;
}
static miPointerScreenFuncRec quartzScreenFuncsRec = {
QuartzCursorOffScreen,
QuartzCrossScreen,
QuartzWarpCursor,
DarwinEnqueuePointerEvent,
};
static void
QuartzCursorQueryBestSize (int class, unsigned short *width,
unsigned short *height, ScreenPtr pScreen)
{
QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
if (class == CursorShape)
{
*width = 32;
*height = 32;
}
else
{
(*ScreenPriv->QueryBestSize) (class, width, height, pScreen);
}
}
Bool
QuartzInitCursor (ScreenPtr pScreen)
{
QuartzCursorScreenPtr ScreenPriv;
miPointerScreenPtr PointPriv;
if (!miDCInitialize (pScreen, &quartzScreenFuncsRec))
return FALSE;
if (darwinCursorGeneration != serverGeneration)
{
if ((darwinCursorScreenIndex = AllocateScreenPrivateIndex ()) < 0)
return FALSE;
darwinCursorGeneration = serverGeneration;
}
ScreenPriv = xcalloc (1, sizeof(QuartzCursorScreenRec));
if (ScreenPriv == NULL)
return FALSE;
CURSOR_PRIV (pScreen) = ScreenPriv;
ScreenPriv->QueryBestSize = pScreen->QueryBestSize;
pScreen->QueryBestSize = QuartzCursorQueryBestSize;
PointPriv = (miPointerScreenPtr) pScreen->devPrivates[miPointerScreenIndex].ptr;
ScreenPriv->spriteFuncs = PointPriv->spriteFuncs;
PointPriv->spriteFuncs = &quartzSpriteFuncsRec;
ScreenPriv->CursorVisible = TRUE;
return TRUE;
}
void
QuartzSuspendXCursor (ScreenPtr pScreen)
{
}
void
QuartzResumeXCursor (ScreenPtr pScreen)
{
WindowPtr pWin;
CursorPtr pCursor;
int x, y;
pWin = GetSpriteWindow ();
if (pWin->drawable.pScreen != pScreen)
return;
pCursor = GetSpriteCursor ();
if (pCursor == NULL)
return;
GetSpritePosition (&x, &y);
QuartzSetCursor (pScreen, pCursor, x, y);
}