diff options
Diffstat (limited to 'mi/mioverlay.c')
| -rw-r--r-- | mi/mioverlay.c | 2466 |
1 files changed, 1210 insertions, 1256 deletions
diff --git a/mi/mioverlay.c b/mi/mioverlay.c index 766c5e7f7..f72159e73 100644 --- a/mi/mioverlay.c +++ b/mi/mioverlay.c @@ -18,46 +18,47 @@ #include "globals.h" - typedef struct { - RegionRec exposed; - RegionRec borderExposed; - RegionPtr borderVisible; - DDXPointRec oldAbsCorner; + RegionRec exposed; + RegionRec borderExposed; + RegionPtr borderVisible; + DDXPointRec oldAbsCorner; } miOverlayValDataRec, *miOverlayValDataPtr; typedef struct _TreeRec { - WindowPtr pWin; - struct _TreeRec *parent; - struct _TreeRec *firstChild; - struct _TreeRec *lastChild; - struct _TreeRec *prevSib; - struct _TreeRec *nextSib; - RegionRec borderClip; - RegionRec clipList; - unsigned visibility; - miOverlayValDataPtr valdata; + WindowPtr pWin; + struct _TreeRec *parent; + struct _TreeRec *firstChild; + struct _TreeRec *lastChild; + struct _TreeRec *prevSib; + struct _TreeRec *nextSib; + RegionRec borderClip; + RegionRec clipList; + unsigned visibility; + miOverlayValDataPtr valdata; } miOverlayTreeRec, *miOverlayTreePtr; typedef struct { - miOverlayTreePtr tree; + miOverlayTreePtr tree; } miOverlayWindowRec, *miOverlayWindowPtr; typedef struct { - CloseScreenProcPtr CloseScreen; - CreateWindowProcPtr CreateWindow; - DestroyWindowProcPtr DestroyWindow; - UnrealizeWindowProcPtr UnrealizeWindow; - RealizeWindowProcPtr RealizeWindow; - miOverlayTransFunc MakeTransparent; - miOverlayInOverlayFunc InOverlay; - Bool underlayMarked; - Bool copyUnderlay; + CloseScreenProcPtr CloseScreen; + CreateWindowProcPtr CreateWindow; + DestroyWindowProcPtr DestroyWindow; + UnrealizeWindowProcPtr UnrealizeWindow; + RealizeWindowProcPtr RealizeWindow; + miOverlayTransFunc MakeTransparent; + miOverlayInOverlayFunc InOverlay; + Bool underlayMarked; + Bool copyUnderlay; } miOverlayScreenRec, *miOverlayScreenPtr; static DevPrivateKeyRec miOverlayWindowKeyRec; + #define miOverlayWindowKey (&miOverlayWindowKeyRec) static DevPrivateKeyRec miOverlayScreenKeyRec; + #define miOverlayScreenKey (&miOverlayScreenKeyRec) static void RebuildTree(WindowPtr); @@ -73,14 +74,14 @@ static Bool miOverlayRealizeWindow(WindowPtr); static void miOverlayMarkWindow(WindowPtr); static void miOverlayReparentWindow(WindowPtr, WindowPtr); static void miOverlayRestackWindow(WindowPtr, WindowPtr); -static Bool miOverlayMarkOverlappedWindows(WindowPtr, WindowPtr, WindowPtr*); +static Bool miOverlayMarkOverlappedWindows(WindowPtr, WindowPtr, WindowPtr *); static void miOverlayMarkUnrealizedWindow(WindowPtr, WindowPtr, Bool); static int miOverlayValidateTree(WindowPtr, WindowPtr, VTKind); static void miOverlayHandleExposures(WindowPtr); static void miOverlayMoveWindow(WindowPtr, int, int, WindowPtr, VTKind); static void miOverlayWindowExposures(WindowPtr, RegionPtr, RegionPtr); static void miOverlayResizeWindow(WindowPtr, int, int, unsigned int, - unsigned int, WindowPtr); + unsigned int, WindowPtr); static void miOverlayClearToBackground(WindowPtr, int, int, int, int, Bool); static void miOverlaySetShape(WindowPtr, int); @@ -104,23 +105,24 @@ static void miOverlayChangeBorderWidth(WindowPtr, unsigned int); (w)->backgroundState == ParentRelative) Bool -miInitOverlay( - ScreenPtr pScreen, - miOverlayInOverlayFunc inOverlayFunc, - miOverlayTransFunc transFunc -){ - miOverlayScreenPtr pScreenPriv; +miInitOverlay(ScreenPtr pScreen, + miOverlayInOverlayFunc inOverlayFunc, + miOverlayTransFunc transFunc) +{ + miOverlayScreenPtr pScreenPriv; - if(!inOverlayFunc || !transFunc) return FALSE; + if (!inOverlayFunc || !transFunc) + return FALSE; - if(!dixRegisterPrivateKey(&miOverlayWindowKeyRec, PRIVATE_WINDOW, sizeof(miOverlayWindowRec))) - return FALSE; + if (!dixRegisterPrivateKey + (&miOverlayWindowKeyRec, PRIVATE_WINDOW, sizeof(miOverlayWindowRec))) + return FALSE; - if(!dixRegisterPrivateKey(&miOverlayScreenKeyRec, PRIVATE_SCREEN, 0)) - return FALSE; + if (!dixRegisterPrivateKey(&miOverlayScreenKeyRec, PRIVATE_SCREEN, 0)) + return FALSE; - if(!(pScreenPriv = malloc(sizeof(miOverlayScreenRec)))) - return FALSE; + if (!(pScreenPriv = malloc(sizeof(miOverlayScreenRec)))) + return FALSE; dixSetPrivate(&pScreen->devPrivates, miOverlayScreenKey, pScreenPriv); @@ -128,7 +130,6 @@ miInitOverlay( pScreenPriv->MakeTransparent = transFunc; pScreenPriv->underlayMarked = FALSE; - pScreenPriv->CloseScreen = pScreen->CloseScreen; pScreenPriv->CreateWindow = pScreen->CreateWindow; pScreenPriv->DestroyWindow = pScreen->DestroyWindow; @@ -158,25 +159,23 @@ miInitOverlay( return TRUE; } - -static Bool +static Bool miOverlayCloseScreen(int i, ScreenPtr pScreen) { - miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); + miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); - pScreen->CloseScreen = pScreenPriv->CloseScreen; - pScreen->CreateWindow = pScreenPriv->CreateWindow; - pScreen->DestroyWindow = pScreenPriv->DestroyWindow; - pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow; - pScreen->RealizeWindow = pScreenPriv->RealizeWindow; + pScreen->CloseScreen = pScreenPriv->CloseScreen; + pScreen->CreateWindow = pScreenPriv->CreateWindow; + pScreen->DestroyWindow = pScreenPriv->DestroyWindow; + pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow; + pScreen->RealizeWindow = pScreenPriv->RealizeWindow; - free(pScreenPriv); + free(pScreenPriv); - return (*pScreen->CloseScreen)(i, pScreen); + return (*pScreen->CloseScreen) (i, pScreen); } - -static Bool +static Bool miOverlayCreateWindow(WindowPtr pWin) { ScreenPtr pScreen = pWin->drawable.pScreen; @@ -187,43 +186,46 @@ miOverlayCreateWindow(WindowPtr pWin) pWinPriv->tree = NULL; - if(!pWin->parent || !((*pScreenPriv->InOverlay)(pWin))) { - if(!(pTree = (miOverlayTreePtr)calloc(1, sizeof(miOverlayTreeRec)))) - return FALSE; + if (!pWin->parent || !((*pScreenPriv->InOverlay) (pWin))) { + if (!(pTree = (miOverlayTreePtr) calloc(1, sizeof(miOverlayTreeRec)))) + return FALSE; } - if(pScreenPriv->CreateWindow) { - pScreen->CreateWindow = pScreenPriv->CreateWindow; - result = (*pScreen->CreateWindow)(pWin); - pScreen->CreateWindow = miOverlayCreateWindow; + if (pScreenPriv->CreateWindow) { + pScreen->CreateWindow = pScreenPriv->CreateWindow; + result = (*pScreen->CreateWindow) (pWin); + pScreen->CreateWindow = miOverlayCreateWindow; } - + if (pTree) { - if(result) { - pTree->pWin = pWin; - pTree->visibility = VisibilityNotViewable; - pWinPriv->tree = pTree; - if(pWin->parent) { - RegionNull(&(pTree->borderClip)); - RegionNull(&(pTree->clipList)); - RebuildTree(pWin); - } else { - BoxRec fullBox; - fullBox.x1 = 0; - fullBox.y1 = 0; - fullBox.x2 = pScreen->width; - fullBox.y2 = pScreen->height; - RegionInit(&(pTree->borderClip), &fullBox, 1); - RegionInit(&(pTree->clipList), &fullBox, 1); - } - } else free(pTree); + if (result) { + pTree->pWin = pWin; + pTree->visibility = VisibilityNotViewable; + pWinPriv->tree = pTree; + if (pWin->parent) { + RegionNull(&(pTree->borderClip)); + RegionNull(&(pTree->clipList)); + RebuildTree(pWin); + } + else { + BoxRec fullBox; + + fullBox.x1 = 0; + fullBox.y1 = 0; + fullBox.x2 = pScreen->width; + fullBox.y2 = pScreen->height; + RegionInit(&(pTree->borderClip), &fullBox, 1); + RegionInit(&(pTree->clipList), &fullBox, 1); + } + } + else + free(pTree); } return TRUE; } - -static Bool +static Bool miOverlayDestroyWindow(WindowPtr pWin) { ScreenPtr pScreen = pWin->drawable.pScreen; @@ -232,31 +234,31 @@ miOverlayDestroyWindow(WindowPtr pWin) Bool result = TRUE; if (pTree) { - if(pTree->prevSib) - pTree->prevSib->nextSib = pTree->nextSib; - else if(pTree->parent) - pTree->parent->firstChild = pTree->nextSib; - - if(pTree->nextSib) - pTree->nextSib->prevSib = pTree->prevSib; - else if(pTree->parent) - pTree->parent->lastChild = pTree->prevSib; - - RegionUninit(&(pTree->borderClip)); - RegionUninit(&(pTree->clipList)); - free(pTree); + if (pTree->prevSib) + pTree->prevSib->nextSib = pTree->nextSib; + else if (pTree->parent) + pTree->parent->firstChild = pTree->nextSib; + + if (pTree->nextSib) + pTree->nextSib->prevSib = pTree->prevSib; + else if (pTree->parent) + pTree->parent->lastChild = pTree->prevSib; + + RegionUninit(&(pTree->borderClip)); + RegionUninit(&(pTree->clipList)); + free(pTree); } - if(pScreenPriv->DestroyWindow) { - pScreen->DestroyWindow = pScreenPriv->DestroyWindow; - result = (*pScreen->DestroyWindow)(pWin); - pScreen->DestroyWindow = miOverlayDestroyWindow; + if (pScreenPriv->DestroyWindow) { + pScreen->DestroyWindow = pScreenPriv->DestroyWindow; + result = (*pScreen->DestroyWindow) (pWin); + pScreen->DestroyWindow = miOverlayDestroyWindow; } return result; } -static Bool +static Bool miOverlayUnrealizeWindow(WindowPtr pWin) { ScreenPtr pScreen = pWin->drawable.pScreen; @@ -264,197 +266,193 @@ miOverlayUnrealizeWindow(WindowPtr pWin) miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); Bool result = TRUE; - if(pTree) pTree->visibility = VisibilityNotViewable; + if (pTree) + pTree->visibility = VisibilityNotViewable; - if(pScreenPriv->UnrealizeWindow) { - pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow; - result = (*pScreen->UnrealizeWindow)(pWin); - pScreen->UnrealizeWindow = miOverlayUnrealizeWindow; + if (pScreenPriv->UnrealizeWindow) { + pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow; + result = (*pScreen->UnrealizeWindow) (pWin); + pScreen->UnrealizeWindow = miOverlayUnrealizeWindow; } return result; } - -static Bool +static Bool miOverlayRealizeWindow(WindowPtr pWin) { ScreenPtr pScreen = pWin->drawable.pScreen; miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); Bool result = TRUE; - if(pScreenPriv->RealizeWindow) { - pScreen->RealizeWindow = pScreenPriv->RealizeWindow; - result = (*pScreen->RealizeWindow)(pWin); - pScreen->RealizeWindow = miOverlayRealizeWindow; + if (pScreenPriv->RealizeWindow) { + pScreen->RealizeWindow = pScreenPriv->RealizeWindow; + result = (*pScreen->RealizeWindow) (pWin); + pScreen->RealizeWindow = miOverlayRealizeWindow; } /* we only need to catch the root window realization */ - if(result && !pWin->parent && !((*pScreenPriv->InOverlay)(pWin))) - { - BoxRec box; - box.x1 = box.y1 = 0; - box.x2 = pWin->drawable.width; - box.y2 = pWin->drawable.height; - (*pScreenPriv->MakeTransparent)(pScreen, 1, &box); + if (result && !pWin->parent && !((*pScreenPriv->InOverlay) (pWin))) { + BoxRec box; + + box.x1 = box.y1 = 0; + box.x2 = pWin->drawable.width; + box.y2 = pWin->drawable.height; + (*pScreenPriv->MakeTransparent) (pScreen, 1, &box); } return result; } - -static void +static void miOverlayReparentWindow(WindowPtr pWin, WindowPtr pPriorParent) { - if(IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) { - /* This could probably be more optimal */ - RebuildTree(pWin->drawable.pScreen->root->firstChild); - } + if (IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) { + /* This could probably be more optimal */ + RebuildTree(pWin->drawable.pScreen->root->firstChild); + } } -static void +static void miOverlayRestackWindow(WindowPtr pWin, WindowPtr oldNextSib) { - if(IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) { - /* This could probably be more optimal */ - RebuildTree(pWin); - } + if (IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) { + /* This could probably be more optimal */ + RebuildTree(pWin); + } } - static Bool -miOverlayMarkOverlappedWindows( - WindowPtr pWin, - WindowPtr pFirst, - WindowPtr *pLayerWin -){ +miOverlayMarkOverlappedWindows(WindowPtr pWin, + WindowPtr pFirst, WindowPtr *pLayerWin) +{ WindowPtr pChild, pLast; Bool overMarked, underMarked, doUnderlay, markAll; miOverlayTreePtr pTree = NULL, tLast, tChild; BoxPtr box; - + overMarked = underMarked = markAll = FALSE; - if(pLayerWin) *pLayerWin = pWin; /* hah! */ + if (pLayerWin) + *pLayerWin = pWin; /* hah! */ doUnderlay = (IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)); box = RegionExtents(&pWin->borderSize); - if((pChild = pFirst)) { - pLast = pChild->parent->lastChild; - while (1) { - if (pChild == pWin) markAll = TRUE; + if ((pChild = pFirst)) { + pLast = pChild->parent->lastChild; + while (1) { + if (pChild == pWin) + markAll = TRUE; - if(doUnderlay && IN_UNDERLAY(pChild)) - pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); + if (doUnderlay && IN_UNDERLAY(pChild)) + pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); - if(pChild->viewable) { + if (pChild->viewable) { if (RegionBroken(&pChild->winSize)) - SetWinSize (pChild); + SetWinSize(pChild); if (RegionBroken(&pChild->borderSize)) - SetBorderSize (pChild); - - if (markAll || - RegionContainsRect(&pChild->borderSize, box)) - { - MARK_OVERLAY(pChild); - overMarked = TRUE; - if(doUnderlay && IN_UNDERLAY(pChild)) { - MARK_UNDERLAY(pChild); - underMarked = TRUE; - } - if (pChild->firstChild) { - pChild = pChild->firstChild; - continue; - } - } - } - while (!pChild->nextSib && (pChild != pLast)) { - pChild = pChild->parent; - if(doUnderlay && IN_UNDERLAY(pChild)) - pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); - } - - if(pChild == pWin) markAll = FALSE; - - if (pChild == pLast) break; - - pChild = pChild->nextSib; - } - if(overMarked) - MARK_OVERLAY(pWin->parent); - } - - if(doUnderlay && !pTree) { - if(!(pTree = MIOVERLAY_GET_WINDOW_TREE(pWin))) { - pChild = pWin->lastChild; - while(1) { - if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) - break; - - if(pChild->lastChild) { - pChild = pChild->lastChild; - continue; - } - - while(!pChild->prevSib) pChild = pChild->parent; - - pChild = pChild->prevSib; - } - } + SetBorderSize(pChild); + + if (markAll || RegionContainsRect(&pChild->borderSize, box)) { + MARK_OVERLAY(pChild); + overMarked = TRUE; + if (doUnderlay && IN_UNDERLAY(pChild)) { + MARK_UNDERLAY(pChild); + underMarked = TRUE; + } + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + } + } + while (!pChild->nextSib && (pChild != pLast)) { + pChild = pChild->parent; + if (doUnderlay && IN_UNDERLAY(pChild)) + pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); + } + + if (pChild == pWin) + markAll = FALSE; + + if (pChild == pLast) + break; + + pChild = pChild->nextSib; + } + if (overMarked) + MARK_OVERLAY(pWin->parent); + } + + if (doUnderlay && !pTree) { + if (!(pTree = MIOVERLAY_GET_WINDOW_TREE(pWin))) { + pChild = pWin->lastChild; + while (1) { + if ((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) + break; + + if (pChild->lastChild) { + pChild = pChild->lastChild; + continue; + } + + while (!pChild->prevSib) + pChild = pChild->parent; + + pChild = pChild->prevSib; + } + } } - - if(pTree && pTree->nextSib) { - tChild = pTree->parent->lastChild; - tLast = pTree->nextSib; - while(1) { - if(tChild->pWin->viewable) { + if (pTree && pTree->nextSib) { + tChild = pTree->parent->lastChild; + tLast = pTree->nextSib; + + while (1) { + if (tChild->pWin->viewable) { if (RegionBroken(&tChild->pWin->winSize)) - SetWinSize (tChild->pWin); + SetWinSize(tChild->pWin); if (RegionBroken(&tChild->pWin->borderSize)) - SetBorderSize (tChild->pWin); + SetBorderSize(tChild->pWin); - if(RegionContainsRect(&(tChild->pWin->borderSize), box)) - { - MARK_UNDERLAY(tChild->pWin); - underMarked = TRUE; - } - } + if (RegionContainsRect(&(tChild->pWin->borderSize), box)) { + MARK_UNDERLAY(tChild->pWin); + underMarked = TRUE; + } + } - if(tChild->lastChild) { - tChild = tChild->lastChild; - continue; - } + if (tChild->lastChild) { + tChild = tChild->lastChild; + continue; + } - while(!tChild->prevSib && (tChild != tLast)) - tChild = tChild->parent; + while (!tChild->prevSib && (tChild != tLast)) + tChild = tChild->parent; - if(tChild == tLast) break; + if (tChild == tLast) + break; - tChild = tChild->prevSib; - } + tChild = tChild->prevSib; + } } - if(underMarked) { - ScreenPtr pScreen = pWin->drawable.pScreen; - MARK_UNDERLAY(pTree->parent->pWin); - MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->underlayMarked = TRUE; + if (underMarked) { + ScreenPtr pScreen = pWin->drawable.pScreen; + + MARK_UNDERLAY(pTree->parent->pWin); + MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->underlayMarked = TRUE; } return underMarked || overMarked; } - static void -miOverlayComputeClips( - WindowPtr pParent, - RegionPtr universe, - VTKind kind, - RegionPtr exposed -){ +miOverlayComputeClips(WindowPtr pParent, + RegionPtr universe, VTKind kind, RegionPtr exposed) +{ ScreenPtr pScreen = pParent->drawable.pScreen; int oldVis, newVis, dx, dy; BoxRec borderSize; @@ -466,44 +464,45 @@ miOverlayComputeClips( borderSize.x1 = pParent->drawable.x - wBorderWidth(pParent); borderSize.y1 = pParent->drawable.y - wBorderWidth(pParent); - dx = (int) pParent->drawable.x + (int) pParent->drawable.width + - wBorderWidth(pParent); - if (dx > 32767) dx = 32767; + dx = (int) pParent->drawable.x + (int) pParent->drawable.width + + wBorderWidth(pParent); + if (dx > 32767) + dx = 32767; borderSize.x2 = dx; - dy = (int) pParent->drawable.y + (int) pParent->drawable.height + - wBorderWidth(pParent); - if (dy > 32767) dy = 32767; + dy = (int) pParent->drawable.y + (int) pParent->drawable.height + + wBorderWidth(pParent); + if (dy > 32767) + dy = 32767; borderSize.y2 = dy; - + oldVis = tParent->visibility; switch (RegionContainsRect(universe, &borderSize)) { - case rgnIN: - newVis = VisibilityUnobscured; - break; - case rgnPART: - newVis = VisibilityPartiallyObscured; - { - RegionPtr pBounding; - - if ((pBounding = wBoundingShape (pParent))) { - switch (miShapedWindowIn (universe, pBounding, - &borderSize, - pParent->drawable.x, - pParent->drawable.y)) - { - case rgnIN: - newVis = VisibilityUnobscured; - break; - case rgnOUT: - newVis = VisibilityFullyObscured; - break; - } - } - } - break; - default: - newVis = VisibilityFullyObscured; - break; + case rgnIN: + newVis = VisibilityUnobscured; + break; + case rgnPART: + newVis = VisibilityPartiallyObscured; + { + RegionPtr pBounding; + + if ((pBounding = wBoundingShape(pParent))) { + switch (miShapedWindowIn(universe, pBounding, + &borderSize, + pParent->drawable.x, + pParent->drawable.y)) { + case rgnIN: + newVis = VisibilityUnobscured; + break; + case rgnOUT: + newVis = VisibilityFullyObscured; + break; + } + } + } + break; + default: + newVis = VisibilityFullyObscured; + break; } tParent->visibility = newVis; @@ -514,222 +513,214 @@ miOverlayComputeClips( case VTMap: case VTStack: case VTUnmap: - break; + break; case VTMove: - if ((oldVis == newVis) && - ((oldVis == VisibilityFullyObscured) || - (oldVis == VisibilityUnobscured))) - { - tChild = tParent; - while (1) { - if (tChild->pWin->viewable) { - if (tChild->visibility != VisibilityFullyObscured) { - RegionTranslate(&tChild->borderClip, dx, dy); - RegionTranslate(&tChild->clipList, dx, dy); - - tChild->pWin->drawable.serialNumber = - NEXT_SERIAL_NUMBER; + if ((oldVis == newVis) && + ((oldVis == VisibilityFullyObscured) || + (oldVis == VisibilityUnobscured))) { + tChild = tParent; + while (1) { + if (tChild->pWin->viewable) { + if (tChild->visibility != VisibilityFullyObscured) { + RegionTranslate(&tChild->borderClip, dx, dy); + RegionTranslate(&tChild->clipList, dx, dy); + + tChild->pWin->drawable.serialNumber = + NEXT_SERIAL_NUMBER; if (pScreen->ClipNotify) - (* pScreen->ClipNotify) (tChild->pWin, dx, dy); - } - if (tChild->valdata) { - RegionNull(&tChild->valdata->borderExposed); - if (HasParentRelativeBorder(tChild->pWin)){ - RegionSubtract(&tChild->valdata->borderExposed, - &tChild->borderClip, - &tChild->pWin->winSize); - } - RegionNull(&tChild->valdata->exposed); - } - if (tChild->firstChild) { - tChild = tChild->firstChild; - continue; - } - } - while (!tChild->nextSib && (tChild != tParent)) - tChild = tChild->parent; - if (tChild == tParent) - break; - tChild = tChild->nextSib; - } - return; - } - /* fall through */ + (*pScreen->ClipNotify) (tChild->pWin, dx, dy); + } + if (tChild->valdata) { + RegionNull(&tChild->valdata->borderExposed); + if (HasParentRelativeBorder(tChild->pWin)) { + RegionSubtract(&tChild->valdata->borderExposed, + &tChild->borderClip, + &tChild->pWin->winSize); + } + RegionNull(&tChild->valdata->exposed); + } + if (tChild->firstChild) { + tChild = tChild->firstChild; + continue; + } + } + while (!tChild->nextSib && (tChild != tParent)) + tChild = tChild->parent; + if (tChild == tParent) + break; + tChild = tChild->nextSib; + } + return; + } + /* fall through */ default: - if (dx || dy) { - RegionTranslate(&tParent->borderClip, dx, dy); - RegionTranslate(&tParent->clipList, dx, dy); - } - break; + if (dx || dy) { + RegionTranslate(&tParent->borderClip, dx, dy); + RegionTranslate(&tParent->clipList, dx, dy); + } + break; case VTBroken: - RegionEmpty(&tParent->borderClip); - RegionEmpty(&tParent->clipList); - break; + RegionEmpty(&tParent->borderClip); + RegionEmpty(&tParent->clipList); + break; } borderVisible = tParent->valdata->borderVisible; RegionNull(&tParent->valdata->borderExposed); RegionNull(&tParent->valdata->exposed); - if (HasBorder (pParent)) { - if (borderVisible) { - RegionSubtract(exposed, universe, borderVisible); - RegionDestroy(borderVisible); - } else - RegionSubtract(exposed, universe, &tParent->borderClip); - - if (HasParentRelativeBorder(pParent) && (dx || dy)) - RegionSubtract(&tParent->valdata->borderExposed, - universe, &pParent->winSize); - else - RegionSubtract(&tParent->valdata->borderExposed, - exposed, &pParent->winSize); - - RegionCopy(&tParent->borderClip, universe); - RegionIntersect(universe, universe, &pParent->winSize); + if (HasBorder(pParent)) { + if (borderVisible) { + RegionSubtract(exposed, universe, borderVisible); + RegionDestroy(borderVisible); + } + else + RegionSubtract(exposed, universe, &tParent->borderClip); + + if (HasParentRelativeBorder(pParent) && (dx || dy)) + RegionSubtract(&tParent->valdata->borderExposed, + universe, &pParent->winSize); + else + RegionSubtract(&tParent->valdata->borderExposed, + exposed, &pParent->winSize); + + RegionCopy(&tParent->borderClip, universe); + RegionIntersect(universe, universe, &pParent->winSize); } else - RegionCopy(&tParent->borderClip, universe); + RegionCopy(&tParent->borderClip, universe); if ((tChild = tParent->firstChild) && pParent->mapped) { - RegionNull(&childUniverse); - RegionNull(&childUnion); - - for (; tChild; tChild = tChild->nextSib) { - if (tChild->pWin->viewable) - RegionAppend(&childUnion, &tChild->pWin->borderSize); - } - - RegionValidate(&childUnion, &overlap); - - for (tChild = tParent->firstChild; - tChild; - tChild = tChild->nextSib) - { - if (tChild->pWin->viewable) { - if (tChild->valdata) { - RegionIntersect(&childUniverse, universe, - &tChild->pWin->borderSize); - miOverlayComputeClips (tChild->pWin, &childUniverse, - kind, exposed); - } - if (overlap) - RegionSubtract(universe, universe, - &tChild->pWin->borderSize); - } - } - if (!overlap) - RegionSubtract(universe, universe, &childUnion); - RegionUninit(&childUnion); - RegionUninit(&childUniverse); - } - - if (oldVis == VisibilityFullyObscured || - oldVis == VisibilityNotViewable) - { - RegionCopy(&tParent->valdata->exposed, universe); + RegionNull(&childUniverse); + RegionNull(&childUnion); + + for (; tChild; tChild = tChild->nextSib) { + if (tChild->pWin->viewable) + RegionAppend(&childUnion, &tChild->pWin->borderSize); + } + + RegionValidate(&childUnion, &overlap); + + for (tChild = tParent->firstChild; tChild; tChild = tChild->nextSib) { + if (tChild->pWin->viewable) { + if (tChild->valdata) { + RegionIntersect(&childUniverse, universe, + &tChild->pWin->borderSize); + miOverlayComputeClips(tChild->pWin, &childUniverse, + kind, exposed); + } + if (overlap) + RegionSubtract(universe, universe, + &tChild->pWin->borderSize); + } + } + if (!overlap) + RegionSubtract(universe, universe, &childUnion); + RegionUninit(&childUnion); + RegionUninit(&childUniverse); + } + + if (oldVis == VisibilityFullyObscured || oldVis == VisibilityNotViewable) { + RegionCopy(&tParent->valdata->exposed, universe); } else if (newVis != VisibilityFullyObscured && - newVis != VisibilityNotViewable) - { - RegionSubtract(&tParent->valdata->exposed, - universe, &tParent->clipList); + newVis != VisibilityNotViewable) { + RegionSubtract(&tParent->valdata->exposed, + universe, &tParent->clipList); } - + /* HACK ALERT - copying contents of regions, instead of regions */ { - RegionRec tmp; + RegionRec tmp; - tmp = tParent->clipList; - tParent->clipList = *universe; - *universe = tmp; + tmp = tParent->clipList; + tParent->clipList = *universe; + *universe = tmp; } pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER; if (pScreen->ClipNotify) - (* pScreen->ClipNotify) (pParent, dx, dy); + (*pScreen->ClipNotify) (pParent, dx, dy); } - -static void +static void miOverlayMarkWindow(WindowPtr pWin) { miOverlayTreePtr pTree = NULL; WindowPtr pChild, pGrandChild; - + miMarkWindow(pWin); /* look for UnmapValdata among immediate children */ - if(!(pChild = pWin->firstChild)) return; - - for( ; pChild; pChild = pChild->nextSib) { - if(pChild->valdata == UnmapValData) { - if(IN_UNDERLAY(pChild)) { - pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); - pTree->valdata = (miOverlayValDataPtr)UnmapValData; - continue; - } else { - if(!(pGrandChild = pChild->firstChild)) - continue; - - while(1) { - if(IN_UNDERLAY(pGrandChild)) { - pTree = MIOVERLAY_GET_WINDOW_TREE(pGrandChild); - pTree->valdata = (miOverlayValDataPtr)UnmapValData; - } else if(pGrandChild->firstChild) { - pGrandChild = pGrandChild->firstChild; - continue; - } - - while(!pGrandChild->nextSib && (pGrandChild != pChild)) - pGrandChild = pGrandChild->parent; - - if(pChild == pGrandChild) break; - - pGrandChild = pGrandChild->nextSib; - } - } + if (!(pChild = pWin->firstChild)) + return; + + for (; pChild; pChild = pChild->nextSib) { + if (pChild->valdata == UnmapValData) { + if (IN_UNDERLAY(pChild)) { + pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); + pTree->valdata = (miOverlayValDataPtr) UnmapValData; + continue; + } + else { + if (!(pGrandChild = pChild->firstChild)) + continue; + + while (1) { + if (IN_UNDERLAY(pGrandChild)) { + pTree = MIOVERLAY_GET_WINDOW_TREE(pGrandChild); + pTree->valdata = (miOverlayValDataPtr) UnmapValData; + } + else if (pGrandChild->firstChild) { + pGrandChild = pGrandChild->firstChild; + continue; + } + + while (!pGrandChild->nextSib && (pGrandChild != pChild)) + pGrandChild = pGrandChild->parent; + + if (pChild == pGrandChild) + break; + + pGrandChild = pGrandChild->nextSib; + } + } } } - if(pTree) { - MARK_UNDERLAY(pTree->parent->pWin); - MIOVERLAY_GET_SCREEN_PRIVATE( - pWin->drawable.pScreen)->underlayMarked = TRUE; + if (pTree) { + MARK_UNDERLAY(pTree->parent->pWin); + MIOVERLAY_GET_SCREEN_PRIVATE(pWin->drawable.pScreen)->underlayMarked = + TRUE; } } static void -miOverlayMarkUnrealizedWindow( - WindowPtr pChild, - WindowPtr pWin, - Bool fromConfigure -){ +miOverlayMarkUnrealizedWindow(WindowPtr pChild, + WindowPtr pWin, Bool fromConfigure) +{ if ((pChild != pWin) || fromConfigure) { - miOverlayTreePtr pTree; + miOverlayTreePtr pTree; RegionEmpty(&pChild->clipList); if (pChild->drawable.pScreen->ClipNotify) - (* pChild->drawable.pScreen->ClipNotify)(pChild, 0, 0); + (*pChild->drawable.pScreen->ClipNotify) (pChild, 0, 0); RegionEmpty(&pChild->borderClip); - if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) { - if(pTree->valdata != (miOverlayValDataPtr)UnmapValData) { - RegionEmpty(&pTree->clipList); - RegionEmpty(&pTree->borderClip); - } - } + if ((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) { + if (pTree->valdata != (miOverlayValDataPtr) UnmapValData) { + RegionEmpty(&pTree->clipList); + RegionEmpty(&pTree->borderClip); + } + } } } - -static int -miOverlayValidateTree( - WindowPtr pParent, - WindowPtr pChild, /* first child effected */ - VTKind kind -){ +static int +miOverlayValidateTree(WindowPtr pParent, WindowPtr pChild, /* first child effected */ + VTKind kind) +{ ScreenPtr pScreen = pParent->drawable.pScreen; miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); RegionRec totalClip, childClip, exposed; @@ -737,10 +728,11 @@ miOverlayValidateTree( Bool overlap; WindowPtr newParent; - if(!pPriv->underlayMarked) - goto SKIP_UNDERLAY; + if (!pPriv->underlayMarked) + goto SKIP_UNDERLAY; - if (!pChild) pChild = pParent->firstChild; + if (!pChild) + pChild = pParent->firstChild; RegionNull(&totalClip); RegionNull(&childClip); @@ -748,90 +740,86 @@ miOverlayValidateTree( newParent = pParent; - while(IN_OVERLAY(newParent)) - newParent = newParent->parent; + while (IN_OVERLAY(newParent)) + newParent = newParent->parent; tParent = MIOVERLAY_GET_WINDOW_TREE(newParent); - if(IN_UNDERLAY(pChild)) - tChild = MIOVERLAY_GET_WINDOW_TREE(pChild); + if (IN_UNDERLAY(pChild)) + tChild = MIOVERLAY_GET_WINDOW_TREE(pChild); else - tChild = tParent->firstChild; + tChild = tParent->firstChild; + + if (RegionBroken(&tParent->clipList) && !RegionBroken(&tParent->borderClip)) { + kind = VTBroken; + RegionCopy(&totalClip, &tParent->borderClip); + RegionIntersect(&totalClip, &totalClip, &tParent->pWin->winSize); - if (RegionBroken(&tParent->clipList) && - !RegionBroken(&tParent->borderClip)) - { - kind = VTBroken; - RegionCopy(&totalClip, &tParent->borderClip); - RegionIntersect(&totalClip, &totalClip, - &tParent->pWin->winSize); - for (tWin = tParent->firstChild; tWin != tChild; tWin = tWin->nextSib) { if (tWin->pWin->viewable) - RegionSubtract(&totalClip, &totalClip, - &tWin->pWin->borderSize); - } + RegionSubtract(&totalClip, &totalClip, &tWin->pWin->borderSize); + } RegionEmpty(&tParent->clipList); - } else { - for(tWin = tChild; tWin; tWin = tWin->nextSib) { - if(tWin->valdata) - RegionAppend(&totalClip, &tWin->borderClip); - } - RegionValidate(&totalClip, &overlap); } + else { + for (tWin = tChild; tWin; tWin = tWin->nextSib) { + if (tWin->valdata) + RegionAppend(&totalClip, &tWin->borderClip); + } + RegionValidate(&totalClip, &overlap); + } + + if (kind != VTStack) + RegionUnion(&totalClip, &totalClip, &tParent->clipList); - if(kind != VTStack) - RegionUnion(&totalClip, &totalClip, &tParent->clipList); - - for(tWin = tChild; tWin; tWin = tWin->nextSib) { - if(tWin->valdata) { - if(tWin->pWin->viewable) { - RegionIntersect(&childClip, &totalClip, - &tWin->pWin->borderSize); - miOverlayComputeClips(tWin->pWin, &childClip, kind, &exposed); - RegionSubtract(&totalClip, &totalClip, - &tWin->pWin->borderSize); - } else { /* Means we are unmapping */ + for (tWin = tChild; tWin; tWin = tWin->nextSib) { + if (tWin->valdata) { + if (tWin->pWin->viewable) { + RegionIntersect(&childClip, &totalClip, + &tWin->pWin->borderSize); + miOverlayComputeClips(tWin->pWin, &childClip, kind, &exposed); + RegionSubtract(&totalClip, &totalClip, &tWin->pWin->borderSize); + } + else { /* Means we are unmapping */ RegionEmpty(&tWin->clipList); RegionEmpty(&tWin->borderClip); - tWin->valdata = NULL; - } - } + tWin->valdata = NULL; + } + } } RegionUninit(&childClip); - if(!((*pPriv->InOverlay)(newParent))) { - RegionNull(&tParent->valdata->exposed); - RegionNull(&tParent->valdata->borderExposed); + if (!((*pPriv->InOverlay) (newParent))) { + RegionNull(&tParent->valdata->exposed); + RegionNull(&tParent->valdata->borderExposed); } switch (kind) { case VTStack: - break; + break; default: - if(!((*pPriv->InOverlay)(newParent))) - RegionSubtract(&tParent->valdata->exposed, &totalClip, - &tParent->clipList); - /* fall through */ + if (!((*pPriv->InOverlay) (newParent))) + RegionSubtract(&tParent->valdata->exposed, &totalClip, + &tParent->clipList); + /* fall through */ case VTMap: - RegionCopy(&tParent->clipList, &totalClip); - if(!((*pPriv->InOverlay)(newParent))) - newParent->drawable.serialNumber = NEXT_SERIAL_NUMBER; - break; + RegionCopy(&tParent->clipList, &totalClip); + if (!((*pPriv->InOverlay) (newParent))) + newParent->drawable.serialNumber = NEXT_SERIAL_NUMBER; + break; } RegionUninit(&totalClip); RegionUninit(&exposed); -SKIP_UNDERLAY: + SKIP_UNDERLAY: miValidateTree(pParent, pChild, kind); return 1; } - static void miOverlayHandleExposures(WindowPtr pWin) { @@ -839,402 +827,385 @@ miOverlayHandleExposures(WindowPtr pWin) miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); WindowPtr pChild; ValidatePtr val; - void (* WindowExposures)(WindowPtr, RegionPtr, RegionPtr); + void (*WindowExposures) (WindowPtr, RegionPtr, RegionPtr); WindowExposures = pWin->drawable.pScreen->WindowExposures; - if(pPriv->underlayMarked) { - miOverlayTreePtr pTree; - miOverlayValDataPtr mival; - - pChild = pWin; - while(IN_OVERLAY(pChild)) - pChild = pChild->parent; - - pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); - - while (1) { - if((mival = pTree->valdata)) { - if(!((*pPriv->InOverlay)(pTree->pWin))) { - if (RegionNotEmpty(&mival->borderExposed)) { - miPaintWindow(pTree->pWin, &mival->borderExposed, - PW_BORDER); - } - RegionUninit(&mival->borderExposed); - - (*WindowExposures)(pTree->pWin,&mival->exposed,NullRegion); - RegionUninit(&mival->exposed); - } - free(mival); - pTree->valdata = NULL; - if (pTree->firstChild) { - pTree = pTree->firstChild; - continue; - } - } - while (!pTree->nextSib && (pTree->pWin != pChild)) - pTree = pTree->parent; - if (pTree->pWin == pChild) - break; - pTree = pTree->nextSib; + if (pPriv->underlayMarked) { + miOverlayTreePtr pTree; + miOverlayValDataPtr mival; + + pChild = pWin; + while (IN_OVERLAY(pChild)) + pChild = pChild->parent; + + pTree = MIOVERLAY_GET_WINDOW_TREE(pChild); + + while (1) { + if ((mival = pTree->valdata)) { + if (!((*pPriv->InOverlay) (pTree->pWin))) { + if (RegionNotEmpty(&mival->borderExposed)) { + miPaintWindow(pTree->pWin, &mival->borderExposed, + PW_BORDER); + } + RegionUninit(&mival->borderExposed); + + (*WindowExposures) (pTree->pWin, &mival->exposed, + NullRegion); + RegionUninit(&mival->exposed); + } + free(mival); + pTree->valdata = NULL; + if (pTree->firstChild) { + pTree = pTree->firstChild; + continue; + } + } + while (!pTree->nextSib && (pTree->pWin != pChild)) + pTree = pTree->parent; + if (pTree->pWin == pChild) + break; + pTree = pTree->nextSib; } - pPriv->underlayMarked = FALSE; + pPriv->underlayMarked = FALSE; } pChild = pWin; while (1) { - if ( (val = pChild->valdata) ) { - if(!((*pPriv->InOverlay)(pChild))) { - RegionUnion(&val->after.exposed, &val->after.exposed, - &val->after.borderExposed); - - if (RegionNotEmpty(&val->after.exposed)) { - (*(MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent))( - pScreen, - RegionNumRects(&val->after.exposed), - RegionRects(&val->after.exposed)); - } - } else { - if (RegionNotEmpty(&val->after.borderExposed)) { - miPaintWindow(pChild, &val->after.borderExposed, - PW_BORDER); - } - (*WindowExposures)(pChild, &val->after.exposed, NullRegion); - } - RegionUninit(&val->after.borderExposed); - RegionUninit(&val->after.exposed); - free(val); - pChild->valdata = NULL; - if (pChild->firstChild) - { - pChild = pChild->firstChild; - continue; - } - } - while (!pChild->nextSib && (pChild != pWin)) - pChild = pChild->parent; - if (pChild == pWin) - break; - pChild = pChild->nextSib; + if ((val = pChild->valdata)) { + if (!((*pPriv->InOverlay) (pChild))) { + RegionUnion(&val->after.exposed, &val->after.exposed, + &val->after.borderExposed); + + if (RegionNotEmpty(&val->after.exposed)) { + (*(MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent)) + (pScreen, RegionNumRects(&val->after.exposed), + RegionRects(&val->after.exposed)); + } + } + else { + if (RegionNotEmpty(&val->after.borderExposed)) { + miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER); + } + (*WindowExposures) (pChild, &val->after.exposed, NullRegion); + } + RegionUninit(&val->after.borderExposed); + RegionUninit(&val->after.exposed); + free(val); + pChild->valdata = NULL; + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } + } + while (!pChild->nextSib && (pChild != pWin)) + pChild = pChild->parent; + if (pChild == pWin) + break; + pChild = pChild->nextSib; } } - static void -miOverlayMoveWindow( - WindowPtr pWin, - int x, - int y, - WindowPtr pNextSib, - VTKind kind -){ +miOverlayMoveWindow(WindowPtr pWin, + int x, int y, WindowPtr pNextSib, VTKind kind) +{ ScreenPtr pScreen = pWin->drawable.pScreen; miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); WindowPtr pParent, windowToValidate; - Bool WasViewable = (Bool)(pWin->viewable); + Bool WasViewable = (Bool) (pWin->viewable); short bw; RegionRec overReg, underReg; DDXPointRec oldpt; if (!(pParent = pWin->parent)) - return ; - bw = wBorderWidth (pWin); + return; + bw = wBorderWidth(pWin); oldpt.x = pWin->drawable.x; oldpt.y = pWin->drawable.y; if (WasViewable) { - RegionNull(&overReg); - RegionNull(&underReg); - if(pTree) { - RegionCopy(&overReg, &pWin->borderClip); - RegionCopy(&underReg, &pTree->borderClip); - } else { - RegionCopy(&overReg, &pWin->borderClip); - CollectUnderlayChildrenRegions(pWin, &underReg); - } - (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL); + RegionNull(&overReg); + RegionNull(&underReg); + if (pTree) { + RegionCopy(&overReg, &pWin->borderClip); + RegionCopy(&underReg, &pTree->borderClip); + } + else { + RegionCopy(&overReg, &pWin->borderClip); + CollectUnderlayChildrenRegions(pWin, &underReg); + } + (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL); } - pWin->origin.x = x + (int)bw; - pWin->origin.y = y + (int)bw; - x = pWin->drawable.x = pParent->drawable.x + x + (int)bw; - y = pWin->drawable.y = pParent->drawable.y + y + (int)bw; + pWin->origin.x = x + (int) bw; + pWin->origin.y = y + (int) bw; + x = pWin->drawable.x = pParent->drawable.x + x + (int) bw; + y = pWin->drawable.y = pParent->drawable.y + y + (int) bw; - SetWinSize (pWin); - SetBorderSize (pWin); + SetWinSize(pWin); + SetBorderSize(pWin); - (*pScreen->PositionWindow)(pWin, x, y); + (*pScreen->PositionWindow) (pWin, x, y); windowToValidate = MoveWindowInStack(pWin, pNextSib); ResizeChildrenWinSize(pWin, x - oldpt.x, y - oldpt.y, 0, 0); if (WasViewable) { - miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); - (*pScreen->MarkOverlappedWindows) (pWin, windowToValidate, NULL); - - - (*pScreen->ValidateTree)(pWin->parent, NullWindow, kind); - if(RegionNotEmpty(&underReg)) { - pPriv->copyUnderlay = TRUE; - (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, &underReg); - } - RegionUninit(&underReg); - if(RegionNotEmpty(&overReg)) { - pPriv->copyUnderlay = FALSE; - (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, &overReg); - } - RegionUninit(&overReg); - (*pScreen->HandleExposures)(pWin->parent); - - if (pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pWin->parent, NullWindow, kind); + miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); + + (*pScreen->MarkOverlappedWindows) (pWin, windowToValidate, NULL); + + (*pScreen->ValidateTree) (pWin->parent, NullWindow, kind); + if (RegionNotEmpty(&underReg)) { + pPriv->copyUnderlay = TRUE; + (*pWin->drawable.pScreen->CopyWindow) (pWin, oldpt, &underReg); + } + RegionUninit(&underReg); + if (RegionNotEmpty(&overReg)) { + pPriv->copyUnderlay = FALSE; + (*pWin->drawable.pScreen->CopyWindow) (pWin, oldpt, &overReg); + } + RegionUninit(&overReg); + (*pScreen->HandleExposures) (pWin->parent); + + if (pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pWin->parent, NullWindow, kind); } if (pWin->realized) - WindowsRestructured (); + WindowsRestructured(); } #ifndef RECTLIMIT #define RECTLIMIT 25 #endif -static void -miOverlayWindowExposures( - WindowPtr pWin, - RegionPtr prgn, - RegionPtr other_exposed -){ - RegionPtr exposures = prgn; +static void +miOverlayWindowExposures(WindowPtr pWin, + RegionPtr prgn, RegionPtr other_exposed) +{ + RegionPtr exposures = prgn; if ((prgn && !RegionNil(prgn)) || - (exposures && !RegionNil(exposures)) || other_exposed) - { - RegionRec expRec; - int clientInterested; - - clientInterested = (pWin->eventMask|wOtherEventMasks(pWin)) & - ExposureMask; - if (other_exposed) { - if (exposures) { - RegionUnion(other_exposed, exposures, other_exposed); - if (exposures != prgn) - RegionDestroy(exposures); - } - exposures = other_exposed; - } - if (clientInterested && exposures && - (RegionNumRects(exposures) > RECTLIMIT)) - { - ScreenPtr pScreen = pWin->drawable.pScreen; + (exposures && !RegionNil(exposures)) || other_exposed) { + RegionRec expRec; + int clientInterested; + + clientInterested = (pWin->eventMask | wOtherEventMasks(pWin)) & + ExposureMask; + if (other_exposed) { + if (exposures) { + RegionUnion(other_exposed, exposures, other_exposed); + if (exposures != prgn) + RegionDestroy(exposures); + } + exposures = other_exposed; + } + if (clientInterested && exposures && + (RegionNumRects(exposures) > RECTLIMIT)) { + ScreenPtr pScreen = pWin->drawable.pScreen; miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); - BoxRec box; - - box = *RegionExtents(exposures); - if (exposures == prgn) { - exposures = &expRec; - RegionInit(exposures, &box, 1); - RegionReset(prgn, &box); - } else { - RegionReset(exposures, &box); - RegionUnion(prgn, prgn, exposures); - } - /* This is the only reason why we are replacing mi's version + BoxRec box; + + box = *RegionExtents(exposures); + if (exposures == prgn) { + exposures = &expRec; + RegionInit(exposures, &box, 1); + RegionReset(prgn, &box); + } + else { + RegionReset(exposures, &box); + RegionUnion(prgn, prgn, exposures); + } + /* This is the only reason why we are replacing mi's version of this file */ - - if(!((*pPriv->InOverlay)(pWin))) { - miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); - RegionIntersect(prgn, prgn, &pTree->clipList); - } else - RegionIntersect(prgn, prgn, &pWin->clipList); - } - if (prgn && !RegionNil(prgn)) - miPaintWindow(pWin, prgn, PW_BACKGROUND); - if (clientInterested && exposures && !RegionNil(exposures)) - miSendExposures(pWin, exposures, - pWin->drawable.x, pWin->drawable.y); - if (exposures == &expRec) { - RegionUninit(exposures); - } - else if (exposures && exposures != prgn && exposures != other_exposed) - RegionDestroy(exposures); - if (prgn) - RegionEmpty(prgn); + + if (!((*pPriv->InOverlay) (pWin))) { + miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); + + RegionIntersect(prgn, prgn, &pTree->clipList); + } + else + RegionIntersect(prgn, prgn, &pWin->clipList); + } + if (prgn && !RegionNil(prgn)) + miPaintWindow(pWin, prgn, PW_BACKGROUND); + if (clientInterested && exposures && !RegionNil(exposures)) + miSendExposures(pWin, exposures, + pWin->drawable.x, pWin->drawable.y); + if (exposures == &expRec) { + RegionUninit(exposures); + } + else if (exposures && exposures != prgn && exposures != other_exposed) + RegionDestroy(exposures); + if (prgn) + RegionEmpty(prgn); } else if (exposures && exposures != prgn) - RegionDestroy(exposures); + RegionDestroy(exposures); } - typedef struct { - RegionPtr over; - RegionPtr under; -} miOverlayTwoRegions; + RegionPtr over; + RegionPtr under; +} miOverlayTwoRegions; static int -miOverlayRecomputeExposures ( - WindowPtr pWin, - pointer value -){ - miOverlayTwoRegions *pValid = (miOverlayTwoRegions*)value; +miOverlayRecomputeExposures(WindowPtr pWin, pointer value) +{ + miOverlayTwoRegions *pValid = (miOverlayTwoRegions *) value; miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); if (pWin->valdata) { - /* - * compute exposed regions of this window - */ - RegionSubtract(&pWin->valdata->after.exposed, - &pWin->clipList, pValid->over); - /* - * compute exposed regions of the border - */ - RegionSubtract(&pWin->valdata->after.borderExposed, - &pWin->borderClip, &pWin->winSize); - RegionSubtract(&pWin->valdata->after.borderExposed, - &pWin->valdata->after.borderExposed, pValid->over); - } - - if(pTree && pTree->valdata) { - RegionSubtract(&pTree->valdata->exposed, - &pTree->clipList, pValid->under); - RegionSubtract(&pTree->valdata->borderExposed, - &pTree->borderClip, &pWin->winSize); - RegionSubtract(&pTree->valdata->borderExposed, - &pTree->valdata->borderExposed, pValid->under); - } else if (!pWin->valdata) - return WT_NOMATCH; + /* + * compute exposed regions of this window + */ + RegionSubtract(&pWin->valdata->after.exposed, + &pWin->clipList, pValid->over); + /* + * compute exposed regions of the border + */ + RegionSubtract(&pWin->valdata->after.borderExposed, + &pWin->borderClip, &pWin->winSize); + RegionSubtract(&pWin->valdata->after.borderExposed, + &pWin->valdata->after.borderExposed, pValid->over); + } + + if (pTree && pTree->valdata) { + RegionSubtract(&pTree->valdata->exposed, + &pTree->clipList, pValid->under); + RegionSubtract(&pTree->valdata->borderExposed, + &pTree->borderClip, &pWin->winSize); + RegionSubtract(&pTree->valdata->borderExposed, + &pTree->valdata->borderExposed, pValid->under); + } + else if (!pWin->valdata) + return WT_NOMATCH; return WT_WALKCHILDREN; } static void -miOverlayResizeWindow( - WindowPtr pWin, - int x, int y, - unsigned int w, unsigned int h, - WindowPtr pSib -){ +miOverlayResizeWindow(WindowPtr pWin, + int x, int y, + unsigned int w, unsigned int h, WindowPtr pSib) +{ ScreenPtr pScreen = pWin->drawable.pScreen; WindowPtr pParent; miOverlayTreePtr tChild, pTree; - Bool WasViewable = (Bool)(pWin->viewable); + Bool WasViewable = (Bool) (pWin->viewable); unsigned short width = pWin->drawable.width; unsigned short height = pWin->drawable.height; short oldx = pWin->drawable.x; short oldy = pWin->drawable.y; - int bw = wBorderWidth (pWin); + int bw = wBorderWidth(pWin); short dw, dh; DDXPointRec oldpt; RegionPtr oldRegion = NULL, oldRegion2 = NULL; WindowPtr pFirstChange; WindowPtr pChild; - RegionPtr gravitate[StaticGravity + 1]; - RegionPtr gravitate2[StaticGravity + 1]; - unsigned g; - int nx, ny; /* destination x,y */ - int newx, newy; /* new inner window position */ - RegionPtr pRegion = NULL; - RegionPtr destClip, destClip2; - RegionPtr oldWinClip = NULL, oldWinClip2 = NULL; - RegionPtr borderVisible = NullRegion; - RegionPtr borderVisible2 = NullRegion; - Bool shrunk = FALSE; /* shrunk in an inner dimension */ - Bool moved = FALSE; /* window position changed */ - Bool doUnderlay; + RegionPtr gravitate[StaticGravity + 1]; + RegionPtr gravitate2[StaticGravity + 1]; + unsigned g; + int nx, ny; /* destination x,y */ + int newx, newy; /* new inner window position */ + RegionPtr pRegion = NULL; + RegionPtr destClip, destClip2; + RegionPtr oldWinClip = NULL, oldWinClip2 = NULL; + RegionPtr borderVisible = NullRegion; + RegionPtr borderVisible2 = NullRegion; + Bool shrunk = FALSE; /* shrunk in an inner dimension */ + Bool moved = FALSE; /* window position changed */ + Bool doUnderlay; /* if this is a root window, can't be resized */ if (!(pParent = pWin->parent)) - return ; + return; pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); doUnderlay = ((pTree) || HasUnderlayChildren(pWin)); newx = pParent->drawable.x + x + bw; newy = pParent->drawable.y + y + bw; - if (WasViewable) - { - /* - * save the visible region of the window - */ - oldRegion = RegionCreate(NullBox, 1); - RegionCopy(oldRegion, &pWin->winSize); - if(doUnderlay) { - oldRegion2 = RegionCreate(NullBox, 1); - RegionCopy(oldRegion2, &pWin->winSize); - } - - /* - * categorize child windows into regions to be moved - */ - for (g = 0; g <= StaticGravity; g++) - gravitate[g] = gravitate2[g] = NULL; - for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) { - g = pChild->winGravity; - if (g != UnmapGravity) { - if (!gravitate[g]) - gravitate[g] = RegionCreate(NullBox, 1); - RegionUnion(gravitate[g], - gravitate[g], &pChild->borderClip); - - if(doUnderlay) { - if (!gravitate2[g]) - gravitate2[g] = RegionCreate(NullBox, 0); - - if((tChild = MIOVERLAY_GET_WINDOW_TREE(pChild))) { - RegionUnion(gravitate2[g], - gravitate2[g], &tChild->borderClip); - } else - CollectUnderlayChildrenRegions(pChild, gravitate2[g]); - } - } else { - UnmapWindow(pChild, TRUE); - } - } - (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL); - - - oldWinClip = oldWinClip2 = NULL; - if (pWin->bitGravity != ForgetGravity) { - oldWinClip = RegionCreate(NullBox, 1); - RegionCopy(oldWinClip, &pWin->clipList); - if(pTree) { - oldWinClip2 = RegionCreate(NullBox, 1); - RegionCopy(oldWinClip2, &pTree->clipList); - } - } - /* - * if the window is changing size, borderExposed - * can't be computed correctly without some help. - */ - if (pWin->drawable.height > h || pWin->drawable.width > w) - shrunk = TRUE; - - if (newx != oldx || newy != oldy) - moved = TRUE; - - if ((pWin->drawable.height != h || pWin->drawable.width != w) && - HasBorder (pWin)) - { - borderVisible = RegionCreate(NullBox, 1); - if(pTree) - borderVisible2 = RegionCreate(NullBox, 1); - /* for tiled borders, we punt and draw the whole thing */ - if (pWin->borderIsPixel || !moved) - { - if (shrunk || moved) - RegionSubtract(borderVisible, - &pWin->borderClip, - &pWin->winSize); - else - RegionCopy(borderVisible, - &pWin->borderClip); - if(pTree) { - if (shrunk || moved) - RegionSubtract(borderVisible, - &pTree->borderClip, - &pWin->winSize); - else - RegionCopy(borderVisible, - &pTree->borderClip); - } - } - } + if (WasViewable) { + /* + * save the visible region of the window + */ + oldRegion = RegionCreate(NullBox, 1); + RegionCopy(oldRegion, &pWin->winSize); + if (doUnderlay) { + oldRegion2 = RegionCreate(NullBox, 1); + RegionCopy(oldRegion2, &pWin->winSize); + } + + /* + * categorize child windows into regions to be moved + */ + for (g = 0; g <= StaticGravity; g++) + gravitate[g] = gravitate2[g] = NULL; + for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) { + g = pChild->winGravity; + if (g != UnmapGravity) { + if (!gravitate[g]) + gravitate[g] = RegionCreate(NullBox, 1); + RegionUnion(gravitate[g], gravitate[g], &pChild->borderClip); + + if (doUnderlay) { + if (!gravitate2[g]) + gravitate2[g] = RegionCreate(NullBox, 0); + + if ((tChild = MIOVERLAY_GET_WINDOW_TREE(pChild))) { + RegionUnion(gravitate2[g], + gravitate2[g], &tChild->borderClip); + } + else + CollectUnderlayChildrenRegions(pChild, gravitate2[g]); + } + } + else { + UnmapWindow(pChild, TRUE); + } + } + (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL); + + oldWinClip = oldWinClip2 = NULL; + if (pWin->bitGravity != ForgetGravity) { + oldWinClip = RegionCreate(NullBox, 1); + RegionCopy(oldWinClip, &pWin->clipList); + if (pTree) { + oldWinClip2 = RegionCreate(NullBox, 1); + RegionCopy(oldWinClip2, &pTree->clipList); + } + } + /* + * if the window is changing size, borderExposed + * can't be computed correctly without some help. + */ + if (pWin->drawable.height > h || pWin->drawable.width > w) + shrunk = TRUE; + + if (newx != oldx || newy != oldy) + moved = TRUE; + + if ((pWin->drawable.height != h || pWin->drawable.width != w) && + HasBorder(pWin)) { + borderVisible = RegionCreate(NullBox, 1); + if (pTree) + borderVisible2 = RegionCreate(NullBox, 1); + /* for tiled borders, we punt and draw the whole thing */ + if (pWin->borderIsPixel || !moved) { + if (shrunk || moved) + RegionSubtract(borderVisible, + &pWin->borderClip, &pWin->winSize); + else + RegionCopy(borderVisible, &pWin->borderClip); + if (pTree) { + if (shrunk || moved) + RegionSubtract(borderVisible, + &pTree->borderClip, &pWin->winSize); + else + RegionCopy(borderVisible, &pTree->borderClip); + } + } + } } pWin->origin.x = x + bw; pWin->origin.y = y + bw; @@ -1244,360 +1215,347 @@ miOverlayResizeWindow( x = pWin->drawable.x = newx; y = pWin->drawable.y = newy; - SetWinSize (pWin); - SetBorderSize (pWin); + SetWinSize(pWin); + SetBorderSize(pWin); - dw = (int)w - (int)width; - dh = (int)h - (int)height; + dw = (int) w - (int) width; + dh = (int) h - (int) height; ResizeChildrenWinSize(pWin, x - oldx, y - oldy, dw, dh); /* let the hardware adjust background and border pixmaps, if any */ - (*pScreen->PositionWindow)(pWin, x, y); + (*pScreen->PositionWindow) (pWin, x, y); pFirstChange = MoveWindowInStack(pWin, pSib); if (WasViewable) { - pRegion = RegionCreate(NullBox, 1); + pRegion = RegionCreate(NullBox, 1); + + (*pScreen->MarkOverlappedWindows) (pWin, pFirstChange, NULL); + + pWin->valdata->before.resized = TRUE; + pWin->valdata->before.borderVisible = borderVisible; + if (pTree) + pTree->valdata->borderVisible = borderVisible2; + + (*pScreen->ValidateTree) (pWin->parent, pFirstChange, VTOther); + /* + * the entire window is trashed unless bitGravity + * recovers portions of it + */ + RegionCopy(&pWin->valdata->after.exposed, &pWin->clipList); + if (pTree) + RegionCopy(&pTree->valdata->exposed, &pTree->clipList); + } + + GravityTranslate(x, y, oldx, oldy, dw, dh, pWin->bitGravity, &nx, &ny); + + if (WasViewable) { + miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); + miOverlayTwoRegions TwoRegions; + + /* avoid the border */ + if (HasBorder(pWin)) { + int offx, offy, dx, dy; + + /* kruft to avoid double translates for each gravity */ + offx = 0; + offy = 0; + for (g = 0; g <= StaticGravity; g++) { + if (!gravitate[g] && !gravitate2[g]) + continue; + + /* align winSize to gravitate[g]. + * winSize is in new coordinates, + * gravitate[g] is still in old coordinates */ + GravityTranslate(x, y, oldx, oldy, dw, dh, g, &nx, &ny); + + dx = (oldx - nx) - offx; + dy = (oldy - ny) - offy; + if (dx || dy) { + RegionTranslate(&pWin->winSize, dx, dy); + offx += dx; + offy += dy; + } + if (gravitate[g]) + RegionIntersect(gravitate[g], gravitate[g], &pWin->winSize); + if (gravitate2[g]) + RegionIntersect(gravitate2[g], gravitate2[g], + &pWin->winSize); + } + /* get winSize back where it belongs */ + if (offx || offy) + RegionTranslate(&pWin->winSize, -offx, -offy); + } + /* + * add screen bits to the appropriate bucket + */ + + if (oldWinClip2) { + RegionCopy(pRegion, oldWinClip2); + RegionTranslate(pRegion, nx - oldx, ny - oldy); + RegionIntersect(oldWinClip2, pRegion, &pTree->clipList); + + for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) { + if (gravitate2[g]) + RegionSubtract(oldWinClip2, oldWinClip2, gravitate2[g]); + } + RegionTranslate(oldWinClip2, oldx - nx, oldy - ny); + g = pWin->bitGravity; + if (!gravitate2[g]) + gravitate2[g] = oldWinClip2; + else { + RegionUnion(gravitate2[g], gravitate2[g], oldWinClip2); + RegionDestroy(oldWinClip2); + } + } - (*pScreen->MarkOverlappedWindows)(pWin, pFirstChange, NULL); + if (oldWinClip) { + /* + * clip to new clipList + */ + RegionCopy(pRegion, oldWinClip); + RegionTranslate(pRegion, nx - oldx, ny - oldy); + RegionIntersect(oldWinClip, pRegion, &pWin->clipList); + /* + * don't step on any gravity bits which will be copied after this + * region. Note -- this assumes that the regions will be copied + * in gravity order. + */ + for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) { + if (gravitate[g]) + RegionSubtract(oldWinClip, oldWinClip, gravitate[g]); + } + RegionTranslate(oldWinClip, oldx - nx, oldy - ny); + g = pWin->bitGravity; + if (!gravitate[g]) + gravitate[g] = oldWinClip; + else { + RegionUnion(gravitate[g], gravitate[g], oldWinClip); + RegionDestroy(oldWinClip); + } + } - pWin->valdata->before.resized = TRUE; - pWin->valdata->before.borderVisible = borderVisible; - if(pTree) - pTree->valdata->borderVisible = borderVisible2; + /* + * move the bits on the screen + */ + destClip = destClip2 = NULL; - (*pScreen->ValidateTree)(pWin->parent, pFirstChange, VTOther); - /* - * the entire window is trashed unless bitGravity - * recovers portions of it - */ - RegionCopy(&pWin->valdata->after.exposed, &pWin->clipList); - if(pTree) - RegionCopy(&pTree->valdata->exposed, &pTree->clipList); - } + for (g = 0; g <= StaticGravity; g++) { + if (!gravitate[g] && !gravitate2[g]) + continue; - GravityTranslate (x, y, oldx, oldy, dw, dh, pWin->bitGravity, &nx, &ny); + GravityTranslate(x, y, oldx, oldy, dw, dh, g, &nx, &ny); - if (WasViewable) { - miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); - miOverlayTwoRegions TwoRegions; - - /* avoid the border */ - if (HasBorder (pWin)) { - int offx, offy, dx, dy; - - /* kruft to avoid double translates for each gravity */ - offx = 0; - offy = 0; - for (g = 0; g <= StaticGravity; g++) { - if (!gravitate[g] && !gravitate2[g]) - continue; - - /* align winSize to gravitate[g]. - * winSize is in new coordinates, - * gravitate[g] is still in old coordinates */ - GravityTranslate (x, y, oldx, oldy, dw, dh, g, &nx, &ny); - - dx = (oldx - nx) - offx; - dy = (oldy - ny) - offy; - if (dx || dy) { - RegionTranslate(&pWin->winSize, dx, dy); - offx += dx; - offy += dy; - } - if(gravitate[g]) - RegionIntersect(gravitate[g], gravitate[g], - &pWin->winSize); - if(gravitate2[g]) - RegionIntersect(gravitate2[g], gravitate2[g], - &pWin->winSize); - } - /* get winSize back where it belongs */ - if (offx || offy) - RegionTranslate(&pWin->winSize, -offx, -offy); - } - /* - * add screen bits to the appropriate bucket - */ - - if (oldWinClip2) - { - RegionCopy(pRegion, oldWinClip2); - RegionTranslate(pRegion, nx - oldx, ny - oldy); - RegionIntersect(oldWinClip2, pRegion, &pTree->clipList); - - for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) { - if (gravitate2[g]) - RegionSubtract(oldWinClip2, oldWinClip2, - gravitate2[g]); - } - RegionTranslate(oldWinClip2, oldx - nx, oldy - ny); - g = pWin->bitGravity; - if (!gravitate2[g]) - gravitate2[g] = oldWinClip2; - else { - RegionUnion(gravitate2[g],gravitate2[g],oldWinClip2); - RegionDestroy(oldWinClip2); - } - } - - if (oldWinClip) - { - /* - * clip to new clipList - */ - RegionCopy(pRegion, oldWinClip); - RegionTranslate(pRegion, nx - oldx, ny - oldy); - RegionIntersect(oldWinClip, pRegion, &pWin->clipList); - /* - * don't step on any gravity bits which will be copied after this - * region. Note -- this assumes that the regions will be copied - * in gravity order. - */ - for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) { - if (gravitate[g]) - RegionSubtract(oldWinClip, oldWinClip, - gravitate[g]); - } - RegionTranslate(oldWinClip, oldx - nx, oldy - ny); - g = pWin->bitGravity; - if (!gravitate[g]) - gravitate[g] = oldWinClip; - else { - RegionUnion(gravitate[g], gravitate[g], oldWinClip); - RegionDestroy(oldWinClip); - } - } - - /* - * move the bits on the screen - */ - - destClip = destClip2 = NULL; - - for (g = 0; g <= StaticGravity; g++) { - if (!gravitate[g] && !gravitate2[g]) - continue; - - GravityTranslate (x, y, oldx, oldy, dw, dh, g, &nx, &ny); - - oldpt.x = oldx + (x - nx); - oldpt.y = oldy + (y - ny); - - /* Note that gravitate[g] is *translated* by CopyWindow */ - - /* only copy the remaining useful bits */ - - if(gravitate[g]) - RegionIntersect(gravitate[g], - gravitate[g], oldRegion); - if(gravitate2[g]) - RegionIntersect(gravitate2[g], - gravitate2[g], oldRegion2); - - /* clip to not overwrite already copied areas */ - - if (destClip && gravitate[g]) { - RegionTranslate(destClip, oldpt.x - x, oldpt.y - y); - RegionSubtract(gravitate[g], gravitate[g], destClip); - RegionTranslate(destClip, x - oldpt.x, y - oldpt.y); - } - if (destClip2 && gravitate2[g]) { - RegionTranslate(destClip2, oldpt.x - x, oldpt.y - y); - RegionSubtract(gravitate2[g],gravitate2[g],destClip2); - RegionTranslate(destClip2, x - oldpt.x, y - oldpt.y); - } - - /* and move those bits */ - - if (oldpt.x != x || oldpt.y != y) { - if(gravitate2[g]) { - pPriv->copyUnderlay = TRUE; - (*pScreen->CopyWindow)(pWin, oldpt, gravitate2[g]); - } - if(gravitate[g]) { - pPriv->copyUnderlay = FALSE; - (*pScreen->CopyWindow)(pWin, oldpt, gravitate[g]); - } - } - - /* remove any overwritten bits from the remaining useful bits */ - - if(gravitate[g]) - RegionSubtract(oldRegion, oldRegion, gravitate[g]); - if(gravitate2[g]) - RegionSubtract(oldRegion2, oldRegion2, gravitate2[g]); - - /* - * recompute exposed regions of child windows - */ - - - for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) { - if (pChild->winGravity != g) - continue; - - TwoRegions.over = gravitate[g]; - TwoRegions.under = gravitate2[g]; - - TraverseTree (pChild, miOverlayRecomputeExposures, - (pointer)(&TwoRegions)); - } - - /* - * remove the successfully copied regions of the - * window from its exposed region - */ - - if (g == pWin->bitGravity) { - if(gravitate[g]) - RegionSubtract(&pWin->valdata->after.exposed, - &pWin->valdata->after.exposed, gravitate[g]); - if(gravitate2[g] && pTree) - RegionSubtract(&pTree->valdata->exposed, - &pTree->valdata->exposed, gravitate2[g]); - } - if(gravitate[g]) { - if (!destClip) - destClip = gravitate[g]; - else { - RegionUnion(destClip, destClip, gravitate[g]); - RegionDestroy(gravitate[g]); - } - } - if(gravitate2[g]) { - if (!destClip2) - destClip2 = gravitate2[g]; - else { - RegionUnion(destClip2, destClip2, gravitate2[g]); - RegionDestroy(gravitate2[g]); - } - } - } - - RegionDestroy(pRegion); - RegionDestroy(oldRegion); - if(doUnderlay) - RegionDestroy(oldRegion2); - if (destClip) - RegionDestroy(destClip); - if (destClip2) - RegionDestroy(destClip2); - (*pScreen->HandleExposures)(pWin->parent); - if (pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pWin->parent, pFirstChange, VTOther); + oldpt.x = oldx + (x - nx); + oldpt.y = oldy + (y - ny); + + /* Note that gravitate[g] is *translated* by CopyWindow */ + + /* only copy the remaining useful bits */ + + if (gravitate[g]) + RegionIntersect(gravitate[g], gravitate[g], oldRegion); + if (gravitate2[g]) + RegionIntersect(gravitate2[g], gravitate2[g], oldRegion2); + + /* clip to not overwrite already copied areas */ + + if (destClip && gravitate[g]) { + RegionTranslate(destClip, oldpt.x - x, oldpt.y - y); + RegionSubtract(gravitate[g], gravitate[g], destClip); + RegionTranslate(destClip, x - oldpt.x, y - oldpt.y); + } + if (destClip2 && gravitate2[g]) { + RegionTranslate(destClip2, oldpt.x - x, oldpt.y - y); + RegionSubtract(gravitate2[g], gravitate2[g], destClip2); + RegionTranslate(destClip2, x - oldpt.x, y - oldpt.y); + } + + /* and move those bits */ + + if (oldpt.x != x || oldpt.y != y) { + if (gravitate2[g]) { + pPriv->copyUnderlay = TRUE; + (*pScreen->CopyWindow) (pWin, oldpt, gravitate2[g]); + } + if (gravitate[g]) { + pPriv->copyUnderlay = FALSE; + (*pScreen->CopyWindow) (pWin, oldpt, gravitate[g]); + } + } + + /* remove any overwritten bits from the remaining useful bits */ + + if (gravitate[g]) + RegionSubtract(oldRegion, oldRegion, gravitate[g]); + if (gravitate2[g]) + RegionSubtract(oldRegion2, oldRegion2, gravitate2[g]); + + /* + * recompute exposed regions of child windows + */ + + for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) { + if (pChild->winGravity != g) + continue; + + TwoRegions.over = gravitate[g]; + TwoRegions.under = gravitate2[g]; + + TraverseTree(pChild, miOverlayRecomputeExposures, + (pointer) (&TwoRegions)); + } + + /* + * remove the successfully copied regions of the + * window from its exposed region + */ + + if (g == pWin->bitGravity) { + if (gravitate[g]) + RegionSubtract(&pWin->valdata->after.exposed, + &pWin->valdata->after.exposed, gravitate[g]); + if (gravitate2[g] && pTree) + RegionSubtract(&pTree->valdata->exposed, + &pTree->valdata->exposed, gravitate2[g]); + } + if (gravitate[g]) { + if (!destClip) + destClip = gravitate[g]; + else { + RegionUnion(destClip, destClip, gravitate[g]); + RegionDestroy(gravitate[g]); + } + } + if (gravitate2[g]) { + if (!destClip2) + destClip2 = gravitate2[g]; + else { + RegionUnion(destClip2, destClip2, gravitate2[g]); + RegionDestroy(gravitate2[g]); + } + } + } + + RegionDestroy(pRegion); + RegionDestroy(oldRegion); + if (doUnderlay) + RegionDestroy(oldRegion2); + if (destClip) + RegionDestroy(destClip); + if (destClip2) + RegionDestroy(destClip2); + (*pScreen->HandleExposures) (pWin->parent); + if (pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pWin->parent, pFirstChange, VTOther); } if (pWin->realized) - WindowsRestructured (); + WindowsRestructured(); } - static void miOverlaySetShape(WindowPtr pWin, int kind) { - Bool WasViewable = (Bool)(pWin->viewable); - ScreenPtr pScreen = pWin->drawable.pScreen; + Bool WasViewable = (Bool) (pWin->viewable); + ScreenPtr pScreen = pWin->drawable.pScreen; if (kind != ShapeInput) { if (WasViewable) { - (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL); + (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL); - if (HasBorder (pWin)) { + if (HasBorder(pWin)) { RegionPtr borderVisible; borderVisible = RegionCreate(NullBox, 1); RegionSubtract(borderVisible, - &pWin->borderClip, &pWin->winSize); + &pWin->borderClip, &pWin->winSize); pWin->valdata->before.borderVisible = borderVisible; pWin->valdata->before.resized = TRUE; - if(IN_UNDERLAY(pWin)) { + if (IN_UNDERLAY(pWin)) { miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); RegionPtr borderVisible2; borderVisible2 = RegionCreate(NULL, 1); RegionSubtract(borderVisible2, - &pTree->borderClip, &pWin->winSize); + &pTree->borderClip, &pWin->winSize); pTree->valdata->borderVisible = borderVisible2; } } } - SetWinSize (pWin); - SetBorderSize (pWin); + SetWinSize(pWin); + SetBorderSize(pWin); ResizeChildrenWinSize(pWin, 0, 0, 0, 0); if (WasViewable) { - (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL); + (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL); - - (*pScreen->ValidateTree)(pWin->parent, NullWindow, VTOther); + (*pScreen->ValidateTree) (pWin->parent, NullWindow, VTOther); } if (WasViewable) { - (*pScreen->HandleExposures)(pWin->parent); + (*pScreen->HandleExposures) (pWin->parent); if (pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pWin->parent, NullWindow, VTOther); + (*pScreen->PostValidateTree) (pWin->parent, NullWindow, + VTOther); } } if (pWin->realized) - WindowsRestructured (); + WindowsRestructured(); CheckCursorConfinement(pWin); } - - static void -miOverlayChangeBorderWidth( - WindowPtr pWin, - unsigned int width -){ +miOverlayChangeBorderWidth(WindowPtr pWin, unsigned int width) +{ int oldwidth; ScreenPtr pScreen; - Bool WasViewable = (Bool)(pWin->viewable); + Bool WasViewable = (Bool) (pWin->viewable); Bool HadBorder; - oldwidth = wBorderWidth (pWin); + oldwidth = wBorderWidth(pWin); if (oldwidth == width) - return; + return; HadBorder = HasBorder(pWin); pScreen = pWin->drawable.pScreen; if (WasViewable && (width < oldwidth)) - (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL); + (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL); pWin->borderWidth = width; - SetBorderSize (pWin); + SetBorderSize(pWin); if (WasViewable) { - if (width > oldwidth) { - (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL); - - if (HadBorder) { - RegionPtr borderVisible; - borderVisible = RegionCreate(NULL, 1); - RegionSubtract(borderVisible, - &pWin->borderClip, &pWin->winSize); - pWin->valdata->before.borderVisible = borderVisible; - if(IN_UNDERLAY(pWin)) { - miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); - RegionPtr borderVisible2; - - borderVisible2 = RegionCreate(NULL, 1); - RegionSubtract(borderVisible2, - &pTree->borderClip, &pWin->winSize); - pTree->valdata->borderVisible = borderVisible2; - } - } - } - (*pScreen->ValidateTree)(pWin->parent, pWin, VTOther); - (*pScreen->HandleExposures)(pWin->parent); - - if (pScreen->PostValidateTree) - (*pScreen->PostValidateTree)(pWin->parent, pWin, VTOther); + if (width > oldwidth) { + (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL); + + if (HadBorder) { + RegionPtr borderVisible; + + borderVisible = RegionCreate(NULL, 1); + RegionSubtract(borderVisible, + &pWin->borderClip, &pWin->winSize); + pWin->valdata->before.borderVisible = borderVisible; + if (IN_UNDERLAY(pWin)) { + miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); + RegionPtr borderVisible2; + + borderVisible2 = RegionCreate(NULL, 1); + RegionSubtract(borderVisible2, + &pTree->borderClip, &pWin->winSize); + pTree->valdata->borderVisible = borderVisible2; + } + } + } + (*pScreen->ValidateTree) (pWin->parent, pWin, VTOther); + (*pScreen->HandleExposures) (pWin->parent); + + if (pScreen->PostValidateTree) + (*pScreen->PostValidateTree) (pWin->parent, pWin, VTOther); } if (pWin->realized) - WindowsRestructured (); + WindowsRestructured(); } /* We need this as an addition since the xf86 common code doesn't @@ -1611,28 +1569,25 @@ miOverlaySetRootClip(ScreenPtr pScreen, Bool enable) MARK_UNDERLAY(pRoot); - if(enable) { - BoxRec box; - - box.x1 = 0; - box.y1 = 0; - box.x2 = pScreen->width; - box.y2 = pScreen->height; + if (enable) { + BoxRec box; + + box.x1 = 0; + box.y1 = 0; + box.x2 = pScreen->width; + box.y2 = pScreen->height; - RegionReset(&pTree->borderClip, &box); - } else - RegionEmpty(&pTree->borderClip); + RegionReset(&pTree->borderClip, &box); + } + else + RegionEmpty(&pTree->borderClip); RegionBreak(&pTree->clipList); } -static void -miOverlayClearToBackground( - WindowPtr pWin, - int x, int y, - int w, int h, - Bool generateExposures -) +static void +miOverlayClearToBackground(WindowPtr pWin, + int x, int y, int w, int h, Bool generateExposures) { miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); BoxRec box; @@ -1641,8 +1596,8 @@ miOverlayClearToBackground( ScreenPtr pScreen = pWin->drawable.pScreen; miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); RegionPtr clipList; - BoxPtr extents; - int x1, y1, x2, y2; + BoxPtr extents; + int x1, y1, x2, y2; x1 = pWin->drawable.x + x; y1 = pWin->drawable.y + y; @@ -1651,54 +1606,57 @@ miOverlayClearToBackground( else x2 = x1 + (int) pWin->drawable.width - (int) x; if (h) - y2 = y1 + h; + y2 = y1 + h; else y2 = y1 + (int) pWin->drawable.height - (int) y; - clipList = ((*pScreenPriv->InOverlay)(pWin)) ? &pWin->clipList : - &pTree->clipList; + clipList = ((*pScreenPriv->InOverlay) (pWin)) ? &pWin->clipList : + &pTree->clipList; extents = RegionExtents(clipList); - - if (x1 < extents->x1) x1 = extents->x1; - if (x2 > extents->x2) x2 = extents->x2; - if (y1 < extents->y1) y1 = extents->y1; - if (y2 > extents->y2) y2 = extents->y2; - if (x2 <= x1 || y2 <= y1) + if (x1 < extents->x1) + x1 = extents->x1; + if (x2 > extents->x2) + x2 = extents->x2; + if (y1 < extents->y1) + y1 = extents->y1; + if (y2 > extents->y2) + y2 = extents->y2; + + if (x2 <= x1 || y2 <= y1) x2 = x1 = y2 = y1 = 0; - box.x1 = x1; box.x2 = x2; - box.y1 = y1; box.y2 = y2; + box.x1 = x1; + box.x2 = x2; + box.y1 = y1; + box.y2 = y2; RegionInit(®, &box, 1); RegionIntersect(®, ®, clipList); if (generateExposures) - (*pScreen->WindowExposures)(pWin, ®, pBSReg); + (*pScreen->WindowExposures) (pWin, ®, pBSReg); else if (pWin->backgroundState != None) - miPaintWindow(pWin, ®, PW_BACKGROUND); + miPaintWindow(pWin, ®, PW_BACKGROUND); RegionUninit(®); if (pBSReg) RegionDestroy(pBSReg); } - /****************************************************************/ /* not used */ Bool -miOverlayGetPrivateClips( - WindowPtr pWin, - RegionPtr *borderClip, - RegionPtr *clipList -){ +miOverlayGetPrivateClips(WindowPtr pWin, + RegionPtr *borderClip, RegionPtr *clipList) +{ miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); - - if(pTree) { - *borderClip = &(pTree->borderClip); - *clipList = &(pTree->clipList); - return TRUE; + + if (pTree) { + *borderClip = &(pTree->borderClip); + *clipList = &(pTree->clipList); + return TRUE; } *borderClip = *clipList = NULL; @@ -1707,10 +1665,8 @@ miOverlayGetPrivateClips( } void -miOverlaySetTransFunction ( - ScreenPtr pScreen, - miOverlayTransFunc transFunc -){ +miOverlaySetTransFunction(ScreenPtr pScreen, miOverlayTransFunc transFunc) +{ MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent = transFunc; } @@ -1724,103 +1680,98 @@ void miOverlayComputeCompositeClip(GCPtr pGC, WindowPtr pWin) { miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); - RegionPtr pregWin; - Bool freeTmpClip, freeCompClip; + RegionPtr pregWin; + Bool freeTmpClip, freeCompClip; - if(!pTree) { - miComputeCompositeClip(pGC, &pWin->drawable); - return; + if (!pTree) { + miComputeCompositeClip(pGC, &pWin->drawable); + return; } if (pGC->subWindowMode == IncludeInferiors) { - pregWin = RegionCreate(NullBox, 1); - freeTmpClip = TRUE; - if (pWin->parent || (screenIsSaved != SCREEN_SAVER_ON) || - !HasSaverWindow (pGC->pScreen)) - { - RegionIntersect(pregWin,&pTree->borderClip,&pWin->winSize); - } - } else { - pregWin = &pTree->clipList; - freeTmpClip = FALSE; + pregWin = RegionCreate(NullBox, 1); + freeTmpClip = TRUE; + if (pWin->parent || (screenIsSaved != SCREEN_SAVER_ON) || + !HasSaverWindow(pGC->pScreen)) { + RegionIntersect(pregWin, &pTree->borderClip, &pWin->winSize); + } + } + else { + pregWin = &pTree->clipList; + freeTmpClip = FALSE; } freeCompClip = pGC->freeCompClip; if (pGC->clientClipType == CT_NONE) { - if (freeCompClip) - RegionDestroy(pGC->pCompositeClip); - pGC->pCompositeClip = pregWin; - pGC->freeCompClip = freeTmpClip; - } else { - RegionTranslate(pGC->clientClip, - pWin->drawable.x + pGC->clipOrg.x, - pWin->drawable.y + pGC->clipOrg.y); - - if (freeCompClip) { - RegionIntersect(pGC->pCompositeClip, - pregWin, pGC->clientClip); - if (freeTmpClip) - RegionDestroy(pregWin); - } else if (freeTmpClip) { - RegionIntersect(pregWin, pregWin, pGC->clientClip); - pGC->pCompositeClip = pregWin; - } else { - pGC->pCompositeClip = RegionCreate(NullBox, 0); - RegionIntersect(pGC->pCompositeClip, - pregWin, pGC->clientClip); - } - pGC->freeCompClip = TRUE; - RegionTranslate(pGC->clientClip, - -(pWin->drawable.x + pGC->clipOrg.x), - -(pWin->drawable.y + pGC->clipOrg.y)); + if (freeCompClip) + RegionDestroy(pGC->pCompositeClip); + pGC->pCompositeClip = pregWin; + pGC->freeCompClip = freeTmpClip; + } + else { + RegionTranslate(pGC->clientClip, + pWin->drawable.x + pGC->clipOrg.x, + pWin->drawable.y + pGC->clipOrg.y); + + if (freeCompClip) { + RegionIntersect(pGC->pCompositeClip, pregWin, pGC->clientClip); + if (freeTmpClip) + RegionDestroy(pregWin); + } + else if (freeTmpClip) { + RegionIntersect(pregWin, pregWin, pGC->clientClip); + pGC->pCompositeClip = pregWin; + } + else { + pGC->pCompositeClip = RegionCreate(NullBox, 0); + RegionIntersect(pGC->pCompositeClip, pregWin, pGC->clientClip); + } + pGC->freeCompClip = TRUE; + RegionTranslate(pGC->clientClip, + -(pWin->drawable.x + pGC->clipOrg.x), + -(pWin->drawable.y + pGC->clipOrg.y)); } } Bool -miOverlayCollectUnderlayRegions( - WindowPtr pWin, - RegionPtr *region -){ +miOverlayCollectUnderlayRegions(WindowPtr pWin, RegionPtr *region) +{ miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); - if(pTree) { - *region = &pTree->borderClip; - return FALSE; + if (pTree) { + *region = &pTree->borderClip; + return FALSE; } *region = RegionCreate(NullBox, 0); - + CollectUnderlayChildrenRegions(pWin, *region); return TRUE; } - static miOverlayTreePtr -DoLeaf( - WindowPtr pWin, - miOverlayTreePtr parent, - miOverlayTreePtr prevSib -){ +DoLeaf(WindowPtr pWin, miOverlayTreePtr parent, miOverlayTreePtr prevSib) +{ miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); - + pTree->parent = parent; pTree->firstChild = NULL; pTree->lastChild = NULL; pTree->prevSib = prevSib; pTree->nextSib = NULL; - if(prevSib) - prevSib->nextSib = pTree; + if (prevSib) + prevSib->nextSib = pTree; + + if (!parent->firstChild) + parent->firstChild = parent->lastChild = pTree; + else if (parent->lastChild == prevSib) + parent->lastChild = pTree; - if(!parent->firstChild) - parent->firstChild = parent->lastChild = pTree; - else if(parent->lastChild == prevSib) - parent->lastChild = pTree; - return pTree; } -static void +static void RebuildTree(WindowPtr pWin) { miOverlayTreePtr parent, prevSib, tChild; @@ -1830,70 +1781,70 @@ RebuildTree(WindowPtr pWin) pWin = pWin->parent; - while(IN_OVERLAY(pWin)) - pWin = pWin->parent; + while (IN_OVERLAY(pWin)) + pWin = pWin->parent; parent = MIOVERLAY_GET_WINDOW_TREE(pWin); pChild = pWin->firstChild; parent->firstChild = parent->lastChild = NULL; - while(1) { - if(IN_UNDERLAY(pChild)) - prevSib = tChild = DoLeaf(pChild, parent, prevSib); - - if(pChild->firstChild) { - if(IN_UNDERLAY(pChild)) { - parent = tChild; - prevSib = NULL; - } - pChild = pChild->firstChild; - continue; - } - - while(!pChild->nextSib) { - pChild = pChild->parent; - if(pChild == pWin) return; - if(IN_UNDERLAY(pChild)) { - prevSib = tChild = MIOVERLAY_GET_WINDOW_TREE(pChild); - parent = tChild->parent; - } - } - - pChild = pChild->nextSib; + while (1) { + if (IN_UNDERLAY(pChild)) + prevSib = tChild = DoLeaf(pChild, parent, prevSib); + + if (pChild->firstChild) { + if (IN_UNDERLAY(pChild)) { + parent = tChild; + prevSib = NULL; + } + pChild = pChild->firstChild; + continue; + } + + while (!pChild->nextSib) { + pChild = pChild->parent; + if (pChild == pWin) + return; + if (IN_UNDERLAY(pChild)) { + prevSib = tChild = MIOVERLAY_GET_WINDOW_TREE(pChild); + parent = tChild->parent; + } + } + + pChild = pChild->nextSib; } } - static Bool HasUnderlayChildren(WindowPtr pWin) { WindowPtr pChild; - if(!(pChild = pWin->firstChild)) - return FALSE; + if (!(pChild = pWin->firstChild)) + return FALSE; - while(1) { - if(IN_UNDERLAY(pChild)) - return TRUE; + while (1) { + if (IN_UNDERLAY(pChild)) + return TRUE; - if(pChild->firstChild) { - pChild = pChild->firstChild; - continue; - } + if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } - while(!pChild->nextSib && (pWin != pChild)) - pChild = pChild->parent; + while (!pChild->nextSib && (pWin != pChild)) + pChild = pChild->parent; - if(pChild == pWin) break; + if (pChild == pWin) + break; - pChild = pChild->nextSib; + pChild = pChild->nextSib; } return FALSE; } - static Bool CollectUnderlayChildrenRegions(WindowPtr pWin, RegionPtr pReg) { @@ -1901,45 +1852,48 @@ CollectUnderlayChildrenRegions(WindowPtr pWin, RegionPtr pReg) miOverlayTreePtr pTree; Bool hasUnderlay; - if(!(pChild = pWin->firstChild)) - return FALSE; + if (!(pChild = pWin->firstChild)) + return FALSE; hasUnderlay = FALSE; - while(1) { - if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) { - RegionAppend(pReg, &pTree->borderClip); - hasUnderlay = TRUE; - } else - if(pChild->firstChild) { - pChild = pChild->firstChild; - continue; - } + while (1) { + if ((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) { + RegionAppend(pReg, &pTree->borderClip); + hasUnderlay = TRUE; + } + else if (pChild->firstChild) { + pChild = pChild->firstChild; + continue; + } - while(!pChild->nextSib && (pWin != pChild)) - pChild = pChild->parent; + while (!pChild->nextSib && (pWin != pChild)) + pChild = pChild->parent; - if(pChild == pWin) break; + if (pChild == pWin) + break; - pChild = pChild->nextSib; + pChild = pChild->nextSib; } - if(hasUnderlay) { - Bool overlap; - RegionValidate(pReg, &overlap); - } + if (hasUnderlay) { + Bool overlap; + + RegionValidate(pReg, &overlap); + } return hasUnderlay; } - -static void +static void MarkUnderlayWindow(WindowPtr pWin) { miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); - if(pTree->valdata) return; - pTree->valdata = (miOverlayValDataPtr)xnfalloc(sizeof(miOverlayValDataRec)); + if (pTree->valdata) + return; + pTree->valdata = + (miOverlayValDataPtr) xnfalloc(sizeof(miOverlayValDataRec)); pTree->valdata->oldAbsCorner.x = pWin->drawable.x; pTree->valdata->oldAbsCorner.y = pWin->drawable.y; pTree->valdata->borderVisible = NullRegion; |