diff options
Diffstat (limited to 'xorg-server/dix/window.c')
| -rw-r--r-- | xorg-server/dix/window.c | 4101 |
1 files changed, 1936 insertions, 2165 deletions
diff --git a/xorg-server/dix/window.c b/xorg-server/dix/window.c index 823294b9a..98f5604c9 100644 --- a/xorg-server/dix/window.c +++ b/xorg-server/dix/window.c @@ -45,7 +45,6 @@ not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. - Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts, All Rights Reserved @@ -97,7 +96,6 @@ Equipment Corporation. ******************************************************************/ - #ifdef HAVE_DIX_CONFIG_H #include <dix-config.h> #endif @@ -124,7 +122,7 @@ Equipment Corporation. #endif #include "dixevents.h" #include "globals.h" -#include "mi.h" /* miPaintWindow */ +#include "mi.h" /* miPaintWindow */ #ifdef COMPOSITE #include "compint.h" #endif @@ -133,7 +131,7 @@ Equipment Corporation. #include "xace.h" #include "exevents.h" -#include <X11/Xatom.h> /* must come after server includes */ +#include <X11/Xatom.h> /* must come after server includes */ /****** * Window stuff for server @@ -147,17 +145,16 @@ Equipment Corporation. Bool bgNoneRoot = FALSE; -static unsigned char _back_lsb[4] = {0x88, 0x22, 0x44, 0x11}; -static unsigned char _back_msb[4] = {0x11, 0x44, 0x22, 0x88}; +static unsigned char _back_lsb[4] = { 0x88, 0x22, 0x44, 0x11 }; +static unsigned char _back_msb[4] = { 0x11, 0x44, 0x22, 0x88 }; + +static Bool WindowParentHasDeviceCursor(WindowPtr pWin, + DeviceIntPtr pDev, CursorPtr pCurs); +static Bool -static Bool WindowParentHasDeviceCursor(WindowPtr pWin, - DeviceIntPtr pDev, - CursorPtr pCurs); -static Bool -WindowSeekDeviceCursor(WindowPtr pWin, - DeviceIntPtr pDev, - DevCursNodePtr* pNode, - DevCursNodePtr* pPrev); +WindowSeekDeviceCursor(WindowPtr pWin, + DeviceIntPtr pDev, + DevCursNodePtr * pNode, DevCursNodePtr * pPrev); int screenIsSaved = SCREEN_SAVER_OFF; @@ -194,6 +191,7 @@ get_window_name(WindowPtr pWin) PropertyPtr prop; static char buf[WINDOW_NAME_BUF_LEN]; int len; + #ifdef COMPOSITE CompScreenPtr comp_screen = GetCompScreen(pWin->drawable.pScreen); @@ -201,11 +199,9 @@ get_window_name(WindowPtr pWin) return overlay_win_name; #endif - for (prop = wUserProps(pWin); prop; prop = prop->next) - { + for (prop = wUserProps(pWin); prop; prop = prop->next) { if (prop->propertyName == XA_WM_NAME && prop->type == XA_STRING && - prop->data) - { + prop->data) { len = min(prop->size, WINDOW_NAME_BUF_LEN - 1); memcpy(buf, prop->data, len); buf[len] = '\0'; @@ -217,7 +213,8 @@ get_window_name(WindowPtr pWin) #undef WINDOW_NAME_BUF_LEN } -static void log_window_info(WindowPtr pWin, int depth) +static void +log_window_info(WindowPtr pWin, int depth) { int i; const char *win_name, *visibility; @@ -241,35 +238,32 @@ static void log_window_info(WindowPtr pWin, int depth) if (pWin->redirectDraw) ErrorF(" (%s compositing: pixmap %x)", (pWin->redirectDraw == RedirectDrawAutomatic) ? - "automatic" : "manual", + "automatic" : "manual", pScreen->GetWindowPixmap(pWin)->drawable.id); #endif - switch (pWin->visibility) - { + switch (pWin->visibility) { case VisibilityUnobscured: - visibility = "unobscured"; - break; + visibility = "unobscured"; + break; case VisibilityPartiallyObscured: - visibility = "partially obscured"; - break; + visibility = "partially obscured"; + break; case VisibilityFullyObscured: - visibility = "fully obscured"; - break; + visibility = "fully obscured"; + break; case VisibilityNotViewable: - visibility = "unviewable"; - break; + visibility = "unviewable"; + break; } ErrorF(", %s", visibility); - if (REGION_NOTEMPTY(pScreen, &pWin->clipList)) - { + if (REGION_NOTEMPTY(pScreen, &pWin->clipList)) { ErrorF(", clip list:"); rects = REGION_RECTS(&pWin->clipList); for (i = 0; i < REGION_NUM_RECTS(&pWin->clipList); i++) ErrorF(" [(%d, %d) to (%d, %d)]", - rects[i].x1, rects[i].y1, - rects[i].x2, rects[i].y2); + rects[i].x1, rects[i].y1, rects[i].x2, rects[i].y2); ErrorF("; extents [(%d, %d) to (%d, %d)]", pWin->clipList.extents.x1, pWin->clipList.extents.y1, pWin->clipList.extents.x2, pWin->clipList.extents.y2); @@ -285,31 +279,27 @@ PrintWindowTree(void) ScreenPtr pScreen; WindowPtr pWin; - for (scrnum = 0; scrnum < screenInfo.numScreens; scrnum++) - { + for (scrnum = 0; scrnum < screenInfo.numScreens; scrnum++) { pScreen = screenInfo.screens[scrnum]; ErrorF("[dix] Dumping windows for screen %d (pixmap %x):\n", scrnum, pScreen->GetScreenPixmap(pScreen)->drawable.id); pWin = pScreen->root; depth = 1; - while (pWin) - { + while (pWin) { log_window_info(pWin, depth); - if (pWin->firstChild) - { + if (pWin->firstChild) { pWin = pWin->firstChild; depth++; continue; } - while (pWin && !pWin->nextSib) - { + while (pWin && !pWin->nextSib) { pWin = pWin->parent; depth--; } if (!pWin) break; pWin = pWin->nextSib; - } + } } } @@ -320,22 +310,20 @@ TraverseTree(WindowPtr pWin, VisitWindowProcPtr func, pointer data) WindowPtr pChild; if (!(pChild = pWin)) - return WT_NOMATCH; - while (1) - { - result = (* func)(pChild, data); - if (result == WT_STOPWALKING) - return WT_STOPWALKING; - if ((result == WT_WALKCHILDREN) && pChild->firstChild) - { - pChild = pChild->firstChild; - continue; - } - while (!pChild->nextSib && (pChild != pWin)) - pChild = pChild->parent; - if (pChild == pWin) - break; - pChild = pChild->nextSib; + return WT_NOMATCH; + while (1) { + result = (*func) (pChild, data); + if (result == WT_STOPWALKING) + return WT_STOPWALKING; + if ((result == WT_WALKCHILDREN) && pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + while (!pChild->nextSib && (pChild != pWin)) + pChild = pChild->parent; + if (pChild == pWin) + break; + pChild = pChild->nextSib; } return WT_NOMATCH; } @@ -351,14 +339,15 @@ TraverseTree(WindowPtr pWin, VisitWindowProcPtr func, pointer data) int WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, pointer data) { - return(TraverseTree(pScreen->root, func, data)); + return (TraverseTree(pScreen->root, func, data)); } /* hack for forcing backing store on all windows */ -int defaultBackingStore = NotUseful; +int defaultBackingStore = NotUseful; + /* hack to force no backing store */ -Bool disableBackingStore = FALSE; -Bool enableBackingStore = FALSE; +Bool disableBackingStore = FALSE; +Bool enableBackingStore = FALSE; static void SetWindowToDefaults(WindowPtr pWin) @@ -367,16 +356,16 @@ SetWindowToDefaults(WindowPtr pWin) pWin->firstChild = NullWindow; pWin->lastChild = NullWindow; - pWin->valdata = (ValidatePtr)NULL; - pWin->optional = (WindowOptPtr)NULL; + pWin->valdata = (ValidatePtr) NULL; + pWin->optional = (WindowOptPtr) NULL; pWin->cursorIsNone = TRUE; pWin->backingStore = NotUseful; pWin->DIXsaveUnder = FALSE; pWin->backStorage = (pointer) NULL; - pWin->mapped = FALSE; /* off */ - pWin->realized = FALSE; /* off */ + pWin->mapped = FALSE; /* off */ + pWin->realized = FALSE; /* off */ pWin->viewable = FALSE; pWin->visibility = VisibilityNotViewable; pWin->overrideRedirect = FALSE; @@ -411,36 +400,37 @@ MakeRootTile(WindowPtr pWin) unsigned char *from, *to; int i, j; - pWin->background.pixmap = (*pScreen->CreatePixmap)(pScreen, 4, 4, - pScreen->rootDepth, 0); + pWin->background.pixmap = (*pScreen->CreatePixmap) (pScreen, 4, 4, + pScreen->rootDepth, 0); pWin->backgroundState = BackgroundPixmap; pGC = GetScratchGC(pScreen->rootDepth, pScreen); if (!pWin->background.pixmap || !pGC) - FatalError("could not create root tile"); + FatalError("could not create root tile"); { - ChangeGCVal attributes[2]; + ChangeGCVal attributes[2]; - attributes[0].val = pScreen->whitePixel; - attributes[1].val = pScreen->blackPixel; + attributes[0].val = pScreen->whitePixel; + attributes[1].val = pScreen->blackPixel; - (void)ChangeGC(NullClient, pGC, GCForeground | GCBackground, attributes); + (void) ChangeGC(NullClient, pGC, GCForeground | GCBackground, + attributes); } - ValidateGC((DrawablePtr)pWin->background.pixmap, pGC); + ValidateGC((DrawablePtr) pWin->background.pixmap, pGC); - from = (screenInfo.bitmapBitOrder == LSBFirst) ? _back_lsb : _back_msb; - to = back; + from = (screenInfo.bitmapBitOrder == LSBFirst) ? _back_lsb : _back_msb; + to = back; - for (i = 4; i > 0; i--, from++) - for (j = len; j > 0; j--) - *to++ = *from; + for (i = 4; i > 0; i--, from++) + for (j = len; j > 0; j--) + *to++ = *from; - (*pGC->ops->PutImage)((DrawablePtr)pWin->background.pixmap, pGC, 1, - 0, 0, len, 4, 0, XYBitmap, (char *)back); + (*pGC->ops->PutImage) ((DrawablePtr) pWin->background.pixmap, pGC, 1, + 0, 0, len, 4, 0, XYBitmap, (char *) back); - FreeScratchGC(pGC); + FreeScratchGC(pGC); } @@ -452,13 +442,13 @@ MakeRootTile(WindowPtr pWin) Bool CreateRootWindow(ScreenPtr pScreen) { - WindowPtr pWin; - BoxRec box; + WindowPtr pWin; + BoxRec box; PixmapFormatRec *format; pWin = dixAllocateObjectWithPrivates(WindowRec, PRIVATE_WINDOW); if (!pWin) - return FALSE; + return FALSE; pScreen->screensaver.pWindow = NULL; pScreen->screensaver.wid = FakeClientID(0); @@ -472,9 +462,7 @@ CreateRootWindow(ScreenPtr pScreen) pWin->drawable.depth = pScreen->rootDepth; for (format = screenInfo.formats; - format->depth != pScreen->rootDepth; - format++) - ; + format->depth != pScreen->rootDepth; format++); pWin->drawable.bitsPerPixel = format->bitsPerPixel; pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER; @@ -482,7 +470,7 @@ CreateRootWindow(ScreenPtr pScreen) pWin->parent = NullWindow; SetWindowToDefaults(pWin); - pWin->optional = malloc(sizeof (WindowOptRec)); + pWin->optional = malloc(sizeof(WindowOptRec)); if (!pWin->optional) return FALSE; @@ -532,16 +520,16 @@ CreateRootWindow(ScreenPtr pScreen) /* security creation/labeling check */ if (XaceHook(XACE_RESOURCE_ACCESS, serverClient, pWin->drawable.id, - RT_WINDOW, pWin, RT_NONE, NULL, DixCreateAccess)) - return FALSE; + RT_WINDOW, pWin, RT_NONE, NULL, DixCreateAccess)) + return FALSE; - if (!AddResource(pWin->drawable.id, RT_WINDOW, (pointer)pWin)) - return FALSE; + if (!AddResource(pWin->drawable.id, RT_WINDOW, (pointer) pWin)) + return FALSE; if (disableBackingStore) - pScreen->backingStoreSupport = NotUseful; + pScreen->backingStoreSupport = NotUseful; if (enableBackingStore) - pScreen->backingStoreSupport = Always; + pScreen->backingStoreSupport = Always; pScreen->saveUnderSupport = NotUseful; @@ -554,35 +542,36 @@ InitRootWindow(WindowPtr pWin) ScreenPtr pScreen = pWin->drawable.pScreen; int backFlag = CWBorderPixel | CWCursor | CWBackingStore; - if (!(*pScreen->CreateWindow)(pWin)) - return; /* XXX */ - (*pScreen->PositionWindow)(pWin, 0, 0); + if (!(*pScreen->CreateWindow) (pWin)) + return; /* XXX */ + (*pScreen->PositionWindow) (pWin, 0, 0); pWin->cursorIsNone = FALSE; pWin->optional->cursor = rootCursor; rootCursor->refcnt++; - if (party_like_its_1989) { MakeRootTile(pWin); backFlag |= CWBackPixmap; - } else if (pScreen->canDoBGNoneRoot && bgNoneRoot) { + } + else if (pScreen->canDoBGNoneRoot && bgNoneRoot) { pWin->backgroundState = XaceBackgroundNoneState(pWin); pWin->background.pixel = pScreen->whitePixel; backFlag |= CWBackPixmap; - } else { + } + else { pWin->backgroundState = BackgroundPixel; - if (whiteRoot) + if (whiteRoot) pWin->background.pixel = pScreen->whitePixel; else pWin->background.pixel = pScreen->blackPixel; backFlag |= CWBackPixel; - } + } pWin->backingStore = defaultBackingStore; pWin->forcedBS = (defaultBackingStore != NotUseful); /* We SHOULD check for an error value here XXX */ - (*pScreen->ChangeWindowAttributes)(pWin, backFlag); + (*pScreen->ChangeWindowAttributes) (pWin, backFlag); MapWindow(pWin, serverClient); } @@ -593,27 +582,25 @@ InitRootWindow(WindowPtr pWin) */ static void -ClippedRegionFromBox(WindowPtr pWin, RegionPtr Rgn, - int x, int y, - int w, int h) +ClippedRegionFromBox(WindowPtr pWin, RegionPtr Rgn, int x, int y, int w, int h) { BoxRec box = *RegionExtents(&pWin->winSize); /* we do these calculations to avoid overflows */ if (x > box.x1) - box.x1 = x; + box.x1 = x; if (y > box.y1) - box.y1 = y; + box.y1 = y; x += w; if (x < box.x2) - box.x2 = x; + box.x2 = x; y += h; if (y < box.y2) - box.y2 = y; + box.y2 = y; if (box.x1 > box.x2) - box.x2 = box.x1; + box.x2 = box.x1; if (box.y1 > box.y2) - box.y2 = box.y1; + box.y2 = box.y1; RegionReset(Rgn, &box); RegionIntersect(Rgn, Rgn, &pWin->winSize); } @@ -621,25 +608,24 @@ ClippedRegionFromBox(WindowPtr pWin, RegionPtr Rgn, static RealChildHeadProc realChildHeadProc = NULL; void -RegisterRealChildHeadProc (RealChildHeadProc proc) +RegisterRealChildHeadProc(RealChildHeadProc proc) { realChildHeadProc = proc; } - WindowPtr RealChildHead(WindowPtr pWin) { if (realChildHeadProc) { - return realChildHeadProc (pWin); + return realChildHeadProc(pWin); } if (!pWin->parent && - (screenIsSaved == SCREEN_SAVER_ON) && - (HasSaverWindow (pWin->drawable.pScreen))) - return pWin->firstChild; + (screenIsSaved == SCREEN_SAVER_ON) && + (HasSaverWindow(pWin->drawable.pScreen))) + return pWin->firstChild; else - return NullWindow; + return NullWindow; } /***** @@ -663,97 +649,82 @@ CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w, WindowOptPtr ancwopt; if (class == CopyFromParent) - class = pParent->drawable.class; + class = pParent->drawable.class; - if ((class != InputOutput) && (class != InputOnly)) - { - *error = BadValue; - client->errorValue = class; - return NullWindow; + if ((class != InputOutput) && (class != InputOnly)) { + *error = BadValue; + client->errorValue = class; + return NullWindow; } - if ((class != InputOnly) && (pParent->drawable.class == InputOnly)) - { - *error = BadMatch; - return NullWindow; + if ((class != InputOnly) && (pParent->drawable.class == InputOnly)) { + *error = BadMatch; + return NullWindow; } - if ((class == InputOnly) && ((bw != 0) || (depth != 0))) - { - *error = BadMatch; - return NullWindow; + if ((class == InputOnly) && ((bw != 0) || (depth != 0))) { + *error = BadMatch; + return NullWindow; } pScreen = pParent->drawable.pScreen; if ((class == InputOutput) && (depth == 0)) - depth = pParent->drawable.depth; + depth = pParent->drawable.depth; ancwopt = pParent->optional; if (!ancwopt) - ancwopt = FindWindowWithOptional(pParent)->optional; + ancwopt = FindWindowWithOptional(pParent)->optional; if (visual == CopyFromParent) { - visual = ancwopt->visual; + visual = ancwopt->visual; } /* Find out if the depth and visual are acceptable for this Screen */ - if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) - { - fOK = FALSE; - for(idepth = 0; idepth < pScreen->numDepths; idepth++) - { - pDepth = (DepthPtr) &pScreen->allowedDepths[idepth]; - if ((depth == pDepth->depth) || (depth == 0)) - { - for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) - { - if (visual == pDepth->vids[ivisual]) - { - fOK = TRUE; - break; - } - } - } - } - if (fOK == FALSE) - { - *error = BadMatch; - return NullWindow; - } + if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) { + fOK = FALSE; + for (idepth = 0; idepth < pScreen->numDepths; idepth++) { + pDepth = (DepthPtr) & pScreen->allowedDepths[idepth]; + if ((depth == pDepth->depth) || (depth == 0)) { + for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) { + if (visual == pDepth->vids[ivisual]) { + fOK = TRUE; + break; + } + } + } + } + if (fOK == FALSE) { + *error = BadMatch; + return NullWindow; + } } if (((vmask & (CWBorderPixmap | CWBorderPixel)) == 0) && - (class != InputOnly) && - (depth != pParent->drawable.depth)) - { - *error = BadMatch; - return NullWindow; + (class != InputOnly) && (depth != pParent->drawable.depth)) { + *error = BadMatch; + return NullWindow; } if (((vmask & CWColormap) == 0) && - (class != InputOnly) && - ((visual != ancwopt->visual) || (ancwopt->colormap == None))) - { - *error = BadMatch; - return NullWindow; + (class != InputOnly) && + ((visual != ancwopt->visual) || (ancwopt->colormap == None))) { + *error = BadMatch; + return NullWindow; } pWin = dixAllocateObjectWithPrivates(WindowRec, PRIVATE_WINDOW); - if (!pWin) - { - *error = BadAlloc; - return NullWindow; + if (!pWin) { + *error = BadAlloc; + return NullWindow; } pWin->drawable = pParent->drawable; pWin->drawable.depth = depth; if (depth == pParent->drawable.depth) - pWin->drawable.bitsPerPixel = pParent->drawable.bitsPerPixel; - else - { - for (format = screenInfo.formats; format->depth != depth; format++) - ; - pWin->drawable.bitsPerPixel = format->bitsPerPixel; + pWin->drawable.bitsPerPixel = pParent->drawable.bitsPerPixel; + else { + for (format = screenInfo.formats; format->depth != depth; format++); + pWin->drawable.bitsPerPixel = format->bitsPerPixel; } if (class == InputOnly) - pWin->drawable.type = (short) UNDRAWABLE_WINDOW; + pWin->drawable.type = (short) UNDRAWABLE_WINDOW; pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER; pWin->drawable.id = wid; @@ -762,16 +733,14 @@ CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w, pWin->parent = pParent; SetWindowToDefaults(pWin); - if (visual != ancwopt->visual) - { - if (!MakeWindowOptional (pWin)) - { - dixFreeObjectWithPrivates(pWin, PRIVATE_WINDOW); - *error = BadAlloc; - return NullWindow; - } - pWin->optional->visual = visual; - pWin->optional->colormap = None; + if (visual != ancwopt->visual) { + if (!MakeWindowOptional(pWin)) { + dixFreeObjectWithPrivates(pWin, PRIVATE_WINDOW); + *error = BadAlloc; + return NullWindow; + } + pWin->optional->visual = visual; + pWin->optional->colormap = None; } pWin->borderWidth = bw; @@ -779,10 +748,11 @@ CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w, /* security creation/labeling check */ *error = XaceHook(XACE_RESOURCE_ACCESS, client, wid, RT_WINDOW, pWin, - RT_WINDOW, pWin->parent, DixCreateAccess|DixSetAttrAccess); + RT_WINDOW, pWin->parent, + DixCreateAccess | DixSetAttrAccess); if (*error != Success) { - dixFreeObjectWithPrivates(pWin, PRIVATE_WINDOW); - return NullWindow; + dixFreeObjectWithPrivates(pWin, PRIVATE_WINDOW); + return NullWindow; } pWin->backgroundState = XaceBackgroundNoneState(pWin); @@ -791,118 +761,112 @@ CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w, pWin->borderIsPixel = pParent->borderIsPixel; pWin->border = pParent->border; if (pWin->borderIsPixel == FALSE) - pWin->border.pixmap->refcnt++; - - pWin->origin.x = x + (int)bw; - pWin->origin.y = y + (int)bw; + pWin->border.pixmap->refcnt++; + + pWin->origin.x = x + (int) bw; + pWin->origin.y = y + (int) bw; pWin->drawable.width = w; pWin->drawable.height = h; - pWin->drawable.x = pParent->drawable.x + x + (int)bw; - pWin->drawable.y = pParent->drawable.y + y + (int)bw; + pWin->drawable.x = pParent->drawable.x + x + (int) bw; + pWin->drawable.y = pParent->drawable.y + y + (int) bw; - /* set up clip list correctly for unobscured WindowPtr */ + /* set up clip list correctly for unobscured WindowPtr */ RegionNull(&pWin->clipList); RegionNull(&pWin->borderClip); RegionNull(&pWin->winSize); RegionNull(&pWin->borderSize); pHead = RealChildHead(pParent); - if (pHead) - { - pWin->nextSib = pHead->nextSib; - if (pHead->nextSib) - pHead->nextSib->prevSib = pWin; - else - pParent->lastChild = pWin; - pHead->nextSib = pWin; - pWin->prevSib = pHead; + if (pHead) { + pWin->nextSib = pHead->nextSib; + if (pHead->nextSib) + pHead->nextSib->prevSib = pWin; + else + pParent->lastChild = pWin; + pHead->nextSib = pWin; + pWin->prevSib = pHead; } - else - { - pWin->nextSib = pParent->firstChild; - if (pParent->firstChild) - pParent->firstChild->prevSib = pWin; - else - pParent->lastChild = pWin; - pParent->firstChild = pWin; + else { + pWin->nextSib = pParent->firstChild; + if (pParent->firstChild) + pParent->firstChild->prevSib = pWin; + else + pParent->lastChild = pWin; + pParent->firstChild = pWin; } - SetWinSize (pWin); - SetBorderSize (pWin); + SetWinSize(pWin); + SetBorderSize(pWin); /* We SHOULD check for an error value here XXX */ - if (!(*pScreen->CreateWindow)(pWin)) - { - *error = BadAlloc; - DeleteWindow(pWin, None); - return NullWindow; + if (!(*pScreen->CreateWindow) (pWin)) { + *error = BadAlloc; + DeleteWindow(pWin, None); + return NullWindow; } /* We SHOULD check for an error value here XXX */ - (*pScreen->PositionWindow)(pWin, pWin->drawable.x, pWin->drawable.y); + (*pScreen->PositionWindow) (pWin, pWin->drawable.x, pWin->drawable.y); if (!(vmask & CWEventMask)) - RecalculateDeliverableEvents(pWin); + RecalculateDeliverableEvents(pWin); if (vmask) - *error = ChangeWindowAttributes(pWin, vmask, vlist, wClient (pWin)); + *error = ChangeWindowAttributes(pWin, vmask, vlist, wClient(pWin)); else - *error = Success; + *error = Success; - if (*error != Success) - { - DeleteWindow(pWin, None); - return NullWindow; - } - if (!(vmask & CWBackingStore) && (defaultBackingStore != NotUseful)) - { - XID value = defaultBackingStore; - (void)ChangeWindowAttributes(pWin, CWBackingStore, &value, wClient (pWin)); - pWin->forcedBS = TRUE; - } - - if (SubSend(pParent)) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = CreateNotify; - event.u.createNotify.window = wid; - event.u.createNotify.parent = pParent->drawable.id; - event.u.createNotify.x = x; - event.u.createNotify.y = y; - event.u.createNotify.width = w; - event.u.createNotify.height = h; - event.u.createNotify.borderWidth = bw; - event.u.createNotify.override = pWin->overrideRedirect; - DeliverEvents(pParent, &event, 1, NullWindow); + if (*error != Success) { + DeleteWindow(pWin, None); + return NullWindow; + } + if (!(vmask & CWBackingStore) && (defaultBackingStore != NotUseful)) { + XID value = defaultBackingStore; + + (void) ChangeWindowAttributes(pWin, CWBackingStore, &value, + wClient(pWin)); + pWin->forcedBS = TRUE; + } + + if (SubSend(pParent)) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = CreateNotify; + event.u.createNotify.window = wid; + event.u.createNotify.parent = pParent->drawable.id; + event.u.createNotify.x = x; + event.u.createNotify.y = y; + event.u.createNotify.width = w; + event.u.createNotify.height = h; + event.u.createNotify.borderWidth = bw; + event.u.createNotify.override = pWin->overrideRedirect; + DeliverEvents(pParent, &event, 1, NullWindow); } return pWin; } static void -DisposeWindowOptional (WindowPtr pWin) +DisposeWindowOptional(WindowPtr pWin) { if (!pWin->optional) - return; + return; /* * everything is peachy. Delete the optional record * and clean up */ - if (pWin->optional->cursor) - { - FreeCursor (pWin->optional->cursor, (Cursor)0); - pWin->cursorIsNone = FALSE; + if (pWin->optional->cursor) { + FreeCursor(pWin->optional->cursor, (Cursor) 0); + pWin->cursorIsNone = FALSE; } else - pWin->cursorIsNone = TRUE; + pWin->cursorIsNone = TRUE; - if (pWin->optional->deviceCursors) - { + if (pWin->optional->deviceCursors) { DevCursorList pList; DevCursorList pPrev; + pList = pWin->optional->deviceCursors; - while(pList) - { + while (pList) { if (pList->cursor) - FreeCursor(pList->cursor, (XID)0); + FreeCursor(pList->cursor, (XID) 0); pPrev = pList; pList = pList->next; free(pPrev); @@ -926,21 +890,21 @@ FreeWindowResources(WindowPtr pWin) RegionUninit(&pWin->winSize); RegionUninit(&pWin->borderClip); RegionUninit(&pWin->borderSize); - if (wBoundingShape (pWin)) - RegionDestroy(wBoundingShape (pWin)); - if (wClipShape (pWin)) - RegionDestroy(wClipShape (pWin)); - if (wInputShape (pWin)) - RegionDestroy(wInputShape (pWin)); + if (wBoundingShape(pWin)) + RegionDestroy(wBoundingShape(pWin)); + if (wClipShape(pWin)) + RegionDestroy(wClipShape(pWin)); + if (wInputShape(pWin)) + RegionDestroy(wInputShape(pWin)); if (pWin->borderIsPixel == FALSE) - (*pScreen->DestroyPixmap)(pWin->border.pixmap); + (*pScreen->DestroyPixmap) (pWin->border.pixmap); if (pWin->backgroundState == BackgroundPixmap) - (*pScreen->DestroyPixmap)(pWin->background.pixmap); + (*pScreen->DestroyPixmap) (pWin->background.pixmap); DeleteAllWindowProperties(pWin); /* We SHOULD check for an error value here XXX */ - (*pScreen->DestroyWindow)(pWin); - DisposeWindowOptional (pWin); + (*pScreen->DestroyWindow) (pWin); + DisposeWindowOptional(pWin); } static void @@ -951,46 +915,41 @@ CrushTree(WindowPtr pWin) xEvent event; if (!(pChild = pWin->firstChild)) - return; + return; UnrealizeWindow = pWin->drawable.pScreen->UnrealizeWindow; - while (1) - { - if (pChild->firstChild) - { - pChild = pChild->firstChild; - continue; - } - while (1) - { - pParent = pChild->parent; - if (SubStrSend(pChild, pParent)) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = DestroyNotify; - event.u.destroyNotify.window = pChild->drawable.id; - DeliverEvents(pChild, &event, 1, NullWindow); - } - FreeResource(pChild->drawable.id, RT_WINDOW); - pSib = pChild->nextSib; - pChild->viewable = FALSE; - if (pChild->realized) - { - pChild->realized = FALSE; - (*UnrealizeWindow)(pChild); - } - FreeWindowResources(pChild); - dixFreeObjectWithPrivates(pChild, PRIVATE_WINDOW); - if ( (pChild = pSib) ) - break; - pChild = pParent; - pChild->firstChild = NullWindow; - pChild->lastChild = NullWindow; - if (pChild == pWin) - return; - } + while (1) { + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + while (1) { + pParent = pChild->parent; + if (SubStrSend(pChild, pParent)) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = DestroyNotify; + event.u.destroyNotify.window = pChild->drawable.id; + DeliverEvents(pChild, &event, 1, NullWindow); + } + FreeResource(pChild->drawable.id, RT_WINDOW); + pSib = pChild->nextSib; + pChild->viewable = FALSE; + if (pChild->realized) { + pChild->realized = FALSE; + (*UnrealizeWindow) (pChild); + } + FreeWindowResources(pChild); + dixFreeObjectWithPrivates(pChild, PRIVATE_WINDOW); + if ((pChild = pSib)) + break; + pChild = pParent; + pChild->firstChild = NullWindow; + pChild->lastChild = NullWindow; + if (pChild == pWin) + return; + } } } - + /***** * DeleteWindow * Deletes child of window then window itself @@ -999,9 +958,9 @@ CrushTree(WindowPtr pWin) int DeleteWindow(pointer value, XID wid) - { +{ WindowPtr pParent; - WindowPtr pWin = (WindowPtr)value; + WindowPtr pWin = (WindowPtr) value; xEvent event; UnmapWindow(pWin, FALSE); @@ -1009,28 +968,26 @@ DeleteWindow(pointer value, XID wid) CrushTree(pWin); pParent = pWin->parent; - if (wid && pParent && SubStrSend(pWin, pParent)) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = DestroyNotify; - event.u.destroyNotify.window = pWin->drawable.id; - DeliverEvents(pWin, &event, 1, NullWindow); + if (wid && pParent && SubStrSend(pWin, pParent)) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = DestroyNotify; + event.u.destroyNotify.window = pWin->drawable.id; + DeliverEvents(pWin, &event, 1, NullWindow); } FreeWindowResources(pWin); - if (pParent) - { - if (pParent->firstChild == pWin) - pParent->firstChild = pWin->nextSib; - if (pParent->lastChild == pWin) - pParent->lastChild = pWin->prevSib; - if (pWin->nextSib) - pWin->nextSib->prevSib = pWin->prevSib; - if (pWin->prevSib) - pWin->prevSib->nextSib = pWin->nextSib; + if (pParent) { + if (pParent->firstChild == pWin) + pParent->firstChild = pWin->nextSib; + if (pParent->lastChild == pWin) + pParent->lastChild = pWin->prevSib; + if (pWin->nextSib) + pWin->nextSib->prevSib = pWin->prevSib; + if (pWin->prevSib) + pWin->prevSib->nextSib = pWin->nextSib; } else - pWin->drawable.pScreen->root = NULL; + pWin->drawable.pScreen->root = NULL; dixFreeObjectWithPrivates(pWin, PRIVATE_WINDOW); return Success; } @@ -1048,12 +1005,13 @@ DestroySubwindows(WindowPtr pWin, ClientPtr client) */ UnmapSubwindows(pWin); while (pWin->lastChild) { - int rc = XaceHook(XACE_RESOURCE_ACCESS, client, - pWin->lastChild->drawable.id, RT_WINDOW, - pWin->lastChild, RT_NONE, NULL, DixDestroyAccess); - if (rc != Success) - return rc; - FreeResource(pWin->lastChild->drawable.id, RT_NONE); + int rc = XaceHook(XACE_RESOURCE_ACCESS, client, + pWin->lastChild->drawable.id, RT_WINDOW, + pWin->lastChild, RT_NONE, NULL, DixDestroyAccess); + + if (rc != Success) + return rc; + FreeResource(pWin->lastChild->drawable.id, RT_NONE); } return Success; } @@ -1064,18 +1022,18 @@ SetRootWindowBackground(WindowPtr pWin, ScreenPtr pScreen, Mask *index2) /* following the protocol: "Changing the background of a root window to * None or ParentRelative restores the default background pixmap" */ if (bgNoneRoot) { - pWin->backgroundState = XaceBackgroundNoneState(pWin); - pWin->background.pixel = pScreen->whitePixel; + pWin->backgroundState = XaceBackgroundNoneState(pWin); + pWin->background.pixel = pScreen->whitePixel; } else if (party_like_its_1989) - MakeRootTile(pWin); + MakeRootTile(pWin); else { pWin->backgroundState = BackgroundPixel; - if (whiteRoot) - pWin->background.pixel = pScreen->whitePixel; - else - pWin->background.pixel = pScreen->blackPixel; - *index2 = CWBackPixel; + if (whiteRoot) + pWin->background.pixel = pScreen->whitePixel; + else + pWin->background.pixel = pScreen->blackPixel; + *index2 = CWBackPixel; } } @@ -1086,7 +1044,7 @@ SetRootWindowBackground(WindowPtr pWin, ScreenPtr pScreen, Mask *index2) * value-list contains one value for each one bit in the mask, from least * to most significant bit in the mask. *****/ - + int ChangeWindowAttributes(WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client) { @@ -1097,7 +1055,7 @@ ChangeWindowAttributes(WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client) Cursor cursorID; WindowPtr pChild; Colormap cmap; - ColormapPtr pCmap; + ColormapPtr pCmap; xEvent xE; int error, rc; ScreenPtr pScreen; @@ -1105,568 +1063,523 @@ ChangeWindowAttributes(WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client) unsigned int val; Bool checkOptional = FALSE, borderRelative = FALSE; - if ((pWin->drawable.class == InputOnly) && (vmask & (~INPUTONLY_LEGAL_MASK))) - return BadMatch; + if ((pWin->drawable.class == InputOnly) && + (vmask & (~INPUTONLY_LEGAL_MASK))) + return BadMatch; error = Success; pScreen = pWin->drawable.pScreen; pVlist = vlist; tmask = vmask; - while (tmask) - { - index2 = (Mask) lowbit (tmask); - tmask &= ~index2; - switch (index2) - { - case CWBackPixmap: - pixID = (Pixmap )*pVlist; - pVlist++; - if (pWin->backgroundState == ParentRelative) - borderRelative = TRUE; - if (pixID == None) - { - if (pWin->backgroundState == BackgroundPixmap) - (*pScreen->DestroyPixmap)(pWin->background.pixmap); - if (!pWin->parent) - SetRootWindowBackground(pWin, pScreen, &index2); - else { - pWin->backgroundState = XaceBackgroundNoneState(pWin); - pWin->background.pixel = pScreen->whitePixel; - } - } - else if (pixID == ParentRelative) - { - if (pWin->parent && - pWin->drawable.depth != pWin->parent->drawable.depth) - { - error = BadMatch; - goto PatchUp; - } - if (pWin->backgroundState == BackgroundPixmap) - (*pScreen->DestroyPixmap)(pWin->background.pixmap); - if (!pWin->parent) - SetRootWindowBackground(pWin, pScreen, &index2); - else - pWin->backgroundState = ParentRelative; - borderRelative = TRUE; - /* Note that the parent's backgroundTile's refcnt is NOT - * incremented. */ - } - else - { - rc = dixLookupResourceByType((pointer *)&pPixmap, pixID, RT_PIXMAP, - client, DixReadAccess); - if (rc == Success) - { - if ((pPixmap->drawable.depth != pWin->drawable.depth) || - (pPixmap->drawable.pScreen != pScreen)) - { - error = BadMatch; - goto PatchUp; - } - if (pWin->backgroundState == BackgroundPixmap) - (*pScreen->DestroyPixmap)(pWin->background.pixmap); - pWin->backgroundState = BackgroundPixmap; - pWin->background.pixmap = pPixmap; - pPixmap->refcnt++; - } - else - { - error = rc; - client->errorValue = pixID; - goto PatchUp; - } - } - break; - case CWBackPixel: - if (pWin->backgroundState == ParentRelative) - borderRelative = TRUE; - if (pWin->backgroundState == BackgroundPixmap) - (*pScreen->DestroyPixmap)(pWin->background.pixmap); - pWin->backgroundState = BackgroundPixel; - pWin->background.pixel = (CARD32 ) *pVlist; - /* background pixel overrides background pixmap, - so don't let the ddx layer see both bits */ - vmaskCopy &= ~CWBackPixmap; - pVlist++; - break; - case CWBorderPixmap: - pixID = (Pixmap ) *pVlist; - pVlist++; - if (pixID == CopyFromParent) - { - if (!pWin->parent || - (pWin->drawable.depth != pWin->parent->drawable.depth)) - { - error = BadMatch; - goto PatchUp; - } - if (pWin->parent->borderIsPixel == TRUE) { - if (pWin->borderIsPixel == FALSE) - (*pScreen->DestroyPixmap)(pWin->border.pixmap); - pWin->border = pWin->parent->border; - pWin->borderIsPixel = TRUE; - index2 = CWBorderPixel; - break; - } - else - { - pixID = pWin->parent->border.pixmap->drawable.id; - } - } - rc = dixLookupResourceByType((pointer *)&pPixmap, pixID, RT_PIXMAP, - client, DixReadAccess); - if (rc == Success) - { - if ((pPixmap->drawable.depth != pWin->drawable.depth) || - (pPixmap->drawable.pScreen != pScreen)) - { - error = BadMatch; - goto PatchUp; - } - if (pWin->borderIsPixel == FALSE) - (*pScreen->DestroyPixmap)(pWin->border.pixmap); - pWin->borderIsPixel = FALSE; - pWin->border.pixmap = pPixmap; - pPixmap->refcnt++; - } - else - { - error = rc; - client->errorValue = pixID; - goto PatchUp; - } - break; - case CWBorderPixel: - if (pWin->borderIsPixel == FALSE) - (*pScreen->DestroyPixmap)(pWin->border.pixmap); - pWin->borderIsPixel = TRUE; - pWin->border.pixel = (CARD32) *pVlist; - /* border pixel overrides border pixmap, - so don't let the ddx layer see both bits */ - vmaskCopy &= ~CWBorderPixmap; - pVlist++; - break; - case CWBitGravity: - val = (CARD8 )*pVlist; - pVlist++; - if (val > StaticGravity) - { - error = BadValue; - client->errorValue = val; - goto PatchUp; - } - pWin->bitGravity = val; - break; - case CWWinGravity: - val = (CARD8 )*pVlist; - pVlist++; - if (val > StaticGravity) - { - error = BadValue; - client->errorValue = val; - goto PatchUp; - } - pWin->winGravity = val; - break; - case CWBackingStore: - val = (CARD8 )*pVlist; - pVlist++; - if ((val != NotUseful) && (val != WhenMapped) && (val != Always)) - { - error = BadValue; - client->errorValue = val; - goto PatchUp; - } - pWin->backingStore = val; - pWin->forcedBS = FALSE; - break; - case CWBackingPlanes: - if (pWin->optional || ((CARD32)*pVlist != (CARD32)~0L)) { - if (!pWin->optional && !MakeWindowOptional (pWin)) - { - error = BadAlloc; - goto PatchUp; - } - pWin->optional->backingBitPlanes = (CARD32) *pVlist; - if ((CARD32)*pVlist == (CARD32)~0L) - checkOptional = TRUE; - } - pVlist++; - break; - case CWBackingPixel: - if (pWin->optional || (CARD32) *pVlist) { - if (!pWin->optional && !MakeWindowOptional (pWin)) - { - error = BadAlloc; - goto PatchUp; - } - pWin->optional->backingPixel = (CARD32) *pVlist; - if (!*pVlist) - checkOptional = TRUE; - } - pVlist++; - break; - case CWSaveUnder: - val = (BOOL) *pVlist; - pVlist++; - if ((val != xTrue) && (val != xFalse)) - { - error = BadValue; - client->errorValue = val; - goto PatchUp; - } - pWin->saveUnder = val; - break; - case CWEventMask: - rc = EventSelectForWindow(pWin, client, (Mask )*pVlist); - if (rc) - { - error = rc; - goto PatchUp; - } - pVlist++; - break; - case CWDontPropagate: - rc = EventSuppressForWindow(pWin, client, (Mask )*pVlist, - &checkOptional); - if (rc) - { - error = rc; - goto PatchUp; - } - pVlist++; - break; - case CWOverrideRedirect: - val = (BOOL ) *pVlist; - pVlist++; - if ((val != xTrue) && (val != xFalse)) - { - error = BadValue; - client->errorValue = val; - goto PatchUp; - } - if (val == xTrue) { - rc = XaceHook(XACE_RESOURCE_ACCESS, client, pWin->drawable.id, - RT_WINDOW, pWin, RT_NONE, NULL, DixGrabAccess); - if (rc != Success) { - error = rc; - client->errorValue = pWin->drawable.id; - goto PatchUp; - } - } - pWin->overrideRedirect = val; - break; - case CWColormap: - cmap = (Colormap) *pVlist; - pVlist++; - if (cmap == CopyFromParent) - { - if (pWin->parent && - (!pWin->optional || - pWin->optional->visual == wVisual (pWin->parent))) - { - cmap = wColormap (pWin->parent); - } - else - cmap = None; - } - if (cmap == None) - { - error = BadMatch; - goto PatchUp; - } - rc = dixLookupResourceByType((pointer *)&pCmap, cmap, RT_COLORMAP, - client, DixUseAccess); - if (rc != Success) - { - error = rc; - client->errorValue = cmap; - goto PatchUp; - } - if (pCmap->pVisual->vid != wVisual (pWin) || - pCmap->pScreen != pScreen) - { - error = BadMatch; - goto PatchUp; - } - if (cmap != wColormap (pWin)) - { - if (!pWin->optional) - { - if (!MakeWindowOptional (pWin)) - { - error = BadAlloc; - goto PatchUp; - } - } - else if (pWin->parent && cmap == wColormap (pWin->parent)) - checkOptional = TRUE; - - /* - * propagate the original colormap to any children - * inheriting it - */ - - for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib) - { - if (!pChild->optional && !MakeWindowOptional (pChild)) - { - error = BadAlloc; - goto PatchUp; - } - } - - pWin->optional->colormap = cmap; - - /* - * check on any children now matching the new colormap - */ - - for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib) - { - if (pChild->optional->colormap == cmap) - CheckWindowOptionalNeed (pChild); - } - - xE.u.u.type = ColormapNotify; - xE.u.colormap.window = pWin->drawable.id; - xE.u.colormap.colormap = cmap; - xE.u.colormap.new = xTrue; - xE.u.colormap.state = IsMapInstalled(cmap, pWin); - DeliverEvents(pWin, &xE, 1, NullWindow); - } - break; - case CWCursor: - cursorID = (Cursor ) *pVlist; - pVlist++; - /* - * install the new - */ - if ( cursorID == None) - { - if (pWin == pWin->drawable.pScreen->root) - pCursor = rootCursor; - else - pCursor = (CursorPtr) None; - } - else - { - rc = dixLookupResourceByType((pointer *)&pCursor, cursorID, - RT_CURSOR, client, DixUseAccess); - if (rc != Success) - { - error = rc; - client->errorValue = cursorID; - goto PatchUp; - } - } - - if (pCursor != wCursor (pWin)) - { - /* - * patch up child windows so they don't lose cursors. - */ - - for (pChild = pWin->firstChild; pChild; pChild=pChild->nextSib) - { - if (!pChild->optional && !pChild->cursorIsNone && - !MakeWindowOptional (pChild)) - { - error = BadAlloc; - goto PatchUp; - } - } - - pOldCursor = 0; - if (pCursor == (CursorPtr) None) - { - pWin->cursorIsNone = TRUE; - if (pWin->optional) - { - pOldCursor = pWin->optional->cursor; - pWin->optional->cursor = (CursorPtr) None; - checkOptional = TRUE; - } - } else { - if (!pWin->optional) - { - if (!MakeWindowOptional (pWin)) - { - error = BadAlloc; - goto PatchUp; - } - } - else if (pWin->parent && pCursor == wCursor (pWin->parent)) - checkOptional = TRUE; - pOldCursor = pWin->optional->cursor; - pWin->optional->cursor = pCursor; - pCursor->refcnt++; - pWin->cursorIsNone = FALSE; - /* - * check on any children now matching the new cursor - */ - - for (pChild=pWin->firstChild; pChild; pChild=pChild->nextSib) - { - if (pChild->optional && - (pChild->optional->cursor == pCursor)) - CheckWindowOptionalNeed (pChild); - } - } - - if (pWin->realized) - WindowHasNewCursor( pWin); - - /* Can't free cursor until here - old cursor - * is needed in WindowHasNewCursor - */ - if (pOldCursor) - FreeCursor (pOldCursor, (Cursor)0); - } - break; - default: - error = BadValue; - client->errorValue = vmask; - goto PatchUp; - } - vmaskCopy |= index2; - } -PatchUp: + while (tmask) { + index2 = (Mask) lowbit(tmask); + tmask &= ~index2; + switch (index2) { + case CWBackPixmap: + pixID = (Pixmap) * pVlist; + pVlist++; + if (pWin->backgroundState == ParentRelative) + borderRelative = TRUE; + if (pixID == None) { + if (pWin->backgroundState == BackgroundPixmap) + (*pScreen->DestroyPixmap) (pWin->background.pixmap); + if (!pWin->parent) + SetRootWindowBackground(pWin, pScreen, &index2); + else { + pWin->backgroundState = XaceBackgroundNoneState(pWin); + pWin->background.pixel = pScreen->whitePixel; + } + } + else if (pixID == ParentRelative) { + if (pWin->parent && + pWin->drawable.depth != pWin->parent->drawable.depth) { + error = BadMatch; + goto PatchUp; + } + if (pWin->backgroundState == BackgroundPixmap) + (*pScreen->DestroyPixmap) (pWin->background.pixmap); + if (!pWin->parent) + SetRootWindowBackground(pWin, pScreen, &index2); + else + pWin->backgroundState = ParentRelative; + borderRelative = TRUE; + /* Note that the parent's backgroundTile's refcnt is NOT + * incremented. */ + } + else { + rc = dixLookupResourceByType((pointer *) &pPixmap, pixID, + RT_PIXMAP, client, DixReadAccess); + if (rc == Success) { + if ((pPixmap->drawable.depth != pWin->drawable.depth) || + (pPixmap->drawable.pScreen != pScreen)) { + error = BadMatch; + goto PatchUp; + } + if (pWin->backgroundState == BackgroundPixmap) + (*pScreen->DestroyPixmap) (pWin->background.pixmap); + pWin->backgroundState = BackgroundPixmap; + pWin->background.pixmap = pPixmap; + pPixmap->refcnt++; + } + else { + error = rc; + client->errorValue = pixID; + goto PatchUp; + } + } + break; + case CWBackPixel: + if (pWin->backgroundState == ParentRelative) + borderRelative = TRUE; + if (pWin->backgroundState == BackgroundPixmap) + (*pScreen->DestroyPixmap) (pWin->background.pixmap); + pWin->backgroundState = BackgroundPixel; + pWin->background.pixel = (CARD32) *pVlist; + /* background pixel overrides background pixmap, + so don't let the ddx layer see both bits */ + vmaskCopy &= ~CWBackPixmap; + pVlist++; + break; + case CWBorderPixmap: + pixID = (Pixmap) * pVlist; + pVlist++; + if (pixID == CopyFromParent) { + if (!pWin->parent || + (pWin->drawable.depth != pWin->parent->drawable.depth)) { + error = BadMatch; + goto PatchUp; + } + if (pWin->parent->borderIsPixel == TRUE) { + if (pWin->borderIsPixel == FALSE) + (*pScreen->DestroyPixmap) (pWin->border.pixmap); + pWin->border = pWin->parent->border; + pWin->borderIsPixel = TRUE; + index2 = CWBorderPixel; + break; + } + else { + pixID = pWin->parent->border.pixmap->drawable.id; + } + } + rc = dixLookupResourceByType((pointer *) &pPixmap, pixID, RT_PIXMAP, + client, DixReadAccess); + if (rc == Success) { + if ((pPixmap->drawable.depth != pWin->drawable.depth) || + (pPixmap->drawable.pScreen != pScreen)) { + error = BadMatch; + goto PatchUp; + } + if (pWin->borderIsPixel == FALSE) + (*pScreen->DestroyPixmap) (pWin->border.pixmap); + pWin->borderIsPixel = FALSE; + pWin->border.pixmap = pPixmap; + pPixmap->refcnt++; + } + else { + error = rc; + client->errorValue = pixID; + goto PatchUp; + } + break; + case CWBorderPixel: + if (pWin->borderIsPixel == FALSE) + (*pScreen->DestroyPixmap) (pWin->border.pixmap); + pWin->borderIsPixel = TRUE; + pWin->border.pixel = (CARD32) *pVlist; + /* border pixel overrides border pixmap, + so don't let the ddx layer see both bits */ + vmaskCopy &= ~CWBorderPixmap; + pVlist++; + break; + case CWBitGravity: + val = (CARD8) *pVlist; + pVlist++; + if (val > StaticGravity) { + error = BadValue; + client->errorValue = val; + goto PatchUp; + } + pWin->bitGravity = val; + break; + case CWWinGravity: + val = (CARD8) *pVlist; + pVlist++; + if (val > StaticGravity) { + error = BadValue; + client->errorValue = val; + goto PatchUp; + } + pWin->winGravity = val; + break; + case CWBackingStore: + val = (CARD8) *pVlist; + pVlist++; + if ((val != NotUseful) && (val != WhenMapped) && (val != Always)) { + error = BadValue; + client->errorValue = val; + goto PatchUp; + } + pWin->backingStore = val; + pWin->forcedBS = FALSE; + break; + case CWBackingPlanes: + if (pWin->optional || ((CARD32) *pVlist != (CARD32) ~0L)) { + if (!pWin->optional && !MakeWindowOptional(pWin)) { + error = BadAlloc; + goto PatchUp; + } + pWin->optional->backingBitPlanes = (CARD32) *pVlist; + if ((CARD32) *pVlist == (CARD32) ~0L) + checkOptional = TRUE; + } + pVlist++; + break; + case CWBackingPixel: + if (pWin->optional || (CARD32) *pVlist) { + if (!pWin->optional && !MakeWindowOptional(pWin)) { + error = BadAlloc; + goto PatchUp; + } + pWin->optional->backingPixel = (CARD32) *pVlist; + if (!*pVlist) + checkOptional = TRUE; + } + pVlist++; + break; + case CWSaveUnder: + val = (BOOL) * pVlist; + pVlist++; + if ((val != xTrue) && (val != xFalse)) { + error = BadValue; + client->errorValue = val; + goto PatchUp; + } + pWin->saveUnder = val; + break; + case CWEventMask: + rc = EventSelectForWindow(pWin, client, (Mask) *pVlist); + if (rc) { + error = rc; + goto PatchUp; + } + pVlist++; + break; + case CWDontPropagate: + rc = EventSuppressForWindow(pWin, client, (Mask) *pVlist, + &checkOptional); + if (rc) { + error = rc; + goto PatchUp; + } + pVlist++; + break; + case CWOverrideRedirect: + val = (BOOL) * pVlist; + pVlist++; + if ((val != xTrue) && (val != xFalse)) { + error = BadValue; + client->errorValue = val; + goto PatchUp; + } + if (val == xTrue) { + rc = XaceHook(XACE_RESOURCE_ACCESS, client, pWin->drawable.id, + RT_WINDOW, pWin, RT_NONE, NULL, DixGrabAccess); + if (rc != Success) { + error = rc; + client->errorValue = pWin->drawable.id; + goto PatchUp; + } + } + pWin->overrideRedirect = val; + break; + case CWColormap: + cmap = (Colormap) * pVlist; + pVlist++; + if (cmap == CopyFromParent) { + if (pWin->parent && + (!pWin->optional || + pWin->optional->visual == wVisual(pWin->parent))) { + cmap = wColormap(pWin->parent); + } + else + cmap = None; + } + if (cmap == None) { + error = BadMatch; + goto PatchUp; + } + rc = dixLookupResourceByType((pointer *) &pCmap, cmap, RT_COLORMAP, + client, DixUseAccess); + if (rc != Success) { + error = rc; + client->errorValue = cmap; + goto PatchUp; + } + if (pCmap->pVisual->vid != wVisual(pWin) || + pCmap->pScreen != pScreen) { + error = BadMatch; + goto PatchUp; + } + if (cmap != wColormap(pWin)) { + if (!pWin->optional) { + if (!MakeWindowOptional(pWin)) { + error = BadAlloc; + goto PatchUp; + } + } + else if (pWin->parent && cmap == wColormap(pWin->parent)) + checkOptional = TRUE; + + /* + * propagate the original colormap to any children + * inheriting it + */ + + for (pChild = pWin->firstChild; pChild; + pChild = pChild->nextSib) { + if (!pChild->optional && !MakeWindowOptional(pChild)) { + error = BadAlloc; + goto PatchUp; + } + } + + pWin->optional->colormap = cmap; + + /* + * check on any children now matching the new colormap + */ + + for (pChild = pWin->firstChild; pChild; + pChild = pChild->nextSib) { + if (pChild->optional->colormap == cmap) + CheckWindowOptionalNeed(pChild); + } + + xE.u.u.type = ColormapNotify; + xE.u.colormap.window = pWin->drawable.id; + xE.u.colormap.colormap = cmap; + xE.u.colormap.new = xTrue; + xE.u.colormap.state = IsMapInstalled(cmap, pWin); + DeliverEvents(pWin, &xE, 1, NullWindow); + } + break; + case CWCursor: + cursorID = (Cursor) * pVlist; + pVlist++; + /* + * install the new + */ + if (cursorID == None) { + if (pWin == pWin->drawable.pScreen->root) + pCursor = rootCursor; + else + pCursor = (CursorPtr) None; + } + else { + rc = dixLookupResourceByType((pointer *) &pCursor, cursorID, + RT_CURSOR, client, DixUseAccess); + if (rc != Success) { + error = rc; + client->errorValue = cursorID; + goto PatchUp; + } + } + + if (pCursor != wCursor(pWin)) { + /* + * patch up child windows so they don't lose cursors. + */ + + for (pChild = pWin->firstChild; pChild; + pChild = pChild->nextSib) { + if (!pChild->optional && !pChild->cursorIsNone && + !MakeWindowOptional(pChild)) { + error = BadAlloc; + goto PatchUp; + } + } + + pOldCursor = 0; + if (pCursor == (CursorPtr) None) { + pWin->cursorIsNone = TRUE; + if (pWin->optional) { + pOldCursor = pWin->optional->cursor; + pWin->optional->cursor = (CursorPtr) None; + checkOptional = TRUE; + } + } + else { + if (!pWin->optional) { + if (!MakeWindowOptional(pWin)) { + error = BadAlloc; + goto PatchUp; + } + } + else if (pWin->parent && pCursor == wCursor(pWin->parent)) + checkOptional = TRUE; + pOldCursor = pWin->optional->cursor; + pWin->optional->cursor = pCursor; + pCursor->refcnt++; + pWin->cursorIsNone = FALSE; + /* + * check on any children now matching the new cursor + */ + + for (pChild = pWin->firstChild; pChild; + pChild = pChild->nextSib) { + if (pChild->optional && + (pChild->optional->cursor == pCursor)) + CheckWindowOptionalNeed(pChild); + } + } + + if (pWin->realized) + WindowHasNewCursor(pWin); + + /* Can't free cursor until here - old cursor + * is needed in WindowHasNewCursor + */ + if (pOldCursor) + FreeCursor(pOldCursor, (Cursor) 0); + } + break; + default: + error = BadValue; + client->errorValue = vmask; + goto PatchUp; + } + vmaskCopy |= index2; + } + PatchUp: if (checkOptional) - CheckWindowOptionalNeed (pWin); + CheckWindowOptionalNeed(pWin); - /* We SHOULD check for an error value here XXX */ - (*pScreen->ChangeWindowAttributes)(pWin, vmaskCopy); + /* We SHOULD check for an error value here XXX */ + (*pScreen->ChangeWindowAttributes) (pWin, vmaskCopy); /* - If the border contents have changed, redraw the border. - Note that this has to be done AFTER pScreen->ChangeWindowAttributes - for the tile to be rotated, and the correct function selected. - */ + If the border contents have changed, redraw the border. + Note that this has to be done AFTER pScreen->ChangeWindowAttributes + for the tile to be rotated, and the correct function selected. + */ if (((vmaskCopy & (CWBorderPixel | CWBorderPixmap)) || borderRelative) - && pWin->viewable && HasBorder (pWin)) - { - RegionRec exposed; + && pWin->viewable && HasBorder(pWin)) { + RegionRec exposed; - RegionNull(&exposed); - RegionSubtract(&exposed, &pWin->borderClip, &pWin->winSize); - miPaintWindow(pWin, &exposed, PW_BORDER); - RegionUninit(&exposed); + RegionNull(&exposed); + RegionSubtract(&exposed, &pWin->borderClip, &pWin->winSize); + miPaintWindow(pWin, &exposed, PW_BORDER); + RegionUninit(&exposed); } return error; } - /***** * GetWindowAttributes * Notice that this is different than ChangeWindowAttributes *****/ void -GetWindowAttributes(WindowPtr pWin, ClientPtr client, xGetWindowAttributesReply *wa) +GetWindowAttributes(WindowPtr pWin, ClientPtr client, + xGetWindowAttributesReply * wa) { wa->type = X_Reply; wa->bitGravity = pWin->bitGravity; wa->winGravity = pWin->winGravity; if (pWin->forcedBS && pWin->backingStore != Always) - wa->backingStore = NotUseful; + wa->backingStore = NotUseful; else - wa->backingStore = pWin->backingStore; + wa->backingStore = pWin->backingStore; wa->length = bytes_to_int32(sizeof(xGetWindowAttributesReply) - - sizeof(xGenericReply)); + sizeof(xGenericReply)); wa->sequenceNumber = client->sequence; - wa->backingBitPlanes = wBackingBitPlanes (pWin); - wa->backingPixel = wBackingPixel (pWin); - wa->saveUnder = (BOOL)pWin->saveUnder; + wa->backingBitPlanes = wBackingBitPlanes(pWin); + wa->backingPixel = wBackingPixel(pWin); + wa->saveUnder = (BOOL) pWin->saveUnder; wa->override = pWin->overrideRedirect; if (!pWin->mapped) - wa->mapState = IsUnmapped; + wa->mapState = IsUnmapped; else if (pWin->realized) - wa->mapState = IsViewable; + wa->mapState = IsViewable; else - wa->mapState = IsUnviewable; + wa->mapState = IsUnviewable; - wa->colormap = wColormap (pWin); + wa->colormap = wColormap(pWin); wa->mapInstalled = (wa->colormap == None) ? xFalse - : IsMapInstalled(wa->colormap, pWin); + : IsMapInstalled(wa->colormap, pWin); wa->yourEventMask = EventMaskForClient(pWin, client); - wa->allEventMasks = pWin->eventMask | wOtherEventMasks (pWin); - wa->doNotPropagateMask = wDontPropagateMask (pWin); + wa->allEventMasks = pWin->eventMask | wOtherEventMasks(pWin); + wa->doNotPropagateMask = wDontPropagateMask(pWin); wa->class = pWin->drawable.class; - wa->visualID = wVisual (pWin); + wa->visualID = wVisual(pWin); } - WindowPtr MoveWindowInStack(WindowPtr pWin, WindowPtr pNextSib) { WindowPtr pParent = pWin->parent; - WindowPtr pFirstChange = pWin; /* highest window where list changes */ + WindowPtr pFirstChange = pWin; /* highest window where list changes */ + + if (pWin->nextSib != pNextSib) { + WindowPtr pOldNextSib = pWin->nextSib; + + if (!pNextSib) { /* move to bottom */ + if (pParent->firstChild == pWin) + pParent->firstChild = pWin->nextSib; + /* if (pWin->nextSib) *//* is always True: pNextSib == NULL + * and pWin->nextSib != pNextSib + * therefore pWin->nextSib != NULL */ + pFirstChange = pWin->nextSib; + pWin->nextSib->prevSib = pWin->prevSib; + if (pWin->prevSib) + pWin->prevSib->nextSib = pWin->nextSib; + pParent->lastChild->nextSib = pWin; + pWin->prevSib = pParent->lastChild; + pWin->nextSib = NullWindow; + pParent->lastChild = pWin; + } + else if (pParent->firstChild == pNextSib) { /* move to top */ + pFirstChange = pWin; + if (pParent->lastChild == pWin) + pParent->lastChild = pWin->prevSib; + if (pWin->nextSib) + pWin->nextSib->prevSib = pWin->prevSib; + if (pWin->prevSib) + pWin->prevSib->nextSib = pWin->nextSib; + pWin->nextSib = pParent->firstChild; + pWin->prevSib = (WindowPtr) NULL; + pNextSib->prevSib = pWin; + pParent->firstChild = pWin; + } + else { /* move in middle of list */ - if (pWin->nextSib != pNextSib) - { - WindowPtr pOldNextSib = pWin->nextSib; - - if (!pNextSib) /* move to bottom */ - { - if (pParent->firstChild == pWin) - pParent->firstChild = pWin->nextSib; - /* if (pWin->nextSib) */ /* is always True: pNextSib == NULL - * and pWin->nextSib != pNextSib - * therefore pWin->nextSib != NULL */ - pFirstChange = pWin->nextSib; - pWin->nextSib->prevSib = pWin->prevSib; - if (pWin->prevSib) - pWin->prevSib->nextSib = pWin->nextSib; - pParent->lastChild->nextSib = pWin; - pWin->prevSib = pParent->lastChild; - pWin->nextSib = NullWindow; - pParent->lastChild = pWin; - } - else if (pParent->firstChild == pNextSib) /* move to top */ - { - pFirstChange = pWin; - if (pParent->lastChild == pWin) - pParent->lastChild = pWin->prevSib; - if (pWin->nextSib) - pWin->nextSib->prevSib = pWin->prevSib; - if (pWin->prevSib) - pWin->prevSib->nextSib = pWin->nextSib; - pWin->nextSib = pParent->firstChild; - pWin->prevSib = (WindowPtr ) NULL; - pNextSib->prevSib = pWin; - pParent->firstChild = pWin; - } - else /* move in middle of list */ - { - WindowPtr pOldNext = pWin->nextSib; - - pFirstChange = NullWindow; - if (pParent->firstChild == pWin) - pFirstChange = pParent->firstChild = pWin->nextSib; - if (pParent->lastChild == pWin) { - pFirstChange = pWin; - pParent->lastChild = pWin->prevSib; - } - if (pWin->nextSib) - pWin->nextSib->prevSib = pWin->prevSib; - if (pWin->prevSib) - pWin->prevSib->nextSib = pWin->nextSib; - pWin->nextSib = pNextSib; - pWin->prevSib = pNextSib->prevSib; - if (pNextSib->prevSib) - pNextSib->prevSib->nextSib = pWin; - pNextSib->prevSib = pWin; - if (!pFirstChange) { /* do we know it yet? */ - pFirstChange = pParent->firstChild; /* no, search from top */ - while ((pFirstChange != pWin) && (pFirstChange != pOldNext)) - pFirstChange = pFirstChange->nextSib; - } - } - if(pWin->drawable.pScreen->RestackWindow) - (*pWin->drawable.pScreen->RestackWindow)(pWin, pOldNextSib); + WindowPtr pOldNext = pWin->nextSib; + + pFirstChange = NullWindow; + if (pParent->firstChild == pWin) + pFirstChange = pParent->firstChild = pWin->nextSib; + if (pParent->lastChild == pWin) { + pFirstChange = pWin; + pParent->lastChild = pWin->prevSib; + } + if (pWin->nextSib) + pWin->nextSib->prevSib = pWin->prevSib; + if (pWin->prevSib) + pWin->prevSib->nextSib = pWin->nextSib; + pWin->nextSib = pNextSib; + pWin->prevSib = pNextSib->prevSib; + if (pNextSib->prevSib) + pNextSib->prevSib->nextSib = pWin; + pNextSib->prevSib = pWin; + if (!pFirstChange) { /* do we know it yet? */ + pFirstChange = pParent->firstChild; /* no, search from top */ + while ((pFirstChange != pWin) && (pFirstChange != pOldNext)) + pFirstChange = pFirstChange->nextSib; + } + } + if (pWin->drawable.pScreen->RestackWindow) + (*pWin->drawable.pScreen->RestackWindow) (pWin, pOldNextSib); } #ifdef ROOTLESS @@ -1677,90 +1590,85 @@ MoveWindowInStack(WindowPtr pWin, WindowPtr pNextSib) * the underlying window system may want to reorder it. */ else if (pWin->drawable.pScreen->RestackWindow) - (*pWin->drawable.pScreen->RestackWindow)(pWin, pWin->nextSib); + (*pWin->drawable.pScreen->RestackWindow) (pWin, pWin->nextSib); #endif return pFirstChange; } void -SetWinSize (WindowPtr pWin) +SetWinSize(WindowPtr pWin) { #ifdef COMPOSITE - if (pWin->redirectDraw != RedirectDrawNone) - { - BoxRec box; - - /* - * Redirected clients get clip list equal to their - * own geometry, not clipped to their parent - */ - box.x1 = pWin->drawable.x; - box.y1 = pWin->drawable.y; - box.x2 = pWin->drawable.x + pWin->drawable.width; - box.y2 = pWin->drawable.y + pWin->drawable.height; - RegionReset(&pWin->winSize, &box); + if (pWin->redirectDraw != RedirectDrawNone) { + BoxRec box; + + /* + * Redirected clients get clip list equal to their + * own geometry, not clipped to their parent + */ + box.x1 = pWin->drawable.x; + box.y1 = pWin->drawable.y; + box.x2 = pWin->drawable.x + pWin->drawable.width; + box.y2 = pWin->drawable.y + pWin->drawable.height; + RegionReset(&pWin->winSize, &box); } else #endif - ClippedRegionFromBox(pWin->parent, &pWin->winSize, - pWin->drawable.x, pWin->drawable.y, - (int)pWin->drawable.width, - (int)pWin->drawable.height); - if (wBoundingShape (pWin) || wClipShape (pWin)) { - RegionTranslate(&pWin->winSize, - pWin->drawable.x, - - pWin->drawable.y); - if (wBoundingShape (pWin)) - RegionIntersect(&pWin->winSize, &pWin->winSize, - wBoundingShape (pWin)); - if (wClipShape (pWin)) - RegionIntersect(&pWin->winSize, &pWin->winSize, - wClipShape (pWin)); - RegionTranslate(&pWin->winSize, pWin->drawable.x, - pWin->drawable.y); + ClippedRegionFromBox(pWin->parent, &pWin->winSize, + pWin->drawable.x, pWin->drawable.y, + (int) pWin->drawable.width, + (int) pWin->drawable.height); + if (wBoundingShape(pWin) || wClipShape(pWin)) { + RegionTranslate(&pWin->winSize, -pWin->drawable.x, -pWin->drawable.y); + if (wBoundingShape(pWin)) + RegionIntersect(&pWin->winSize, &pWin->winSize, + wBoundingShape(pWin)); + if (wClipShape(pWin)) + RegionIntersect(&pWin->winSize, &pWin->winSize, wClipShape(pWin)); + RegionTranslate(&pWin->winSize, pWin->drawable.x, pWin->drawable.y); } } void -SetBorderSize (WindowPtr pWin) +SetBorderSize(WindowPtr pWin) { - int bw; + int bw; - if (HasBorder (pWin)) { - bw = wBorderWidth (pWin); + if (HasBorder(pWin)) { + bw = wBorderWidth(pWin); #ifdef COMPOSITE - if (pWin->redirectDraw != RedirectDrawNone) - { - BoxRec box; - - /* - * Redirected clients get clip list equal to their - * own geometry, not clipped to their parent - */ - box.x1 = pWin->drawable.x - bw; - box.y1 = pWin->drawable.y - bw; - box.x2 = pWin->drawable.x + pWin->drawable.width + bw; - box.y2 = pWin->drawable.y + pWin->drawable.height + bw; - RegionReset(&pWin->borderSize, &box); - } - else + if (pWin->redirectDraw != RedirectDrawNone) { + BoxRec box; + + /* + * Redirected clients get clip list equal to their + * own geometry, not clipped to their parent + */ + box.x1 = pWin->drawable.x - bw; + box.y1 = pWin->drawable.y - bw; + box.x2 = pWin->drawable.x + pWin->drawable.width + bw; + box.y2 = pWin->drawable.y + pWin->drawable.height + bw; + RegionReset(&pWin->borderSize, &box); + } + else #endif - ClippedRegionFromBox(pWin->parent, &pWin->borderSize, - pWin->drawable.x - bw, pWin->drawable.y - bw, - (int)(pWin->drawable.width + (bw<<1)), - (int)(pWin->drawable.height + (bw<<1))); - if (wBoundingShape (pWin)) { - RegionTranslate(&pWin->borderSize, - pWin->drawable.x, - - pWin->drawable.y); - RegionIntersect(&pWin->borderSize, &pWin->borderSize, - wBoundingShape (pWin)); - RegionTranslate(&pWin->borderSize, pWin->drawable.x, - pWin->drawable.y); - RegionUnion(&pWin->borderSize, &pWin->borderSize, - &pWin->winSize); - } - } else { - RegionCopy(&pWin->borderSize, &pWin->winSize); + ClippedRegionFromBox(pWin->parent, &pWin->borderSize, + pWin->drawable.x - bw, pWin->drawable.y - bw, + (int) (pWin->drawable.width + (bw << 1)), + (int) (pWin->drawable.height + (bw << 1))); + if (wBoundingShape(pWin)) { + RegionTranslate(&pWin->borderSize, -pWin->drawable.x, + -pWin->drawable.y); + RegionIntersect(&pWin->borderSize, &pWin->borderSize, + wBoundingShape(pWin)); + RegionTranslate(&pWin->borderSize, pWin->drawable.x, + pWin->drawable.y); + RegionUnion(&pWin->borderSize, &pWin->borderSize, &pWin->winSize); + } + } + else { + RegionCopy(&pWin->borderSize, &pWin->winSize); } } @@ -1772,51 +1680,50 @@ SetBorderSize (WindowPtr pWin) */ void -GravityTranslate (int x, int y, int oldx, int oldy, - int dw, int dh, unsigned gravity, - int *destx, int *desty) +GravityTranslate(int x, int y, int oldx, int oldy, + int dw, int dh, unsigned gravity, int *destx, int *desty) { switch (gravity) { case NorthGravity: - *destx = x + dw / 2; - *desty = y; - break; + *destx = x + dw / 2; + *desty = y; + break; case NorthEastGravity: - *destx = x + dw; - *desty = y; - break; + *destx = x + dw; + *desty = y; + break; case WestGravity: - *destx = x; - *desty = y + dh / 2; - break; + *destx = x; + *desty = y + dh / 2; + break; case CenterGravity: - *destx = x + dw / 2; - *desty = y + dh / 2; - break; + *destx = x + dw / 2; + *desty = y + dh / 2; + break; case EastGravity: - *destx = x + dw; - *desty = y + dh / 2; - break; + *destx = x + dw; + *desty = y + dh / 2; + break; case SouthWestGravity: - *destx = x; - *desty = y + dh; - break; + *destx = x; + *desty = y + dh; + break; case SouthGravity: - *destx = x + dw / 2; - *desty = y + dh; - break; + *destx = x + dw / 2; + *desty = y + dh; + break; case SouthEastGravity: - *destx = x + dw; - *desty = y + dh; - break; + *destx = x + dw; + *desty = y + dh; + break; case StaticGravity: - *destx = oldx; - *desty = oldy; - break; + *destx = oldx; + *desty = oldy; + break; default: - *destx = x; - *desty = y; - break; + *destx = x; + *desty = y; + break; } } @@ -1830,59 +1737,54 @@ ResizeChildrenWinSize(WindowPtr pWin, int dx, int dy, int dw, int dh) pScreen = pWin->drawable.pScreen; - for (pSib = pWin->firstChild; pSib; pSib = pSib->nextSib) - { - if (resized && (pSib->winGravity > NorthWestGravity)) - { - int cwsx, cwsy; - - cwsx = pSib->origin.x; - cwsy = pSib->origin.y; - GravityTranslate (cwsx, cwsy, cwsx - dx, cwsy - dy, dw, dh, - pSib->winGravity, &cwsx, &cwsy); - if (cwsx != pSib->origin.x || cwsy != pSib->origin.y) - { - xEvent event; - - event.u.u.type = GravityNotify; - event.u.gravity.window = pSib->drawable.id; - event.u.gravity.x = cwsx - wBorderWidth (pSib); - event.u.gravity.y = cwsy - wBorderWidth (pSib); - DeliverEvents (pSib, &event, 1, NullWindow); - pSib->origin.x = cwsx; - pSib->origin.y = cwsy; - } - } - pSib->drawable.x = pWin->drawable.x + pSib->origin.x; - pSib->drawable.y = pWin->drawable.y + pSib->origin.y; - SetWinSize (pSib); - SetBorderSize (pSib); - (*pScreen->PositionWindow)(pSib, pSib->drawable.x, pSib->drawable.y); - - if ( (pChild = pSib->firstChild) ) - { - while (1) - { - pChild->drawable.x = pChild->parent->drawable.x + - pChild->origin.x; - pChild->drawable.y = pChild->parent->drawable.y + - pChild->origin.y; - SetWinSize (pChild); - SetBorderSize (pChild); - (*pScreen->PositionWindow)(pChild, - pChild->drawable.x, pChild->drawable.y); - if (pChild->firstChild) - { - pChild = pChild->firstChild; - continue; - } - while (!pChild->nextSib && (pChild != pSib)) - pChild = pChild->parent; - if (pChild == pSib) - break; - pChild = pChild->nextSib; - } - } + for (pSib = pWin->firstChild; pSib; pSib = pSib->nextSib) { + if (resized && (pSib->winGravity > NorthWestGravity)) { + int cwsx, cwsy; + + cwsx = pSib->origin.x; + cwsy = pSib->origin.y; + GravityTranslate(cwsx, cwsy, cwsx - dx, cwsy - dy, dw, dh, + pSib->winGravity, &cwsx, &cwsy); + if (cwsx != pSib->origin.x || cwsy != pSib->origin.y) { + xEvent event; + + event.u.u.type = GravityNotify; + event.u.gravity.window = pSib->drawable.id; + event.u.gravity.x = cwsx - wBorderWidth(pSib); + event.u.gravity.y = cwsy - wBorderWidth(pSib); + DeliverEvents(pSib, &event, 1, NullWindow); + pSib->origin.x = cwsx; + pSib->origin.y = cwsy; + } + } + pSib->drawable.x = pWin->drawable.x + pSib->origin.x; + pSib->drawable.y = pWin->drawable.y + pSib->origin.y; + SetWinSize(pSib); + SetBorderSize(pSib); + (*pScreen->PositionWindow) (pSib, pSib->drawable.x, pSib->drawable.y); + + if ((pChild = pSib->firstChild)) { + while (1) { + pChild->drawable.x = pChild->parent->drawable.x + + pChild->origin.x; + pChild->drawable.y = pChild->parent->drawable.y + + pChild->origin.y; + SetWinSize(pChild); + SetBorderSize(pChild); + (*pScreen->PositionWindow) (pChild, + pChild->drawable.x, + pChild->drawable.y); + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + while (!pChild->nextSib && (pChild != pSib)) + pChild = pChild->parent; + if (pChild == pSib) + break; + pChild = pChild->nextSib; + } + } } } @@ -1916,68 +1818,58 @@ ResizeChildrenWinSize(WindowPtr pWin, int dx, int dy, int dw, int dh) */ static int -IsSiblingAboveMe( - WindowPtr pMe, - WindowPtr pSib) +IsSiblingAboveMe(WindowPtr pMe, WindowPtr pSib) { WindowPtr pWin; pWin = pMe->parent->firstChild; - while (pWin) - { - if (pWin == pSib) - return Above; - else if (pWin == pMe) - return Below; - pWin = pWin->nextSib; + while (pWin) { + if (pWin == pSib) + return Above; + else if (pWin == pMe) + return Below; + pWin = pWin->nextSib; } return Below; } static BoxPtr -WindowExtents( - WindowPtr pWin, - BoxPtr pBox) +WindowExtents(WindowPtr pWin, BoxPtr pBox) { - pBox->x1 = pWin->drawable.x - wBorderWidth (pWin); - pBox->y1 = pWin->drawable.y - wBorderWidth (pWin); - pBox->x2 = pWin->drawable.x + (int)pWin->drawable.width - + wBorderWidth (pWin); - pBox->y2 = pWin->drawable.y + (int)pWin->drawable.height - + wBorderWidth (pWin); + pBox->x1 = pWin->drawable.x - wBorderWidth(pWin); + pBox->y1 = pWin->drawable.y - wBorderWidth(pWin); + pBox->x2 = pWin->drawable.x + (int) pWin->drawable.width + + wBorderWidth(pWin); + pBox->y2 = pWin->drawable.y + (int) pWin->drawable.height + + wBorderWidth(pWin); return pBox; } #define IS_SHAPED(pWin) (wBoundingShape (pWin) != (RegionPtr) NULL) static RegionPtr -MakeBoundingRegion ( - WindowPtr pWin, - BoxPtr pBox) +MakeBoundingRegion(WindowPtr pWin, BoxPtr pBox) { - RegionPtr pRgn = RegionCreate(pBox, 1); - if (wBoundingShape (pWin)) { - RegionTranslate(pRgn, -pWin->origin.x, -pWin->origin.y); - RegionIntersect(pRgn, pRgn, wBoundingShape (pWin)); - RegionTranslate(pRgn, pWin->origin.x, pWin->origin.y); + RegionPtr pRgn = RegionCreate(pBox, 1); + + if (wBoundingShape(pWin)) { + RegionTranslate(pRgn, -pWin->origin.x, -pWin->origin.y); + RegionIntersect(pRgn, pRgn, wBoundingShape(pWin)); + RegionTranslate(pRgn, pWin->origin.x, pWin->origin.y); } return pRgn; } static Bool -ShapeOverlap ( - WindowPtr pWin, - BoxPtr pWinBox, - WindowPtr pSib, - BoxPtr pSibBox) +ShapeOverlap(WindowPtr pWin, BoxPtr pWinBox, WindowPtr pSib, BoxPtr pSibBox) { - RegionPtr pWinRgn, pSibRgn; - Bool ret; + RegionPtr pWinRgn, pSibRgn; + Bool ret; if (!IS_SHAPED(pWin) && !IS_SHAPED(pSib)) - return TRUE; - pWinRgn = MakeBoundingRegion (pWin, pWinBox); - pSibRgn = MakeBoundingRegion (pSib, pSibBox); + return TRUE; + pWinRgn = MakeBoundingRegion(pWin, pWinBox); + pSibRgn = MakeBoundingRegion(pSib, pSibBox); RegionIntersect(pWinRgn, pWinRgn, pSibRgn); ret = RegionNotEmpty(pWinRgn); RegionDestroy(pWinRgn); @@ -1986,48 +1878,39 @@ ShapeOverlap ( } static Bool -AnyWindowOverlapsMe( - WindowPtr pWin, - WindowPtr pHead, - BoxPtr box) +AnyWindowOverlapsMe(WindowPtr pWin, WindowPtr pHead, BoxPtr box) { WindowPtr pSib; BoxRec sboxrec; BoxPtr sbox; - for (pSib = pWin->prevSib; pSib != pHead; pSib = pSib->prevSib) - { - if (pSib->mapped) - { - sbox = WindowExtents(pSib, &sboxrec); - if (BOXES_OVERLAP(sbox, box) - && ShapeOverlap (pWin, box, pSib, sbox) - ) - return TRUE; - } + for (pSib = pWin->prevSib; pSib != pHead; pSib = pSib->prevSib) { + if (pSib->mapped) { + sbox = WindowExtents(pSib, &sboxrec); + if (BOXES_OVERLAP(sbox, box) + && ShapeOverlap(pWin, box, pSib, sbox) + ) + return TRUE; + } } return FALSE; } static Bool -IOverlapAnyWindow( - WindowPtr pWin, - BoxPtr box) +IOverlapAnyWindow(WindowPtr pWin, BoxPtr box) { WindowPtr pSib; BoxRec sboxrec; BoxPtr sbox; - for (pSib = pWin->nextSib; pSib; pSib = pSib->nextSib) - { - if (pSib->mapped) - { - sbox = WindowExtents(pSib, &sboxrec); - if (BOXES_OVERLAP(sbox, box) - && ShapeOverlap (pWin, box, pSib, sbox) - ) - return TRUE; - } + for (pSib = pWin->nextSib; pSib; pSib = pSib->nextSib) { + if (pSib->mapped) { + sbox = WindowExtents(pSib, &sboxrec); + if (BOXES_OVERLAP(sbox, box) + && ShapeOverlap(pWin, box, pSib, sbox) + ) + return TRUE; + } } return FALSE; } @@ -2061,144 +1944,130 @@ IOverlapAnyWindow( */ static WindowPtr -WhereDoIGoInTheStack( - WindowPtr pWin, - WindowPtr pSib, - short x, - short y, - unsigned short w, - unsigned short h, - int smode) +WhereDoIGoInTheStack(WindowPtr pWin, + WindowPtr pSib, + short x, + short y, unsigned short w, unsigned short h, int smode) { BoxRec box; WindowPtr pHead, pFirst; - if ((pWin == pWin->parent->firstChild) && - (pWin == pWin->parent->lastChild)) - return((WindowPtr ) NULL); + if ((pWin == pWin->parent->firstChild) && (pWin == pWin->parent->lastChild)) + return ((WindowPtr) NULL); pHead = RealChildHead(pWin->parent); pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild; box.x1 = x; box.y1 = y; - box.x2 = x + (int)w; - box.y2 = y + (int)h; - switch (smode) + box.x2 = x + (int) w; + box.y2 = y + (int) h; + switch (smode) { + case Above: + if (pSib) + return pSib; + else if (pWin == pFirst) + return pWin->nextSib; + else + return pFirst; + case Below: + if (pSib) + if (pSib->nextSib != pWin) + return pSib->nextSib; + else + return pWin->nextSib; + else + return NullWindow; + case TopIf: + if ((!pWin->mapped || (pSib && !pSib->mapped))) + return pWin->nextSib; + else if (pSib) { + if ((IsSiblingAboveMe(pWin, pSib) == Above) && + (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT)) + return pFirst; + else + return pWin->nextSib; + } + else if (AnyWindowOverlapsMe(pWin, pHead, &box)) + return pFirst; + else + return pWin->nextSib; + case BottomIf: + if ((!pWin->mapped || (pSib && !pSib->mapped))) + return pWin->nextSib; + else if (pSib) { + if ((IsSiblingAboveMe(pWin, pSib) == Below) && + (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT)) + return NullWindow; + else + return pWin->nextSib; + } + else if (IOverlapAnyWindow(pWin, &box)) + return NullWindow; + else + return pWin->nextSib; + case Opposite: + if ((!pWin->mapped || (pSib && !pSib->mapped))) + return pWin->nextSib; + else if (pSib) { + if (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT) { + if (IsSiblingAboveMe(pWin, pSib) == Above) + return pFirst; + else + return NullWindow; + } + else + return pWin->nextSib; + } + else if (AnyWindowOverlapsMe(pWin, pHead, &box)) { + /* If I'm occluded, I can't possibly be the first child + * if (pWin == pWin->parent->firstChild) + * return pWin->nextSib; + */ + return pFirst; + } + else if (IOverlapAnyWindow(pWin, &box)) + return NullWindow; + else + return pWin->nextSib; + default: { - case Above: - if (pSib) - return pSib; - else if (pWin == pFirst) - return pWin->nextSib; - else - return pFirst; - case Below: - if (pSib) - if (pSib->nextSib != pWin) - return pSib->nextSib; - else - return pWin->nextSib; - else - return NullWindow; - case TopIf: - if ((!pWin->mapped || (pSib && !pSib->mapped))) - return pWin->nextSib; - else if (pSib) - { - if ((IsSiblingAboveMe(pWin, pSib) == Above) && - (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT)) - return pFirst; - else - return pWin->nextSib; - } - else if (AnyWindowOverlapsMe(pWin, pHead, &box)) - return pFirst; - else - return pWin->nextSib; - case BottomIf: - if ((!pWin->mapped || (pSib && !pSib->mapped))) - return pWin->nextSib; - else if (pSib) - { - if ((IsSiblingAboveMe(pWin, pSib) == Below) && - (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT)) - return NullWindow; - else - return pWin->nextSib; - } - else if (IOverlapAnyWindow(pWin, &box)) - return NullWindow; - else - return pWin->nextSib; - case Opposite: - if ((!pWin->mapped || (pSib && !pSib->mapped))) - return pWin->nextSib; - else if (pSib) - { - if (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT) - { - if (IsSiblingAboveMe(pWin, pSib) == Above) - return pFirst; - else - return NullWindow; - } - else - return pWin->nextSib; - } - else if (AnyWindowOverlapsMe(pWin, pHead, &box)) - { - /* If I'm occluded, I can't possibly be the first child - * if (pWin == pWin->parent->firstChild) - * return pWin->nextSib; - */ - return pFirst; - } - else if (IOverlapAnyWindow(pWin, &box)) - return NullWindow; - else - return pWin->nextSib; - default: - { - /* should never happen; make something up. */ - return pWin->nextSib; - } + /* should never happen; make something up. */ + return pWin->nextSib; + } } } static void -ReflectStackChange( - WindowPtr pWin, - WindowPtr pSib, - VTKind kind) +ReflectStackChange(WindowPtr pWin, WindowPtr pSib, VTKind kind) { /* Note that pSib might be NULL */ - Bool WasViewable = (Bool)pWin->viewable; + Bool WasViewable = (Bool) pWin->viewable; Bool anyMarked; WindowPtr pFirstChange; - WindowPtr pLayerWin; + WindowPtr pLayerWin; ScreenPtr pScreen = pWin->drawable.pScreen; /* if this is a root window, can't be restacked */ if (!pWin->parent) - return; + return; pFirstChange = MoveWindowInStack(pWin, pSib); - if (WasViewable) - { - anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pFirstChange, - &pLayerWin); - if (pLayerWin != pWin) pFirstChange = pLayerWin; - if (anyMarked) - { - (*pScreen->ValidateTree)(pLayerWin->parent, pFirstChange, kind); - (*pScreen->HandleExposures)(pLayerWin->parent); - } - if (anyMarked && pWin->drawable.pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pLayerWin->parent, pFirstChange, kind); + if (WasViewable) { + anyMarked = (*pScreen->MarkOverlappedWindows) (pWin, pFirstChange, + &pLayerWin); + if (pLayerWin != pWin) + pFirstChange = pLayerWin; + if (anyMarked) { + (*pScreen->ValidateTree) (pLayerWin->parent, pFirstChange, kind); + (*pScreen->HandleExposures) (pLayerWin->parent); + } + if (anyMarked && pWin->drawable.pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange, + kind); } if (pWin->realized) - WindowsRestructured (); + WindowsRestructured(); } /***** @@ -2217,251 +2086,236 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client) Window sibwid = 0; Mask index2, tmask; XID *pVlist; - short x, y, beforeX, beforeY; + short x, y, beforeX, beforeY; unsigned short w = pWin->drawable.width, - h = pWin->drawable.height, - bw = pWin->borderWidth; + h = pWin->drawable.height, bw = pWin->borderWidth; int rc, action, smode = Above; xEvent event; - if ((pWin->drawable.class == InputOnly) && (mask & IllegalInputOnlyConfigureMask)) - return BadMatch; + if ((pWin->drawable.class == InputOnly) && + (mask & IllegalInputOnlyConfigureMask)) + return BadMatch; if ((mask & CWSibling) && !(mask & CWStackMode)) - return BadMatch; + return BadMatch; pVlist = vlist; - if (pParent) - { - x = pWin->drawable.x - pParent->drawable.x - (int)bw; - y = pWin->drawable.y - pParent->drawable.y - (int)bw; + if (pParent) { + x = pWin->drawable.x - pParent->drawable.x - (int) bw; + y = pWin->drawable.y - pParent->drawable.y - (int) bw; } - else - { - x = pWin->drawable.x; - y = pWin->drawable.y; + else { + x = pWin->drawable.x; + y = pWin->drawable.y; } beforeX = x; beforeY = y; - action = RESTACK_WIN; - if ((mask & (CWX | CWY)) && (!(mask & (CWHeight | CWWidth)))) - { - GET_INT16(CWX, x); - GET_INT16(CWY, y); - action = MOVE_WIN; - } - /* or should be resized */ - else if (mask & (CWX | CWY | CWWidth | CWHeight)) - { - GET_INT16(CWX, x); - GET_INT16(CWY, y); - GET_CARD16(CWWidth, w); - GET_CARD16 (CWHeight, h); - if (!w || !h) - { - client->errorValue = 0; - return BadValue; - } - action = RESIZE_WIN; + action = RESTACK_WIN; + if ((mask & (CWX | CWY)) && (!(mask & (CWHeight | CWWidth)))) { + GET_INT16(CWX, x); + GET_INT16(CWY, y); + action = MOVE_WIN; + } + /* or should be resized */ + else if (mask & (CWX | CWY | CWWidth | CWHeight)) { + GET_INT16(CWX, x); + GET_INT16(CWY, y); + GET_CARD16(CWWidth, w); + GET_CARD16(CWHeight, h); + if (!w || !h) { + client->errorValue = 0; + return BadValue; + } + action = RESIZE_WIN; } tmask = mask & ~ChangeMask; - while (tmask) - { - index2 = (Mask)lowbit (tmask); - tmask &= ~index2; - switch (index2) - { - case CWBorderWidth: - GET_CARD16(CWBorderWidth, bw); - break; - case CWSibling: - sibwid = (Window ) *pVlist; - pVlist++; - rc = dixLookupWindow(&pSib, sibwid, client, DixGetAttrAccess); - if (rc != Success) - { - client->errorValue = sibwid; - return rc; - } - if (pSib->parent != pParent) - return BadMatch; - if (pSib == pWin) - return BadMatch; - break; - case CWStackMode: - GET_CARD8(CWStackMode, smode); - if ((smode != TopIf) && (smode != BottomIf) && - (smode != Opposite) && (smode != Above) && (smode != Below)) - { - client->errorValue = smode; - return BadValue; - } - break; - default: - client->errorValue = mask; - return BadValue; - } - } - /* root really can't be reconfigured, so just return */ + while (tmask) { + index2 = (Mask) lowbit(tmask); + tmask &= ~index2; + switch (index2) { + case CWBorderWidth: + GET_CARD16(CWBorderWidth, bw); + break; + case CWSibling: + sibwid = (Window) *pVlist; + pVlist++; + rc = dixLookupWindow(&pSib, sibwid, client, DixGetAttrAccess); + if (rc != Success) { + client->errorValue = sibwid; + return rc; + } + if (pSib->parent != pParent) + return BadMatch; + if (pSib == pWin) + return BadMatch; + break; + case CWStackMode: + GET_CARD8(CWStackMode, smode); + if ((smode != TopIf) && (smode != BottomIf) && + (smode != Opposite) && (smode != Above) && (smode != Below)) { + client->errorValue = smode; + return BadValue; + } + break; + default: + client->errorValue = mask; + return BadValue; + } + } + /* root really can't be reconfigured, so just return */ if (!pParent) - return Success; + return Success; - /* Figure out if the window should be moved. Doesnt - make the changes to the window if event sent */ + /* Figure out if the window should be moved. Doesnt + make the changes to the window if event sent */ if (mask & CWStackMode) - pSib = WhereDoIGoInTheStack(pWin, pSib, pParent->drawable.x + x, - pParent->drawable.y + y, - w + (bw << 1), h + (bw << 1), smode); + pSib = WhereDoIGoInTheStack(pWin, pSib, pParent->drawable.x + x, + pParent->drawable.y + y, + w + (bw << 1), h + (bw << 1), smode); else - pSib = pWin->nextSib; - - - if ((!pWin->overrideRedirect) && - (RedirectSend(pParent) - )) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = ConfigureRequest; - event.u.configureRequest.window = pWin->drawable.id; - if (mask & CWSibling) - event.u.configureRequest.sibling = sibwid; - else - event.u.configureRequest.sibling = None; - if (mask & CWStackMode) - event.u.u.detail = smode; - else - event.u.u.detail = Above; - event.u.configureRequest.x = x; - event.u.configureRequest.y = y; + pSib = pWin->nextSib; + + if ((!pWin->overrideRedirect) && (RedirectSend(pParent) + )) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = ConfigureRequest; + event.u.configureRequest.window = pWin->drawable.id; + if (mask & CWSibling) + event.u.configureRequest.sibling = sibwid; + else + event.u.configureRequest.sibling = None; + if (mask & CWStackMode) + event.u.u.detail = smode; + else + event.u.u.detail = Above; + event.u.configureRequest.x = x; + event.u.configureRequest.y = y; #ifdef PANORAMIX - if(!noPanoramiXExtension && (!pParent || !pParent->parent)) { + if (!noPanoramiXExtension && (!pParent || !pParent->parent)) { event.u.configureRequest.x += screenInfo.screens[0]->x; event.u.configureRequest.y += screenInfo.screens[0]->y; - } + } #endif - event.u.configureRequest.width = w; - event.u.configureRequest.height = h; - event.u.configureRequest.borderWidth = bw; - event.u.configureRequest.valueMask = mask; - event.u.configureRequest.parent = pParent->drawable.id; - if (MaybeDeliverEventsToClient(pParent, &event, 1, - SubstructureRedirectMask, client) == 1) - return Success; + event.u.configureRequest.width = w; + event.u.configureRequest.height = h; + event.u.configureRequest.borderWidth = bw; + event.u.configureRequest.valueMask = mask; + event.u.configureRequest.parent = pParent->drawable.id; + if (MaybeDeliverEventsToClient(pParent, &event, 1, + SubstructureRedirectMask, client) == 1) + return Success; } - if (action == RESIZE_WIN) - { - Bool size_change = (w != pWin->drawable.width) - || (h != pWin->drawable.height); - if (size_change && ((pWin->eventMask|wOtherEventMasks(pWin)) & ResizeRedirectMask)) - { - xEvent eventT; - memset(&eventT, 0, sizeof(xEvent)); - eventT.u.u.type = ResizeRequest; - eventT.u.resizeRequest.window = pWin->drawable.id; - eventT.u.resizeRequest.width = w; - eventT.u.resizeRequest.height = h; - if (MaybeDeliverEventsToClient(pWin, &eventT, 1, - ResizeRedirectMask, client) == 1) - { - /* if event is delivered, leave the actual size alone. */ - w = pWin->drawable.width; - h = pWin->drawable.height; - size_change = FALSE; - } - } - if (!size_change) - { - if (mask & (CWX | CWY)) - action = MOVE_WIN; - else if (mask & (CWStackMode | CWBorderWidth)) - action = RESTACK_WIN; - else /* really nothing to do */ - return(Success) ; - } + if (action == RESIZE_WIN) { + Bool size_change = (w != pWin->drawable.width) + || (h != pWin->drawable.height); + + if (size_change && + ((pWin->eventMask | wOtherEventMasks(pWin)) & ResizeRedirectMask)) { + xEvent eventT; + + memset(&eventT, 0, sizeof(xEvent)); + eventT.u.u.type = ResizeRequest; + eventT.u.resizeRequest.window = pWin->drawable.id; + eventT.u.resizeRequest.width = w; + eventT.u.resizeRequest.height = h; + if (MaybeDeliverEventsToClient(pWin, &eventT, 1, + ResizeRedirectMask, client) == 1) { + /* if event is delivered, leave the actual size alone. */ + w = pWin->drawable.width; + h = pWin->drawable.height; + size_change = FALSE; + } + } + if (!size_change) { + if (mask & (CWX | CWY)) + action = MOVE_WIN; + else if (mask & (CWStackMode | CWBorderWidth)) + action = RESTACK_WIN; + else /* really nothing to do */ + return (Success); + } } if (action == RESIZE_WIN) - /* we've already checked whether there's really a size change */ - goto ActuallyDoSomething; + /* we've already checked whether there's really a size change */ + goto ActuallyDoSomething; if ((mask & CWX) && (x != beforeX)) - goto ActuallyDoSomething; + goto ActuallyDoSomething; if ((mask & CWY) && (y != beforeY)) - goto ActuallyDoSomething; - if ((mask & CWBorderWidth) && (bw != wBorderWidth (pWin))) - goto ActuallyDoSomething; - if (mask & CWStackMode) - { + goto ActuallyDoSomething; + if ((mask & CWBorderWidth) && (bw != wBorderWidth(pWin))) + goto ActuallyDoSomething; + if (mask & CWStackMode) { #ifndef ROOTLESS /* See above for why we always reorder in rootless mode. */ - if (pWin->nextSib != pSib) + if (pWin->nextSib != pSib) #endif - goto ActuallyDoSomething; + goto ActuallyDoSomething; } return Success; -ActuallyDoSomething: - if (pWin->drawable.pScreen->ConfigNotify) - { - int ret; - ret = (*pWin->drawable.pScreen->ConfigNotify)(pWin, x, y, w, h, bw, pSib); - if (ret) { - client->errorValue = 0; - return ret; - } + ActuallyDoSomething: + if (pWin->drawable.pScreen->ConfigNotify) { + int ret; + + ret = + (*pWin->drawable.pScreen->ConfigNotify) (pWin, x, y, w, h, bw, + pSib); + if (ret) { + client->errorValue = 0; + return ret; + } } - if (SubStrSend(pWin, pParent)) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = ConfigureNotify; - event.u.configureNotify.window = pWin->drawable.id; - if (pSib) - event.u.configureNotify.aboveSibling = pSib->drawable.id; - else - event.u.configureNotify.aboveSibling = None; - event.u.configureNotify.x = x; - event.u.configureNotify.y = y; + if (SubStrSend(pWin, pParent)) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = ConfigureNotify; + event.u.configureNotify.window = pWin->drawable.id; + if (pSib) + event.u.configureNotify.aboveSibling = pSib->drawable.id; + else + event.u.configureNotify.aboveSibling = None; + event.u.configureNotify.x = x; + event.u.configureNotify.y = y; #ifdef PANORAMIX - if(!noPanoramiXExtension && (!pParent || !pParent->parent)) { - event.u.configureNotify.x += screenInfo.screens[0]->x; - event.u.configureNotify.y += screenInfo.screens[0]->y; - } + if (!noPanoramiXExtension && (!pParent || !pParent->parent)) { + event.u.configureNotify.x += screenInfo.screens[0]->x; + event.u.configureNotify.y += screenInfo.screens[0]->y; + } #endif - event.u.configureNotify.width = w; - event.u.configureNotify.height = h; - event.u.configureNotify.borderWidth = bw; - event.u.configureNotify.override = pWin->overrideRedirect; - DeliverEvents(pWin, &event, 1, NullWindow); - } - if (mask & CWBorderWidth) - { - if (action == RESTACK_WIN) - { - action = MOVE_WIN; - pWin->borderWidth = bw; - } - else if ((action == MOVE_WIN) && - (beforeX + wBorderWidth (pWin) == x + (int)bw) && - (beforeY + wBorderWidth (pWin) == y + (int)bw)) - { - action = REBORDER_WIN; - (*pWin->drawable.pScreen->ChangeBorderWidth)(pWin, bw); - } - else - pWin->borderWidth = bw; + event.u.configureNotify.width = w; + event.u.configureNotify.height = h; + event.u.configureNotify.borderWidth = bw; + event.u.configureNotify.override = pWin->overrideRedirect; + DeliverEvents(pWin, &event, 1, NullWindow); + } + if (mask & CWBorderWidth) { + if (action == RESTACK_WIN) { + action = MOVE_WIN; + pWin->borderWidth = bw; + } + else if ((action == MOVE_WIN) && + (beforeX + wBorderWidth(pWin) == x + (int) bw) && + (beforeY + wBorderWidth(pWin) == y + (int) bw)) { + action = REBORDER_WIN; + (*pWin->drawable.pScreen->ChangeBorderWidth) (pWin, bw); + } + else + pWin->borderWidth = bw; } if (action == MOVE_WIN) - (*pWin->drawable.pScreen->MoveWindow)(pWin, x, y, pSib, - (mask & CWBorderWidth) ? VTOther : VTMove); + (*pWin->drawable.pScreen->MoveWindow) (pWin, x, y, pSib, + (mask & CWBorderWidth) ? VTOther + : VTMove); else if (action == RESIZE_WIN) - (*pWin->drawable.pScreen->ResizeWindow)(pWin, x, y, w, h, pSib); + (*pWin->drawable.pScreen->ResizeWindow) (pWin, x, y, w, h, pSib); else if (mask & CWStackMode) - ReflectStackChange(pWin, pSib, VTOther); + ReflectStackChange(pWin, pSib, VTOther); if (action != RESTACK_WIN) - CheckCursorConfinement(pWin); + CheckCursorConfinement(pWin); return Success; #undef RESTACK_WIN #undef MOVE_WIN @@ -2469,7 +2323,6 @@ ActuallyDoSomething: #undef REBORDER_WIN } - /****** * * CirculateWindow @@ -2489,63 +2342,58 @@ CirculateWindow(WindowPtr pParent, int direction, ClientPtr client) pHead = RealChildHead(pParent); pFirst = pHead ? pHead->nextSib : pParent->firstChild; - if (direction == RaiseLowest) - { - for (pWin = pParent->lastChild; - (pWin != pHead) && - !(pWin->mapped && - AnyWindowOverlapsMe(pWin, pHead, WindowExtents(pWin, &box))); - pWin = pWin->prevSib) ; - if (pWin == pHead) - return Success; + if (direction == RaiseLowest) { + for (pWin = pParent->lastChild; + (pWin != pHead) && + !(pWin->mapped && + AnyWindowOverlapsMe(pWin, pHead, WindowExtents(pWin, &box))); + pWin = pWin->prevSib); + if (pWin == pHead) + return Success; } - else - { - for (pWin = pFirst; - pWin && - !(pWin->mapped && - IOverlapAnyWindow(pWin, WindowExtents(pWin, &box))); - pWin = pWin->nextSib) ; - if (!pWin) - return Success; + else { + for (pWin = pFirst; + pWin && + !(pWin->mapped && + IOverlapAnyWindow(pWin, WindowExtents(pWin, &box))); + pWin = pWin->nextSib); + if (!pWin) + return Success; } event.u.circulate.window = pWin->drawable.id; event.u.circulate.parent = pParent->drawable.id; event.u.circulate.event = pParent->drawable.id; if (direction == RaiseLowest) - event.u.circulate.place = PlaceOnTop; + event.u.circulate.place = PlaceOnTop; else - event.u.circulate.place = PlaceOnBottom; + event.u.circulate.place = PlaceOnBottom; - if (RedirectSend(pParent)) - { - event.u.u.type = CirculateRequest; - if (MaybeDeliverEventsToClient(pParent, &event, 1, - SubstructureRedirectMask, client) == 1) - return Success; + if (RedirectSend(pParent)) { + event.u.u.type = CirculateRequest; + if (MaybeDeliverEventsToClient(pParent, &event, 1, + SubstructureRedirectMask, client) == 1) + return Success; } event.u.u.type = CirculateNotify; DeliverEvents(pWin, &event, 1, NullWindow); ReflectStackChange(pWin, - (direction == RaiseLowest) ? pFirst : NullWindow, - VTStack); + (direction == RaiseLowest) ? pFirst : NullWindow, + VTStack); return Success; } static int -CompareWIDs( - WindowPtr pWin, - pointer value) /* must conform to VisitWindowProcPtr */ -{ - Window *wid = (Window *)value; +CompareWIDs(WindowPtr pWin, pointer value) +{ /* must conform to VisitWindowProcPtr */ + Window *wid = (Window *) value; if (pWin->drawable.id == *wid) - return WT_STOPWALKING; + return WT_STOPWALKING; else - return WT_WALKCHILDREN; + return WT_WALKCHILDREN; } /***** @@ -2557,19 +2405,20 @@ ReparentWindow(WindowPtr pWin, WindowPtr pParent, int x, int y, ClientPtr client) { WindowPtr pPrev, pPriorParent; - Bool WasMapped = (Bool)(pWin->mapped); + Bool WasMapped = (Bool) (pWin->mapped); xEvent event; - int bw = wBorderWidth (pWin); + int bw = wBorderWidth(pWin); ScreenPtr pScreen; pScreen = pWin->drawable.pScreen; - if (TraverseTree(pWin, CompareWIDs, (pointer)&pParent->drawable.id) == WT_STOPWALKING) - return BadMatch; + if (TraverseTree(pWin, CompareWIDs, (pointer) &pParent->drawable.id) == + WT_STOPWALKING) + return BadMatch; if (!MakeWindowOptional(pWin)) - return BadAlloc; + return BadAlloc; if (WasMapped) - UnmapWindow(pWin, FALSE); + UnmapWindow(pWin, FALSE); memset(&event, 0, sizeof(xEvent)); event.u.u.type = ReparentNotify; @@ -2578,9 +2427,9 @@ ReparentWindow(WindowPtr pWin, WindowPtr pParent, event.u.reparent.x = x; event.u.reparent.y = y; #ifdef PANORAMIX - if(!noPanoramiXExtension && !pParent->parent) { - event.u.reparent.x += screenInfo.screens[0]->x; - event.u.reparent.y += screenInfo.screens[0]->y; + if (!noPanoramiXExtension && !pParent->parent) { + event.u.reparent.x += screenInfo.screens[0]->x; + event.u.reparent.y += screenInfo.screens[0]->y; } #endif event.u.reparent.override = pWin->overrideRedirect; @@ -2590,37 +2439,35 @@ ReparentWindow(WindowPtr pWin, WindowPtr pParent, pPriorParent = pPrev = pWin->parent; if (pPrev->firstChild == pWin) - pPrev->firstChild = pWin->nextSib; + pPrev->firstChild = pWin->nextSib; if (pPrev->lastChild == pWin) - pPrev->lastChild = pWin->prevSib; + pPrev->lastChild = pWin->prevSib; if (pWin->nextSib) - pWin->nextSib->prevSib = pWin->prevSib; + pWin->nextSib->prevSib = pWin->prevSib; if (pWin->prevSib) - pWin->prevSib->nextSib = pWin->nextSib; + pWin->prevSib->nextSib = pWin->nextSib; /* insert at begining of pParent */ pWin->parent = pParent; pPrev = RealChildHead(pParent); - if (pPrev) - { - pWin->nextSib = pPrev->nextSib; - if (pPrev->nextSib) - pPrev->nextSib->prevSib = pWin; - else - pParent->lastChild = pWin; - pPrev->nextSib = pWin; - pWin->prevSib = pPrev; + if (pPrev) { + pWin->nextSib = pPrev->nextSib; + if (pPrev->nextSib) + pPrev->nextSib->prevSib = pWin; + else + pParent->lastChild = pWin; + pPrev->nextSib = pWin; + pWin->prevSib = pPrev; } - else - { - pWin->nextSib = pParent->firstChild; - pWin->prevSib = NullWindow; - if (pParent->firstChild) - pParent->firstChild->prevSib = pWin; - else - pParent->lastChild = pWin; - pParent->firstChild = pWin; + else { + pWin->nextSib = pParent->firstChild; + pWin->prevSib = NullWindow; + if (pParent->firstChild) + pParent->firstChild->prevSib = pWin; + else + pParent->lastChild = pWin; + pParent->firstChild = pWin; } pWin->origin.x = x + bw; @@ -2629,18 +2476,18 @@ ReparentWindow(WindowPtr pWin, WindowPtr pParent, pWin->drawable.y = y + bw + pParent->drawable.y; /* clip to parent */ - SetWinSize (pWin); - SetBorderSize (pWin); + SetWinSize(pWin); + SetBorderSize(pWin); if (pScreen->ReparentWindow) - (*pScreen->ReparentWindow)(pWin, pPriorParent); - (*pScreen->PositionWindow)(pWin, pWin->drawable.x, pWin->drawable.y); + (*pScreen->ReparentWindow) (pWin, pPriorParent); + (*pScreen->PositionWindow) (pWin, pWin->drawable.x, pWin->drawable.y); ResizeChildrenWinSize(pWin, 0, 0, 0, 0); CheckWindowOptionalNeed(pWin); if (WasMapped) - MapWindow(pWin, client); + MapWindow(pWin, client); RecalculateDeliverableEvents(pWin); return Success; } @@ -2653,24 +2500,21 @@ RealizeTree(WindowPtr pWin) Realize = pWin->drawable.pScreen->RealizeWindow; pChild = pWin; - while (1) - { - if (pChild->mapped) - { - pChild->realized = TRUE; - pChild->viewable = (pChild->drawable.class == InputOutput); - (* Realize)(pChild); - if (pChild->firstChild) - { - pChild = pChild->firstChild; - continue; - } - } - while (!pChild->nextSib && (pChild != pWin)) - pChild = pChild->parent; - if (pChild == pWin) - return; - pChild = pChild->nextSib; + while (1) { + if (pChild->mapped) { + pChild->realized = TRUE; + pChild->viewable = (pChild->drawable.class == InputOutput); + (*Realize) (pChild); + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + } + while (!pChild->nextSib && (pChild != pWin)) + pChild = pChild->parent; + if (pChild == pWin) + return; + pChild = pChild->nextSib; } } @@ -2679,15 +2523,15 @@ static WindowPtr windowDisableMapUnmapEvents; void DisableMapUnmapEvents(WindowPtr pWin) { - assert (windowDisableMapUnmapEvents == NULL); - + assert(windowDisableMapUnmapEvents == NULL); + windowDisableMapUnmapEvents = pWin; } void EnableMapUnmapEvents(WindowPtr pWin) { - assert (windowDisableMapUnmapEvents != NULL); + assert(windowDisableMapUnmapEvents != NULL); windowDisableMapUnmapEvents = NULL; } @@ -2712,86 +2556,80 @@ MapWindow(WindowPtr pWin, ClientPtr client) ScreenPtr pScreen; WindowPtr pParent; - WindowPtr pLayerWin; + WindowPtr pLayerWin; if (pWin->mapped) - return Success; + return Success; /* general check for permission to map window */ if (XaceHook(XACE_RESOURCE_ACCESS, client, pWin->drawable.id, RT_WINDOW, - pWin, RT_NONE, NULL, DixShowAccess) != Success) - return Success; + pWin, RT_NONE, NULL, DixShowAccess) != Success) + return Success; pScreen = pWin->drawable.pScreen; - if ( (pParent = pWin->parent) ) - { - xEvent event; - Bool anyMarked; - - if ((!pWin->overrideRedirect) && - (RedirectSend(pParent) - )) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = MapRequest; - event.u.mapRequest.window = pWin->drawable.id; - event.u.mapRequest.parent = pParent->drawable.id; - - if (MaybeDeliverEventsToClient(pParent, &event, 1, - SubstructureRedirectMask, client) == 1) - return Success; - } - - pWin->mapped = TRUE; - if (SubStrSend(pWin, pParent) && MapUnmapEventsEnabled(pWin)) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = MapNotify; - event.u.mapNotify.window = pWin->drawable.id; - event.u.mapNotify.override = pWin->overrideRedirect; - DeliverEvents(pWin, &event, 1, NullWindow); - } - - if (!pParent->realized) - return Success; - RealizeTree(pWin); - if (pWin->viewable) - { - anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pWin, - &pLayerWin); - if (anyMarked) - { - (*pScreen->ValidateTree)(pLayerWin->parent, pLayerWin, VTMap); - (*pScreen->HandleExposures)(pLayerWin->parent); - } - if (anyMarked && pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pLayerWin->parent, pLayerWin, VTMap); - } - WindowsRestructured (); + if ((pParent = pWin->parent)) { + xEvent event; + Bool anyMarked; + + if ((!pWin->overrideRedirect) && (RedirectSend(pParent) + )) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = MapRequest; + event.u.mapRequest.window = pWin->drawable.id; + event.u.mapRequest.parent = pParent->drawable.id; + + if (MaybeDeliverEventsToClient(pParent, &event, 1, + SubstructureRedirectMask, + client) == 1) + return Success; + } + + pWin->mapped = TRUE; + if (SubStrSend(pWin, pParent) && MapUnmapEventsEnabled(pWin)) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = MapNotify; + event.u.mapNotify.window = pWin->drawable.id; + event.u.mapNotify.override = pWin->overrideRedirect; + DeliverEvents(pWin, &event, 1, NullWindow); + } + + if (!pParent->realized) + return Success; + RealizeTree(pWin); + if (pWin->viewable) { + anyMarked = (*pScreen->MarkOverlappedWindows) (pWin, pWin, + &pLayerWin); + if (anyMarked) { + (*pScreen->ValidateTree) (pLayerWin->parent, pLayerWin, VTMap); + (*pScreen->HandleExposures) (pLayerWin->parent); + } + if (anyMarked && pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin, + VTMap); + } + WindowsRestructured(); } - else - { - RegionRec temp; - - pWin->mapped = TRUE; - pWin->realized = TRUE; /* for roots */ - pWin->viewable = pWin->drawable.class == InputOutput; - /* We SHOULD check for an error value here XXX */ - (*pScreen->RealizeWindow)(pWin); - if (pScreen->ClipNotify) - (*pScreen->ClipNotify) (pWin, 0, 0); - if (pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(NullWindow, pWin, VTMap); - RegionNull(&temp); - RegionCopy(&temp, &pWin->clipList); - (*pScreen->WindowExposures) (pWin, &temp, NullRegion); - RegionUninit(&temp); + else { + RegionRec temp; + + pWin->mapped = TRUE; + pWin->realized = TRUE; /* for roots */ + pWin->viewable = pWin->drawable.class == InputOutput; + /* We SHOULD check for an error value here XXX */ + (*pScreen->RealizeWindow) (pWin); + if (pScreen->ClipNotify) + (*pScreen->ClipNotify) (pWin, 0, 0); + if (pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (NullWindow, pWin, VTMap); + RegionNull(&temp); + RegionCopy(&temp, &pWin->clipList); + (*pScreen->WindowExposures) (pWin, &temp, NullRegion); + RegionUninit(&temp); } return Success; } - /***** * MapSubwindows * Performs a MapWindow all unmapped children of the window, in top @@ -2801,84 +2639,76 @@ MapWindow(WindowPtr pWin, ClientPtr client) void MapSubwindows(WindowPtr pParent, ClientPtr client) { - WindowPtr pWin; - WindowPtr pFirstMapped = NullWindow; - ScreenPtr pScreen; - Mask parentRedirect; - Mask parentNotify; - xEvent event; - Bool anyMarked; - WindowPtr pLayerWin; + WindowPtr pWin; + WindowPtr pFirstMapped = NullWindow; + ScreenPtr pScreen; + Mask parentRedirect; + Mask parentNotify; + xEvent event; + Bool anyMarked; + WindowPtr pLayerWin; pScreen = pParent->drawable.pScreen; parentRedirect = RedirectSend(pParent); parentNotify = SubSend(pParent); anyMarked = FALSE; - for (pWin = pParent->firstChild; pWin; pWin = pWin->nextSib) - { - if (!pWin->mapped) - { - if (parentRedirect && !pWin->overrideRedirect) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = MapRequest; - event.u.mapRequest.window = pWin->drawable.id; - event.u.mapRequest.parent = pParent->drawable.id; - - if (MaybeDeliverEventsToClient(pParent, &event, 1, - SubstructureRedirectMask, client) == 1) - continue; - } - - pWin->mapped = TRUE; - if (parentNotify || StrSend(pWin)) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = MapNotify; - event.u.mapNotify.window = pWin->drawable.id; - event.u.mapNotify.override = pWin->overrideRedirect; - DeliverEvents(pWin, &event, 1, NullWindow); - } - - if (!pFirstMapped) - pFirstMapped = pWin; - if (pParent->realized) - { - RealizeTree(pWin); - if (pWin->viewable) - { - anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pWin, - (WindowPtr *)NULL); - } - } - } - } - - if (pFirstMapped) - { - pLayerWin = (*pScreen->GetLayerWindow)(pParent); - if (pLayerWin->parent != pParent) { - anyMarked |= (*pScreen->MarkOverlappedWindows)(pLayerWin, - pLayerWin, - (WindowPtr *)NULL); - pFirstMapped = pLayerWin; - } - if (anyMarked) - { - (*pScreen->ValidateTree)(pLayerWin->parent, pFirstMapped, VTMap); - (*pScreen->HandleExposures)(pLayerWin->parent); - } + for (pWin = pParent->firstChild; pWin; pWin = pWin->nextSib) { + if (!pWin->mapped) { + if (parentRedirect && !pWin->overrideRedirect) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = MapRequest; + event.u.mapRequest.window = pWin->drawable.id; + event.u.mapRequest.parent = pParent->drawable.id; + + if (MaybeDeliverEventsToClient(pParent, &event, 1, + SubstructureRedirectMask, + client) == 1) + continue; + } + + pWin->mapped = TRUE; + if (parentNotify || StrSend(pWin)) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = MapNotify; + event.u.mapNotify.window = pWin->drawable.id; + event.u.mapNotify.override = pWin->overrideRedirect; + DeliverEvents(pWin, &event, 1, NullWindow); + } + + if (!pFirstMapped) + pFirstMapped = pWin; + if (pParent->realized) { + RealizeTree(pWin); + if (pWin->viewable) { + anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin, pWin, + (WindowPtr + *) NULL); + } + } + } + } + + if (pFirstMapped) { + pLayerWin = (*pScreen->GetLayerWindow) (pParent); + if (pLayerWin->parent != pParent) { + anyMarked |= (*pScreen->MarkOverlappedWindows) (pLayerWin, + pLayerWin, + (WindowPtr *) NULL); + pFirstMapped = pLayerWin; + } + if (anyMarked) { + (*pScreen->ValidateTree) (pLayerWin->parent, pFirstMapped, VTMap); + (*pScreen->HandleExposures) (pLayerWin->parent); + } if (anyMarked && pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pLayerWin->parent, pFirstMapped, - VTMap); - WindowsRestructured (); + (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstMapped, + VTMap); + WindowsRestructured(); } } static void -UnrealizeTree( - WindowPtr pWin, - Bool fromConfigure) +UnrealizeTree(WindowPtr pWin, Bool fromConfigure) { WindowPtr pChild; UnrealizeWindowProcPtr Unrealize; @@ -2887,42 +2717,40 @@ UnrealizeTree( Unrealize = pWin->drawable.pScreen->UnrealizeWindow; MarkUnrealizedWindow = pWin->drawable.pScreen->MarkUnrealizedWindow; pChild = pWin; - while (1) - { - if (pChild->realized) - { - pChild->realized = FALSE; - pChild->visibility = VisibilityNotViewable; + while (1) { + if (pChild->realized) { + pChild->realized = FALSE; + pChild->visibility = VisibilityNotViewable; #ifdef PANORAMIX - if(!noPanoramiXExtension && !pChild->drawable.pScreen->myNum) { - PanoramiXRes *win; - int rc = dixLookupResourceByType((pointer *)&win, - pChild->drawable.id, XRT_WINDOW, - serverClient, DixWriteAccess); - if (rc == Success) - win->u.win.visibility = VisibilityNotViewable; - } + if (!noPanoramiXExtension && !pChild->drawable.pScreen->myNum) { + PanoramiXRes *win; + int rc = dixLookupResourceByType((pointer *) &win, + pChild->drawable.id, + XRT_WINDOW, + serverClient, DixWriteAccess); + + if (rc == Success) + win->u.win.visibility = VisibilityNotViewable; + } #endif - (* Unrealize)(pChild); - if (MapUnmapEventsEnabled(pWin)) - DeleteWindowFromAnyEvents(pChild, FALSE); - if (pChild->viewable) - { - pChild->viewable = FALSE; - (* MarkUnrealizedWindow)(pChild, pWin, fromConfigure); - pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER; - } - if (pChild->firstChild) - { - pChild = pChild->firstChild; - continue; - } - } - while (!pChild->nextSib && (pChild != pWin)) - pChild = pChild->parent; - if (pChild == pWin) - return; - pChild = pChild->nextSib; + (*Unrealize) (pChild); + if (MapUnmapEventsEnabled(pWin)) + DeleteWindowFromAnyEvents(pChild, FALSE); + if (pChild->viewable) { + pChild->viewable = FALSE; + (*MarkUnrealizedWindow) (pChild, pWin, fromConfigure); + pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER; + } + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + } + while (!pChild->nextSib && (pChild != pWin)) + pChild = pChild->parent; + if (pChild == pWin) + return; + pChild = pChild->nextSib; } } @@ -2938,43 +2766,39 @@ UnmapWindow(WindowPtr pWin, Bool fromConfigure) { WindowPtr pParent; xEvent event; - Bool wasRealized = (Bool)pWin->realized; - Bool wasViewable = (Bool)pWin->viewable; + Bool wasRealized = (Bool) pWin->realized; + Bool wasViewable = (Bool) pWin->viewable; ScreenPtr pScreen = pWin->drawable.pScreen; WindowPtr pLayerWin = pWin; if ((!pWin->mapped) || (!(pParent = pWin->parent))) - return Success; - if (SubStrSend(pWin, pParent) && MapUnmapEventsEnabled(pWin)) - { - memset(&event, 0, sizeof(xEvent)); - event.u.u.type = UnmapNotify; - event.u.unmapNotify.window = pWin->drawable.id; - event.u.unmapNotify.fromConfigure = fromConfigure; - DeliverEvents(pWin, &event, 1, NullWindow); - } - if (wasViewable && !fromConfigure) - { - pWin->valdata = UnmapValData; - (*pScreen->MarkOverlappedWindows)(pWin, pWin->nextSib, &pLayerWin); - (*pScreen->MarkWindow)(pLayerWin->parent); + return Success; + if (SubStrSend(pWin, pParent) && MapUnmapEventsEnabled(pWin)) { + memset(&event, 0, sizeof(xEvent)); + event.u.u.type = UnmapNotify; + event.u.unmapNotify.window = pWin->drawable.id; + event.u.unmapNotify.fromConfigure = fromConfigure; + DeliverEvents(pWin, &event, 1, NullWindow); + } + if (wasViewable && !fromConfigure) { + pWin->valdata = UnmapValData; + (*pScreen->MarkOverlappedWindows) (pWin, pWin->nextSib, &pLayerWin); + (*pScreen->MarkWindow) (pLayerWin->parent); } pWin->mapped = FALSE; if (wasRealized) - UnrealizeTree(pWin, fromConfigure); - if (wasViewable) - { - if (!fromConfigure) - { - (*pScreen->ValidateTree)(pLayerWin->parent, pWin, VTUnmap); - (*pScreen->HandleExposures)(pLayerWin->parent); - } - if (!fromConfigure && pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pLayerWin->parent, pWin, VTUnmap); + UnrealizeTree(pWin, fromConfigure); + if (wasViewable) { + if (!fromConfigure) { + (*pScreen->ValidateTree) (pLayerWin->parent, pWin, VTUnmap); + (*pScreen->HandleExposures) (pLayerWin->parent); + } + if (!fromConfigure && pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pLayerWin->parent, pWin, VTUnmap); } if (wasRealized && !fromConfigure) { - WindowsRestructured (); - WindowGone(pWin); + WindowsRestructured(); + WindowGone(pWin); } return Success; } @@ -2990,125 +2814,114 @@ UnmapSubwindows(WindowPtr pWin) { WindowPtr pChild, pHead; xEvent event; - Bool wasRealized = (Bool)pWin->realized; - Bool wasViewable = (Bool)pWin->viewable; + Bool wasRealized = (Bool) pWin->realized; + Bool wasViewable = (Bool) pWin->viewable; Bool anyMarked = FALSE; Mask parentNotify; WindowPtr pLayerWin = NULL; ScreenPtr pScreen = pWin->drawable.pScreen; if (!pWin->firstChild) - return; + return; parentNotify = SubSend(pWin); pHead = RealChildHead(pWin); if (wasViewable) - pLayerWin = (*pScreen->GetLayerWindow)(pWin); - - for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib) - { - if (pChild->mapped) - { - if (parentNotify || StrSend(pChild)) - { - event.u.u.type = UnmapNotify; - event.u.unmapNotify.window = pChild->drawable.id; - event.u.unmapNotify.fromConfigure = xFalse; - DeliverEvents(pChild, &event, 1, NullWindow); - } - if (pChild->viewable) - { - pChild->valdata = UnmapValData; - anyMarked = TRUE; - } - pChild->mapped = FALSE; - if (pChild->realized) - UnrealizeTree(pChild, FALSE); - if (wasViewable) - { - } - } + pLayerWin = (*pScreen->GetLayerWindow) (pWin); + + for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib) { + if (pChild->mapped) { + if (parentNotify || StrSend(pChild)) { + event.u.u.type = UnmapNotify; + event.u.unmapNotify.window = pChild->drawable.id; + event.u.unmapNotify.fromConfigure = xFalse; + DeliverEvents(pChild, &event, 1, NullWindow); + } + if (pChild->viewable) { + pChild->valdata = UnmapValData; + anyMarked = TRUE; + } + pChild->mapped = FALSE; + if (pChild->realized) + UnrealizeTree(pChild, FALSE); + if (wasViewable) { + } + } } - if (wasViewable) - { - if (anyMarked) - { - if (pLayerWin->parent == pWin) - (*pScreen->MarkWindow)(pWin); - else - { - WindowPtr ptmp; - (*pScreen->MarkOverlappedWindows)(pWin, pLayerWin, - (WindowPtr *)NULL); - (*pScreen->MarkWindow)(pLayerWin->parent); - - /* Windows between pWin and pLayerWin may not have been marked */ - ptmp = pWin; - - while (ptmp != pLayerWin->parent) - { - (*pScreen->MarkWindow)(ptmp); - ptmp = ptmp->parent; - } + if (wasViewable) { + if (anyMarked) { + if (pLayerWin->parent == pWin) + (*pScreen->MarkWindow) (pWin); + else { + WindowPtr ptmp; + + (*pScreen->MarkOverlappedWindows) (pWin, pLayerWin, + (WindowPtr *) NULL); + (*pScreen->MarkWindow) (pLayerWin->parent); + + /* Windows between pWin and pLayerWin may not have been marked */ + ptmp = pWin; + + while (ptmp != pLayerWin->parent) { + (*pScreen->MarkWindow) (ptmp); + ptmp = ptmp->parent; + } pHead = pWin->firstChild; - } - (*pScreen->ValidateTree)(pLayerWin->parent, pHead, VTUnmap); - (*pScreen->HandleExposures)(pLayerWin->parent); - } - if (anyMarked && pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pLayerWin->parent, pHead, VTUnmap); + } + (*pScreen->ValidateTree) (pLayerWin->parent, pHead, VTUnmap); + (*pScreen->HandleExposures) (pLayerWin->parent); + } + if (anyMarked && pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pLayerWin->parent, pHead, VTUnmap); } if (wasRealized) { - WindowsRestructured (); - WindowGone(pWin); + WindowsRestructured(); + WindowGone(pWin); } } - void HandleSaveSet(ClientPtr client) { WindowPtr pParent, pWin; int j; - for (j=0; j<client->numSaved; j++) - { - pWin = SaveSetWindow(client->saveSet[j]); + for (j = 0; j < client->numSaved; j++) { + pWin = SaveSetWindow(client->saveSet[j]); #ifdef XFIXES - if (SaveSetToRoot(client->saveSet[j])) - pParent = pWin->drawable.pScreen->root; - else + if (SaveSetToRoot(client->saveSet[j])) + pParent = pWin->drawable.pScreen->root; + else #endif - { - pParent = pWin->parent; - while (pParent && (wClient (pParent) == client)) - pParent = pParent->parent; - } - if (pParent) - { - if (pParent != pWin->parent) - { + { + pParent = pWin->parent; + while (pParent && (wClient(pParent) == client)) + pParent = pParent->parent; + } + if (pParent) { + if (pParent != pWin->parent) { #ifdef XFIXES - /* unmap first so that ReparentWindow doesn't remap */ - if (!SaveSetShouldMap (client->saveSet[j])) - UnmapWindow(pWin, FALSE); + /* unmap first so that ReparentWindow doesn't remap */ + if (!SaveSetShouldMap(client->saveSet[j])) + UnmapWindow(pWin, FALSE); #endif - ReparentWindow(pWin, pParent, - pWin->drawable.x - wBorderWidth (pWin) - pParent->drawable.x, - pWin->drawable.y - wBorderWidth (pWin) - pParent->drawable.y, - client); - if(!pWin->realized && pWin->mapped) - pWin->mapped = FALSE; - } + ReparentWindow(pWin, pParent, + pWin->drawable.x - wBorderWidth(pWin) - + pParent->drawable.x, + pWin->drawable.y - wBorderWidth(pWin) - + pParent->drawable.y, client); + if (!pWin->realized && pWin->mapped) + pWin->mapped = FALSE; + } #ifdef XFIXES - if (SaveSetShouldMap (client->saveSet[j])) + if (SaveSetShouldMap(client->saveSet[j])) #endif - MapWindow(pWin, client); - } + MapWindow(pWin, client); + } } free(client->saveSet); client->numSaved = 0; - client->saveSet = (SaveSetElt *)NULL; + client->saveSet = (SaveSetElt *) NULL; } /** @@ -3121,27 +2934,25 @@ PointInWindowIsVisible(WindowPtr pWin, int x, int y) BoxRec box; if (!pWin->realized) - return FALSE; - if (RegionContainsPoint(&pWin->borderClip, - x, y, &box) - && (!wInputShape(pWin) || - RegionContainsPoint(wInputShape(pWin), - x - pWin->drawable.x, - y - pWin->drawable.y, &box))) - return TRUE; + return FALSE; + if (RegionContainsPoint(&pWin->borderClip, x, y, &box) + && (!wInputShape(pWin) || + RegionContainsPoint(wInputShape(pWin), + x - pWin->drawable.x, + y - pWin->drawable.y, &box))) + return TRUE; return FALSE; } - RegionPtr NotClippedByChildren(WindowPtr pWin) { RegionPtr pReg = RegionCreate(NullBox, 1); + if (pWin->parent || - screenIsSaved != SCREEN_SAVER_ON || - !HasSaverWindow (pWin->drawable.pScreen)) - { - RegionIntersect(pReg, &pWin->borderClip, &pWin->winSize); + screenIsSaved != SCREEN_SAVER_ON || + !HasSaverWindow(pWin->drawable.pScreen)) { + RegionIntersect(pReg, &pWin->borderClip, &pWin->winSize); } return pReg; } @@ -3156,59 +2967,64 @@ SendVisibilityNotify(WindowPtr pWin) return; #ifdef PANORAMIX /* This is not quite correct yet, but it's close */ - if(!noPanoramiXExtension) { - PanoramiXRes *win; - WindowPtr pWin2; - int rc, i, Scrnum; - - Scrnum = pWin->drawable.pScreen->myNum; - - win = PanoramiXFindIDByScrnum(XRT_WINDOW, pWin->drawable.id, Scrnum); - - if(!win || (win->u.win.visibility == visibility)) - return; - - switch(visibility) { - case VisibilityUnobscured: - FOR_NSCREENS(i) { - if(i == Scrnum) continue; - - rc = dixLookupWindow(&pWin2, win->info[i].id, serverClient, - DixWriteAccess); - - if (rc == Success) { - if(pWin2->visibility == VisibilityPartiallyObscured) - return; - - if(!i) pWin = pWin2; - } - } - break; - case VisibilityPartiallyObscured: - if(Scrnum) { - rc = dixLookupWindow(&pWin2, win->info[0].id, serverClient, - DixWriteAccess); - if (rc == Success) pWin = pWin2; - } - break; - case VisibilityFullyObscured: - FOR_NSCREENS(i) { - if(i == Scrnum) continue; - - rc = dixLookupWindow(&pWin2, win->info[i].id, serverClient, - DixWriteAccess); - - if (rc == Success) { - if(pWin2->visibility != VisibilityFullyObscured) - return; - - if(!i) pWin = pWin2; - } - } - break; - } - - win->u.win.visibility = visibility; + if (!noPanoramiXExtension) { + PanoramiXRes *win; + WindowPtr pWin2; + int rc, i, Scrnum; + + Scrnum = pWin->drawable.pScreen->myNum; + + win = PanoramiXFindIDByScrnum(XRT_WINDOW, pWin->drawable.id, Scrnum); + + if (!win || (win->u.win.visibility == visibility)) + return; + + switch (visibility) { + case VisibilityUnobscured: + FOR_NSCREENS(i) { + if (i == Scrnum) + continue; + + rc = dixLookupWindow(&pWin2, win->info[i].id, serverClient, + DixWriteAccess); + + if (rc == Success) { + if (pWin2->visibility == VisibilityPartiallyObscured) + return; + + if (!i) + pWin = pWin2; + } + } + break; + case VisibilityPartiallyObscured: + if (Scrnum) { + rc = dixLookupWindow(&pWin2, win->info[0].id, serverClient, + DixWriteAccess); + if (rc == Success) + pWin = pWin2; + } + break; + case VisibilityFullyObscured: + FOR_NSCREENS(i) { + if (i == Scrnum) + continue; + + rc = dixLookupWindow(&pWin2, win->info[i].id, serverClient, + DixWriteAccess); + + if (rc == Success) { + if (pWin2->visibility != VisibilityFullyObscured) + return; + + if (!i) + pWin = pWin2; + } + } + break; + } + + win->u.win.visibility = visibility; } #endif @@ -3225,109 +3041,105 @@ dixSaveScreens(ClientPtr client, int on, int mode) { int rc, i, what, type; - if (on == SCREEN_SAVER_FORCER) - { - if (mode == ScreenSaverReset) - what = SCREEN_SAVER_OFF; - else - what = SCREEN_SAVER_ON; - type = what; + if (on == SCREEN_SAVER_FORCER) { + if (mode == ScreenSaverReset) + what = SCREEN_SAVER_OFF; + else + what = SCREEN_SAVER_ON; + type = what; } - else - { - what = on; - type = what; - if (what == screenIsSaved) - type = SCREEN_SAVER_CYCLE; + else { + what = on; + type = what; + if (what == screenIsSaved) + type = SCREEN_SAVER_CYCLE; } for (i = 0; i < screenInfo.numScreens; i++) { - rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, screenInfo.screens[i], - DixShowAccess | DixHideAccess); - if (rc != Success) - return rc; + rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, screenInfo.screens[i], + DixShowAccess | DixHideAccess); + if (rc != Success) + return rc; } - for (i = 0; i < screenInfo.numScreens; i++) - { - ScreenPtr pScreen = screenInfo.screens[i]; - if (on == SCREEN_SAVER_FORCER) - (* pScreen->SaveScreen) (pScreen, on); - if (pScreen->screensaver.ExternalScreenSaver) - { - if ((*pScreen->screensaver.ExternalScreenSaver) - (pScreen, type, on == SCREEN_SAVER_FORCER)) - continue; - } - if (type == screenIsSaved) - continue; - switch (type) { - case SCREEN_SAVER_OFF: - if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED) - { - (* pScreen->SaveScreen) (pScreen, what); - } - else if (HasSaverWindow (pScreen)) - { - pScreen->screensaver.pWindow = NullWindow; - FreeResource(pScreen->screensaver.wid, RT_NONE); - } - break; - case SCREEN_SAVER_CYCLE: - if (pScreen->screensaver.blanked == SCREEN_IS_TILED) - { - WindowPtr pWin = pScreen->screensaver.pWindow; - /* make it look like screen saver is off, so that - * NotClippedByChildren will compute a clip list - * for the root window, so miPaintWindow works - */ - screenIsSaved = SCREEN_SAVER_OFF; - (*pWin->drawable.pScreen->MoveWindow)(pWin, - (short)(-(rand() % RANDOM_WIDTH)), - (short)(-(rand() % RANDOM_WIDTH)), - pWin->nextSib, VTMove); - screenIsSaved = SCREEN_SAVER_ON; - } - /* - * Call the DDX saver in case it wants to do something - * at cycle time - */ - else if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED) - { - (* pScreen->SaveScreen) (pScreen, type); - } - break; - case SCREEN_SAVER_ON: - if (ScreenSaverBlanking != DontPreferBlanking) - { - if ((* pScreen->SaveScreen) (pScreen, what)) - { - pScreen->screensaver.blanked = SCREEN_IS_BLANKED; - continue; - } - if ((ScreenSaverAllowExposures != DontAllowExposures) && - TileScreenSaver(pScreen, SCREEN_IS_BLACK)) - { - pScreen->screensaver.blanked = SCREEN_IS_BLACK; - continue; - } - } - if ((ScreenSaverAllowExposures != DontAllowExposures) && - TileScreenSaver(pScreen, SCREEN_IS_TILED)) - { - pScreen->screensaver.blanked = SCREEN_IS_TILED; - } - else - pScreen->screensaver.blanked = SCREEN_ISNT_SAVED; - break; - } + for (i = 0; i < screenInfo.numScreens; i++) { + ScreenPtr pScreen = screenInfo.screens[i]; + + if (on == SCREEN_SAVER_FORCER) + (*pScreen->SaveScreen) (pScreen, on); + if (pScreen->screensaver.ExternalScreenSaver) { + if ((*pScreen->screensaver.ExternalScreenSaver) + (pScreen, type, on == SCREEN_SAVER_FORCER)) + continue; + } + if (type == screenIsSaved) + continue; + switch (type) { + case SCREEN_SAVER_OFF: + if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED) { + (*pScreen->SaveScreen) (pScreen, what); + } + else if (HasSaverWindow(pScreen)) { + pScreen->screensaver.pWindow = NullWindow; + FreeResource(pScreen->screensaver.wid, RT_NONE); + } + break; + case SCREEN_SAVER_CYCLE: + if (pScreen->screensaver.blanked == SCREEN_IS_TILED) { + WindowPtr pWin = pScreen->screensaver.pWindow; + + /* make it look like screen saver is off, so that + * NotClippedByChildren will compute a clip list + * for the root window, so miPaintWindow works + */ + screenIsSaved = SCREEN_SAVER_OFF; + (*pWin->drawable.pScreen->MoveWindow) (pWin, + (short) (- + (rand() % + RANDOM_WIDTH)), + (short) (- + (rand() % + RANDOM_WIDTH)), + pWin->nextSib, VTMove); + screenIsSaved = SCREEN_SAVER_ON; + } + /* + * Call the DDX saver in case it wants to do something + * at cycle time + */ + else if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED) { + (*pScreen->SaveScreen) (pScreen, type); + } + break; + case SCREEN_SAVER_ON: + if (ScreenSaverBlanking != DontPreferBlanking) { + if ((*pScreen->SaveScreen) (pScreen, what)) { + pScreen->screensaver.blanked = SCREEN_IS_BLANKED; + continue; + } + if ((ScreenSaverAllowExposures != DontAllowExposures) && + TileScreenSaver(pScreen, SCREEN_IS_BLACK)) { + pScreen->screensaver.blanked = SCREEN_IS_BLACK; + continue; + } + } + if ((ScreenSaverAllowExposures != DontAllowExposures) && + TileScreenSaver(pScreen, SCREEN_IS_TILED)) { + pScreen->screensaver.blanked = SCREEN_IS_TILED; + } + else + pScreen->screensaver.blanked = SCREEN_ISNT_SAVED; + break; + } } screenIsSaved = what; if (mode == ScreenSaverReset) { - if (on == SCREEN_SAVER_FORCER) { - UpdateCurrentTimeIf(); - lastDeviceEventTime = currentTime; - } - SetScreenSaverTimer(); + if (on == SCREEN_SAVER_FORCER) { + DeviceIntPtr dev; + UpdateCurrentTimeIf(); + nt_list_for_each_entry(dev, inputInfo.devices, next) + lastDeviceEventTime[dev->id] = currentTime; + } + SetScreenSaverTimer(); } return Success; } @@ -3345,34 +3157,34 @@ TileScreenSaver(ScreenPtr pScreen, int kind) int result; XID attributes[3]; Mask mask; - WindowPtr pWin; + WindowPtr pWin; CursorMetricRec cm; unsigned char *srcbits, *mskbits; CursorPtr cursor; - XID cursorID = 0; - int attri; + XID cursorID = 0; + int attri; mask = 0; attri = 0; switch (kind) { case SCREEN_IS_TILED: - switch (pScreen->root->backgroundState) { - case BackgroundPixel: - attributes[attri++] = pScreen->root->background.pixel; - mask |= CWBackPixel; - break; - case BackgroundPixmap: - attributes[attri++] = None; - mask |= CWBackPixmap; - break; - default: - break; - } - break; + switch (pScreen->root->backgroundState) { + case BackgroundPixel: + attributes[attri++] = pScreen->root->background.pixel; + mask |= CWBackPixel; + break; + case BackgroundPixmap: + attributes[attri++] = None; + mask |= CWBackPixmap; + break; + default: + break; + } + break; case SCREEN_IS_BLACK: - attributes[attri++] = pScreen->root->drawable.pScreen->blackPixel; - mask |= CWBackPixel; - break; + attributes[attri++] = pScreen->root->drawable.pScreen->blackPixel; + mask |= CWBackPixel; + break; } mask |= CWOverrideRedirect; attributes[attri++] = xTrue; @@ -3381,65 +3193,59 @@ TileScreenSaver(ScreenPtr pScreen, int kind) * create a blank cursor */ - cm.width=16; - cm.height=16; - cm.xhot=8; - cm.yhot=8; - srcbits = malloc( BitmapBytePad(32)*16); - mskbits = malloc( BitmapBytePad(32)*16); - if (!srcbits || !mskbits) - { - free(srcbits); - free(mskbits); - cursor = 0; + cm.width = 16; + cm.height = 16; + cm.xhot = 8; + cm.yhot = 8; + srcbits = malloc(BitmapBytePad(32) * 16); + mskbits = malloc(BitmapBytePad(32) * 16); + if (!srcbits || !mskbits) { + free(srcbits); + free(mskbits); + cursor = 0; } - else - { - for (j=0; j<BitmapBytePad(32)*16; j++) - srcbits[j] = mskbits[j] = 0x0; - result = AllocARGBCursor(srcbits, mskbits, NULL, &cm, 0, 0, 0, 0, 0, 0, - &cursor, serverClient, (XID)0); - if (cursor) - { - cursorID = FakeClientID(0); - if (AddResource (cursorID, RT_CURSOR, (pointer) cursor)) - { - attributes[attri] = cursorID; - mask |= CWCursor; - } - else - cursor = 0; - } - else - { - free(srcbits); - free(mskbits); - } + else { + for (j = 0; j < BitmapBytePad(32) * 16; j++) + srcbits[j] = mskbits[j] = 0x0; + result = AllocARGBCursor(srcbits, mskbits, NULL, &cm, 0, 0, 0, 0, 0, 0, + &cursor, serverClient, (XID) 0); + if (cursor) { + cursorID = FakeClientID(0); + if (AddResource(cursorID, RT_CURSOR, (pointer) cursor)) { + attributes[attri] = cursorID; + mask |= CWCursor; + } + else + cursor = 0; + } + else { + free(srcbits); + free(mskbits); + } } pWin = pScreen->screensaver.pWindow = - CreateWindow(pScreen->screensaver.wid, - pScreen->root, - -RANDOM_WIDTH, -RANDOM_WIDTH, - (unsigned short)pScreen->width + RANDOM_WIDTH, - (unsigned short)pScreen->height + RANDOM_WIDTH, - 0, InputOutput, mask, attributes, 0, serverClient, - wVisual (pScreen->root), &result); + CreateWindow(pScreen->screensaver.wid, + pScreen->root, + -RANDOM_WIDTH, -RANDOM_WIDTH, + (unsigned short) pScreen->width + RANDOM_WIDTH, + (unsigned short) pScreen->height + RANDOM_WIDTH, + 0, InputOutput, mask, attributes, 0, serverClient, + wVisual(pScreen->root), &result); if (cursor) - FreeResource (cursorID, RT_NONE); + FreeResource(cursorID, RT_NONE); if (!pWin) - return FALSE; + return FALSE; if (!AddResource(pWin->drawable.id, RT_WINDOW, - (pointer)pScreen->screensaver.pWindow)) - return FALSE; + (pointer) pScreen->screensaver.pWindow)) + return FALSE; - if (mask & CWBackPixmap) - { - MakeRootTile (pWin); - (*pWin->drawable.pScreen->ChangeWindowAttributes)(pWin, CWBackPixmap); + if (mask & CWBackPixmap) { + MakeRootTile(pWin); + (*pWin->drawable.pScreen->ChangeWindowAttributes) (pWin, CWBackPixmap); } MapWindow(pWin, serverClient); return TRUE; @@ -3454,10 +3260,10 @@ TileScreenSaver(ScreenPtr pScreen, int kind) */ WindowPtr -FindWindowWithOptional (WindowPtr w) +FindWindowWithOptional(WindowPtr w) { do - w = w->parent; + w = w->parent; while (!w->optional); return w; } @@ -3471,41 +3277,40 @@ FindWindowWithOptional (WindowPtr w) */ void -CheckWindowOptionalNeed (WindowPtr w) +CheckWindowOptionalNeed(WindowPtr w) { WindowOptPtr optional; WindowOptPtr parentOptional; if (!w->parent || !w->optional) - return; + return; optional = w->optional; if (optional->dontPropagateMask != DontPropagateMasks[w->dontPropagate]) - return; + return; if (optional->otherEventMasks != 0) - return; + return; if (optional->otherClients != NULL) - return; + return; if (optional->passiveGrabs != NULL) - return; + return; if (optional->userProps != NULL) - return; + return; if (optional->backingBitPlanes != ~0L) - return; + return; if (optional->backingPixel != 0) - return; + return; if (optional->boundingShape != NULL) - return; + return; if (optional->clipShape != NULL) - return; + return; if (optional->inputShape != NULL) - return; + return; if (optional->inputMasks != NULL) - return; - if (optional->deviceCursors != NULL) - { + return; + if (optional->deviceCursors != NULL) { DevCursNodePtr pNode = optional->deviceCursors; - while(pNode) - { + + while (pNode) { if (pNode->cursor != None) return; pNode = pNode->next; @@ -3514,14 +3319,13 @@ CheckWindowOptionalNeed (WindowPtr w) parentOptional = FindWindowWithOptional(w)->optional; if (optional->visual != parentOptional->visual) - return; + return; if (optional->cursor != None && - (optional->cursor != parentOptional->cursor || - w->parent->cursorIsNone)) - return; + (optional->cursor != parentOptional->cursor || w->parent->cursorIsNone)) + return; if (optional->colormap != parentOptional->colormap) - return; - DisposeWindowOptional (w); + return; + DisposeWindowOptional(w); } /* @@ -3532,16 +3336,16 @@ CheckWindowOptionalNeed (WindowPtr w) */ Bool -MakeWindowOptional (WindowPtr pWin) +MakeWindowOptional(WindowPtr pWin) { WindowOptPtr optional; WindowOptPtr parentOptional; if (pWin->optional) - return TRUE; - optional = malloc(sizeof (WindowOptRec)); + return TRUE; + optional = malloc(sizeof(WindowOptRec)); if (!optional) - return FALSE; + return FALSE; optional->dontPropagateMask = DontPropagateMasks[pWin->dontPropagate]; optional->otherEventMasks = 0; optional->otherClients = NULL; @@ -3557,14 +3361,12 @@ MakeWindowOptional (WindowPtr pWin) parentOptional = FindWindowWithOptional(pWin)->optional; optional->visual = parentOptional->visual; - if (!pWin->cursorIsNone) - { - optional->cursor = parentOptional->cursor; - optional->cursor->refcnt++; + if (!pWin->cursorIsNone) { + optional->cursor = parentOptional->cursor; + optional->cursor->refcnt++; } - else - { - optional->cursor = None; + else { + optional->cursor = None; } optional->colormap = parentOptional->colormap; pWin->optional = optional; @@ -3586,9 +3388,7 @@ MakeWindowOptional (WindowPtr pWin) * cursor. If the cursor is set to None, it is inherited by the parent. */ int -ChangeWindowDeviceCursor(WindowPtr pWin, - DeviceIntPtr pDev, - CursorPtr pCursor) +ChangeWindowDeviceCursor(WindowPtr pWin, DeviceIntPtr pDev, CursorPtr pCursor) { DevCursNodePtr pNode, pPrev; CursorPtr pOldCursor = NULL; @@ -3613,8 +3413,7 @@ ChangeWindowDeviceCursor(WindowPtr pWin, pScreen = pWin->drawable.pScreen; - if (WindowSeekDeviceCursor(pWin, pDev, &pNode, &pPrev)) - { + if (WindowSeekDeviceCursor(pWin, pDev, &pNode, &pPrev)) { /* has device cursor */ if (pNode->cursor == pCursor) @@ -3622,20 +3421,19 @@ ChangeWindowDeviceCursor(WindowPtr pWin, pOldCursor = pNode->cursor; - if (!pCursor) /* remove from list */ - { - if(pPrev) - pPrev->next = pNode->next; - else - /* first item in list */ - pWin->optional->deviceCursors = pNode->next; + if (!pCursor) { /* remove from list */ + if (pPrev) + pPrev->next = pNode->next; + else + /* first item in list */ + pWin->optional->deviceCursors = pNode->next; free(pNode); goto out; } - } else - { + } + else { /* no device cursor yet */ DevCursNodePtr pNewNode; @@ -3652,40 +3450,36 @@ ChangeWindowDeviceCursor(WindowPtr pWin, if (pCursor && WindowParentHasDeviceCursor(pWin, pDev, pCursor)) pNode->cursor = None; - else - { + else { pNode->cursor = pCursor; pCursor->refcnt++; } pNode = pPrev = NULL; /* fix up children */ - for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) - { - if (WindowSeekDeviceCursor(pChild, pDev, &pNode, &pPrev)) - { - if (pNode->cursor == None) /* inherited from parent */ - { + for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) { + if (WindowSeekDeviceCursor(pChild, pDev, &pNode, &pPrev)) { + if (pNode->cursor == None) { /* inherited from parent */ pNode->cursor = pOldCursor; pOldCursor->refcnt++; - } else if (pNode->cursor == pCursor) - { + } + else if (pNode->cursor == pCursor) { pNode->cursor = None; - FreeCursor(pCursor, (Cursor)0); /* fix up refcnt */ + FreeCursor(pCursor, (Cursor) 0); /* fix up refcnt */ } } } -out: + out: if (pWin->realized) WindowHasNewCursor(pWin); if (pOldCursor) - FreeCursor(pOldCursor, (Cursor)0); + FreeCursor(pOldCursor, (Cursor) 0); /* FIXME: We SHOULD check for an error value here XXX (comment taken from ChangeWindowAttributes) */ - (*pScreen->ChangeWindowAttributes)(pWin, CWCursor); + (*pScreen->ChangeWindowAttributes) (pWin, CWCursor); return Success; } @@ -3701,11 +3495,9 @@ WindowGetDeviceCursor(WindowPtr pWin, DeviceIntPtr pDev) pList = pWin->optional->deviceCursors; - while(pList) - { - if (pList->dev == pDev) - { - if (pList->cursor == None) /* inherited from parent */ + while (pList) { + if (pList->dev == pDev) { + if (pList->cursor == None) /* inherited from parent */ return WindowGetDeviceCursor(pWin->parent, pDev); else return pList->cursor; @@ -3720,11 +3512,10 @@ WindowGetDeviceCursor(WindowPtr pWin, DeviceIntPtr pDev) * before the node respectively. Otherwise return False. * If the device is the first in list, pPrev is set to NULL. */ -static Bool -WindowSeekDeviceCursor(WindowPtr pWin, - DeviceIntPtr pDev, - DevCursNodePtr* pNode, - DevCursNodePtr* pPrev) +static Bool +WindowSeekDeviceCursor(WindowPtr pWin, + DeviceIntPtr pDev, + DevCursNodePtr * pNode, DevCursNodePtr * pPrev) { DevCursorList pList; @@ -3733,19 +3524,15 @@ WindowSeekDeviceCursor(WindowPtr pWin, pList = pWin->optional->deviceCursors; - if (pList && pList->dev == pDev) - { + if (pList && pList->dev == pDev) { *pNode = pList; *pPrev = NULL; return TRUE; } - while(pList) - { - if (pList->next) - { - if (pList->next->dev == pDev) - { + while (pList) { + if (pList->next) { + if (pList->next->dev == pDev) { *pNode = pList->next; *pPrev = pList; return TRUE; @@ -3758,30 +3545,26 @@ WindowSeekDeviceCursor(WindowPtr pWin, /* Return True if a parent has the same device cursor set or False if * otherwise - */ -static Bool -WindowParentHasDeviceCursor(WindowPtr pWin, - DeviceIntPtr pDev, - CursorPtr pCursor) + */ +static Bool +WindowParentHasDeviceCursor(WindowPtr pWin, + DeviceIntPtr pDev, CursorPtr pCursor) { WindowPtr pParent; DevCursNodePtr pParentNode, pParentPrev; pParent = pWin->parent; - while(pParent) - { - if (WindowSeekDeviceCursor(pParent, pDev, - &pParentNode, &pParentPrev)) - { + while (pParent) { + if (WindowSeekDeviceCursor(pParent, pDev, &pParentNode, &pParentPrev)) { /* if there is a node in the list, the win has a dev cursor */ - if (!pParentNode->cursor) /* inherited. */ + if (!pParentNode->cursor) /* inherited. */ pParent = pParent->parent; - else if (pParentNode->cursor == pCursor) /* inherit */ + else if (pParentNode->cursor == pCursor) /* inherit */ return TRUE; - else /* different cursor */ + else /* different cursor */ return FALSE; - } - else + } + else /* parent does not have a device cursor for our device */ return FALSE; } @@ -3797,39 +3580,34 @@ WindowParentHasDeviceCursor(WindowPtr pWin, void SetRootClip(ScreenPtr pScreen, Bool enable) { - WindowPtr pWin = pScreen->root; - WindowPtr pChild; - Bool WasViewable; - Bool anyMarked = FALSE; - WindowPtr pLayerWin; - BoxRec box; + WindowPtr pWin = pScreen->root; + WindowPtr pChild; + Bool WasViewable; + Bool anyMarked = FALSE; + WindowPtr pLayerWin; + BoxRec box; if (!pWin) - return; - WasViewable = (Bool)(pWin->viewable); - if (WasViewable) - { - for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) - { - (void) (*pScreen->MarkOverlappedWindows)(pChild, - pChild, - &pLayerWin); - } - (*pScreen->MarkWindow) (pWin); - anyMarked = TRUE; - if (pWin->valdata) - { - if (HasBorder (pWin)) - { - RegionPtr borderVisible; - - borderVisible = RegionCreate(NullBox, 1); - RegionSubtract(borderVisible, - &pWin->borderClip, &pWin->winSize); - pWin->valdata->before.borderVisible = borderVisible; - } - pWin->valdata->before.resized = TRUE; - } + return; + WasViewable = (Bool) (pWin->viewable); + if (WasViewable) { + for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) { + (void) (*pScreen->MarkOverlappedWindows) (pChild, + pChild, &pLayerWin); + } + (*pScreen->MarkWindow) (pWin); + anyMarked = TRUE; + if (pWin->valdata) { + if (HasBorder(pWin)) { + RegionPtr borderVisible; + + borderVisible = RegionCreate(NullBox, 1); + RegionSubtract(borderVisible, + &pWin->borderClip, &pWin->winSize); + pWin->valdata->before.borderVisible = borderVisible; + } + pWin->valdata->before.resized = TRUE; + } } /* @@ -3837,55 +3615,48 @@ SetRootClip(ScreenPtr pScreen, Bool enable) * that assume the root borderClip can't change well, normally * it doesn't...) */ - if (enable) - { - box.x1 = 0; - box.y1 = 0; - box.x2 = pScreen->width; - box.y2 = pScreen->height; - RegionInit(&pWin->winSize, &box, 1); - RegionInit(&pWin->borderSize, &box, 1); - if (WasViewable) - RegionReset(&pWin->borderClip, &box); - pWin->drawable.width = pScreen->width; - pWin->drawable.height = pScreen->height; - RegionBreak(&pWin->clipList); + if (enable) { + box.x1 = 0; + box.y1 = 0; + box.x2 = pScreen->width; + box.y2 = pScreen->height; + RegionInit(&pWin->winSize, &box, 1); + RegionInit(&pWin->borderSize, &box, 1); + if (WasViewable) + RegionReset(&pWin->borderClip, &box); + pWin->drawable.width = pScreen->width; + pWin->drawable.height = pScreen->height; + RegionBreak(&pWin->clipList); } - else - { - RegionEmpty(&pWin->borderClip); - RegionBreak(&pWin->clipList); + else { + RegionEmpty(&pWin->borderClip); + RegionBreak(&pWin->clipList); } - ResizeChildrenWinSize (pWin, 0, 0, 0, 0); - - if (WasViewable) - { - if (pWin->firstChild) - { - anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin->firstChild, - pWin->firstChild, - (WindowPtr *)NULL); - } - else - { - (*pScreen->MarkWindow) (pWin); - anyMarked = TRUE; - } + ResizeChildrenWinSize(pWin, 0, 0, 0, 0); + if (WasViewable) { + if (pWin->firstChild) { + anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin->firstChild, + pWin->firstChild, + (WindowPtr *) NULL); + } + else { + (*pScreen->MarkWindow) (pWin); + anyMarked = TRUE; + } - if (anyMarked) - (*pScreen->ValidateTree)(pWin, NullWindow, VTOther); + if (anyMarked) + (*pScreen->ValidateTree) (pWin, NullWindow, VTOther); } - if (WasViewable) - { - if (anyMarked) - (*pScreen->HandleExposures)(pWin); - if (anyMarked && pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pWin, NullWindow, VTOther); + if (WasViewable) { + if (anyMarked) + (*pScreen->HandleExposures) (pWin); + if (anyMarked && pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pWin, NullWindow, VTOther); } if (pWin->realized) - WindowsRestructured (); + WindowsRestructured(); FlushAllOutput(); } |