From 0f834b91a4768673833ab4917e87d86c237bb1a6 Mon Sep 17 00:00:00 2001 From: marha Date: Fri, 23 Mar 2012 10:05:55 +0100 Subject: libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update 23 Mar 2012 --- xorg-server/xfixes/cursor.c | 1165 +++++++++++++++++++++--------------------- xorg-server/xfixes/region.c | 758 +++++++++++++-------------- xorg-server/xfixes/saveset.c | 32 +- xorg-server/xfixes/select.c | 302 +++++------ xorg-server/xfixes/xfixes.c | 260 +++++----- xorg-server/xfixes/xfixes.h | 17 +- 6 files changed, 1243 insertions(+), 1291 deletions(-) (limited to 'xorg-server/xfixes') 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; } - diff --git a/xorg-server/xfixes/region.c b/xorg-server/xfixes/region.c index 4c2263702..624109de1 100644 --- a/xorg-server/xfixes/region.c +++ b/xorg-server/xfixes/region.c @@ -28,6 +28,7 @@ #include "scrnintstr.h" #include extern int RenderErrBase; + #include #include #include @@ -35,31 +36,31 @@ extern int RenderErrBase; RESTYPE RegionResType; static int -RegionResFree (pointer data, XID id) +RegionResFree(pointer data, XID id) { - RegionPtr pRegion = (RegionPtr) data; + RegionPtr pRegion = (RegionPtr) data; RegionDestroy(pRegion); return Success; } RegionPtr -XFixesRegionCopy (RegionPtr pRegion) +XFixesRegionCopy(RegionPtr pRegion) { - RegionPtr pNew = RegionCreate(RegionExtents(pRegion), - RegionNumRects(pRegion)); + RegionPtr pNew = RegionCreate(RegionExtents(pRegion), + RegionNumRects(pRegion)); + if (!pNew) - return 0; - if (!RegionCopy(pNew, pRegion)) - { - RegionDestroy(pNew); - return 0; + return 0; + if (!RegionCopy(pNew, pRegion)) { + RegionDestroy(pNew); + return 0; } return pNew; } Bool -XFixesRegionInit (void) +XFixesRegionInit(void) { RegionResType = CreateNewResourceType(RegionResFree, "XFixesRegion"); @@ -67,34 +68,35 @@ XFixesRegionInit (void) } int -ProcXFixesCreateRegion (ClientPtr client) +ProcXFixesCreateRegion(ClientPtr client) { - int things; - RegionPtr pRegion; - REQUEST (xXFixesCreateRegionReq); - + int things; + RegionPtr pRegion; + + REQUEST(xXFixesCreateRegionReq); + REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq); - LEGAL_NEW_RESOURCE (stuff->region, client); - - things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq); + LEGAL_NEW_RESOURCE(stuff->region, client); + + things = (client->req_len << 2) - sizeof(xXFixesCreateRegionReq); if (things & 4) - return BadLength; + return BadLength; things >>= 3; pRegion = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED); if (!pRegion) - return BadAlloc; - if (!AddResource (stuff->region, RegionResType, (pointer) pRegion)) - return BadAlloc; - + return BadAlloc; + if (!AddResource(stuff->region, RegionResType, (pointer) pRegion)) + return BadAlloc; + return Success; } int -SProcXFixesCreateRegion (ClientPtr client) +SProcXFixesCreateRegion(ClientPtr client) { REQUEST(xXFixesCreateRegionReq); - + swaps(&stuff->length); REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq); swapl(&stuff->region); @@ -103,221 +105,221 @@ SProcXFixesCreateRegion (ClientPtr client) } int -ProcXFixesCreateRegionFromBitmap (ClientPtr client) +ProcXFixesCreateRegionFromBitmap(ClientPtr client) { - RegionPtr pRegion; - PixmapPtr pPixmap; + RegionPtr pRegion; + PixmapPtr pPixmap; int rc; - REQUEST (xXFixesCreateRegionFromBitmapReq); - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromBitmapReq); - LEGAL_NEW_RESOURCE (stuff->region, client); + REQUEST(xXFixesCreateRegionFromBitmapReq); - rc = dixLookupResourceByType((pointer *)&pPixmap, stuff->bitmap, RT_PIXMAP, - client, DixReadAccess); - if (rc != Success) - { - client->errorValue = stuff->bitmap; - return rc; + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromBitmapReq); + LEGAL_NEW_RESOURCE(stuff->region, client); + + rc = dixLookupResourceByType((pointer *) &pPixmap, stuff->bitmap, RT_PIXMAP, + client, DixReadAccess); + if (rc != Success) { + client->errorValue = stuff->bitmap; + return rc; } if (pPixmap->drawable.depth != 1) - return BadMatch; + return BadMatch; pRegion = BitmapToRegion(pPixmap->drawable.pScreen, pPixmap); if (!pRegion) - return BadAlloc; - - if (!AddResource (stuff->region, RegionResType, (pointer) pRegion)) - return BadAlloc; - + return BadAlloc; + + if (!AddResource(stuff->region, RegionResType, (pointer) pRegion)) + return BadAlloc; + return Success; } int -SProcXFixesCreateRegionFromBitmap (ClientPtr client) +SProcXFixesCreateRegionFromBitmap(ClientPtr client) { - REQUEST (xXFixesCreateRegionFromBitmapReq); + REQUEST(xXFixesCreateRegionFromBitmapReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromBitmapReq); + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromBitmapReq); swapl(&stuff->region); swapl(&stuff->bitmap); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } int -ProcXFixesCreateRegionFromWindow (ClientPtr client) +ProcXFixesCreateRegionFromWindow(ClientPtr client) { - RegionPtr pRegion; - Bool copy = TRUE; - WindowPtr pWin; + RegionPtr pRegion; + Bool copy = TRUE; + WindowPtr pWin; int rc; - REQUEST (xXFixesCreateRegionFromWindowReq); - - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq); - LEGAL_NEW_RESOURCE (stuff->region, client); - rc = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW, - client, DixGetAttrAccess); - if (rc != Success) - { - client->errorValue = stuff->window; - return rc; + + REQUEST(xXFixesCreateRegionFromWindowReq); + + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromWindowReq); + LEGAL_NEW_RESOURCE(stuff->region, client); + rc = dixLookupResourceByType((pointer *) &pWin, stuff->window, RT_WINDOW, + client, DixGetAttrAccess); + if (rc != Success) { + client->errorValue = stuff->window; + return rc; } switch (stuff->kind) { case WindowRegionBounding: - pRegion = wBoundingShape(pWin); - if (!pRegion) - { - pRegion = CreateBoundingShape (pWin); - copy = FALSE; - } - break; + pRegion = wBoundingShape(pWin); + if (!pRegion) { + pRegion = CreateBoundingShape(pWin); + copy = FALSE; + } + break; case WindowRegionClip: - pRegion = wClipShape(pWin); - if (!pRegion) - { - pRegion = CreateClipShape (pWin); - copy = FALSE; - } - break; + pRegion = wClipShape(pWin); + if (!pRegion) { + pRegion = CreateClipShape(pWin); + copy = FALSE; + } + break; default: - client->errorValue = stuff->kind; - return BadValue; + client->errorValue = stuff->kind; + return BadValue; } if (copy && pRegion) - pRegion = XFixesRegionCopy (pRegion); + pRegion = XFixesRegionCopy(pRegion); if (!pRegion) - return BadAlloc; - if (!AddResource (stuff->region, RegionResType, (pointer) pRegion)) - return BadAlloc; - + return BadAlloc; + if (!AddResource(stuff->region, RegionResType, (pointer) pRegion)) + return BadAlloc; + return Success; } int -SProcXFixesCreateRegionFromWindow (ClientPtr client) +SProcXFixesCreateRegionFromWindow(ClientPtr client) { - REQUEST (xXFixesCreateRegionFromWindowReq); + REQUEST(xXFixesCreateRegionFromWindowReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq); + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromWindowReq); swapl(&stuff->region); swapl(&stuff->window); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } int -ProcXFixesCreateRegionFromGC (ClientPtr client) +ProcXFixesCreateRegionFromGC(ClientPtr client) { - RegionPtr pRegion, pClip; - GCPtr pGC; - int rc; - REQUEST (xXFixesCreateRegionFromGCReq); + RegionPtr pRegion, pClip; + GCPtr pGC; + int rc; + + REQUEST(xXFixesCreateRegionFromGCReq); - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq); - LEGAL_NEW_RESOURCE (stuff->region, client); + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromGCReq); + LEGAL_NEW_RESOURCE(stuff->region, client); rc = dixLookupGC(&pGC, stuff->gc, client, DixGetAttrAccess); if (rc != Success) - return rc; - + return rc; + switch (pGC->clientClipType) { case CT_PIXMAP: - pRegion = BitmapToRegion(pGC->pScreen, (PixmapPtr) pGC->clientClip); - if (!pRegion) - return BadAlloc; - break; + pRegion = BitmapToRegion(pGC->pScreen, (PixmapPtr) pGC->clientClip); + if (!pRegion) + return BadAlloc; + break; case CT_REGION: - pClip = (RegionPtr) pGC->clientClip; - pRegion = XFixesRegionCopy (pClip); - if (!pRegion) - return BadAlloc; - break; + pClip = (RegionPtr) pGC->clientClip; + pRegion = XFixesRegionCopy(pClip); + if (!pRegion) + return BadAlloc; + break; default: - return BadImplementation; /* assume sane server bits */ + return BadImplementation; /* assume sane server bits */ } - - if (!AddResource (stuff->region, RegionResType, (pointer) pRegion)) - return BadAlloc; - + + if (!AddResource(stuff->region, RegionResType, (pointer) pRegion)) + return BadAlloc; + return Success; } int -SProcXFixesCreateRegionFromGC (ClientPtr client) +SProcXFixesCreateRegionFromGC(ClientPtr client) { - REQUEST (xXFixesCreateRegionFromGCReq); + REQUEST(xXFixesCreateRegionFromGCReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq); + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromGCReq); swapl(&stuff->region); swapl(&stuff->gc); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } int -ProcXFixesCreateRegionFromPicture (ClientPtr client) +ProcXFixesCreateRegionFromPicture(ClientPtr client) { - RegionPtr pRegion; - PicturePtr pPicture; - REQUEST (xXFixesCreateRegionFromPictureReq); + RegionPtr pRegion; + PicturePtr pPicture; - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq); - LEGAL_NEW_RESOURCE (stuff->region, client); + REQUEST(xXFixesCreateRegionFromPictureReq); + + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromPictureReq); + LEGAL_NEW_RESOURCE(stuff->region, client); VERIFY_PICTURE(pPicture, stuff->picture, client, DixGetAttrAccess); - + switch (pPicture->clientClipType) { case CT_PIXMAP: - pRegion = BitmapToRegion(pPicture->pDrawable->pScreen, - (PixmapPtr) pPicture->clientClip); - if (!pRegion) - return BadAlloc; - break; + pRegion = BitmapToRegion(pPicture->pDrawable->pScreen, + (PixmapPtr) pPicture->clientClip); + if (!pRegion) + return BadAlloc; + break; case CT_REGION: - pRegion = XFixesRegionCopy ((RegionPtr) pPicture->clientClip); - if (!pRegion) - return BadAlloc; - break; + pRegion = XFixesRegionCopy((RegionPtr) pPicture->clientClip); + if (!pRegion) + return BadAlloc; + break; default: - return BadImplementation; /* assume sane server bits */ + return BadImplementation; /* assume sane server bits */ } - - if (!AddResource (stuff->region, RegionResType, (pointer) pRegion)) - return BadAlloc; - + + if (!AddResource(stuff->region, RegionResType, (pointer) pRegion)) + return BadAlloc; + return Success; } int -SProcXFixesCreateRegionFromPicture (ClientPtr client) +SProcXFixesCreateRegionFromPicture(ClientPtr client) { - REQUEST (xXFixesCreateRegionFromPictureReq); + REQUEST(xXFixesCreateRegionFromPictureReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq); + REQUEST_SIZE_MATCH(xXFixesCreateRegionFromPictureReq); swapl(&stuff->region); swapl(&stuff->picture); return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } int -ProcXFixesDestroyRegion (ClientPtr client) +ProcXFixesDestroyRegion(ClientPtr client) { - REQUEST (xXFixesDestroyRegionReq); - RegionPtr pRegion; + REQUEST(xXFixesDestroyRegionReq); + RegionPtr pRegion; REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq); VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess); - FreeResource (stuff->region, RT_NONE); + FreeResource(stuff->region, RT_NONE); return Success; } int -SProcXFixesDestroyRegion (ClientPtr client) +SProcXFixesDestroyRegion(ClientPtr client) { - REQUEST (xXFixesDestroyRegionReq); + REQUEST(xXFixesDestroyRegionReq); swaps(&stuff->length); REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq); @@ -326,36 +328,36 @@ SProcXFixesDestroyRegion (ClientPtr client) } int -ProcXFixesSetRegion (ClientPtr client) +ProcXFixesSetRegion(ClientPtr client) { - int things; - RegionPtr pRegion, pNew; - REQUEST (xXFixesSetRegionReq); + int things; + RegionPtr pRegion, pNew; + + REQUEST(xXFixesSetRegionReq); REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq); VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess); - - things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq); + + things = (client->req_len << 2) - sizeof(xXFixesCreateRegionReq); if (things & 4) - return BadLength; + return BadLength; things >>= 3; pNew = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED); if (!pNew) - return BadAlloc; - if (!RegionCopy(pRegion, pNew)) - { - RegionDestroy(pNew); - return BadAlloc; + return BadAlloc; + if (!RegionCopy(pRegion, pNew)) { + RegionDestroy(pNew); + return BadAlloc; } RegionDestroy(pNew); return Success; } int -SProcXFixesSetRegion (ClientPtr client) +SProcXFixesSetRegion(ClientPtr client) { - REQUEST (xXFixesSetRegionReq); + REQUEST(xXFixesSetRegionReq); swaps(&stuff->length); REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq); @@ -365,24 +367,25 @@ SProcXFixesSetRegion (ClientPtr client) } int -ProcXFixesCopyRegion (ClientPtr client) +ProcXFixesCopyRegion(ClientPtr client) { - RegionPtr pSource, pDestination; - REQUEST (xXFixesCopyRegionReq); - + RegionPtr pSource, pDestination; + + REQUEST(xXFixesCopyRegionReq); + VERIFY_REGION(pSource, stuff->source, client, DixReadAccess); VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess); - + if (!RegionCopy(pDestination, pSource)) - return BadAlloc; + return BadAlloc; return Success; } int -SProcXFixesCopyRegion (ClientPtr client) +SProcXFixesCopyRegion(ClientPtr client) { - REQUEST (xXFixesCopyRegionReq); + REQUEST(xXFixesCopyRegionReq); swaps(&stuff->length); REQUEST_AT_LEAST_SIZE(xXFixesCopyRegionReq); @@ -392,41 +395,42 @@ SProcXFixesCopyRegion (ClientPtr client) } int -ProcXFixesCombineRegion (ClientPtr client) +ProcXFixesCombineRegion(ClientPtr client) { - RegionPtr pSource1, pSource2, pDestination; - REQUEST (xXFixesCombineRegionReq); + RegionPtr pSource1, pSource2, pDestination; - REQUEST_SIZE_MATCH (xXFixesCombineRegionReq); + REQUEST(xXFixesCombineRegionReq); + + REQUEST_SIZE_MATCH(xXFixesCombineRegionReq); VERIFY_REGION(pSource1, stuff->source1, client, DixReadAccess); VERIFY_REGION(pSource2, stuff->source2, client, DixReadAccess); VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess); - + switch (stuff->xfixesReqType) { case X_XFixesUnionRegion: - if (!RegionUnion(pDestination, pSource1, pSource2)) - return BadAlloc; - break; + if (!RegionUnion(pDestination, pSource1, pSource2)) + return BadAlloc; + break; case X_XFixesIntersectRegion: - if (!RegionIntersect(pDestination, pSource1, pSource2)) - return BadAlloc; - break; + if (!RegionIntersect(pDestination, pSource1, pSource2)) + return BadAlloc; + break; case X_XFixesSubtractRegion: - if (!RegionSubtract(pDestination, pSource1, pSource2)) - return BadAlloc; - break; + if (!RegionSubtract(pDestination, pSource1, pSource2)) + return BadAlloc; + break; } - + return Success; } int -SProcXFixesCombineRegion (ClientPtr client) +SProcXFixesCombineRegion(ClientPtr client) { - REQUEST (xXFixesCombineRegionReq); + REQUEST(xXFixesCombineRegionReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesCombineRegionReq); + REQUEST_SIZE_MATCH(xXFixesCombineRegionReq); swapl(&stuff->source1); swapl(&stuff->source2); swapl(&stuff->destination); @@ -434,10 +438,11 @@ SProcXFixesCombineRegion (ClientPtr client) } int -ProcXFixesInvertRegion (ClientPtr client) +ProcXFixesInvertRegion(ClientPtr client) { - RegionPtr pSource, pDestination; - BoxRec bounds; + RegionPtr pSource, pDestination; + BoxRec bounds; + REQUEST(xXFixesInvertRegionReq); REQUEST_SIZE_MATCH(xXFixesInvertRegionReq); @@ -448,23 +453,23 @@ ProcXFixesInvertRegion (ClientPtr client) bounds.x1 = stuff->x; bounds.y1 = stuff->y; if ((int) stuff->x + (int) stuff->width > MAXSHORT) - bounds.x2 = MAXSHORT; + bounds.x2 = MAXSHORT; else - bounds.x2 = stuff->x + stuff->width; - + bounds.x2 = stuff->x + stuff->width; + if ((int) stuff->y + (int) stuff->height > MAXSHORT) - bounds.y2 = MAXSHORT; + bounds.y2 = MAXSHORT; else - bounds.y2 = stuff->y + stuff->height; + bounds.y2 = stuff->y + stuff->height; if (!RegionInverse(pDestination, pSource, &bounds)) - return BadAlloc; + return BadAlloc; return Success; } int -SProcXFixesInvertRegion (ClientPtr client) +SProcXFixesInvertRegion(ClientPtr client) { REQUEST(xXFixesInvertRegionReq); @@ -480,9 +485,10 @@ SProcXFixesInvertRegion (ClientPtr client) } int -ProcXFixesTranslateRegion (ClientPtr client) +ProcXFixesTranslateRegion(ClientPtr client) { - RegionPtr pRegion; + RegionPtr pRegion; + REQUEST(xXFixesTranslateRegionReq); REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq); @@ -493,7 +499,7 @@ ProcXFixesTranslateRegion (ClientPtr client) } int -SProcXFixesTranslateRegion (ClientPtr client) +SProcXFixesTranslateRegion(ClientPtr client) { REQUEST(xXFixesTranslateRegionReq); @@ -506,9 +512,10 @@ SProcXFixesTranslateRegion (ClientPtr client) } int -ProcXFixesRegionExtents (ClientPtr client) +ProcXFixesRegionExtents(ClientPtr client) { - RegionPtr pSource, pDestination; + RegionPtr pSource, pDestination; + REQUEST(xXFixesRegionExtentsReq); REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq); @@ -521,10 +528,10 @@ ProcXFixesRegionExtents (ClientPtr client) } int -SProcXFixesRegionExtents (ClientPtr client) +SProcXFixesRegionExtents(ClientPtr client) { REQUEST(xXFixesRegionExtentsReq); - + swaps(&stuff->length); REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq); swapl(&stuff->source); @@ -533,27 +540,27 @@ SProcXFixesRegionExtents (ClientPtr client) } int -ProcXFixesFetchRegion (ClientPtr client) +ProcXFixesFetchRegion(ClientPtr client) { - RegionPtr pRegion; + RegionPtr pRegion; xXFixesFetchRegionReply *reply; - xRectangle *pRect; - BoxPtr pExtent; - BoxPtr pBox; - int i, nBox; + xRectangle *pRect; + BoxPtr pExtent; + BoxPtr pBox; + int i, nBox; + REQUEST(xXFixesFetchRegionReq); REQUEST_SIZE_MATCH(xXFixesFetchRegionReq); VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess); pExtent = RegionExtents(pRegion); - pBox = RegionRects (pRegion); - nBox = RegionNumRects (pRegion); - - reply = malloc(sizeof (xXFixesFetchRegionReply) + - nBox * sizeof (xRectangle)); + pBox = RegionRects(pRegion); + nBox = RegionNumRects(pRegion); + + reply = malloc(sizeof(xXFixesFetchRegionReply) + nBox * sizeof(xRectangle)); if (!reply) - return BadAlloc; + return BadAlloc; reply->type = X_Reply; reply->sequenceNumber = client->sequence; reply->length = nBox << 1; @@ -563,31 +570,29 @@ ProcXFixesFetchRegion (ClientPtr client) reply->height = pExtent->y2 - pExtent->y1; pRect = (xRectangle *) (reply + 1); - for (i = 0; i < nBox; i++) - { - pRect[i].x = pBox[i].x1; - pRect[i].y = pBox[i].y1; - pRect[i].width = pBox[i].x2 - pBox[i].x1; - pRect[i].height = pBox[i].y2 - pBox[i].y1; + for (i = 0; i < nBox; i++) { + pRect[i].x = pBox[i].x1; + pRect[i].y = pBox[i].y1; + pRect[i].width = pBox[i].x2 - pBox[i].x1; + pRect[i].height = pBox[i].y2 - pBox[i].y1; } - if (client->swapped) - { - swaps(&reply->sequenceNumber); - swapl(&reply->length); - swaps(&reply->x); - swaps(&reply->y); - swaps(&reply->width); - swaps(&reply->height); - SwapShorts ((INT16 *) pRect, nBox * 4); + if (client->swapped) { + swaps(&reply->sequenceNumber); + swapl(&reply->length); + swaps(&reply->x); + swaps(&reply->y); + swaps(&reply->width); + swaps(&reply->height); + SwapShorts((INT16 *) pRect, nBox * 4); } - (void) WriteToClient(client, sizeof (xXFixesFetchRegionReply) + - nBox * sizeof (xRectangle), (char *) reply); + (void) WriteToClient(client, sizeof(xXFixesFetchRegionReply) + + nBox * sizeof(xRectangle), (char *) reply); free(reply); return Success; } int -SProcXFixesFetchRegion (ClientPtr client) +SProcXFixesFetchRegion(ClientPtr client) { REQUEST(xXFixesFetchRegionReq); @@ -598,38 +603,39 @@ SProcXFixesFetchRegion (ClientPtr client) } int -ProcXFixesSetGCClipRegion (ClientPtr client) +ProcXFixesSetGCClipRegion(ClientPtr client) { - GCPtr pGC; - RegionPtr pRegion; - ChangeGCVal vals[2]; - int rc; + GCPtr pGC; + RegionPtr pRegion; + ChangeGCVal vals[2]; + int rc; + REQUEST(xXFixesSetGCClipRegionReq); REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq); rc = dixLookupGC(&pGC, stuff->gc, client, DixSetAttrAccess); if (rc != Success) - return rc; + return rc; - VERIFY_REGION_OR_NONE (pRegion, stuff->region, client, DixReadAccess); + VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess); - if (pRegion) - { - pRegion = XFixesRegionCopy (pRegion); - if (!pRegion) - return BadAlloc; + if (pRegion) { + pRegion = XFixesRegionCopy(pRegion); + if (!pRegion) + return BadAlloc; } - + vals[0].val = stuff->xOrigin; vals[1].val = stuff->yOrigin; - ChangeGC (NullClient, pGC, GCClipXOrigin|GCClipYOrigin, vals); - (*pGC->funcs->ChangeClip)(pGC, pRegion ? CT_REGION : CT_NONE, (pointer)pRegion, 0); + ChangeGC(NullClient, pGC, GCClipXOrigin | GCClipYOrigin, vals); + (*pGC->funcs->ChangeClip) (pGC, pRegion ? CT_REGION : CT_NONE, + (pointer) pRegion, 0); return Success; } int -SProcXFixesSetGCClipRegion (ClientPtr client) +SProcXFixesSetGCClipRegion(ClientPtr client) { REQUEST(xXFixesSetGCClipRegionReq); @@ -642,87 +648,84 @@ SProcXFixesSetGCClipRegion (ClientPtr client) return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } -typedef RegionPtr (*CreateDftPtr)(WindowPtr pWin); +typedef RegionPtr (*CreateDftPtr) (WindowPtr pWin); int -ProcXFixesSetWindowShapeRegion (ClientPtr client) +ProcXFixesSetWindowShapeRegion(ClientPtr client) { - WindowPtr pWin; - RegionPtr pRegion; - RegionPtr *pDestRegion; + WindowPtr pWin; + RegionPtr pRegion; + RegionPtr *pDestRegion; int rc; + REQUEST(xXFixesSetWindowShapeRegionReq); REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq); - rc = dixLookupResourceByType((pointer *)&pWin, stuff->dest, RT_WINDOW, - client, DixSetAttrAccess); - if (rc != Success) - { - client->errorValue = stuff->dest; - return rc; + rc = dixLookupResourceByType((pointer *) &pWin, stuff->dest, RT_WINDOW, + client, DixSetAttrAccess); + if (rc != Success) { + client->errorValue = stuff->dest; + return rc; } VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixWriteAccess); switch (stuff->destKind) { case ShapeBounding: case ShapeClip: case ShapeInput: - break; + break; default: - client->errorValue = stuff->destKind; - return BadValue; + client->errorValue = stuff->destKind; + return BadValue; } - if (pRegion) - { - pRegion = XFixesRegionCopy (pRegion); - if (!pRegion) - return BadAlloc; - if (!pWin->optional) - MakeWindowOptional (pWin); - switch (stuff->destKind) { - default: - case ShapeBounding: - pDestRegion = &pWin->optional->boundingShape; - break; - case ShapeClip: - pDestRegion = &pWin->optional->clipShape; - break; - case ShapeInput: - pDestRegion = &pWin->optional->inputShape; - break; - } - if (stuff->xOff || stuff->yOff) - RegionTranslate(pRegion, stuff->xOff, stuff->yOff); + if (pRegion) { + pRegion = XFixesRegionCopy(pRegion); + if (!pRegion) + return BadAlloc; + if (!pWin->optional) + MakeWindowOptional(pWin); + switch (stuff->destKind) { + default: + case ShapeBounding: + pDestRegion = &pWin->optional->boundingShape; + break; + case ShapeClip: + pDestRegion = &pWin->optional->clipShape; + break; + case ShapeInput: + pDestRegion = &pWin->optional->inputShape; + break; + } + if (stuff->xOff || stuff->yOff) + RegionTranslate(pRegion, stuff->xOff, stuff->yOff); } - else - { - if (pWin->optional) - { - switch (stuff->destKind) { - default: - case ShapeBounding: - pDestRegion = &pWin->optional->boundingShape; - break; - case ShapeClip: - pDestRegion = &pWin->optional->clipShape; - break; - case ShapeInput: - pDestRegion = &pWin->optional->inputShape; - break; - } - } - else - pDestRegion = &pRegion; /* a NULL region pointer */ + else { + if (pWin->optional) { + switch (stuff->destKind) { + default: + case ShapeBounding: + pDestRegion = &pWin->optional->boundingShape; + break; + case ShapeClip: + pDestRegion = &pWin->optional->clipShape; + break; + case ShapeInput: + pDestRegion = &pWin->optional->inputShape; + break; + } + } + else + pDestRegion = &pRegion; /* a NULL region pointer */ } if (*pDestRegion) - RegionDestroy(*pDestRegion); + RegionDestroy(*pDestRegion); *pDestRegion = pRegion; (*pWin->drawable.pScreen->SetShape) (pWin, stuff->destKind); - SendShapeNotify (pWin, stuff->destKind); + SendShapeNotify(pWin, stuff->destKind); return Success; } int -SProcXFixesSetWindowShapeRegion (ClientPtr client) +SProcXFixesSetWindowShapeRegion(ClientPtr client) { REQUEST(xXFixesSetWindowShapeRegionReq); @@ -736,27 +739,28 @@ SProcXFixesSetWindowShapeRegion (ClientPtr client) } int -ProcXFixesSetPictureClipRegion (ClientPtr client) +ProcXFixesSetPictureClipRegion(ClientPtr client) { - PicturePtr pPicture; - RegionPtr pRegion; + PicturePtr pPicture; + RegionPtr pRegion; + REQUEST(xXFixesSetPictureClipRegionReq); - - REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq); + + REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq); VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess); VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess); - - return SetPictureClipRegion (pPicture, stuff->xOrigin, stuff->yOrigin, - pRegion); + + return SetPictureClipRegion(pPicture, stuff->xOrigin, stuff->yOrigin, + pRegion); } int -SProcXFixesSetPictureClipRegion (ClientPtr client) +SProcXFixesSetPictureClipRegion(ClientPtr client) { REQUEST(xXFixesSetPictureClipRegionReq); - + swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq); + REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq); swapl(&stuff->picture); swapl(&stuff->region); swaps(&stuff->xOrigin); @@ -765,52 +769,51 @@ SProcXFixesSetPictureClipRegion (ClientPtr client) } int -ProcXFixesExpandRegion (ClientPtr client) +ProcXFixesExpandRegion(ClientPtr client) { - RegionPtr pSource, pDestination; - REQUEST (xXFixesExpandRegionReq); - BoxPtr pTmp; - BoxPtr pSrc; - int nBoxes; - int i; + RegionPtr pSource, pDestination; + + REQUEST(xXFixesExpandRegionReq); + BoxPtr pTmp; + BoxPtr pSrc; + int nBoxes; + int i; - REQUEST_SIZE_MATCH (xXFixesExpandRegionReq); + REQUEST_SIZE_MATCH(xXFixesExpandRegionReq); VERIFY_REGION(pSource, stuff->source, client, DixReadAccess); VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess); - + nBoxes = RegionNumRects(pSource); pSrc = RegionRects(pSource); - if (nBoxes) - { - pTmp = malloc(nBoxes * sizeof (BoxRec)); - if (!pTmp) - return BadAlloc; - for (i = 0; i < nBoxes; i++) - { - pTmp[i].x1 = pSrc[i].x1 - stuff->left; - pTmp[i].x2 = pSrc[i].x2 + stuff->right; - pTmp[i].y1 = pSrc[i].y1 - stuff->top; - pTmp[i].y2 = pSrc[i].y2 + stuff->bottom; - } - RegionEmpty(pDestination); - for (i = 0; i < nBoxes; i++) - { - RegionRec r; - RegionInit(&r, &pTmp[i], 0); - RegionUnion(pDestination, pDestination, &r); - } - free(pTmp); + if (nBoxes) { + pTmp = malloc(nBoxes * sizeof(BoxRec)); + if (!pTmp) + return BadAlloc; + for (i = 0; i < nBoxes; i++) { + pTmp[i].x1 = pSrc[i].x1 - stuff->left; + pTmp[i].x2 = pSrc[i].x2 + stuff->right; + pTmp[i].y1 = pSrc[i].y1 - stuff->top; + pTmp[i].y2 = pSrc[i].y2 + stuff->bottom; + } + RegionEmpty(pDestination); + for (i = 0; i < nBoxes; i++) { + RegionRec r; + + RegionInit(&r, &pTmp[i], 0); + RegionUnion(pDestination, pDestination, &r); + } + free(pTmp); } return Success; } int -SProcXFixesExpandRegion (ClientPtr client) +SProcXFixesExpandRegion(ClientPtr client) { - REQUEST (xXFixesExpandRegionReq); + REQUEST(xXFixesExpandRegionReq); swaps(&stuff->length); - REQUEST_SIZE_MATCH (xXFixesExpandRegionReq); + REQUEST_SIZE_MATCH(xXFixesExpandRegionReq); swapl(&stuff->source); swapl(&stuff->destination); swaps(&stuff->left); @@ -825,73 +828,80 @@ SProcXFixesExpandRegion (ClientPtr client) #include "panoramiXsrv.h" int -PanoramiXFixesSetGCClipRegion (ClientPtr client) +PanoramiXFixesSetGCClipRegion(ClientPtr client) { REQUEST(xXFixesSetGCClipRegionReq); - int result = Success, j; - PanoramiXRes *gc; + int result = Success, j; + PanoramiXRes *gc; + REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq); - if ((result = dixLookupResourceByType((void **)&gc, stuff->gc, XRT_GC, - client, DixWriteAccess))) { - client->errorValue = stuff->gc; - return result; + if ((result = dixLookupResourceByType((void **) &gc, stuff->gc, XRT_GC, + client, DixWriteAccess))) { + client->errorValue = stuff->gc; + return result; } FOR_NSCREENS_BACKWARD(j) { stuff->gc = gc->info[j].id; result = (*PanoramiXSaveXFixesVector[X_XFixesSetGCClipRegion]) (client); - if(result != Success) break; + if (result != Success) + break; } return result; } int -PanoramiXFixesSetWindowShapeRegion (ClientPtr client) +PanoramiXFixesSetWindowShapeRegion(ClientPtr client) { - int result = Success, j; - PanoramiXRes *win; + int result = Success, j; + PanoramiXRes *win; + REQUEST(xXFixesSetWindowShapeRegionReq); REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq); - if ((result = dixLookupResourceByType((void **)&win, stuff->dest, - XRT_WINDOW, client, - DixWriteAccess))) { - client->errorValue = stuff->dest; - return result; + if ((result = dixLookupResourceByType((void **) &win, stuff->dest, + XRT_WINDOW, client, + DixWriteAccess))) { + client->errorValue = stuff->dest; + return result; } FOR_NSCREENS_FORWARD(j) { - stuff->dest = win->info[j].id; - result = (*PanoramiXSaveXFixesVector[X_XFixesSetWindowShapeRegion]) (client); - if(result != Success) break; + stuff->dest = win->info[j].id; + result = + (*PanoramiXSaveXFixesVector[X_XFixesSetWindowShapeRegion]) (client); + if (result != Success) + break; } return result; } int -PanoramiXFixesSetPictureClipRegion (ClientPtr client) +PanoramiXFixesSetPictureClipRegion(ClientPtr client) { REQUEST(xXFixesSetPictureClipRegionReq); - int result = Success, j; - PanoramiXRes *pict; + int result = Success, j; + PanoramiXRes *pict; - REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq); + REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq); - if ((result = dixLookupResourceByType((void **)&pict, stuff->picture, - XRT_PICTURE, client, - DixWriteAccess))) { - client->errorValue = stuff->picture; - return result; + if ((result = dixLookupResourceByType((void **) &pict, stuff->picture, + XRT_PICTURE, client, + DixWriteAccess))) { + client->errorValue = stuff->picture; + return result; } FOR_NSCREENS_BACKWARD(j) { stuff->picture = pict->info[j].id; - result = (*PanoramiXSaveXFixesVector[X_XFixesSetPictureClipRegion]) (client); - if(result != Success) break; + result = + (*PanoramiXSaveXFixesVector[X_XFixesSetPictureClipRegion]) (client); + if (result != Success) + break; } return result; diff --git a/xorg-server/xfixes/saveset.c b/xorg-server/xfixes/saveset.c index ba959c22b..eb3f6589e 100644 --- a/xorg-server/xfixes/saveset.c +++ b/xorg-server/xfixes/saveset.c @@ -29,31 +29,29 @@ int ProcXFixesChangeSaveSet(ClientPtr client) { - Bool toRoot, map; - int result; - WindowPtr pWin; + Bool toRoot, map; + int result; + WindowPtr pWin; + REQUEST(xXFixesChangeSaveSetReq); - + REQUEST_SIZE_MATCH(xXFixesChangeSaveSetReq); result = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess); if (result != Success) return result; if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id))) return BadMatch; - if ((stuff->mode != SetModeInsert) && (stuff->mode != SetModeDelete)) - { - client->errorValue = stuff->mode; - return BadValue; + if ((stuff->mode != SetModeInsert) && (stuff->mode != SetModeDelete)) { + client->errorValue = stuff->mode; + return BadValue; } - if ((stuff->target != SaveSetNearest) && (stuff->target != SaveSetRoot)) - { - client->errorValue = stuff->target; - return BadValue; + if ((stuff->target != SaveSetNearest) && (stuff->target != SaveSetRoot)) { + client->errorValue = stuff->target; + return BadValue; } - if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap)) - { - client->errorValue = stuff->map; - return BadValue; + if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap)) { + client->errorValue = stuff->map; + return BadValue; } toRoot = (stuff->target == SaveSetRoot); map = (stuff->map == SaveSetMap); @@ -67,5 +65,5 @@ SProcXFixesChangeSaveSet(ClientPtr client) swaps(&stuff->length); swapl(&stuff->window); - return (*ProcXFixesVector[stuff->xfixesReqType])(client); + return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } diff --git a/xorg-server/xfixes/select.c b/xorg-server/xfixes/select.c index 2bf13f3fd..a896846a7 100644 --- a/xorg-server/xfixes/select.c +++ b/xorg-server/xfixes/select.c @@ -27,8 +27,8 @@ #include "xfixesint.h" #include "xace.h" -static RESTYPE SelectionClientType, SelectionWindowType; -static Bool SelectionCallbackRegistered = FALSE; +static RESTYPE SelectionClientType, SelectionWindowType; +static Bool SelectionCallbackRegistered = FALSE; /* * There is a global list of windows selecting for selection events @@ -40,83 +40,76 @@ static Bool SelectionCallbackRegistered = FALSE; typedef struct _SelectionEvent *SelectionEventPtr; typedef struct _SelectionEvent { - SelectionEventPtr next; - Atom selection; - CARD32 eventMask; - ClientPtr pClient; - WindowPtr pWindow; - XID clientResource; + SelectionEventPtr next; + Atom selection; + CARD32 eventMask; + ClientPtr pClient; + WindowPtr pWindow; + XID clientResource; } SelectionEventRec; -static SelectionEventPtr selectionEvents; +static SelectionEventPtr selectionEvents; static void -XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args) +XFixesSelectionCallback(CallbackListPtr *callbacks, pointer data, pointer args) { - SelectionEventPtr e; - SelectionInfoRec *info = (SelectionInfoRec *) args; - Selection *selection = info->selection; - int subtype; - CARD32 eventMask; - + SelectionEventPtr e; + SelectionInfoRec *info = (SelectionInfoRec *) args; + Selection *selection = info->selection; + int subtype; + CARD32 eventMask; + switch (info->kind) { case SelectionSetOwner: - subtype = XFixesSetSelectionOwnerNotify; - eventMask = XFixesSetSelectionOwnerNotifyMask; - break; + subtype = XFixesSetSelectionOwnerNotify; + eventMask = XFixesSetSelectionOwnerNotifyMask; + break; case SelectionWindowDestroy: - subtype = XFixesSelectionWindowDestroyNotify; - eventMask = XFixesSelectionWindowDestroyNotifyMask; - break; + subtype = XFixesSelectionWindowDestroyNotify; + eventMask = XFixesSelectionWindowDestroyNotifyMask; + break; case SelectionClientClose: - subtype = XFixesSelectionClientCloseNotify; - eventMask = XFixesSelectionClientCloseNotifyMask; - break; + subtype = XFixesSelectionClientCloseNotify; + eventMask = XFixesSelectionClientCloseNotifyMask; + break; default: - return; + return; } - for (e = selectionEvents; e; e = e->next) - { - if (e->selection == selection->selection && - (e->eventMask & eventMask)) - { - xXFixesSelectionNotifyEvent ev; + for (e = selectionEvents; e; e = e->next) { + if (e->selection == selection->selection && (e->eventMask & eventMask)) { + xXFixesSelectionNotifyEvent ev; - memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent)); - ev.type = XFixesEventBase + XFixesSelectionNotify; - ev.subtype = subtype; - ev.window = e->pWindow->drawable.id; - if (subtype == XFixesSetSelectionOwnerNotify) - ev.owner = selection->window; - else - ev.owner = 0; - ev.selection = e->selection; - ev.timestamp = currentTime.milliseconds; - ev.selectionTimestamp = selection->lastTimeChanged.milliseconds; - WriteEventsToClient (e->pClient, 1, (xEvent *) &ev); - } + memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent)); + ev.type = XFixesEventBase + XFixesSelectionNotify; + ev.subtype = subtype; + ev.window = e->pWindow->drawable.id; + if (subtype == XFixesSetSelectionOwnerNotify) + ev.owner = selection->window; + else + ev.owner = 0; + ev.selection = e->selection; + ev.timestamp = currentTime.milliseconds; + ev.selectionTimestamp = selection->lastTimeChanged.milliseconds; + WriteEventsToClient(e->pClient, 1, (xEvent *) &ev); + } } } static Bool -CheckSelectionCallback (void) +CheckSelectionCallback(void) { - if (selectionEvents) - { - if (!SelectionCallbackRegistered) - { - if (!AddCallback (&SelectionCallback, XFixesSelectionCallback, NULL)) - return FALSE; - SelectionCallbackRegistered = TRUE; - } + if (selectionEvents) { + if (!SelectionCallbackRegistered) { + if (!AddCallback(&SelectionCallback, XFixesSelectionCallback, NULL)) + return FALSE; + SelectionCallbackRegistered = TRUE; + } } - else - { - if (SelectionCallbackRegistered) - { - DeleteCallback (&SelectionCallback, XFixesSelectionCallback, NULL); - SelectionCallbackRegistered = FALSE; - } + else { + if (SelectionCallbackRegistered) { + DeleteCallback(&SelectionCallback, XFixesSelectionCallback, NULL); + SelectionCallbackRegistered = FALSE; + } } return TRUE; } @@ -126,99 +119,88 @@ CheckSelectionCallback (void) XFixesSelectionClientCloseNotifyMask) static int -XFixesSelectSelectionInput (ClientPtr pClient, - Atom selection, - WindowPtr pWindow, - CARD32 eventMask) +XFixesSelectSelectionInput(ClientPtr pClient, + Atom selection, WindowPtr pWindow, CARD32 eventMask) { pointer val; int rc; - SelectionEventPtr *prev, e; + SelectionEventPtr *prev, e; rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess); if (rc != Success) - return rc; + return rc; - for (prev = &selectionEvents; (e = *prev); prev = &e->next) - { - if (e->selection == selection && - e->pClient == pClient && - e->pWindow == pWindow) - { - break; - } + for (prev = &selectionEvents; (e = *prev); prev = &e->next) { + if (e->selection == selection && + 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 = (SelectionEventPtr) malloc(sizeof (SelectionEventRec)); - if (!e) - return BadAlloc; + if (!e) { + e = (SelectionEventPtr) malloc(sizeof(SelectionEventRec)); + if (!e) + return BadAlloc; - e->next = 0; - e->selection = selection; - e->pClient = pClient; - e->pWindow = pWindow; - e->clientResource = FakeClientID(pClient->index); + e->next = 0; + e->selection = selection; + 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, - SelectionWindowType, serverClient, - DixGetAttrAccess); - if (rc != Success) - if (!AddResource (pWindow->drawable.id, SelectionWindowType, - (pointer) pWindow)) - { - free(e); - return BadAlloc; - } + /* + * Add a resource hanging from the window to + * catch window destroy + */ + rc = dixLookupResourceByType(&val, pWindow->drawable.id, + SelectionWindowType, serverClient, + DixGetAttrAccess); + if (rc != Success) + if (!AddResource(pWindow->drawable.id, SelectionWindowType, + (pointer) pWindow)) { + free(e); + return BadAlloc; + } - if (!AddResource (e->clientResource, SelectionClientType, (pointer) e)) - return BadAlloc; + if (!AddResource(e->clientResource, SelectionClientType, (pointer) e)) + return BadAlloc; - *prev = e; - if (!CheckSelectionCallback ()) - { - FreeResource (e->clientResource, 0); - return BadAlloc; - } + *prev = e; + if (!CheckSelectionCallback()) { + FreeResource(e->clientResource, 0); + return BadAlloc; + } } e->eventMask = eventMask; return Success; } int -ProcXFixesSelectSelectionInput (ClientPtr client) +ProcXFixesSelectSelectionInput(ClientPtr client) { - REQUEST (xXFixesSelectSelectionInputReq); - WindowPtr pWin; - int rc; + REQUEST(xXFixesSelectSelectionInputReq); + WindowPtr pWin; + int rc; - REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq); + REQUEST_SIZE_MATCH(xXFixesSelectSelectionInputReq); rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); if (rc != Success) return rc; - if (stuff->eventMask & ~SelectionAllEvents) - { - client->errorValue = stuff->eventMask; - return BadValue; + if (stuff->eventMask & ~SelectionAllEvents) { + client->errorValue = stuff->eventMask; + return BadValue; } - return XFixesSelectSelectionInput (client, stuff->selection, - pWin, stuff->eventMask); + return XFixesSelectSelectionInput(client, stuff->selection, + pWin, stuff->eventMask); } int -SProcXFixesSelectSelectionInput (ClientPtr client) +SProcXFixesSelectSelectionInput(ClientPtr client) { REQUEST(xXFixesSelectSelectionInputReq); @@ -226,64 +208,60 @@ SProcXFixesSelectSelectionInput (ClientPtr client) swapl(&stuff->window); swapl(&stuff->selection); swapl(&stuff->eventMask); - return (*ProcXFixesVector[stuff->xfixesReqType])(client); + return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } - + void -SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from, - xXFixesSelectionNotifyEvent *to) +SXFixesSelectionNotifyEvent(xXFixesSelectionNotifyEvent * from, + xXFixesSelectionNotifyEvent * to) { to->type = from->type; - cpswaps (from->sequenceNumber, to->sequenceNumber); - cpswapl (from->window, to->window); - cpswapl (from->owner, to->owner); - cpswapl (from->selection, to->selection); - cpswapl (from->timestamp, to->timestamp); - cpswapl (from->selectionTimestamp, to->selectionTimestamp); + cpswaps(from->sequenceNumber, to->sequenceNumber); + cpswapl(from->window, to->window); + cpswapl(from->owner, to->owner); + cpswapl(from->selection, to->selection); + cpswapl(from->timestamp, to->timestamp); + cpswapl(from->selectionTimestamp, to->selectionTimestamp); } static int -SelectionFreeClient (pointer data, XID id) +SelectionFreeClient(pointer data, XID id) { - SelectionEventPtr old = (SelectionEventPtr) data; - SelectionEventPtr *prev, e; - - for (prev = &selectionEvents; (e = *prev); prev = &e->next) - { - if (e == old) - { - *prev = e->next; - free(e); - CheckSelectionCallback (); - break; - } + SelectionEventPtr old = (SelectionEventPtr) data; + SelectionEventPtr *prev, e; + + for (prev = &selectionEvents; (e = *prev); prev = &e->next) { + if (e == old) { + *prev = e->next; + free(e); + CheckSelectionCallback(); + break; + } } return 1; } static int -SelectionFreeWindow (pointer data, XID id) +SelectionFreeWindow(pointer data, XID id) { - WindowPtr pWindow = (WindowPtr) data; - SelectionEventPtr e, next; + WindowPtr pWindow = (WindowPtr) data; + SelectionEventPtr e, next; - for (e = selectionEvents; e; e = next) - { - next = e->next; - if (e->pWindow == pWindow) - { - FreeResource (e->clientResource, 0); - } + for (e = selectionEvents; e; e = next) { + next = e->next; + if (e->pWindow == pWindow) { + FreeResource(e->clientResource, 0); + } } return 1; } Bool -XFixesSelectionInit (void) +XFixesSelectionInit(void) { SelectionClientType = CreateNewResourceType(SelectionFreeClient, - "XFixesSelectionClient"); + "XFixesSelectionClient"); SelectionWindowType = CreateNewResourceType(SelectionFreeWindow, - "XFixesSelectionWindow"); + "XFixesSelectionWindow"); return SelectionClientType && SelectionWindowType; } diff --git a/xorg-server/xfixes/xfixes.c b/xorg-server/xfixes/xfixes.c index 96d33c00b..f80230fd3 100644 --- a/xorg-server/xfixes/xfixes.c +++ b/xorg-server/xfixes/xfixes.c @@ -49,18 +49,20 @@ #include "xfixesint.h" #include "protocol-versions.h" -static unsigned char XFixesReqCode; -int XFixesEventBase; -int XFixesErrorBase; +static unsigned char XFixesReqCode; +int XFixesEventBase; +int XFixesErrorBase; static DevPrivateKeyRec XFixesClientPrivateKeyRec; + #define XFixesClientPrivateKey (&XFixesClientPrivateKeyRec) static int ProcXFixesQueryVersion(ClientPtr client) { - XFixesClientPtr pXFixesClient = GetXFixesClient (client); + XFixesClientPtr pXFixesClient = GetXFixesClient(client); xXFixesQueryVersionReply rep; + REQUEST(xXFixesQueryVersionReq); REQUEST_SIZE_MATCH(xXFixesQueryVersionReq); @@ -70,90 +72,86 @@ ProcXFixesQueryVersion(ClientPtr client) rep.sequenceNumber = client->sequence; if (version_compare(stuff->majorVersion, stuff->minorVersion, - SERVER_XFIXES_MAJOR_VERSION, SERVER_XFIXES_MAJOR_VERSION) < 0) - { - rep.majorVersion = stuff->majorVersion; - rep.minorVersion = stuff->minorVersion; - } else { - rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION; + SERVER_XFIXES_MAJOR_VERSION, + SERVER_XFIXES_MAJOR_VERSION) < 0) { + rep.majorVersion = stuff->majorVersion; + rep.minorVersion = stuff->minorVersion; + } + else { + rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION; rep.minorVersion = SERVER_XFIXES_MINOR_VERSION; } pXFixesClient->major_version = rep.majorVersion; pXFixesClient->minor_version = rep.minorVersion; if (client->swapped) { - swaps(&rep.sequenceNumber); - swapl(&rep.length); - swapl(&rep.majorVersion); - swapl(&rep.minorVersion); + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swapl(&rep.majorVersion); + swapl(&rep.minorVersion); } - WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep); + WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *) &rep); return Success; } /* Major version controls available requests */ static const int version_requests[] = { - X_XFixesQueryVersion, /* before client sends QueryVersion */ - X_XFixesGetCursorImage, /* Version 1 */ - X_XFixesChangeCursorByName, /* Version 2 */ - X_XFixesExpandRegion, /* Version 3 */ - X_XFixesShowCursor, /* Version 4 */ - X_XFixesDestroyPointerBarrier, /* Version 5 */ + X_XFixesQueryVersion, /* before client sends QueryVersion */ + X_XFixesGetCursorImage, /* Version 1 */ + X_XFixesChangeCursorByName, /* Version 2 */ + X_XFixesExpandRegion, /* Version 3 */ + X_XFixesShowCursor, /* Version 4 */ + X_XFixesDestroyPointerBarrier, /* Version 5 */ }; #define NUM_VERSION_REQUESTS (sizeof (version_requests) / sizeof (version_requests[0])) - -int (*ProcXFixesVector[XFixesNumberRequests])(ClientPtr) = { + +int (*ProcXFixesVector[XFixesNumberRequests]) (ClientPtr) = { /*************** Version 1 ******************/ ProcXFixesQueryVersion, - ProcXFixesChangeSaveSet, - ProcXFixesSelectSelectionInput, - ProcXFixesSelectCursorInput, - ProcXFixesGetCursorImage, + ProcXFixesChangeSaveSet, + ProcXFixesSelectSelectionInput, + ProcXFixesSelectCursorInput, ProcXFixesGetCursorImage, /*************** Version 2 ******************/ - ProcXFixesCreateRegion, - ProcXFixesCreateRegionFromBitmap, - ProcXFixesCreateRegionFromWindow, - ProcXFixesCreateRegionFromGC, - ProcXFixesCreateRegionFromPicture, - ProcXFixesDestroyRegion, - ProcXFixesSetRegion, - ProcXFixesCopyRegion, - ProcXFixesCombineRegion, - ProcXFixesCombineRegion, - ProcXFixesCombineRegion, - ProcXFixesInvertRegion, - ProcXFixesTranslateRegion, - ProcXFixesRegionExtents, - ProcXFixesFetchRegion, - ProcXFixesSetGCClipRegion, - ProcXFixesSetWindowShapeRegion, - ProcXFixesSetPictureClipRegion, - ProcXFixesSetCursorName, - ProcXFixesGetCursorName, - ProcXFixesGetCursorImageAndName, - ProcXFixesChangeCursor, - ProcXFixesChangeCursorByName, + ProcXFixesCreateRegion, + ProcXFixesCreateRegionFromBitmap, + ProcXFixesCreateRegionFromWindow, + ProcXFixesCreateRegionFromGC, + ProcXFixesCreateRegionFromPicture, + ProcXFixesDestroyRegion, + ProcXFixesSetRegion, + ProcXFixesCopyRegion, + ProcXFixesCombineRegion, + ProcXFixesCombineRegion, + ProcXFixesCombineRegion, + ProcXFixesInvertRegion, + ProcXFixesTranslateRegion, + ProcXFixesRegionExtents, + ProcXFixesFetchRegion, + ProcXFixesSetGCClipRegion, + ProcXFixesSetWindowShapeRegion, + ProcXFixesSetPictureClipRegion, + ProcXFixesSetCursorName, + ProcXFixesGetCursorName, + ProcXFixesGetCursorImageAndName, + ProcXFixesChangeCursor, ProcXFixesChangeCursorByName, /*************** Version 3 ******************/ - ProcXFixesExpandRegion, + ProcXFixesExpandRegion, /*************** Version 4 ****************/ - ProcXFixesHideCursor, - ProcXFixesShowCursor, + ProcXFixesHideCursor, ProcXFixesShowCursor, /*************** Version 5 ****************/ - ProcXFixesCreatePointerBarrier, - ProcXFixesDestroyPointerBarrier, -}; +ProcXFixesCreatePointerBarrier, ProcXFixesDestroyPointerBarrier,}; static int -ProcXFixesDispatch (ClientPtr client) +ProcXFixesDispatch(ClientPtr client) { REQUEST(xXFixesReq); - XFixesClientPtr pXFixesClient = GetXFixesClient (client); + XFixesClientPtr pXFixesClient = GetXFixesClient(client); if (pXFixesClient->major_version >= NUM_VERSION_REQUESTS) - return BadRequest; + return BadRequest; if (stuff->xfixesReqType > version_requests[pXFixesClient->major_version]) - return BadRequest; + return BadRequest; return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } @@ -168,74 +166,66 @@ SProcXFixesQueryVersion(ClientPtr client) return (*ProcXFixesVector[stuff->xfixesReqType]) (client); } -static int (*SProcXFixesVector[XFixesNumberRequests])(ClientPtr) = { +static int (*SProcXFixesVector[XFixesNumberRequests]) (ClientPtr) = { /*************** Version 1 ******************/ SProcXFixesQueryVersion, - SProcXFixesChangeSaveSet, - SProcXFixesSelectSelectionInput, - SProcXFixesSelectCursorInput, - SProcXFixesGetCursorImage, + SProcXFixesChangeSaveSet, + SProcXFixesSelectSelectionInput, + SProcXFixesSelectCursorInput, SProcXFixesGetCursorImage, /*************** Version 2 ******************/ - SProcXFixesCreateRegion, - SProcXFixesCreateRegionFromBitmap, - SProcXFixesCreateRegionFromWindow, - SProcXFixesCreateRegionFromGC, - SProcXFixesCreateRegionFromPicture, - SProcXFixesDestroyRegion, - SProcXFixesSetRegion, - SProcXFixesCopyRegion, - SProcXFixesCombineRegion, - SProcXFixesCombineRegion, - SProcXFixesCombineRegion, - SProcXFixesInvertRegion, - SProcXFixesTranslateRegion, - SProcXFixesRegionExtents, - SProcXFixesFetchRegion, - SProcXFixesSetGCClipRegion, - SProcXFixesSetWindowShapeRegion, - SProcXFixesSetPictureClipRegion, - SProcXFixesSetCursorName, - SProcXFixesGetCursorName, - SProcXFixesGetCursorImageAndName, - SProcXFixesChangeCursor, - SProcXFixesChangeCursorByName, + SProcXFixesCreateRegion, + SProcXFixesCreateRegionFromBitmap, + SProcXFixesCreateRegionFromWindow, + SProcXFixesCreateRegionFromGC, + SProcXFixesCreateRegionFromPicture, + SProcXFixesDestroyRegion, + SProcXFixesSetRegion, + SProcXFixesCopyRegion, + SProcXFixesCombineRegion, + SProcXFixesCombineRegion, + SProcXFixesCombineRegion, + SProcXFixesInvertRegion, + SProcXFixesTranslateRegion, + SProcXFixesRegionExtents, + SProcXFixesFetchRegion, + SProcXFixesSetGCClipRegion, + SProcXFixesSetWindowShapeRegion, + SProcXFixesSetPictureClipRegion, + SProcXFixesSetCursorName, + SProcXFixesGetCursorName, + SProcXFixesGetCursorImageAndName, + SProcXFixesChangeCursor, SProcXFixesChangeCursorByName, /*************** Version 3 ******************/ - SProcXFixesExpandRegion, + SProcXFixesExpandRegion, /*************** Version 4 ****************/ - SProcXFixesHideCursor, - SProcXFixesShowCursor, + SProcXFixesHideCursor, SProcXFixesShowCursor, /*************** Version 5 ****************/ - SProcXFixesCreatePointerBarrier, - SProcXFixesDestroyPointerBarrier, -}; +SProcXFixesCreatePointerBarrier, SProcXFixesDestroyPointerBarrier,}; static int -SProcXFixesDispatch (ClientPtr client) +SProcXFixesDispatch(ClientPtr client) { REQUEST(xXFixesReq); if (stuff->xfixesReqType >= XFixesNumberRequests) - return BadRequest; + return BadRequest; return (*SProcXFixesVector[stuff->xfixesReqType]) (client); } static void -XFixesClientCallback (CallbackListPtr *list, - pointer closure, - pointer data) +XFixesClientCallback(CallbackListPtr *list, pointer closure, pointer data) { - NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; - ClientPtr pClient = clientinfo->client; - XFixesClientPtr pXFixesClient = GetXFixesClient (pClient); + NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; + ClientPtr pClient = clientinfo->client; + XFixesClientPtr pXFixesClient = GetXFixesClient(pClient); pXFixesClient->major_version = 0; pXFixesClient->minor_version = 0; } -/*ARGSUSED*/ -static void -XFixesResetProc (ExtensionEntry *extEntry) + /*ARGSUSED*/ static void +XFixesResetProc(ExtensionEntry * extEntry) { - DeleteCallback (&ClientStateCallback, XFixesClientCallback, 0); + DeleteCallback(&ClientStateCallback, XFixesClientCallback, 0); } void @@ -243,56 +233,58 @@ XFixesExtensionInit(void) { ExtensionEntry *extEntry; - if (!dixRegisterPrivateKey(&XFixesClientPrivateKeyRec, PRIVATE_CLIENT, sizeof (XFixesClientRec))) - return; - if (!AddCallback (&ClientStateCallback, XFixesClientCallback, 0)) - return; - - if (XFixesSelectionInit() && XFixesCursorInit () && XFixesRegionInit () && - (extEntry = AddExtension(XFIXES_NAME, XFixesNumberEvents, - XFixesNumberErrors, - ProcXFixesDispatch, SProcXFixesDispatch, - XFixesResetProc, StandardMinorOpcode)) != 0) - { - XFixesReqCode = (unsigned char)extEntry->base; - XFixesEventBase = extEntry->eventBase; - XFixesErrorBase = extEntry->errorBase; - EventSwapVector[XFixesEventBase + XFixesSelectionNotify] = - (EventSwapPtr) SXFixesSelectionNotifyEvent; - EventSwapVector[XFixesEventBase + XFixesCursorNotify] = - (EventSwapPtr) SXFixesCursorNotifyEvent; - SetResourceTypeErrorValue(RegionResType, XFixesErrorBase + BadRegion); - SetResourceTypeErrorValue(PointerBarrierType, - XFixesErrorBase + BadBarrier); + if (!dixRegisterPrivateKey + (&XFixesClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(XFixesClientRec))) + return; + if (!AddCallback(&ClientStateCallback, XFixesClientCallback, 0)) + return; + + if (XFixesSelectionInit() && XFixesCursorInit() && XFixesRegionInit() && + (extEntry = AddExtension(XFIXES_NAME, XFixesNumberEvents, + XFixesNumberErrors, + ProcXFixesDispatch, SProcXFixesDispatch, + XFixesResetProc, StandardMinorOpcode)) != 0) { + XFixesReqCode = (unsigned char) extEntry->base; + XFixesEventBase = extEntry->eventBase; + XFixesErrorBase = extEntry->errorBase; + EventSwapVector[XFixesEventBase + XFixesSelectionNotify] = + (EventSwapPtr) SXFixesSelectionNotifyEvent; + EventSwapVector[XFixesEventBase + XFixesCursorNotify] = + (EventSwapPtr) SXFixesCursorNotifyEvent; + SetResourceTypeErrorValue(RegionResType, XFixesErrorBase + BadRegion); + SetResourceTypeErrorValue(PointerBarrierType, + XFixesErrorBase + BadBarrier); } } #ifdef PANORAMIX -int (*PanoramiXSaveXFixesVector[XFixesNumberRequests])(ClientPtr); +int (*PanoramiXSaveXFixesVector[XFixesNumberRequests]) (ClientPtr); void -PanoramiXFixesInit (void) +PanoramiXFixesInit(void) { int i; for (i = 0; i < XFixesNumberRequests; i++) - PanoramiXSaveXFixesVector[i] = ProcXFixesVector[i]; + PanoramiXSaveXFixesVector[i] = ProcXFixesVector[i]; /* * Stuff in Xinerama aware request processing hooks */ ProcXFixesVector[X_XFixesSetGCClipRegion] = PanoramiXFixesSetGCClipRegion; - ProcXFixesVector[X_XFixesSetWindowShapeRegion] = PanoramiXFixesSetWindowShapeRegion; - ProcXFixesVector[X_XFixesSetPictureClipRegion] = PanoramiXFixesSetPictureClipRegion; + ProcXFixesVector[X_XFixesSetWindowShapeRegion] = + PanoramiXFixesSetWindowShapeRegion; + ProcXFixesVector[X_XFixesSetPictureClipRegion] = + PanoramiXFixesSetPictureClipRegion; } void -PanoramiXFixesReset (void) +PanoramiXFixesReset(void) { int i; for (i = 0; i < XFixesNumberRequests; i++) - ProcXFixesVector[i] = PanoramiXSaveXFixesVector[i]; + ProcXFixesVector[i] = PanoramiXSaveXFixesVector[i]; } #endif diff --git a/xorg-server/xfixes/xfixes.h b/xorg-server/xfixes/xfixes.h index 5765e64b5..19af09f7d 100644 --- a/xorg-server/xfixes/xfixes.h +++ b/xorg-server/xfixes/xfixes.h @@ -50,23 +50,22 @@ extern _X_EXPORT int XFixesErrorBase; } extern _X_EXPORT RegionPtr -XFixesRegionCopy (RegionPtr pRegion); + XFixesRegionCopy(RegionPtr pRegion); struct PointerBarrier { CARD16 x1, x2, y1, y2; CARD32 directions; }; - extern int -barrier_get_direction(int, int, int, int); -extern BOOL -barrier_is_blocking(const struct PointerBarrier*, int, int, int, int, double*); + barrier_get_direction(int, int, int, int); extern BOOL -barrier_is_blocking_direction(const struct PointerBarrier*, int); +barrier_is_blocking(const struct PointerBarrier *, int, int, int, int, + double *); +extern BOOL barrier_is_blocking_direction(const struct PointerBarrier *, int); extern 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); -#endif /* _XFIXES_H_ */ +#endif /* _XFIXES_H_ */ -- cgit v1.2.3