diff options
Diffstat (limited to 'xorg-server/xfixes/cursor.c')
| -rw-r--r-- | xorg-server/xfixes/cursor.c | 1165 |
1 files changed, 570 insertions, 595 deletions
diff --git a/xorg-server/xfixes/cursor.c b/xorg-server/xfixes/cursor.c index 7c46269bf..602b9061e 100644 --- a/xorg-server/xfixes/cursor.c +++ b/xorg-server/xfixes/cursor.c @@ -57,16 +57,17 @@ #include "xace.h" #include "list.h" -static RESTYPE CursorClientType; -static RESTYPE CursorHideCountType; -static RESTYPE CursorWindowType; -RESTYPE PointerBarrierType; -static CursorPtr CursorCurrent[MAXDEVICES]; +static RESTYPE CursorClientType; +static RESTYPE CursorHideCountType; +static RESTYPE CursorWindowType; +RESTYPE PointerBarrierType; +static CursorPtr CursorCurrent[MAXDEVICES]; static DevPrivateKeyRec CursorScreenPrivateKeyRec; + #define CursorScreenPrivateKey (&CursorScreenPrivateKeyRec) -static void deleteCursorHideCountsForScreen (ScreenPtr pScreen); +static void deleteCursorHideCountsForScreen(ScreenPtr pScreen); #define VERIFY_CURSOR(pCursor, cursor, client, access) \ do { \ @@ -86,14 +87,14 @@ static void deleteCursorHideCountsForScreen (ScreenPtr pScreen); typedef struct _CursorEvent *CursorEventPtr; typedef struct _CursorEvent { - CursorEventPtr next; - CARD32 eventMask; - ClientPtr pClient; - WindowPtr pWindow; - XID clientResource; + CursorEventPtr next; + CARD32 eventMask; + ClientPtr pClient; + WindowPtr pWindow; + XID clientResource; } CursorEventRec; -static CursorEventPtr cursorEvents; +static CursorEventPtr cursorEvents; /* * Each screen has a list of clients which have requested @@ -104,11 +105,11 @@ static CursorEventPtr cursorEvents; typedef struct _CursorHideCountRec *CursorHideCountPtr; typedef struct _CursorHideCountRec { - CursorHideCountPtr pNext; - ClientPtr pClient; - ScreenPtr pScreen; - int hideCount; - XID resource; + CursorHideCountPtr pNext; + ClientPtr pClient; + ScreenPtr pScreen; + int hideCount; + XID resource; } CursorHideCountRec; typedef struct PointerBarrierClient *PointerBarrierClientPtr; @@ -124,11 +125,11 @@ struct PointerBarrierClient { */ typedef struct _CursorScreen { - DisplayCursorProcPtr DisplayCursor; - CloseScreenProcPtr CloseScreen; + DisplayCursorProcPtr DisplayCursor; + CloseScreenProcPtr CloseScreen; ConstrainCursorHarderProcPtr ConstrainCursorHarder; - CursorHideCountPtr pCursorHideCounts; - struct xorg_list barriers; + CursorHideCountPtr pCursorHideCounts; + struct xorg_list barriers; } CursorScreenRec, *CursorScreenPtr; #define GetCursorScreen(s) ((CursorScreenPtr)dixLookupPrivate(&(s)->devPrivates, CursorScreenPrivateKey)) @@ -143,66 +144,63 @@ static Bool CursorVisible = FALSE; Bool EnableCursor = TRUE; static Bool -CursorDisplayCursor (DeviceIntPtr pDev, - ScreenPtr pScreen, - CursorPtr pCursor) +CursorDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor) { - CursorScreenPtr cs = GetCursorScreen(pScreen); - Bool ret; + CursorScreenPtr cs = GetCursorScreen(pScreen); + Bool ret; DisplayCursorProcPtr backupProc; - Unwrap (cs, pScreen, DisplayCursor, backupProc); + Unwrap(cs, pScreen, DisplayCursor, backupProc); /* * Have to check ConnectionInfo to distinguish client requests from * initial root window setup. Not a great way to do it, I admit. */ if (ConnectionInfo) - CursorVisible = EnableCursor; + CursorVisible = EnableCursor; if (cs->pCursorHideCounts != NULL || !CursorVisible) { - ret = (*pScreen->DisplayCursor) (pDev, pScreen, NullCursor); - } else { - ret = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor); + ret = (*pScreen->DisplayCursor) (pDev, pScreen, NullCursor); + } + else { + ret = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor); } - if (pCursor != CursorCurrent[pDev->id]) - { - CursorEventPtr e; - - CursorCurrent[pDev->id] = pCursor; - for (e = cursorEvents; e; e = e->next) - { - if ((e->eventMask & XFixesDisplayCursorNotifyMask)) - { - xXFixesCursorNotifyEvent ev; - ev.type = XFixesEventBase + XFixesCursorNotify; - ev.subtype = XFixesDisplayCursorNotify; - ev.window = e->pWindow->drawable.id; - ev.cursorSerial = pCursor ? pCursor->serialNumber : 0; - ev.timestamp = currentTime.milliseconds; - ev.name = pCursor ? pCursor->name : None; - WriteEventsToClient (e->pClient, 1, (xEvent *) &ev); - } - } + if (pCursor != CursorCurrent[pDev->id]) { + CursorEventPtr e; + + CursorCurrent[pDev->id] = pCursor; + for (e = cursorEvents; e; e = e->next) { + if ((e->eventMask & XFixesDisplayCursorNotifyMask)) { + xXFixesCursorNotifyEvent ev; + + ev.type = XFixesEventBase + XFixesCursorNotify; + ev.subtype = XFixesDisplayCursorNotify; + ev.window = e->pWindow->drawable.id; + ev.cursorSerial = pCursor ? pCursor->serialNumber : 0; + ev.timestamp = currentTime.milliseconds; + ev.name = pCursor ? pCursor->name : None; + WriteEventsToClient(e->pClient, 1, (xEvent *) &ev); + } + } } - Wrap (cs, pScreen, DisplayCursor, backupProc); + Wrap(cs, pScreen, DisplayCursor, backupProc); return ret; } static Bool -CursorCloseScreen (int index, ScreenPtr pScreen) +CursorCloseScreen(int index, ScreenPtr pScreen) { - CursorScreenPtr cs = GetCursorScreen (pScreen); - Bool ret; - _X_UNUSED CloseScreenProcPtr close_proc; - _X_UNUSED DisplayCursorProcPtr display_proc; + CursorScreenPtr cs = GetCursorScreen(pScreen); + Bool ret; + _X_UNUSED CloseScreenProcPtr close_proc; + _X_UNUSED DisplayCursorProcPtr display_proc; ConstrainCursorHarderProcPtr constrain_proc; - Unwrap (cs, pScreen, CloseScreen, close_proc); - Unwrap (cs, pScreen, DisplayCursor, display_proc); - Unwrap (cs, pScreen, ConstrainCursorHarder, constrain_proc); + Unwrap(cs, pScreen, CloseScreen, close_proc); + Unwrap(cs, pScreen, DisplayCursor, display_proc); + Unwrap(cs, pScreen, ConstrainCursorHarder, constrain_proc); deleteCursorHideCountsForScreen(pScreen); ret = (*pScreen->CloseScreen) (index, pScreen); free(cs); @@ -212,102 +210,92 @@ CursorCloseScreen (int index, ScreenPtr pScreen) #define CursorAllEvents (XFixesDisplayCursorNotifyMask) static int -XFixesSelectCursorInput (ClientPtr pClient, - WindowPtr pWindow, - CARD32 eventMask) +XFixesSelectCursorInput(ClientPtr pClient, WindowPtr pWindow, CARD32 eventMask) { - CursorEventPtr *prev, e; + CursorEventPtr *prev, e; pointer val; int rc; - for (prev = &cursorEvents; (e = *prev); prev = &e->next) - { - if (e->pClient == pClient && - e->pWindow == pWindow) - { - break; - } + for (prev = &cursorEvents; (e = *prev); prev = &e->next) { + if (e->pClient == pClient && e->pWindow == pWindow) { + break; + } } - if (!eventMask) - { - if (e) - { - FreeResource (e->clientResource, 0); - } - return Success; + if (!eventMask) { + if (e) { + FreeResource(e->clientResource, 0); + } + return Success; } - if (!e) - { - e = (CursorEventPtr) malloc(sizeof (CursorEventRec)); - if (!e) - return BadAlloc; - - e->next = 0; - e->pClient = pClient; - e->pWindow = pWindow; - e->clientResource = FakeClientID(pClient->index); - - /* - * Add a resource hanging from the window to - * catch window destroy - */ - rc = dixLookupResourceByType( &val, pWindow->drawable.id, - CursorWindowType, serverClient, - DixGetAttrAccess); - if (rc != Success) - if (!AddResource (pWindow->drawable.id, CursorWindowType, - (pointer) pWindow)) - { - free(e); - return BadAlloc; - } - - if (!AddResource (e->clientResource, CursorClientType, (pointer) e)) - return BadAlloc; - - *prev = e; + if (!e) { + e = (CursorEventPtr) malloc(sizeof(CursorEventRec)); + if (!e) + return BadAlloc; + + e->next = 0; + e->pClient = pClient; + e->pWindow = pWindow; + e->clientResource = FakeClientID(pClient->index); + + /* + * Add a resource hanging from the window to + * catch window destroy + */ + rc = dixLookupResourceByType(&val, pWindow->drawable.id, + CursorWindowType, serverClient, + DixGetAttrAccess); + if (rc != Success) + if (!AddResource(pWindow->drawable.id, CursorWindowType, + (pointer) pWindow)) { + free(e); + return BadAlloc; + } + + if (!AddResource(e->clientResource, CursorClientType, (pointer) e)) + return BadAlloc; + + *prev = e; } e->eventMask = eventMask; return Success; } int -ProcXFixesSelectCursorInput (ClientPtr client) +ProcXFixesSelectCursorInput(ClientPtr client) { - REQUEST (xXFixesSelectCursorInputReq); - WindowPtr pWin; - int rc; + REQUEST(xXFixesSelectCursorInputReq); + WindowPtr pWin; + int rc; - REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq); + REQUEST_SIZE_MATCH(xXFixesSelectCursorInputReq); rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); if (rc != Success) return rc; - if (stuff->eventMask & ~CursorAllEvents) - { - client->errorValue = stuff->eventMask; - return BadValue; + if (stuff->eventMask & ~CursorAllEvents) { + client->errorValue = stuff->eventMask; + return BadValue; } - return XFixesSelectCursorInput (client, pWin, stuff->eventMask); + return XFixesSelectCursorInput(client, pWin, stuff->eventMask); } static int -GetBit (unsigned char *line, int x) +GetBit(unsigned char *line, int x) { - unsigned char mask; - + unsigned char mask; + if (screenInfo.bitmapBitOrder == LSBFirst) - mask = (1 << (x & 7)); + mask = (1 << (x & 7)); else - mask = (0x80 >> (x & 7)); + mask = (0x80 >> (x & 7)); /* XXX assumes byte order is host byte order */ line += (x >> 3); if (*line & mask) - return 1; + return 1; return 0; } int -SProcXFixesSelectCursorInput (ClientPtr client) +SProcXFixesSelectCursorInput(ClientPtr client) { REQUEST(xXFixesSelectCursorInputReq); @@ -316,91 +304,85 @@ SProcXFixesSelectCursorInput (ClientPtr client) swapl(&stuff->eventMask); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } - + void -SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from, - xXFixesCursorNotifyEvent *to) +SXFixesCursorNotifyEvent(xXFixesCursorNotifyEvent * from, + xXFixesCursorNotifyEvent * to) { to->type = from->type; - cpswaps (from->sequenceNumber, to->sequenceNumber); - cpswapl (from->window, to->window); - cpswapl (from->cursorSerial, to->cursorSerial); - cpswapl (from->timestamp, to->timestamp); - cpswapl (from->name, to->name); + cpswaps(from->sequenceNumber, to->sequenceNumber); + cpswapl(from->window, to->window); + cpswapl(from->cursorSerial, to->cursorSerial); + cpswapl(from->timestamp, to->timestamp); + cpswapl(from->name, to->name); } static void -CopyCursorToImage (CursorPtr pCursor, CARD32 *image) +CopyCursorToImage(CursorPtr pCursor, CARD32 *image) { int width = pCursor->bits->width; int height = pCursor->bits->height; int npixels = width * height; - + #ifdef ARGB_CURSOR if (pCursor->bits->argb) - memcpy (image, pCursor->bits->argb, npixels * sizeof (CARD32)); + memcpy(image, pCursor->bits->argb, npixels * sizeof(CARD32)); else #endif { - unsigned char *srcLine = pCursor->bits->source; - unsigned char *mskLine = pCursor->bits->mask; - int stride = BitmapBytePad (width); - int x, y; - CARD32 fg, bg; - - fg = (0xff000000 | - ((pCursor->foreRed & 0xff00) << 8) | - (pCursor->foreGreen & 0xff00) | - (pCursor->foreBlue >> 8)); - bg = (0xff000000 | - ((pCursor->backRed & 0xff00) << 8) | - (pCursor->backGreen & 0xff00) | - (pCursor->backBlue >> 8)); - for (y = 0; y < height; y++) - { - for (x = 0; x < width; x++) - { - if (GetBit (mskLine, x)) - { - if (GetBit (srcLine, x)) - *image++ = fg; - else - *image++ = bg; - } - else - *image++ = 0; - } - srcLine += stride; - mskLine += stride; - } + unsigned char *srcLine = pCursor->bits->source; + unsigned char *mskLine = pCursor->bits->mask; + int stride = BitmapBytePad(width); + int x, y; + CARD32 fg, bg; + + fg = (0xff000000 | + ((pCursor->foreRed & 0xff00) << 8) | + (pCursor->foreGreen & 0xff00) | (pCursor->foreBlue >> 8)); + bg = (0xff000000 | + ((pCursor->backRed & 0xff00) << 8) | + (pCursor->backGreen & 0xff00) | (pCursor->backBlue >> 8)); + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + if (GetBit(mskLine, x)) { + if (GetBit(srcLine, x)) + *image++ = fg; + else + *image++ = bg; + } + else + *image++ = 0; + } + srcLine += stride; + mskLine += stride; + } } } int -ProcXFixesGetCursorImage (ClientPtr client) +ProcXFixesGetCursorImage(ClientPtr client) { /* REQUEST(xXFixesGetCursorImageReq); */ - xXFixesGetCursorImageReply *rep; - CursorPtr pCursor; - CARD32 *image; - int npixels, width, height, rc, x, y; + xXFixesGetCursorImageReply *rep; + CursorPtr pCursor; + CARD32 *image; + int npixels, width, height, rc, x, y; REQUEST_SIZE_MATCH(xXFixesGetCursorImageReq); pCursor = CursorCurrent[PickPointer(client)->id]; if (!pCursor) - return BadCursor; + return BadCursor; rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR, - pCursor, RT_NONE, NULL, DixReadAccess); + pCursor, RT_NONE, NULL, DixReadAccess); if (rc != Success) - return rc; - GetSpritePosition (PickPointer(client), &x, &y); + return rc; + GetSpritePosition(PickPointer(client), &x, &y); width = pCursor->bits->width; height = pCursor->bits->height; npixels = width * height; - rep = malloc(sizeof (xXFixesGetCursorImageReply) + - npixels * sizeof (CARD32)); + rep = malloc(sizeof(xXFixesGetCursorImageReply) + npixels * sizeof(CARD32)); if (!rep) - return BadAlloc; + return BadAlloc; rep->type = X_Reply; rep->sequenceNumber = client->sequence; @@ -410,32 +392,31 @@ ProcXFixesGetCursorImage (ClientPtr client) rep->x = x; rep->y = y; rep->xhot = pCursor->bits->xhot; - rep->yhot = pCursor->bits->yhot; + rep->yhot = pCursor->bits->yhot; rep->cursorSerial = pCursor->serialNumber; image = (CARD32 *) (rep + 1); - CopyCursorToImage (pCursor, image); - if (client->swapped) - { - swaps(&rep->sequenceNumber); - swapl(&rep->length); - swaps(&rep->x); - swaps(&rep->y); - swaps(&rep->width); - swaps(&rep->height); - swaps(&rep->xhot); - swaps(&rep->yhot); - swapl(&rep->cursorSerial); - SwapLongs (image, npixels); + CopyCursorToImage(pCursor, image); + if (client->swapped) { + swaps(&rep->sequenceNumber); + swapl(&rep->length); + swaps(&rep->x); + swaps(&rep->y); + swaps(&rep->width); + swaps(&rep->height); + swaps(&rep->xhot); + swaps(&rep->yhot); + swapl(&rep->cursorSerial); + SwapLongs(image, npixels); } - WriteToClient(client, sizeof (xXFixesGetCursorImageReply) + - (npixels << 2), (char *) rep); + WriteToClient(client, sizeof(xXFixesGetCursorImageReply) + + (npixels << 2), (char *) rep); free(rep); return Success; } int -SProcXFixesGetCursorImage (ClientPtr client) +SProcXFixesGetCursorImage(ClientPtr client) { REQUEST(xXFixesGetCursorImageReq); swaps(&stuff->length); @@ -443,26 +424,27 @@ SProcXFixesGetCursorImage (ClientPtr client) } int -ProcXFixesSetCursorName (ClientPtr client) +ProcXFixesSetCursorName(ClientPtr client) { CursorPtr pCursor; char *tchar; + REQUEST(xXFixesSetCursorNameReq); Atom atom; REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq); VERIFY_CURSOR(pCursor, stuff->cursor, client, DixSetAttrAccess); tchar = (char *) &stuff[1]; - atom = MakeAtom (tchar, stuff->nbytes, TRUE); + atom = MakeAtom(tchar, stuff->nbytes, TRUE); if (atom == BAD_RESOURCE) - return BadAlloc; - + return BadAlloc; + pCursor->name = atom; return Success; } int -SProcXFixesSetCursorName (ClientPtr client) +SProcXFixesSetCursorName(ClientPtr client) { REQUEST(xXFixesSetCursorNameReq); @@ -474,10 +456,11 @@ SProcXFixesSetCursorName (ClientPtr client) } int -ProcXFixesGetCursorName (ClientPtr client) +ProcXFixesGetCursorName(ClientPtr client) { - CursorPtr pCursor; - xXFixesGetCursorNameReply reply; + CursorPtr pCursor; + xXFixesGetCursorNameReply reply; + REQUEST(xXFixesGetCursorNameReq); const char *str; int len; @@ -485,31 +468,30 @@ ProcXFixesGetCursorName (ClientPtr client) REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq); VERIFY_CURSOR(pCursor, stuff->cursor, client, DixGetAttrAccess); if (pCursor->name) - str = NameForAtom (pCursor->name); + str = NameForAtom(pCursor->name); else - str = ""; - len = strlen (str); - + str = ""; + len = strlen(str); + reply.type = X_Reply; reply.length = bytes_to_int32(len); reply.sequenceNumber = client->sequence; reply.atom = pCursor->name; reply.nbytes = len; - if (client->swapped) - { - swaps(&reply.sequenceNumber); - swapl(&reply.length); - swapl(&reply.atom); - swaps(&reply.nbytes); + if (client->swapped) { + swaps(&reply.sequenceNumber); + swapl(&reply.length); + swapl(&reply.atom); + swaps(&reply.nbytes); } WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply); WriteToClient(client, len, str); - + return Success; } int -SProcXFixesGetCursorName (ClientPtr client) +SProcXFixesGetCursorName(ClientPtr client) { REQUEST(xXFixesGetCursorNameReq); @@ -520,37 +502,37 @@ SProcXFixesGetCursorName (ClientPtr client) } int -ProcXFixesGetCursorImageAndName (ClientPtr client) +ProcXFixesGetCursorImageAndName(ClientPtr client) { /* REQUEST(xXFixesGetCursorImageAndNameReq); */ - xXFixesGetCursorImageAndNameReply *rep; - CursorPtr pCursor; - CARD32 *image; - int npixels; - const char *name; - int nbytes, nbytesRound; - int width, height; - int rc, x, y; + xXFixesGetCursorImageAndNameReply *rep; + CursorPtr pCursor; + CARD32 *image; + int npixels; + const char *name; + int nbytes, nbytesRound; + int width, height; + int rc, x, y; REQUEST_SIZE_MATCH(xXFixesGetCursorImageAndNameReq); pCursor = CursorCurrent[PickPointer(client)->id]; if (!pCursor) - return BadCursor; + return BadCursor; rc = XaceHook(XACE_RESOURCE_ACCESS, client, pCursor->id, RT_CURSOR, - pCursor, RT_NONE, NULL, DixReadAccess|DixGetAttrAccess); + pCursor, RT_NONE, NULL, DixReadAccess | DixGetAttrAccess); if (rc != Success) - return rc; - GetSpritePosition (PickPointer(client), &x, &y); + return rc; + GetSpritePosition(PickPointer(client), &x, &y); width = pCursor->bits->width; height = pCursor->bits->height; npixels = width * height; - name = pCursor->name ? NameForAtom (pCursor->name) : ""; - nbytes = strlen (name); + name = pCursor->name ? NameForAtom(pCursor->name) : ""; + nbytes = strlen(name); nbytesRound = pad_to_int32(nbytes); - rep = malloc(sizeof (xXFixesGetCursorImageAndNameReply) + - npixels * sizeof (CARD32) + nbytesRound); + rep = malloc(sizeof(xXFixesGetCursorImageAndNameReply) + + npixels * sizeof(CARD32) + nbytesRound); if (!rep) - return BadAlloc; + return BadAlloc; rep->type = X_Reply; rep->sequenceNumber = client->sequence; @@ -560,37 +542,36 @@ ProcXFixesGetCursorImageAndName (ClientPtr client) rep->x = x; rep->y = y; rep->xhot = pCursor->bits->xhot; - rep->yhot = pCursor->bits->yhot; + rep->yhot = pCursor->bits->yhot; rep->cursorSerial = pCursor->serialNumber; rep->cursorName = pCursor->name; rep->nbytes = nbytes; image = (CARD32 *) (rep + 1); - CopyCursorToImage (pCursor, image); - memcpy ((image + npixels), name, nbytes); - if (client->swapped) - { - swaps(&rep->sequenceNumber); - swapl(&rep->length); - swaps(&rep->x); - swaps(&rep->y); - swaps(&rep->width); - swaps(&rep->height); - swaps(&rep->xhot); - swaps(&rep->yhot); - swapl(&rep->cursorSerial); - swapl(&rep->cursorName); - swaps(&rep->nbytes); - SwapLongs (image, npixels); + CopyCursorToImage(pCursor, image); + memcpy((image + npixels), name, nbytes); + if (client->swapped) { + swaps(&rep->sequenceNumber); + swapl(&rep->length); + swaps(&rep->x); + swaps(&rep->y); + swaps(&rep->width); + swaps(&rep->height); + swaps(&rep->xhot); + swaps(&rep->yhot); + swapl(&rep->cursorSerial); + swapl(&rep->cursorName); + swaps(&rep->nbytes); + SwapLongs(image, npixels); } - WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) + - (npixels << 2) + nbytesRound, (char *) rep); + WriteToClient(client, sizeof(xXFixesGetCursorImageAndNameReply) + + (npixels << 2) + nbytesRound, (char *) rep); free(rep); return Success; } int -SProcXFixesGetCursorImageAndName (ClientPtr client) +SProcXFixesGetCursorImageAndName(ClientPtr client) { REQUEST(xXFixesGetCursorImageAndNameReq); swaps(&stuff->length); @@ -611,66 +592,61 @@ typedef struct { pointer closure; } ReplaceCursorLookupRec, *ReplaceCursorLookupPtr; -static const RESTYPE CursorRestypes[] = { +static const RESTYPE CursorRestypes[] = { RT_WINDOW, RT_PASSIVEGRAB, RT_CURSOR }; #define NUM_CURSOR_RESTYPES (sizeof (CursorRestypes) / sizeof (CursorRestypes[0])) static Bool -ReplaceCursorLookup (pointer value, XID id, pointer closure) +ReplaceCursorLookup(pointer value, XID id, pointer closure) { - ReplaceCursorLookupPtr rcl = (ReplaceCursorLookupPtr) closure; - WindowPtr pWin; - GrabPtr pGrab; - CursorPtr pCursor = 0, *pCursorRef = 0; - XID cursor = 0; + ReplaceCursorLookupPtr rcl = (ReplaceCursorLookupPtr) closure; + WindowPtr pWin; + GrabPtr pGrab; + CursorPtr pCursor = 0, *pCursorRef = 0; + XID cursor = 0; switch (rcl->type) { case RT_WINDOW: - pWin = (WindowPtr) value; - if (pWin->optional) - { - pCursorRef = &pWin->optional->cursor; - pCursor = *pCursorRef; - } - break; + pWin = (WindowPtr) value; + if (pWin->optional) { + pCursorRef = &pWin->optional->cursor; + pCursor = *pCursorRef; + } + break; case RT_PASSIVEGRAB: - pGrab = (GrabPtr) value; - pCursorRef = &pGrab->cursor; - pCursor = *pCursorRef; - break; + pGrab = (GrabPtr) value; + pCursorRef = &pGrab->cursor; + pCursor = *pCursorRef; + break; case RT_CURSOR: - pCursorRef = 0; - pCursor = (CursorPtr) value; - cursor = id; - break; + pCursorRef = 0; + pCursor = (CursorPtr) value; + cursor = id; + break; } - if (pCursor && pCursor != rcl->pNew) - { - if ((*rcl->testCursor) (pCursor, rcl->closure)) - { - rcl->pNew->refcnt++; - /* either redirect reference or update resource database */ - if (pCursorRef) - *pCursorRef = rcl->pNew; - else - ChangeResourceValue (id, RT_CURSOR, rcl->pNew); - FreeCursor (pCursor, cursor); - } + if (pCursor && pCursor != rcl->pNew) { + if ((*rcl->testCursor) (pCursor, rcl->closure)) { + rcl->pNew->refcnt++; + /* either redirect reference or update resource database */ + if (pCursorRef) + *pCursorRef = rcl->pNew; + else + ChangeResourceValue(id, RT_CURSOR, rcl->pNew); + FreeCursor(pCursor, cursor); + } } - return FALSE; /* keep walking */ + return FALSE; /* keep walking */ } static void -ReplaceCursor (CursorPtr pCursor, - TestCursorFunc testCursor, - pointer closure) +ReplaceCursor(CursorPtr pCursor, TestCursorFunc testCursor, pointer closure) { - int clientIndex; + int clientIndex; int resIndex; - ReplaceCursorLookupRec rcl; - + ReplaceCursorLookupRec rcl; + /* * Cursors exist only in the resource database, windows and grabs. * All of these are always pointed at by the resource database. Walk @@ -681,50 +657,48 @@ ReplaceCursor (CursorPtr pCursor, rcl.closure = closure; /* for each client */ - for (clientIndex = 0; clientIndex < currentMaxClients; clientIndex++) - { - if (!clients[clientIndex]) - continue; - for (resIndex = 0; resIndex < NUM_CURSOR_RESTYPES; resIndex++) - { - rcl.type = CursorRestypes[resIndex]; - /* - * This function walks the entire client resource database - */ - LookupClientResourceComplex (clients[clientIndex], - rcl.type, - ReplaceCursorLookup, - (pointer) &rcl); - } + for (clientIndex = 0; clientIndex < currentMaxClients; clientIndex++) { + if (!clients[clientIndex]) + continue; + for (resIndex = 0; resIndex < NUM_CURSOR_RESTYPES; resIndex++) { + rcl.type = CursorRestypes[resIndex]; + /* + * This function walks the entire client resource database + */ + LookupClientResourceComplex(clients[clientIndex], + rcl.type, + ReplaceCursorLookup, (pointer) &rcl); + } } /* this "knows" that WindowHasNewCursor doesn't depend on it's argument */ - WindowHasNewCursor (screenInfo.screens[0]->root); + WindowHasNewCursor(screenInfo.screens[0]->root); } -static Bool -TestForCursor (CursorPtr pCursor, pointer closure) +static Bool +TestForCursor(CursorPtr pCursor, pointer closure) { return (pCursor == (CursorPtr) closure); } int -ProcXFixesChangeCursor (ClientPtr client) +ProcXFixesChangeCursor(ClientPtr client) { - CursorPtr pSource, pDestination; + CursorPtr pSource, pDestination; + REQUEST(xXFixesChangeCursorReq); REQUEST_SIZE_MATCH(xXFixesChangeCursorReq); - VERIFY_CURSOR (pSource, stuff->source, client, - DixReadAccess|DixGetAttrAccess); - VERIFY_CURSOR (pDestination, stuff->destination, client, - DixWriteAccess|DixSetAttrAccess); + VERIFY_CURSOR(pSource, stuff->source, client, + DixReadAccess | DixGetAttrAccess); + VERIFY_CURSOR(pDestination, stuff->destination, client, + DixWriteAccess | DixSetAttrAccess); - ReplaceCursor (pSource, TestForCursor, (pointer) pDestination); + ReplaceCursor(pSource, TestForCursor, (pointer) pDestination); return Success; } int -SProcXFixesChangeCursor (ClientPtr client) +SProcXFixesChangeCursor(ClientPtr client) { REQUEST(xXFixesChangeCursorReq); @@ -736,37 +710,39 @@ SProcXFixesChangeCursor (ClientPtr client) } static Bool -TestForCursorName (CursorPtr pCursor, pointer closure) +TestForCursorName(CursorPtr pCursor, pointer closure) { Atom *pName = closure; + return pCursor->name == *pName; } int -ProcXFixesChangeCursorByName (ClientPtr client) +ProcXFixesChangeCursorByName(ClientPtr client) { - CursorPtr pSource; - Atom name; - char *tchar; + CursorPtr pSource; + Atom name; + char *tchar; + REQUEST(xXFixesChangeCursorByNameReq); REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes); VERIFY_CURSOR(pSource, stuff->source, client, - DixReadAccess|DixGetAttrAccess); + DixReadAccess | DixGetAttrAccess); tchar = (char *) &stuff[1]; - name = MakeAtom (tchar, stuff->nbytes, FALSE); + name = MakeAtom(tchar, stuff->nbytes, FALSE); if (name) - ReplaceCursor (pSource, TestForCursorName, &name); + ReplaceCursor(pSource, TestForCursorName, &name); return Success; } int -SProcXFixesChangeCursorByName (ClientPtr client) +SProcXFixesChangeCursorByName(ClientPtr client) { REQUEST(xXFixesChangeCursorByNameReq); swaps(&stuff->length); - REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq); + REQUEST_AT_LEAST_SIZE(xXFixesChangeCursorByNameReq); swapl(&stuff->source); swaps(&stuff->nbytes); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); @@ -780,29 +756,29 @@ SProcXFixesChangeCursorByName (ClientPtr client) /* Return the screen's hide-counts list element for the given client */ static CursorHideCountPtr -findCursorHideCount (ClientPtr pClient, ScreenPtr pScreen) +findCursorHideCount(ClientPtr pClient, ScreenPtr pScreen) { - CursorScreenPtr cs = GetCursorScreen(pScreen); + CursorScreenPtr cs = GetCursorScreen(pScreen); CursorHideCountPtr pChc; for (pChc = cs->pCursorHideCounts; pChc != NULL; pChc = pChc->pNext) { - if (pChc->pClient == pClient) { - return pChc; - } + if (pChc->pClient == pClient) { + return pChc; + } } - return NULL; + return NULL; } static int -createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen) +createCursorHideCount(ClientPtr pClient, ScreenPtr pScreen) { - CursorScreenPtr cs = GetCursorScreen(pScreen); + CursorScreenPtr cs = GetCursorScreen(pScreen); CursorHideCountPtr pChc; pChc = (CursorHideCountPtr) malloc(sizeof(CursorHideCountRec)); if (pChc == NULL) { - return BadAlloc; + return BadAlloc; } pChc->pClient = pClient; pChc->pScreen = pScreen; @@ -810,15 +786,14 @@ createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen) pChc->resource = FakeClientID(pClient->index); pChc->pNext = cs->pCursorHideCounts; cs->pCursorHideCounts = pChc; - + /* * Create a resource for this element so it can be deleted * when the client goes away. */ - if (!AddResource (pChc->resource, CursorHideCountType, - (pointer) pChc)) { - free(pChc); - return BadAlloc; + if (!AddResource(pChc->resource, CursorHideCountType, (pointer) pChc)) { + free(pChc); + return BadAlloc; } return Success; @@ -828,26 +803,27 @@ createCursorHideCount (ClientPtr pClient, ScreenPtr pScreen) * Delete the given hide-counts list element from its screen list. */ static void -deleteCursorHideCount (CursorHideCountPtr pChcToDel, ScreenPtr pScreen) +deleteCursorHideCount(CursorHideCountPtr pChcToDel, ScreenPtr pScreen) { - CursorScreenPtr cs = GetCursorScreen(pScreen); + CursorScreenPtr cs = GetCursorScreen(pScreen); CursorHideCountPtr pChc, pNext; CursorHideCountPtr pChcLast = NULL; pChc = cs->pCursorHideCounts; while (pChc != NULL) { - pNext = pChc->pNext; - if (pChc == pChcToDel) { - free(pChc); - if (pChcLast == NULL) { - cs->pCursorHideCounts = pNext; - } else { - pChcLast->pNext = pNext; - } - return; - } - pChcLast = pChc; - pChc = pNext; + pNext = pChc->pNext; + if (pChc == pChcToDel) { + free(pChc); + if (pChcLast == NULL) { + cs->pCursorHideCounts = pNext; + } + else { + pChcLast->pNext = pNext; + } + return; + } + pChcLast = pChc; + pChc = pNext; } } @@ -855,35 +831,36 @@ deleteCursorHideCount (CursorHideCountPtr pChcToDel, ScreenPtr pScreen) * Delete all the hide-counts list elements for this screen. */ static void -deleteCursorHideCountsForScreen (ScreenPtr pScreen) +deleteCursorHideCountsForScreen(ScreenPtr pScreen) { - CursorScreenPtr cs = GetCursorScreen(pScreen); + CursorScreenPtr cs = GetCursorScreen(pScreen); CursorHideCountPtr pChc, pTmp; pChc = cs->pCursorHideCounts; while (pChc != NULL) { - pTmp = pChc->pNext; - FreeResource(pChc->resource, 0); - pChc = pTmp; + pTmp = pChc->pNext; + FreeResource(pChc->resource, 0); + pChc = pTmp; } - cs->pCursorHideCounts = NULL; + cs->pCursorHideCounts = NULL; } -int -ProcXFixesHideCursor (ClientPtr client) +int +ProcXFixesHideCursor(ClientPtr client) { WindowPtr pWin; CursorHideCountPtr pChc; + REQUEST(xXFixesHideCursorReq); int ret; - REQUEST_SIZE_MATCH (xXFixesHideCursorReq); + REQUEST_SIZE_MATCH(xXFixesHideCursorReq); - ret = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW, - client, DixGetAttrAccess); + ret = dixLookupResourceByType((pointer *) &pWin, stuff->window, RT_WINDOW, + client, DixGetAttrAccess); if (ret != Success) { - client->errorValue = stuff->window; - return ret; + client->errorValue = stuff->window; + return ret; } /* @@ -893,8 +870,8 @@ ProcXFixesHideCursor (ClientPtr client) pChc = findCursorHideCount(client, pWin->drawable.pScreen); if (pChc != NULL) { - pChc->hideCount++; - return Success; + pChc->hideCount++; + return Success; } /* @@ -902,50 +879,52 @@ ProcXFixesHideCursor (ClientPtr client) * for this screen. */ ret = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen, - DixHideAccess); + DixHideAccess); if (ret != Success) - return ret; + return ret; ret = createCursorHideCount(client, pWin->drawable.pScreen); if (ret == Success) { - DeviceIntPtr dev; - for (dev = inputInfo.devices; dev; dev = dev->next) - { - if (IsMaster(dev) && IsPointerDevice(dev)) - CursorDisplayCursor(dev, pWin->drawable.pScreen, CursorCurrent[dev->id]); - } + DeviceIntPtr dev; + + for (dev = inputInfo.devices; dev; dev = dev->next) { + if (IsMaster(dev) && IsPointerDevice(dev)) + CursorDisplayCursor(dev, pWin->drawable.pScreen, + CursorCurrent[dev->id]); + } } return ret; } -int -SProcXFixesHideCursor (ClientPtr client) +int +SProcXFixesHideCursor(ClientPtr client) { REQUEST(xXFixesHideCursorReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesHideCursorReq); + REQUEST_SIZE_MATCH(xXFixesHideCursorReq); swapl(&stuff->window); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } -int -ProcXFixesShowCursor (ClientPtr client) +int +ProcXFixesShowCursor(ClientPtr client) { WindowPtr pWin; CursorHideCountPtr pChc; int rc; + REQUEST(xXFixesShowCursorReq); - REQUEST_SIZE_MATCH (xXFixesShowCursorReq); + REQUEST_SIZE_MATCH(xXFixesShowCursorReq); - rc = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW, - client, DixGetAttrAccess); + rc = dixLookupResourceByType((pointer *) &pWin, stuff->window, RT_WINDOW, + client, DixGetAttrAccess); if (rc != Success) { - client->errorValue = stuff->window; - return rc; + client->errorValue = stuff->window; + return rc; } /* @@ -954,61 +933,58 @@ ProcXFixesShowCursor (ClientPtr client) */ pChc = findCursorHideCount(client, pWin->drawable.pScreen); if (pChc == NULL) { - return BadMatch; + return BadMatch; } rc = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen, - DixShowAccess); + DixShowAccess); if (rc != Success) - return rc; + return rc; pChc->hideCount--; if (pChc->hideCount <= 0) { - FreeResource(pChc->resource, 0); + FreeResource(pChc->resource, 0); } return Success; } -int -SProcXFixesShowCursor (ClientPtr client) +int +SProcXFixesShowCursor(ClientPtr client) { REQUEST(xXFixesShowCursorReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesShowCursorReq); + REQUEST_SIZE_MATCH(xXFixesShowCursorReq); swapl(&stuff->window); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } static int -CursorFreeClient (pointer data, XID id) +CursorFreeClient(pointer data, XID id) { - CursorEventPtr old = (CursorEventPtr) data; - CursorEventPtr *prev, e; - - for (prev = &cursorEvents; (e = *prev); prev = &e->next) - { - if (e == old) - { - *prev = e->next; - free(e); - break; - } + CursorEventPtr old = (CursorEventPtr) data; + CursorEventPtr *prev, e; + + for (prev = &cursorEvents; (e = *prev); prev = &e->next) { + if (e == old) { + *prev = e->next; + free(e); + break; + } } return 1; } static int -CursorFreeHideCount (pointer data, XID id) +CursorFreeHideCount(pointer data, XID id) { CursorHideCountPtr pChc = (CursorHideCountPtr) data; ScreenPtr pScreen = pChc->pScreen; DeviceIntPtr dev; deleteCursorHideCount(pChc, pChc->pScreen); - for (dev = inputInfo.devices; dev; dev = dev->next) - { + for (dev = inputInfo.devices; dev; dev = dev->next) { if (IsMaster(dev) && IsPointerDevice(dev)) CursorDisplayCursor(dev, pScreen, CursorCurrent[dev->id]); } @@ -1017,18 +993,16 @@ CursorFreeHideCount (pointer data, XID id) } static int -CursorFreeWindow (pointer data, XID id) +CursorFreeWindow(pointer data, XID id) { - WindowPtr pWindow = (WindowPtr) data; - CursorEventPtr e, next; + WindowPtr pWindow = (WindowPtr) data; + CursorEventPtr e, next; - for (e = cursorEvents; e; e = next) - { - next = e->next; - if (e->pWindow == pWindow) - { - FreeResource (e->clientResource, 0); - } + for (e = cursorEvents; e; e = next) { + next = e->next; + if (e->pWindow == pWindow) { + FreeResource(e->clientResource, 0); + } } return 1; } @@ -1056,13 +1030,13 @@ barrier_get_direction(int x1, int y1, int x2, int y2) /* which way are we trying to go */ if (x2 > x1) - direction |= BarrierPositiveX; + direction |= BarrierPositiveX; if (x2 < x1) - direction |= BarrierNegativeX; + direction |= BarrierNegativeX; if (y2 > y1) - direction |= BarrierPositiveY; + direction |= BarrierPositiveY; if (y2 < y1) - direction |= BarrierNegativeY; + direction |= BarrierNegativeY; return direction; } @@ -1076,7 +1050,8 @@ barrier_get_direction(int x1, int y1, int x2, int y2) * otherwise. */ BOOL -barrier_is_blocking_direction(const struct PointerBarrier *barrier, int direction) +barrier_is_blocking_direction(const struct PointerBarrier * barrier, + int direction) { /* Barriers define which way is ok, not which way is blocking */ return (barrier->directions & direction) != direction; @@ -1096,9 +1071,8 @@ barrier_is_blocking_direction(const struct PointerBarrier *barrier, int directio * @return TRUE if the barrier intersects with the given vector */ BOOL -barrier_is_blocking(const struct PointerBarrier *barrier, - int x1, int y1, int x2, int y2, - double *distance) +barrier_is_blocking(const struct PointerBarrier * barrier, + int x1, int y1, int x2, int y2, double *distance) { BOOL rc = FALSE; float ua, ub, ud; @@ -1107,48 +1081,49 @@ barrier_is_blocking(const struct PointerBarrier *barrier, /* Algorithm below doesn't handle edge cases well, hence the extra * checks. */ if (barrier_is_vertical(barrier)) { - /* handle immediate barrier adjacency, moving away */ - if (dir & BarrierPositiveX && x1 == barrier->x1) - return FALSE; - if (dir & BarrierNegativeX && x1 == (barrier->x1 - 1)) - return FALSE; - /* startpoint adjacent to barrier, moving towards -> block */ - if (x1 == barrier->x1 && y1 >= barrier->y1 && y1 <= barrier->y2) { - *distance = 0; - return TRUE; - } - } else { - /* handle immediate barrier adjacency, moving away */ - if (dir & BarrierPositiveY && y1 == barrier->y1) - return FALSE; - if (dir & BarrierNegativeY && y1 == (barrier->y1 - 1)) - return FALSE; - /* startpoint adjacent to barrier, moving towards -> block */ - if (y1 == barrier->y1 && x1 >= barrier->x1 && x1 <= barrier->x2) { - *distance = 0; - return TRUE; + /* handle immediate barrier adjacency, moving away */ + if (dir & BarrierPositiveX && x1 == barrier->x1) + return FALSE; + if (dir & BarrierNegativeX && x1 == (barrier->x1 - 1)) + return FALSE; + /* startpoint adjacent to barrier, moving towards -> block */ + if (x1 == barrier->x1 && y1 >= barrier->y1 && y1 <= barrier->y2) { + *distance = 0; + return TRUE; + } + } + else { + /* handle immediate barrier adjacency, moving away */ + if (dir & BarrierPositiveY && y1 == barrier->y1) + return FALSE; + if (dir & BarrierNegativeY && y1 == (barrier->y1 - 1)) + return FALSE; + /* startpoint adjacent to barrier, moving towards -> block */ + if (y1 == barrier->y1 && x1 >= barrier->x1 && x1 <= barrier->x2) { + *distance = 0; + return TRUE; } } /* not an edge case, compute distance */ ua = 0; - ud = (barrier->y2 - barrier->y1) * (x2 - x1) - (barrier->x2 - barrier->x1) * (y2 - y1); + ud = (barrier->y2 - barrier->y1) * (x2 - x1) - (barrier->x2 - + barrier->x1) * (y2 - y1); if (ud != 0) { - ua = ((barrier->x2 - barrier->x1) * (y1 - barrier->y1) - - (barrier->y2 - barrier->y1) * (x1 - barrier->x1)) / ud; - ub = ((x2 - x1) * (y1 - barrier->y1) - - (y2 - y1) * (x1 - barrier->x1)) / ud; - if (ua < 0 || ua > 1 || ub < 0 || ub > 1) - ua = 0; + ua = ((barrier->x2 - barrier->x1) * (y1 - barrier->y1) - + (barrier->y2 - barrier->y1) * (x1 - barrier->x1)) / ud; + ub = ((x2 - x1) * (y1 - barrier->y1) - + (y2 - y1) * (x1 - barrier->x1)) / ud; + if (ua < 0 || ua > 1 || ub < 0 || ub > 1) + ua = 0; } - if (ua > 0 && ua <= 1) - { - double ix = barrier->x1 + ua * (barrier->x2 - barrier->x1); - double iy = barrier->y1 + ua * (barrier->y2 - barrier->y1); + if (ua > 0 && ua <= 1) { + double ix = barrier->x1 + ua * (barrier->x2 - barrier->x1); + double iy = barrier->y1 + ua * (barrier->y2 - barrier->y1); - *distance = sqrt(pow(x1 - ix, 2) + pow(y1 - iy, 2)); - rc = TRUE; + *distance = sqrt(pow(x1 - ix, 2) + pow(y1 - iy, 2)); + rc = TRUE; } return rc; @@ -1164,29 +1139,27 @@ barrier_is_blocking(const struct PointerBarrier *barrier, * @param y2 Y end coordinate of movement vector * @return The barrier nearest to the movement origin that blocks this movement. */ -static struct PointerBarrier* +static struct PointerBarrier * barrier_find_nearest(CursorScreenPtr cs, int dir, - int x1, int y1, int x2, int y2) + int x1, int y1, int x2, int y2) { struct PointerBarrierClient *c; struct PointerBarrier *nearest = NULL; - double min_distance = INT_MAX; /* can't get higher than that in X anyway */ + double min_distance = INT_MAX; /* can't get higher than that in X anyway */ xorg_list_for_each_entry(c, &cs->barriers, entry) { - struct PointerBarrier *b = &c->barrier; - double distance; - - if (!barrier_is_blocking_direction(b, dir)) - continue; - - if (barrier_is_blocking(b, x1, y1, x2, y2, &distance)) - { - if (min_distance > distance) - { - min_distance = distance; - nearest = b; - } - } + struct PointerBarrier *b = &c->barrier; + double distance; + + if (!barrier_is_blocking_direction(b, dir)) + continue; + + if (barrier_is_blocking(b, x1, y1, x2, y2, &distance)) { + if (min_distance > distance) { + min_distance = distance; + nearest = b; + } + } } return nearest; @@ -1201,117 +1174,120 @@ barrier_find_nearest(CursorScreenPtr cs, int dir, * @param[out] y The clamped x coordinate. */ void -barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, int *y) +barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, + int *y) { - if (barrier_is_vertical(barrier)) - { - if ((dir & BarrierNegativeX) & ~barrier->directions) - *x = barrier->x1; - if ((dir & BarrierPositiveX) & ~barrier->directions) - *x = barrier->x1 - 1; + if (barrier_is_vertical(barrier)) { + if ((dir & BarrierNegativeX) & ~barrier->directions) + *x = barrier->x1; + if ((dir & BarrierPositiveX) & ~barrier->directions) + *x = barrier->x1 - 1; } - if (barrier_is_horizontal(barrier)) - { - if ((dir & BarrierNegativeY) & ~barrier->directions) - *y = barrier->y1; - if ((dir & BarrierPositiveY) & ~barrier->directions) - *y = barrier->y1 - 1; + if (barrier_is_horizontal(barrier)) { + if ((dir & BarrierNegativeY) & ~barrier->directions) + *y = barrier->y1; + if ((dir & BarrierPositiveY) & ~barrier->directions) + *y = barrier->y1 - 1; } } static void -CursorConstrainCursorHarder(DeviceIntPtr dev, ScreenPtr screen, int mode, int *x, int *y) +CursorConstrainCursorHarder(DeviceIntPtr dev, ScreenPtr screen, int mode, + int *x, int *y) { CursorScreenPtr cs = GetCursorScreen(screen); - if (!xorg_list_is_empty(&cs->barriers) && !IsFloating(dev) && mode == Relative) { - int ox, oy; - int dir; - struct PointerBarrier *nearest = NULL; - - /* where are we coming from */ - miPointerGetPosition(dev, &ox, &oy); - - /* How this works: - * Given the origin and the movement vector, get the nearest barrier - * to the origin that is blocking the movement. - * Clamp to that barrier. - * Then, check from the clamped intersection to the original - * destination, again finding the nearest barrier and clamping. - */ - dir = barrier_get_direction(ox, oy, *x, *y); - - nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y); - if (nearest) { - barrier_clamp_to_barrier(nearest, dir, x, y); - - if (barrier_is_vertical(nearest)) { - dir &= ~(BarrierNegativeX | BarrierPositiveX); - ox = *x; - } else if (barrier_is_horizontal(nearest)) { - dir &= ~(BarrierNegativeY | BarrierPositiveY); - oy = *y; - } - - nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y); - if (nearest) { - barrier_clamp_to_barrier(nearest, dir, x, y); - } - } + if (!xorg_list_is_empty(&cs->barriers) && !IsFloating(dev) && + mode == Relative) { + int ox, oy; + int dir; + struct PointerBarrier *nearest = NULL; + + /* where are we coming from */ + miPointerGetPosition(dev, &ox, &oy); + + /* How this works: + * Given the origin and the movement vector, get the nearest barrier + * to the origin that is blocking the movement. + * Clamp to that barrier. + * Then, check from the clamped intersection to the original + * destination, again finding the nearest barrier and clamping. + */ + dir = barrier_get_direction(ox, oy, *x, *y); + + nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y); + if (nearest) { + barrier_clamp_to_barrier(nearest, dir, x, y); + + if (barrier_is_vertical(nearest)) { + dir &= ~(BarrierNegativeX | BarrierPositiveX); + ox = *x; + } + else if (barrier_is_horizontal(nearest)) { + dir &= ~(BarrierNegativeY | BarrierPositiveY); + oy = *y; + } + + nearest = barrier_find_nearest(cs, dir, ox, oy, *x, *y); + if (nearest) { + barrier_clamp_to_barrier(nearest, dir, x, y); + } + } } if (cs->ConstrainCursorHarder) { - screen->ConstrainCursorHarder = cs->ConstrainCursorHarder; - screen->ConstrainCursorHarder(dev, screen, mode, x, y); - screen->ConstrainCursorHarder = CursorConstrainCursorHarder; + screen->ConstrainCursorHarder = cs->ConstrainCursorHarder; + screen->ConstrainCursorHarder(dev, screen, mode, x, y); + screen->ConstrainCursorHarder = CursorConstrainCursorHarder; } } static struct PointerBarrierClient * CreatePointerBarrierClient(ScreenPtr screen, ClientPtr client, - xXFixesCreatePointerBarrierReq *stuff) + xXFixesCreatePointerBarrierReq * stuff) { CursorScreenPtr cs = GetCursorScreen(screen); struct PointerBarrierClient *ret = malloc(sizeof(*ret)); if (ret) { - ret->screen = screen; - ret->barrier.x1 = min(stuff->x1, stuff->x2); - ret->barrier.x2 = max(stuff->x1, stuff->x2); - ret->barrier.y1 = min(stuff->y1, stuff->y2); - ret->barrier.y2 = max(stuff->y1, stuff->y2); - ret->barrier.directions = stuff->directions & 0x0f; - if (barrier_is_horizontal(&ret->barrier)) - ret->barrier.directions &= ~(BarrierPositiveX | BarrierNegativeX); - if (barrier_is_vertical(&ret->barrier)) - ret->barrier.directions &= ~(BarrierPositiveY | BarrierNegativeY); - xorg_list_add(&ret->entry, &cs->barriers); + ret->screen = screen; + ret->barrier.x1 = min(stuff->x1, stuff->x2); + ret->barrier.x2 = max(stuff->x1, stuff->x2); + ret->barrier.y1 = min(stuff->y1, stuff->y2); + ret->barrier.y2 = max(stuff->y1, stuff->y2); + ret->barrier.directions = stuff->directions & 0x0f; + if (barrier_is_horizontal(&ret->barrier)) + ret->barrier.directions &= ~(BarrierPositiveX | BarrierNegativeX); + if (barrier_is_vertical(&ret->barrier)) + ret->barrier.directions &= ~(BarrierPositiveY | BarrierNegativeY); + xorg_list_add(&ret->entry, &cs->barriers); } return ret; } int -ProcXFixesCreatePointerBarrier (ClientPtr client) +ProcXFixesCreatePointerBarrier(ClientPtr client) { int err; WindowPtr pWin; struct PointerBarrierClient *barrier; struct PointerBarrier b; - REQUEST (xXFixesCreatePointerBarrierReq); + + REQUEST(xXFixesCreatePointerBarrierReq); REQUEST_SIZE_MATCH(xXFixesCreatePointerBarrierReq); LEGAL_NEW_RESOURCE(stuff->barrier, client); err = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); if (err != Success) { - client->errorValue = stuff->window; - return err; + client->errorValue = stuff->window; + return err; } /* This sure does need fixing. */ if (stuff->num_devices) - return BadImplementation; + return BadImplementation; b.x1 = stuff->x1; b.x2 = stuff->x2; @@ -1319,24 +1295,24 @@ ProcXFixesCreatePointerBarrier (ClientPtr client) b.y2 = stuff->y2; if (!barrier_is_horizontal(&b) && !barrier_is_vertical(&b)) - return BadValue; + return BadValue; /* no 0-sized barriers */ if (barrier_is_horizontal(&b) && barrier_is_vertical(&b)) - return BadValue; + return BadValue; if (!(barrier = CreatePointerBarrierClient(pWin->drawable.pScreen, - client, stuff))) - return BadAlloc; + client, stuff))) + return BadAlloc; if (!AddResource(stuff->barrier, PointerBarrierType, &barrier->barrier)) - return BadAlloc; + return BadAlloc; return Success; } int -SProcXFixesCreatePointerBarrier (ClientPtr client) +SProcXFixesCreatePointerBarrier(ClientPtr client) { REQUEST(xXFixesCreatePointerBarrierReq); @@ -1349,7 +1325,7 @@ SProcXFixesCreatePointerBarrier (ClientPtr client) swaps(&stuff->x2); swaps(&stuff->y2); swapl(&stuff->directions); - return ProcXFixesVector[stuff->xfixesReqType](client); + return ProcXFixesVector[stuff->xfixesReqType] (client); } static int @@ -1360,15 +1336,16 @@ CursorFreeBarrier(void *data, XID id) CursorScreenPtr cs; barrier = container_of(data, struct PointerBarrierClient, barrier); + screen = barrier->screen; cs = GetCursorScreen(screen); /* find and unlink from the screen private */ xorg_list_for_each_entry(b, &cs->barriers, entry) { - if (b == barrier) { - xorg_list_del(&b->entry); - break; - } + if (b == barrier) { + xorg_list_del(&b->entry); + break; + } } free(barrier); @@ -1376,20 +1353,20 @@ CursorFreeBarrier(void *data, XID id) } int -ProcXFixesDestroyPointerBarrier (ClientPtr client) +ProcXFixesDestroyPointerBarrier(ClientPtr client) { int err; void *barrier; - REQUEST (xXFixesDestroyPointerBarrierReq); + + REQUEST(xXFixesDestroyPointerBarrierReq); REQUEST_SIZE_MATCH(xXFixesDestroyPointerBarrierReq); - err = dixLookupResourceByType((void **)&barrier, stuff->barrier, - PointerBarrierType, client, - DixDestroyAccess); + err = dixLookupResourceByType((void **) &barrier, stuff->barrier, + PointerBarrierType, client, DixDestroyAccess); if (err != Success) { - client->errorValue = stuff->barrier; - return err; + client->errorValue = stuff->barrier; + return err; } FreeResource(stuff->barrier, RT_NONE); @@ -1397,52 +1374,50 @@ ProcXFixesDestroyPointerBarrier (ClientPtr client) } int -SProcXFixesDestroyPointerBarrier (ClientPtr client) +SProcXFixesDestroyPointerBarrier(ClientPtr client) { REQUEST(xXFixesDestroyPointerBarrierReq); swaps(&stuff->length); REQUEST_SIZE_MATCH(xXFixesDestroyPointerBarrierReq); swapl(&stuff->barrier); - return ProcXFixesVector[stuff->xfixesReqType](client); + return ProcXFixesVector[stuff->xfixesReqType] (client); } Bool -XFixesCursorInit (void) +XFixesCursorInit(void) { - int i; + int i; if (party_like_its_1989) - CursorVisible = EnableCursor; - - if (!dixRegisterPrivateKey(&CursorScreenPrivateKeyRec, PRIVATE_SCREEN, 0)) - return FALSE; + CursorVisible = EnableCursor; - for (i = 0; i < screenInfo.numScreens; i++) - { - ScreenPtr pScreen = screenInfo.screens[i]; - CursorScreenPtr cs; - - cs = (CursorScreenPtr) calloc(1, sizeof (CursorScreenRec)); - if (!cs) - return FALSE; - xorg_list_init(&cs->barriers); - Wrap (cs, pScreen, CloseScreen, CursorCloseScreen); - Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor); - Wrap (cs, pScreen, ConstrainCursorHarder, CursorConstrainCursorHarder); - cs->pCursorHideCounts = NULL; - SetCursorScreen (pScreen, cs); + if (!dixRegisterPrivateKey(&CursorScreenPrivateKeyRec, PRIVATE_SCREEN, 0)) + return FALSE; + + for (i = 0; i < screenInfo.numScreens; i++) { + ScreenPtr pScreen = screenInfo.screens[i]; + CursorScreenPtr cs; + + cs = (CursorScreenPtr) calloc(1, sizeof(CursorScreenRec)); + if (!cs) + return FALSE; + xorg_list_init(&cs->barriers); + Wrap(cs, pScreen, CloseScreen, CursorCloseScreen); + Wrap(cs, pScreen, DisplayCursor, CursorDisplayCursor); + Wrap(cs, pScreen, ConstrainCursorHarder, CursorConstrainCursorHarder); + cs->pCursorHideCounts = NULL; + SetCursorScreen(pScreen, cs); } CursorClientType = CreateNewResourceType(CursorFreeClient, - "XFixesCursorClient"); + "XFixesCursorClient"); CursorHideCountType = CreateNewResourceType(CursorFreeHideCount, - "XFixesCursorHideCount"); + "XFixesCursorHideCount"); CursorWindowType = CreateNewResourceType(CursorFreeWindow, - "XFixesCursorWindow"); + "XFixesCursorWindow"); PointerBarrierType = CreateNewResourceType(CursorFreeBarrier, - "XFixesPointerBarrier"); + "XFixesPointerBarrier"); return CursorClientType && CursorHideCountType && CursorWindowType && - PointerBarrierType; + PointerBarrierType; } - |