frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'ajax/mi-cleanup'

This commit is contained in:
Keith Packard 2014-10-09 15:05:26 +02:00
parent f12e7f4980 5ecd7866f7
commit 6622f0cb17
38 changed files with 211 additions and 437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Xext/panoramiXprocs.c
View File

@ -1193,9 +1193,8 @@ PanoramiXCopyArea(ClientPtr client)
Bool overlap; Bool overlap;
RegionValidate(&totalReg, &overlap); RegionValidate(&totalReg, &overlap);
(*pDst->pScreen->SendGraphicsExpose) (client, &totalReg, SendGraphicsExpose(client, &totalReg, stuff->dstDrawable,
stuff->dstDrawable, X_CopyArea, 0);
X_CopyArea, 0);
RegionUninit(&totalReg); RegionUninit(&totalReg);
} }
} }
@ -1306,9 +1305,8 @@ PanoramiXCopyPlane(ClientPtr client)
Bool overlap; Bool overlap;
RegionValidate(&totalReg, &overlap); RegionValidate(&totalReg, &overlap);
(*pdstDraw->pScreen->SendGraphicsExpose) (client, &totalReg, SendGraphicsExpose(client, &totalReg, stuff->dstDrawable,
stuff->dstDrawable, X_CopyPlane, 0);
X_CopyPlane, 0);
RegionUninit(&totalReg); RegionUninit(&totalReg);
} }

3
composite/compext.c
View File

@ -594,9 +594,6 @@ CompositeExtensionInit(void)
return; return;
CompositeReqCode = (CARD8) extEntry->base; CompositeReqCode = (CARD8) extEntry->base;
miRegisterRedirectBorderClipProc(compSetRedirectBorderClip,
compGetRedirectBorderClip);
/* Initialization succeeded */ /* Initialization succeeded */
noCompositeExtension = FALSE; noCompositeExtension = FALSE;
} }

4
composite/compinit.c
View File

@ -119,12 +119,12 @@ compChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
pScreen->backingStoreSupport != NotUseful) { pScreen->backingStoreSupport != NotUseful) {
if (pWin->backingStore != NotUseful && !pWin->backStorage) { if (pWin->backingStore != NotUseful && !pWin->backStorage) {
compRedirectWindow(serverClient, pWin, CompositeRedirectAutomatic); compRedirectWindow(serverClient, pWin, CompositeRedirectAutomatic);
pWin->backStorage = (void *) (intptr_t) 1; pWin->backStorage = TRUE;
} }
else if (pWin->backingStore == NotUseful && pWin->backStorage) { else if (pWin->backingStore == NotUseful && pWin->backStorage) {
compUnredirectWindow(serverClient, pWin, compUnredirectWindow(serverClient, pWin,
CompositeRedirectAutomatic); CompositeRedirectAutomatic);
pWin->backStorage = NULL; pWin->backStorage = FALSE;
} }
} }

52
dix/dispatch.c
View File

@ -1597,6 +1597,52 @@ ProcClearToBackground(ClientPtr client)
return Success; return Success;
} }
/* send GraphicsExpose events, or a NoExpose event, based on the region */
void
SendGraphicsExpose(ClientPtr client, RegionPtr pRgn, XID drawable,
int major, int minor)
{
if (pRgn && !RegionNil(pRgn)) {
xEvent *pEvent;
xEvent *pe;
BoxPtr pBox;
int i;
int numRects;
numRects = RegionNumRects(pRgn);
pBox = RegionRects(pRgn);
if (!(pEvent = calloc(numRects, sizeof(xEvent))))
return;
pe = pEvent;
for (i = 1; i <= numRects; i++, pe++, pBox++) {
pe->u.u.type = GraphicsExpose;
pe->u.graphicsExposure.drawable = drawable;
pe->u.graphicsExposure.x = pBox->x1;
pe->u.graphicsExposure.y = pBox->y1;
pe->u.graphicsExposure.width = pBox->x2 - pBox->x1;
pe->u.graphicsExposure.height = pBox->y2 - pBox->y1;
pe->u.graphicsExposure.count = numRects - i;
pe->u.graphicsExposure.majorEvent = major;
pe->u.graphicsExposure.minorEvent = minor;
}
/* GraphicsExpose is a "critical event", which TryClientEvents
* handles specially. */
TryClientEvents(client, NULL, pEvent, numRects,
(Mask) 0, NoEventMask, NullGrab);
free(pEvent);
}
else {
xEvent event = {
.u.noExposure.drawable = drawable,
.u.noExposure.majorEvent = major,
.u.noExposure.minorEvent = minor
};
event.u.u.type = NoExpose;
WriteEventsToClient(client, 1, &event);
}
}
int int
ProcCopyArea(ClientPtr client) ProcCopyArea(ClientPtr client)
{ {
@ -1628,8 +1674,7 @@ ProcCopyArea(ClientPtr client)
stuff->width, stuff->height, stuff->width, stuff->height,
stuff->dstX, stuff->dstY); stuff->dstX, stuff->dstY);
if (pGC->graphicsExposures) { if (pGC->graphicsExposures) {
(*pDst->pScreen->SendGraphicsExpose) SendGraphicsExpose(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);
(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);
if (pRgn) if (pRgn)
RegionDestroy(pRgn); RegionDestroy(pRgn);
} }
@ -1676,8 +1721,7 @@ ProcCopyPlane(ClientPtr client)
stuff->srcY, stuff->width, stuff->height, stuff->srcY, stuff->width, stuff->height,
stuff->dstX, stuff->dstY, stuff->bitPlane); stuff->dstX, stuff->dstY, stuff->bitPlane);
if (pGC->graphicsExposures) { if (pGC->graphicsExposures) {
(*pdstDraw->pScreen->SendGraphicsExpose) SendGraphicsExpose(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);
(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);
if (pRgn) if (pRgn)
RegionDestroy(pRgn); RegionDestroy(pRgn);
} }

73
dix/window.c
View File

@ -357,13 +357,12 @@ SetWindowToDefaults(WindowPtr pWin)
pWin->firstChild = NullWindow; pWin->firstChild = NullWindow;
pWin->lastChild = NullWindow; pWin->lastChild = NullWindow;
pWin->valdata = (ValidatePtr) NULL; pWin->valdata = NULL;
pWin->optional = (WindowOptPtr) NULL; pWin->optional = NULL;
pWin->cursorIsNone = TRUE; pWin->cursorIsNone = TRUE;
pWin->backingStore = NotUseful; pWin->backingStore = NotUseful;
pWin->DIXsaveUnder = FALSE; pWin->backStorage = 0;
pWin->backStorage = (void *) NULL;
pWin->mapped = FALSE; /* off */ pWin->mapped = FALSE; /* off */
pWin->realized = FALSE; /* off */ pWin->realized = FALSE; /* off */
@ -1551,7 +1550,7 @@ MoveWindowInStack(WindowPtr pWin, WindowPtr pNextSib)
if (pWin->prevSib) if (pWin->prevSib)
pWin->prevSib->nextSib = pWin->nextSib; pWin->prevSib->nextSib = pWin->nextSib;
pWin->nextSib = pParent->firstChild; pWin->nextSib = pParent->firstChild;
pWin->prevSib = (WindowPtr) NULL; pWin->prevSib = NULL;
pNextSib->prevSib = pWin; pNextSib->prevSib = pWin;
pParent->firstChild = pWin; pParent->firstChild = pWin;
} }
@ -1813,8 +1812,6 @@ ResizeChildrenWinSize(WindowPtr pWin, int dx, int dy, int dw, int dh)
#define ChangeMask ((Mask)(CWX | CWY | CWWidth | CWHeight)) #define ChangeMask ((Mask)(CWX | CWY | CWWidth | CWHeight))
#define IllegalInputOnlyConfigureMask (CWBorderWidth)
/* /*
* IsSiblingAboveMe * IsSiblingAboveMe
* returns Above if pSib above pMe in stack or Below otherwise * returns Above if pSib above pMe in stack or Below otherwise
@ -1848,7 +1845,7 @@ WindowExtents(WindowPtr pWin, BoxPtr pBox)
return pBox; return pBox;
} }
#define IS_SHAPED(pWin) (wBoundingShape (pWin) != (RegionPtr) NULL) #define IS_SHAPED(pWin) (wBoundingShape (pWin) != NULL)
static RegionPtr static RegionPtr
MakeBoundingRegion(WindowPtr pWin, BoxPtr pBox) MakeBoundingRegion(WindowPtr pWin, BoxPtr pBox)
@ -1954,7 +1951,7 @@ WhereDoIGoInTheStack(WindowPtr pWin,
WindowPtr pHead, pFirst; WindowPtr pHead, pFirst;
if ((pWin == pWin->parent->firstChild) && (pWin == pWin->parent->lastChild)) if ((pWin == pWin->parent->firstChild) && (pWin == pWin->parent->lastChild))
return ((WindowPtr) NULL); return NULL;
pHead = RealChildHead(pWin->parent); pHead = RealChildHead(pWin->parent);
pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild; pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild;
box.x1 = x; box.x1 = x;
@ -2062,10 +2059,10 @@ ReflectStackChange(WindowPtr pWin, WindowPtr pSib, VTKind kind)
if (anyMarked) { if (anyMarked) {
(*pScreen->ValidateTree) (pLayerWin->parent, pFirstChange, kind); (*pScreen->ValidateTree) (pLayerWin->parent, pFirstChange, kind);
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (pWin->drawable.pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange,
kind);
} }
if (anyMarked && pWin->drawable.pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange,
kind);
} }
if (pWin->realized) if (pWin->realized)
WindowsRestructured(); WindowsRestructured();
@ -2092,8 +2089,7 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
h = pWin->drawable.height, bw = pWin->borderWidth; h = pWin->drawable.height, bw = pWin->borderWidth;
int rc, action, smode = Above; int rc, action, smode = Above;
if ((pWin->drawable.class == InputOnly) && if ((pWin->drawable.class == InputOnly) && (mask & CWBorderWidth))
(mask & IllegalInputOnlyConfigureMask))
return BadMatch; return BadMatch;
if ((mask & CWSibling) && !(mask & CWStackMode)) if ((mask & CWSibling) && !(mask & CWStackMode))
@ -2580,10 +2576,10 @@ MapWindow(WindowPtr pWin, ClientPtr client)
if (anyMarked) { if (anyMarked) {
(*pScreen->ValidateTree) (pLayerWin->parent, pLayerWin, VTMap); (*pScreen->ValidateTree) (pLayerWin->parent, pLayerWin, VTMap);
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
VTMap);
} }
if (anyMarked && pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
VTMap);
} }
WindowsRestructured(); WindowsRestructured();
} }
@ -2601,7 +2597,7 @@ MapWindow(WindowPtr pWin, ClientPtr client)
(*pScreen->PostValidateTree) (NullWindow, pWin, VTMap); (*pScreen->PostValidateTree) (NullWindow, pWin, VTMap);
RegionNull(&temp); RegionNull(&temp);
RegionCopy(&temp, &pWin->clipList); RegionCopy(&temp, &pWin->clipList);
(*pScreen->WindowExposures) (pWin, &temp, NullRegion); (*pScreen->WindowExposures) (pWin, &temp);
RegionUninit(&temp); RegionUninit(&temp);
} }
@ -2645,8 +2641,7 @@ MapSubwindows(WindowPtr pParent, ClientPtr client)
RealizeTree(pWin); RealizeTree(pWin);
if (pWin->viewable) { if (pWin->viewable) {
anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin, pWin, anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin, pWin,
(WindowPtr NULL);
*) NULL);
} }
} }
} }
@ -2656,17 +2651,16 @@ MapSubwindows(WindowPtr pParent, ClientPtr client)
pLayerWin = (*pScreen->GetLayerWindow) (pParent); pLayerWin = (*pScreen->GetLayerWindow) (pParent);
if (pLayerWin->parent != pParent) { if (pLayerWin->parent != pParent) {
anyMarked |= (*pScreen->MarkOverlappedWindows) (pLayerWin, anyMarked |= (*pScreen->MarkOverlappedWindows) (pLayerWin,
pLayerWin, pLayerWin, NULL);
(WindowPtr *) NULL);
pFirstMapped = pLayerWin; pFirstMapped = pLayerWin;
} }
if (anyMarked) { if (anyMarked) {
(*pScreen->ValidateTree) (pLayerWin->parent, pFirstMapped, VTMap); (*pScreen->ValidateTree) (pLayerWin->parent, pFirstMapped, VTMap);
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pFirstMapped,
VTMap);
} }
if (anyMarked && pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pFirstMapped,
VTMap);
WindowsRestructured(); WindowsRestructured();
} }
} }
@ -2760,9 +2754,9 @@ UnmapWindow(WindowPtr pWin, Bool fromConfigure)
if (!fromConfigure) { if (!fromConfigure) {
(*pScreen->ValidateTree) (pLayerWin->parent, pWin, VTUnmap); (*pScreen->ValidateTree) (pLayerWin->parent, pWin, VTUnmap);
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pWin, VTUnmap);
} }
if (!fromConfigure && pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pWin, VTUnmap);
} }
if (wasRealized && !fromConfigure) { if (wasRealized && !fromConfigure) {
WindowsRestructured(); WindowsRestructured();
@ -2807,8 +2801,6 @@ UnmapSubwindows(WindowPtr pWin)
pChild->mapped = FALSE; pChild->mapped = FALSE;
if (pChild->realized) if (pChild->realized)
UnrealizeTree(pChild, FALSE); UnrealizeTree(pChild, FALSE);
if (wasViewable) {
}
} }
} }
if (wasViewable) { if (wasViewable) {
@ -2818,8 +2810,7 @@ UnmapSubwindows(WindowPtr pWin)
else { else {
WindowPtr ptmp; WindowPtr ptmp;
(*pScreen->MarkOverlappedWindows) (pWin, pLayerWin, (*pScreen->MarkOverlappedWindows) (pWin, pLayerWin, NULL);
(WindowPtr *) NULL);
(*pScreen->MarkWindow) (pLayerWin->parent); (*pScreen->MarkWindow) (pLayerWin->parent);
/* Windows between pWin and pLayerWin may not have been marked */ /* Windows between pWin and pLayerWin may not have been marked */
@ -2833,9 +2824,10 @@ UnmapSubwindows(WindowPtr pWin)
} }
(*pScreen->ValidateTree) (pLayerWin->parent, pHead, VTUnmap); (*pScreen->ValidateTree) (pLayerWin->parent, pHead, VTUnmap);
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pHead,
VTUnmap);
} }
if (anyMarked && pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pHead, VTUnmap);
} }
if (wasRealized) { if (wasRealized) {
WindowsRestructured(); WindowsRestructured();
@ -2878,7 +2870,7 @@ HandleSaveSet(ClientPtr client)
} }
free(client->saveSet); free(client->saveSet);
client->numSaved = 0; client->numSaved = 0;
client->saveSet = (SaveSetElt *) NULL; client->saveSet = NULL;
} }
/** /**
@ -3594,22 +3586,19 @@ SetRootClip(ScreenPtr pScreen, Bool enable)
if (pWin->firstChild) { if (pWin->firstChild) {
anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin->firstChild, anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin->firstChild,
pWin->firstChild, pWin->firstChild,
(WindowPtr *) NULL); NULL);
} }
else { else {
(*pScreen->MarkWindow) (pWin); (*pScreen->MarkWindow) (pWin);
anyMarked = TRUE; anyMarked = TRUE;
} }
if (anyMarked) if (anyMarked) {
(*pScreen->ValidateTree) (pWin, NullWindow, VTOther); (*pScreen->ValidateTree) (pWin, NullWindow, VTOther);
}
if (WasViewable) {
if (anyMarked)
(*pScreen->HandleExposures) (pWin); (*pScreen->HandleExposures) (pWin);
if (anyMarked && pScreen->PostValidateTree) if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pWin, NullWindow, VTOther); (*pScreen->PostValidateTree) (pWin, NullWindow, VTOther);
}
} }
if (pWin->realized) if (pWin->realized)
WindowsRestructured(); WindowsRestructured();

4
fb/fb.h
View File

@ -1621,13 +1621,13 @@ extern _X_EXPORT Bool
fbDestroyWindow(WindowPtr pWin); fbDestroyWindow(WindowPtr pWin);
extern _X_EXPORT Bool extern _X_EXPORT Bool
fbMapWindow(WindowPtr pWindow); fbRealizeWindow(WindowPtr pWindow);
extern _X_EXPORT Bool extern _X_EXPORT Bool
fbPositionWindow(WindowPtr pWin, int x, int y); fbPositionWindow(WindowPtr pWin, int x, int y);
extern _X_EXPORT Bool extern _X_EXPORT Bool
fbUnmapWindow(WindowPtr pWindow); fbUnrealizeWindow(WindowPtr pWindow);
extern _X_EXPORT void extern _X_EXPORT void

2
fb/fbcopy.c
View File

@ -271,5 +271,5 @@ fbCopyPlane(DrawablePtr pSrcDrawable,
else else
return miHandleExposures(pSrcDrawable, pDstDrawable, pGC, return miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
xIn, yIn, xIn, yIn,
widthSrc, heightSrc, xOut, yOut, bitplane); widthSrc, heightSrc, xOut, yOut);
} }

5
fb/fboverlay.c
View File

@ -240,12 +240,11 @@ fbOverlayCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
} }
void void
fbOverlayWindowExposures(WindowPtr pWin, fbOverlayWindowExposures(WindowPtr pWin, RegionPtr prgn)
RegionPtr prgn, RegionPtr other_exposed)
{ {
fbOverlayUpdateLayerRegion(pWin->drawable.pScreen, fbOverlayUpdateLayerRegion(pWin->drawable.pScreen,
fbOverlayWindowLayer(pWin), prgn); fbOverlayWindowLayer(pWin), prgn);
miWindowExposures(pWin, prgn, other_exposed); miWindowExposures(pWin, prgn);
} }
Bool Bool

4
fb/fboverlay.h
View File

@ -82,9 +82,7 @@ extern _X_EXPORT void
fbOverlayCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); fbOverlayCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
extern _X_EXPORT void extern _X_EXPORT void
fbOverlayWindowExposures(WindowPtr pWin, RegionPtr prgn);
fbOverlayWindowExposures(WindowPtr pWin,
RegionPtr prgn, RegionPtr other_exposed);
extern _X_EXPORT Bool extern _X_EXPORT Bool

4
fb/fbscreen.c
View File

@ -110,8 +110,8 @@ fbSetupScreen(ScreenPtr pScreen, void *pbits, /* pointer to screen bitmap */
pScreen->DestroyWindow = fbDestroyWindow; pScreen->DestroyWindow = fbDestroyWindow;
pScreen->PositionWindow = fbPositionWindow; pScreen->PositionWindow = fbPositionWindow;
pScreen->ChangeWindowAttributes = fbChangeWindowAttributes; pScreen->ChangeWindowAttributes = fbChangeWindowAttributes;
pScreen->RealizeWindow = fbMapWindow; pScreen->RealizeWindow = fbRealizeWindow;
pScreen->UnrealizeWindow = fbUnmapWindow; pScreen->UnrealizeWindow = fbUnrealizeWindow;
pScreen->CopyWindow = fbCopyWindow; pScreen->CopyWindow = fbCopyWindow;
pScreen->CreatePixmap = fbCreatePixmap; pScreen->CreatePixmap = fbCreatePixmap;
pScreen->DestroyPixmap = fbDestroyPixmap; pScreen->DestroyPixmap = fbDestroyPixmap;

4
fb/fbwindow.c
View File

@ -46,7 +46,7 @@ fbDestroyWindow(WindowPtr pWin)
} }
Bool Bool
fbMapWindow(WindowPtr pWindow) fbRealizeWindow(WindowPtr pWindow)
{ {
return TRUE; return TRUE;
} }
@ -58,7 +58,7 @@ fbPositionWindow(WindowPtr pWin, int x, int y)
} }
Bool Bool
fbUnmapWindow(WindowPtr pWindow) fbUnrealizeWindow(WindowPtr pWindow)
{ {
return TRUE; return TRUE;
} }

4
fb/wfbrename.h
View File

@ -88,7 +88,6 @@
#define fbInstallColormap wfbInstallColormap #define fbInstallColormap wfbInstallColormap
#define fbLaneTable wfbLaneTable #define fbLaneTable wfbLaneTable
#define fbListInstalledColormaps wfbListInstalledColormaps #define fbListInstalledColormaps wfbListInstalledColormaps
#define fbMapWindow wfbMapWindow
#define FbMergeRopBits wFbMergeRopBits #define FbMergeRopBits wFbMergeRopBits
#define fbOddStipple wfbOddStipple #define fbOddStipple wfbOddStipple
#define fbOddTile wfbOddTile #define fbOddTile wfbOddTile
@ -134,6 +133,7 @@
#define fbQueryBestSize wfbQueryBestSize #define fbQueryBestSize wfbQueryBestSize
#define fbRasterizeTrapezoid wfbRasterizeTrapezoid #define fbRasterizeTrapezoid wfbRasterizeTrapezoid
#define fbRealizeFont wfbRealizeFont #define fbRealizeFont wfbRealizeFont
#define fbRealizeWindow wfbRealizeWindow
#define fbReduceRasterOp wfbReduceRasterOp #define fbReduceRasterOp wfbReduceRasterOp
#define fbReplicatePixel wfbReplicatePixel #define fbReplicatePixel wfbReplicatePixel
#define fbResolveColor wfbResolveColor #define fbResolveColor wfbResolveColor
@ -160,7 +160,7 @@
#define fbTrapezoids wfbTrapezoids #define fbTrapezoids wfbTrapezoids
#define fbTriangles wfbTriangles #define fbTriangles wfbTriangles
#define fbUninstallColormap wfbUninstallColormap #define fbUninstallColormap wfbUninstallColormap
#define fbUnmapWindow wfbUnmapWindow #define fbUnrealizeWindow wfbUnrealizeWindow
#define fbUnrealizeFont wfbUnrealizeFont #define fbUnrealizeFont wfbUnrealizeFont
#define fbValidateGC wfbValidateGC #define fbValidateGC wfbValidateGC
#define fbWinPrivateKeyRec wfbWinPrivateKeyRec #define fbWinPrivateKeyRec wfbWinPrivateKeyRec

3
glamor/glamor_copy.c
View File

@ -677,8 +677,7 @@ glamor_copy_plane(DrawablePtr src, DrawablePtr dst, GCPtr gc,
{ {
if ((bitplane & FbFullMask(src->depth)) == 0) if ((bitplane & FbFullMask(src->depth)) == 0)
return miHandleExposures(src, dst, gc, return miHandleExposures(src, dst, gc,
srcx, srcy, width, height, dstx, dsty, srcx, srcy, width, height, dstx, dsty);
bitplane);
return miDoCopy(src, dst, gc, return miDoCopy(src, dst, gc,
srcx, srcy, width, height, srcx, srcy, width, height,
dstx, dsty, glamor_copy, bitplane, NULL); dstx, dsty, glamor_copy, bitplane, NULL);

8
hw/dmx/dmxgcops.c
View File

@ -179,7 +179,7 @@ dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst)) if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
dstx, dsty, 0L); dstx, dsty);
DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw); DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw); DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
@ -188,7 +188,7 @@ dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
srcx, srcy, w, h, dstx, dsty); srcx, srcy, w, h, dstx, dsty);
dmxSync(dmxScreen, FALSE); dmxSync(dmxScreen, FALSE);
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, 0L); return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);
} }
/** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst /** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst
@ -206,7 +206,7 @@ dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst)) if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height, return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
dstx, dsty, bitPlane); dstx, dsty);
DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw); DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw); DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
@ -216,7 +216,7 @@ dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
dmxSync(dmxScreen, FALSE); dmxSync(dmxScreen, FALSE);
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height, return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
dstx, dsty, bitPlane); dstx, dsty);
} }
/** Render list of points, \a pptInit in \a pDrawable on the back-end /** Render list of points, \a pptInit in \a pDrawable on the back-end

4
hw/dmx/dmxwindow.c
View File

@ -772,7 +772,7 @@ dmxWindowExposurePredicate(Display * dpy, XEvent * ev, XPointer ptr)
* in DMX, the events that are generated by the back-end server are * in DMX, the events that are generated by the back-end server are
* redundant, so we eat them here. */ * redundant, so we eat them here. */
void void
dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed) dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn)
{ {
ScreenPtr pScreen = pWindow->drawable.pScreen; ScreenPtr pScreen = pWindow->drawable.pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
@ -799,7 +799,7 @@ dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed)
#if 1 #if 1
if (pScreen->WindowExposures) if (pScreen->WindowExposures)
pScreen->WindowExposures(pWindow, prgn, other_exposed); pScreen->WindowExposures(pWindow, prgn);
#endif #endif
DMX_WRAP(WindowExposures, dmxWindowExposures, dmxScreen, pScreen); DMX_WRAP(WindowExposures, dmxWindowExposures, dmxScreen, pScreen);
} }

3
hw/dmx/dmxwindow.h
View File

@ -73,8 +73,7 @@ extern Bool dmxChangeWindowAttributes(WindowPtr pWindow, unsigned long mask);
extern Bool dmxRealizeWindow(WindowPtr pWindow); extern Bool dmxRealizeWindow(WindowPtr pWindow);
extern Bool dmxUnrealizeWindow(WindowPtr pWindow); extern Bool dmxUnrealizeWindow(WindowPtr pWindow);
extern void dmxRestackWindow(WindowPtr pWindow, WindowPtr pOldNextSib); extern void dmxRestackWindow(WindowPtr pWindow, WindowPtr pOldNextSib);
extern void dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, extern void dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn);
RegionPtr other_exposed);
extern void dmxCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, extern void dmxCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg,
RegionPtr prgnSrc); RegionPtr prgnSrc);

2
hw/kdrive/ephyr/ephyr.c
View File

@ -878,7 +878,7 @@ ephyrExposePairedWindow(int a_remote)
screen = pair->local->drawable.pScreen; screen = pair->local->drawable.pScreen;
RegionNull(&reg); RegionNull(&reg);
RegionCopy(&reg, &pair->local->clipList); RegionCopy(&reg, &pair->local->clipList);
screen->WindowExposures(pair->local, &reg, NullRegion); screen->WindowExposures(pair->local, &reg);
RegionUninit(&reg); RegionUninit(&reg);
} }
#endif /* XF86DRI */ #endif /* XF86DRI */

4
hw/kdrive/src/kdrive.c
View File

@ -909,10 +909,6 @@ KdScreenInit(ScreenPtr pScreen, int argc, char **argv)
if (!(*card->cfuncs->finishInitScreen) (pScreen)) if (!(*card->cfuncs->finishInitScreen) (pScreen))
return FALSE; return FALSE;
#if 0
fbInitValidateTree(pScreen);
#endif
/* /*
* Wrap CloseScreen, the order now is: * Wrap CloseScreen, the order now is:
* KdCloseScreen * KdCloseScreen

6
hw/kdrive/src/kxv.c
View File

@ -86,7 +86,7 @@ static int KdXVQueryImageAttributes(XvPortPtr, XvImagePtr,
/* ScreenRec fields */ /* ScreenRec fields */
static Bool KdXVDestroyWindow(WindowPtr pWin); static Bool KdXVDestroyWindow(WindowPtr pWin);
static void KdXVWindowExposures(WindowPtr pWin, RegionPtr r1, RegionPtr r2); static void KdXVWindowExposures(WindowPtr pWin, RegionPtr r1);
static void KdXVClipNotify(WindowPtr pWin, int dx, int dy); static void KdXVClipNotify(WindowPtr pWin, int dx, int dy);
static Bool KdXVCloseScreen(ScreenPtr); static Bool KdXVCloseScreen(ScreenPtr);
@ -822,7 +822,7 @@ KdXVDestroyWindow(WindowPtr pWin)
} }
static void static void
KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2) KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1)
{ {
ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen); KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
@ -834,7 +834,7 @@ KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1)); AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));
pScreen->WindowExposures = ScreenPriv->WindowExposures; pScreen->WindowExposures = ScreenPriv->WindowExposures;
(*pScreen->WindowExposures) (pWin, reg1, reg2); (*pScreen->WindowExposures) (pWin, reg1);
pScreen->WindowExposures = KdXVWindowExposures; pScreen->WindowExposures = KdXVWindowExposures;
/* filter out XClearWindow/Area */ /* filter out XClearWindow/Area */

6
hw/xfree86/common/xf86xv.c
View File

@ -84,7 +84,7 @@ static int xf86XVQueryImageAttributes(XvPortPtr, XvImagePtr,
/* ScreenRec fields */ /* ScreenRec fields */
static Bool xf86XVDestroyWindow(WindowPtr pWin); static Bool xf86XVDestroyWindow(WindowPtr pWin);
static void xf86XVWindowExposures(WindowPtr pWin, RegionPtr r1, RegionPtr r2); static void xf86XVWindowExposures(WindowPtr pWin, RegionPtr r1);
static void xf86XVPostValidateTree(WindowPtr pWin, WindowPtr pLayerWin, static void xf86XVPostValidateTree(WindowPtr pWin, WindowPtr pLayerWin,
VTKind kind); VTKind kind);
static void xf86XVClipNotify(WindowPtr pWin, int dx, int dy); static void xf86XVClipNotify(WindowPtr pWin, int dx, int dy);
@ -1048,7 +1048,7 @@ xf86XVPostValidateTree(WindowPtr pWin, WindowPtr pLayerWin, VTKind kind)
} }
static void static void
xf86XVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2) xf86XVWindowExposures(WindowPtr pWin, RegionPtr reg1)
{ {
ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
XF86XVScreenPtr ScreenPriv = GET_XF86XV_SCREEN(pScreen); XF86XVScreenPtr ScreenPriv = GET_XF86XV_SCREEN(pScreen);
@ -1059,7 +1059,7 @@ xf86XVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1)); AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));
pScreen->WindowExposures = ScreenPriv->WindowExposures; pScreen->WindowExposures = ScreenPriv->WindowExposures;
(*pScreen->WindowExposures) (pWin, reg1, reg2); (*pScreen->WindowExposures) (pWin, reg1);
pScreen->WindowExposures = xf86XVWindowExposures; pScreen->WindowExposures = xf86XVWindowExposures;
/* filter out XClearWindow/Area */ /* filter out XClearWindow/Area */

4
hw/xfree86/dri/dri.c
View File

@ -1828,7 +1828,7 @@ DRIGetContextStore(DRIContextPrivPtr context)
} }
void void
DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg) DRIWindowExposures(WindowPtr pWin, RegionPtr prgn)
{ {
ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen); DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
@ -1846,7 +1846,7 @@ DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg)
pScreen->WindowExposures = pDRIPriv->wrap.WindowExposures; pScreen->WindowExposures = pDRIPriv->wrap.WindowExposures;
/* call lower layers */ /* call lower layers */
(*pScreen->WindowExposures) (pWin, prgn, bsreg); (*pScreen->WindowExposures) (pWin, prgn);
/* rewrap */ /* rewrap */
pDRIPriv->wrap.WindowExposures = pScreen->WindowExposures; pDRIPriv->wrap.WindowExposures = pScreen->WindowExposures;

3
hw/xfree86/dri/dri.h
View File

@ -280,8 +280,7 @@ extern _X_EXPORT void DRISwapContext(int drmFD, void *oldctx, void *newctx);
extern _X_EXPORT void *DRIGetContextStore(DRIContextPrivPtr context); extern _X_EXPORT void *DRIGetContextStore(DRIContextPrivPtr context);
extern _X_EXPORT void DRIWindowExposures(WindowPtr pWin, extern _X_EXPORT void DRIWindowExposures(WindowPtr pWin, RegionPtr prgn);
RegionPtr prgn, RegionPtr bsreg);
extern _X_EXPORT Bool DRIDestroyWindow(WindowPtr pWin); extern _X_EXPORT Bool DRIDestroyWindow(WindowPtr pWin);

4
hw/xnest/Window.c
View File

@ -386,7 +386,7 @@ xnestWindowExposurePredicate(Display * dpy, XEvent * event, XPointer ptr)
} }
void void
xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed) xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn)
{ {
XEvent event; XEvent event;
Window window; Window window;
@ -410,7 +410,7 @@ xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
XPutBackEvent(xnestDisplay, &event); XPutBackEvent(xnestDisplay, &event);
} }
miWindowExposures(pWin, pRgn, other_exposed); miWindowExposures(pWin, pRgn);
} }
void void

3
hw/xnest/XNWindow.h
View File

@ -66,8 +66,7 @@ Bool xnestRealizeWindow(WindowPtr pWin);
Bool xnestUnrealizeWindow(WindowPtr pWin); Bool xnestUnrealizeWindow(WindowPtr pWin);
void xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion); void xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion);
void xnestClipNotify(WindowPtr pWin, int dx, int dy); void xnestClipNotify(WindowPtr pWin, int dx, int dy);
void xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, void xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn);
RegionPtr other_exposed);
void xnestSetShape(WindowPtr pWin, int kind); void xnestSetShape(WindowPtr pWin, int kind);
void xnestShapeWindow(WindowPtr pWin); void xnestShapeWindow(WindowPtr pWin);

21
hw/xquartz/xpr/dri.c
View File

@ -138,9 +138,6 @@ DRIFinishScreenInit(ScreenPtr pScreen)
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen); DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
/* Wrap DRI support */ /* Wrap DRI support */
pDRIPriv->wrap.WindowExposures = pScreen->WindowExposures;
pScreen->WindowExposures = DRIWindowExposures;
pDRIPriv->wrap.CopyWindow = pScreen->CopyWindow; pDRIPriv->wrap.CopyWindow = pScreen->CopyWindow;
pScreen->CopyWindow = DRICopyWindow; pScreen->CopyWindow = DRICopyWindow;
@ -576,24 +573,6 @@ DRIDrawablePrivDelete(void *pResource, XID id)
return TRUE; return TRUE;
} }
void
DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
DRIDrawablePrivPtr pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin);
if (pDRIDrawablePriv) {
/* FIXME: something? */
}
pScreen->WindowExposures = pDRIPriv->wrap.WindowExposures;
(*pScreen->WindowExposures)(pWin, prgn, bsreg);
pScreen->WindowExposures = DRIWindowExposures;
}
void void
DRICopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) DRICopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{ {

4
hw/xquartz/xpr/dri.h
View File

@ -51,7 +51,6 @@ typedef void (*ClipNotifyPtr)(WindowPtr, int, int);
* overridden by the driver in its [driver]DRIScreenInit function. * overridden by the driver in its [driver]DRIScreenInit function.
*/ */
typedef struct { typedef struct {
WindowExposuresProcPtr WindowExposures;
CopyWindowProcPtr CopyWindow; CopyWindowProcPtr CopyWindow;
ClipNotifyProcPtr ClipNotify; ClipNotifyProcPtr ClipNotify;
} DRIWrappedFuncsRec, *DRIWrappedFuncsPtr; } DRIWrappedFuncsRec, *DRIWrappedFuncsPtr;
@ -108,9 +107,6 @@ DRICopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
extern void extern void
DRIClipNotify(WindowPtr pWin, int dx, int dy); DRIClipNotify(WindowPtr pWin, int dx, int dy);
extern void
DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg);
extern void extern void
DRISurfaceNotify(xp_surface_id id, int kind); DRISurfaceNotify(xp_surface_id id, int kind);

6
include/dix.h
View File

@ -254,6 +254,12 @@ extern _X_EXPORT void ClientWakeup(ClientPtr /*client */ );
extern _X_EXPORT Bool ClientIsAsleep(ClientPtr /*client */ ); extern _X_EXPORT Bool ClientIsAsleep(ClientPtr /*client */ );
extern _X_EXPORT void SendGraphicsExpose(ClientPtr /*client */ ,
RegionPtr /*pRgn */ ,
XID /*drawable */ ,
int /*major */ ,
int /*minor */);
/* atom.c */ /* atom.c */
extern _X_EXPORT Atom MakeAtom(const char * /*string */ , extern _X_EXPORT Atom MakeAtom(const char * /*string */ ,

10
include/scrnintstr.h
View File

@ -155,8 +155,7 @@ typedef void (*PostValidateTreeProcPtr) (WindowPtr /*pParent */ ,
VTKind /*kind */ ); VTKind /*kind */ );
typedef void (*WindowExposuresProcPtr) (WindowPtr /*pWindow */ , typedef void (*WindowExposuresProcPtr) (WindowPtr /*pWindow */ ,
RegionPtr /*prgn */ , RegionPtr /*prgn */);
RegionPtr /*other_exposed */ );
typedef void (*CopyWindowProcPtr) (WindowPtr /*pWindow */ , typedef void (*CopyWindowProcPtr) (WindowPtr /*pWindow */ ,
DDXPointRec /*ptOldOrg */ , DDXPointRec /*ptOldOrg */ ,
@ -253,12 +252,6 @@ typedef void (*ResolveColorProcPtr) (unsigned short * /*pred */ ,
typedef RegionPtr (*BitmapToRegionProcPtr) (PixmapPtr /*pPix */ ); typedef RegionPtr (*BitmapToRegionProcPtr) (PixmapPtr /*pPix */ );
typedef void (*SendGraphicsExposeProcPtr) (ClientPtr /*client */ ,
RegionPtr /*pRgn */ ,
XID /*drawable */ ,
int /*major */ ,
int /*minor */ );
typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen, typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen,
void *pTimeout, void *pTimeout,
void *pReadmask); void *pReadmask);
@ -541,7 +534,6 @@ typedef struct _Screen {
/* Region procedures */ /* Region procedures */
BitmapToRegionProcPtr BitmapToRegion; BitmapToRegionProcPtr BitmapToRegion;
SendGraphicsExposeProcPtr SendGraphicsExpose;
/* os layer procedures */ /* os layer procedures */

3
include/windowstr.h
View File

@ -144,14 +144,13 @@ typedef struct _Window {
Mask eventMask; /* mask from the creating client */ Mask eventMask; /* mask from the creating client */
PixUnion background; PixUnion background;
PixUnion border; PixUnion border;
void *backStorage; /* null when BS disabled */
WindowOptPtr optional; WindowOptPtr optional;
unsigned backgroundState:2; /* None, Relative, Pixel, Pixmap */ unsigned backgroundState:2; /* None, Relative, Pixel, Pixmap */
unsigned borderIsPixel:1; unsigned borderIsPixel:1;
unsigned cursorIsNone:1; /* else real cursor (might inherit) */ unsigned cursorIsNone:1; /* else real cursor (might inherit) */
unsigned backingStore:2; unsigned backingStore:2;
unsigned backStorage:1; /* if bs is allocated */
unsigned saveUnder:1; unsigned saveUnder:1;
unsigned DIXsaveUnder:1;
unsigned bitGravity:4; unsigned bitGravity:4;
unsigned winGravity:4; unsigned winGravity:4;
unsigned overrideRedirect:1; unsigned overrideRedirect:1;

37
mi/mi.h
View File

@ -229,15 +229,7 @@ extern _X_EXPORT RegionPtr miHandleExposures(DrawablePtr /*pSrcDrawable */ ,
int /*width */ , int /*width */ ,
int /*height */ , int /*height */ ,
int /*dstx */ , int /*dstx */ ,
int /*dsty */ , int /*dsty */
unsigned long /*plane */
);
extern _X_EXPORT void miSendGraphicsExpose(ClientPtr /*client */ ,
RegionPtr /*pRgn */ ,
XID /*drawable */ ,
int /*major */ ,
int /*minor */
); );
extern _X_EXPORT void miSendExposures(WindowPtr /*pWin */ , extern _X_EXPORT void miSendExposures(WindowPtr /*pWin */ ,
@ -247,9 +239,7 @@ extern _X_EXPORT void miSendExposures(WindowPtr /*pWin */ ,
); );
extern _X_EXPORT void miWindowExposures(WindowPtr /*pWin */ , extern _X_EXPORT void miWindowExposures(WindowPtr /*pWin */ ,
RegionPtr /*prgn */ , RegionPtr /*prgn */);
RegionPtr /*other_exposed */
);
extern _X_EXPORT void miPaintWindow(WindowPtr /*pWin */ , extern _X_EXPORT void miPaintWindow(WindowPtr /*pWin */ ,
RegionPtr /*prgn */ , RegionPtr /*prgn */ ,
@ -427,17 +417,6 @@ extern _X_EXPORT int miShapedWindowIn(RegionPtr /*universe */ ,
int /*y */ int /*y */
); );
typedef void
(*SetRedirectBorderClipProcPtr) (WindowPtr pWindow, RegionPtr pRegion);
typedef RegionPtr
(*GetRedirectBorderClipProcPtr) (WindowPtr pWindow);
extern _X_EXPORT void
miRegisterRedirectBorderClipProc(SetRedirectBorderClipProcPtr setBorderClip,
GetRedirectBorderClipProcPtr getBorderClip);
extern _X_EXPORT int miValidateTree(WindowPtr /*pParent */ , extern _X_EXPORT int miValidateTree(WindowPtr /*pParent */ ,
WindowPtr /*pChild */ , WindowPtr /*pChild */ ,
VTKind /*kind */ VTKind /*kind */
@ -491,12 +470,12 @@ extern _X_EXPORT void miMoveWindow(WindowPtr /*pWin */ ,
VTKind /*kind */ VTKind /*kind */
); );
extern _X_EXPORT void miSlideAndSizeWindow(WindowPtr /*pWin */ , extern _X_EXPORT void miResizeWindow(WindowPtr /*pWin */ ,
int /*x */ , int /*x */ ,
int /*y */ , int /*y */ ,
unsigned int /*w */ , unsigned int /*w */ ,
unsigned int /*h */ , unsigned int /*h */ ,
WindowPtr /*pSib */ WindowPtr /*pSib */
); );
extern _X_EXPORT WindowPtr miGetLayerWindow(WindowPtr /*pWin */ extern _X_EXPORT WindowPtr miGetLayerWindow(WindowPtr /*pWin */

5
mi/mibitblt.c
View File

@ -242,8 +242,7 @@ miCopyArea(DrawablePtr pSrcDrawable,
} }
} }
prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, xIn, yIn, prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, xIn, yIn,
widthSrc, heightSrc, xOut, yOut, widthSrc, heightSrc, xOut, yOut);
(unsigned long) 0);
if (realSrcClip) if (realSrcClip)
RegionDestroy(prgnSrcClip); RegionDestroy(prgnSrcClip);
@ -579,7 +578,7 @@ miCopyPlane(DrawablePtr pSrcDrawable,
} }
} }
prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx, srcy, prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
width, height, dstx, dsty, bitPlane); width, height, dstx, dsty);
RegionDestroy(prgnSrc); RegionDestroy(prgnSrc);
return prgnExposed; return prgnExposed;
} }

3
mi/micopy.c
View File

@ -304,8 +304,7 @@ miDoCopy(DrawablePtr pSrcDrawable,
yIn - pSrcDrawable->y, yIn - pSrcDrawable->y,
widthSrc, heightSrc, widthSrc, heightSrc,
xOut - pDstDrawable->x, xOut - pDstDrawable->x,
yOut - pDstDrawable->y, yOut - pDstDrawable->y);
(unsigned long) bitPlane);
RegionUninit(&rgnDst); RegionUninit(&rgnDst);
if (freeSrcClip) if (freeSrcClip)
RegionDestroy(prgnSrcClip); RegionDestroy(prgnSrcClip);

109
mi/miexpose.c
View File

@ -116,18 +116,12 @@ NOTE:
this should generally be called, even if graphicsExposures is false, this should generally be called, even if graphicsExposures is false,
because this is where bits get recovered from backing store. because this is where bits get recovered from backing store.
NOTE:
added argument 'plane' is used to indicate how exposures from backing
store should be accomplished. If plane is 0 (i.e. no bit plane), CopyArea
should be used, else a CopyPlane of the indicated plane will be used. The
exposing is done by the backing store's GraphicsExpose function, of course.
*/ */
RegionPtr RegionPtr
miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
GCPtr pGC, int srcx, int srcy, int width, int height, GCPtr pGC, int srcx, int srcy, int width, int height,
int dstx, int dsty, unsigned long plane) int dstx, int dsty)
{ {
RegionPtr prgnSrcClip; /* drawable-relative source clip */ RegionPtr prgnSrcClip; /* drawable-relative source clip */
RegionRec rgnSrcRec; RegionRec rgnSrcRec;
@ -149,7 +143,7 @@ miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
if (!pGC->graphicsExposures && if (!pGC->graphicsExposures &&
(pDstDrawable->type == DRAWABLE_PIXMAP) && (pDstDrawable->type == DRAWABLE_PIXMAP) &&
((pSrcDrawable->type == DRAWABLE_PIXMAP) || ((pSrcDrawable->type == DRAWABLE_PIXMAP) ||
(((WindowPtr) pSrcDrawable)->backStorage == NULL))) (((WindowPtr) pSrcDrawable)->backStorage == 0)))
return NULL; return NULL;
srcBox.x1 = srcx; srcBox.x1 = srcx;
@ -312,53 +306,6 @@ miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
} }
} }
/* send GraphicsExpose events, or a NoExpose event, based on the region */
void
miSendGraphicsExpose(ClientPtr client, RegionPtr pRgn, XID drawable,
int major, int minor)
{
if (pRgn && !RegionNil(pRgn)) {
xEvent *pEvent;
xEvent *pe;
BoxPtr pBox;
int i;
int numRects;
numRects = RegionNumRects(pRgn);
pBox = RegionRects(pRgn);
if (!(pEvent = calloc(numRects, sizeof(xEvent))))
return;
pe = pEvent;
for (i = 1; i <= numRects; i++, pe++, pBox++) {
pe->u.u.type = GraphicsExpose;
pe->u.graphicsExposure.drawable = drawable;
pe->u.graphicsExposure.x = pBox->x1;
pe->u.graphicsExposure.y = pBox->y1;
pe->u.graphicsExposure.width = pBox->x2 - pBox->x1;
pe->u.graphicsExposure.height = pBox->y2 - pBox->y1;
pe->u.graphicsExposure.count = numRects - i;
pe->u.graphicsExposure.majorEvent = major;
pe->u.graphicsExposure.minorEvent = minor;
}
/* GraphicsExpose is a "critical event", which TryClientEvents
* handles specially. */
TryClientEvents(client, NULL, pEvent, numRects,
(Mask) 0, NoEventMask, NullGrab);
free(pEvent);
}
else {
xEvent event = {
.u.noExposure.drawable = drawable,
.u.noExposure.majorEvent = major,
.u.noExposure.minorEvent = minor
};
event.u.u.type = NoExpose;
WriteEventsToClient(client, 1, &event);
}
}
void void
miSendExposures(WindowPtr pWin, RegionPtr pRgn, int dx, int dy) miSendExposures(WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
{ {
@ -421,30 +368,15 @@ miSendExposures(WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
} }
void void
miWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr other_exposed) miWindowExposures(WindowPtr pWin, RegionPtr prgn)
{ {
RegionPtr exposures = prgn; RegionPtr exposures = prgn;
if ((prgn && !RegionNil(prgn)) || if (prgn && !RegionNil(prgn)) {
(exposures && !RegionNil(exposures)) || other_exposed) {
RegionRec expRec; RegionRec expRec;
int clientInterested; int clientInterested =
/*
* Restore from backing-store FIRST.
*/
clientInterested =
(pWin->eventMask | wOtherEventMasks(pWin)) & ExposureMask; (pWin->eventMask | wOtherEventMasks(pWin)) & ExposureMask;
if (other_exposed) { if (clientInterested && (RegionNumRects(prgn) > RECTLIMIT)) {
if (exposures) {
RegionUnion(other_exposed, exposures, other_exposed);
if (exposures != prgn)
RegionDestroy(exposures);
}
exposures = other_exposed;
}
if (clientInterested && exposures &&
(RegionNumRects(exposures) > RECTLIMIT)) {
/* /*
* If we have LOTS of rectangles, we decide to take the extents * If we have LOTS of rectangles, we decide to take the extents
* and force an exposure on that. This should require much less * and force an exposure on that. This should require much less
@ -453,34 +385,21 @@ miWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr other_exposed)
*/ */
BoxRec box; BoxRec box;
box = *RegionExtents(exposures); box = *RegionExtents(prgn);
if (exposures == prgn) { exposures = &expRec;
exposures = &expRec; RegionInit(exposures, &box, 1);
RegionInit(exposures, &box, 1); RegionReset(prgn, &box);
RegionReset(prgn, &box);
}
else {
RegionReset(exposures, &box);
RegionUnion(prgn, prgn, exposures);
}
/* miPaintWindow doesn't clip, so we have to */ /* miPaintWindow doesn't clip, so we have to */
RegionIntersect(prgn, prgn, &pWin->clipList); RegionIntersect(prgn, prgn, &pWin->clipList);
} }
if (prgn && !RegionNil(prgn)) miPaintWindow(pWin, prgn, PW_BACKGROUND);
miPaintWindow(pWin, prgn, PW_BACKGROUND); if (clientInterested)
if (clientInterested && exposures && !RegionNil(exposures))
miSendExposures(pWin, exposures, miSendExposures(pWin, exposures,
pWin->drawable.x, pWin->drawable.y); pWin->drawable.x, pWin->drawable.y);
if (exposures == &expRec) { if (exposures == &expRec)
RegionUninit(exposures); RegionUninit(exposures);
} RegionEmpty(prgn);
else if (exposures && exposures != prgn && exposures != other_exposed)
RegionDestroy(exposures);
if (prgn)
RegionEmpty(prgn);
} }
else if (exposures && exposures != prgn)
RegionDestroy(exposures);
} }
#ifdef ROOTLESS #ifdef ROOTLESS

70
mi/mioverlay.c
View File

@ -79,7 +79,7 @@ static void miOverlayMarkUnrealizedWindow(WindowPtr, WindowPtr, Bool);
static int miOverlayValidateTree(WindowPtr, WindowPtr, VTKind); static int miOverlayValidateTree(WindowPtr, WindowPtr, VTKind);
static void miOverlayHandleExposures(WindowPtr); static void miOverlayHandleExposures(WindowPtr);
static void miOverlayMoveWindow(WindowPtr, int, int, WindowPtr, VTKind); static void miOverlayMoveWindow(WindowPtr, int, int, WindowPtr, VTKind);
static void miOverlayWindowExposures(WindowPtr, RegionPtr, RegionPtr); static void miOverlayWindowExposures(WindowPtr, RegionPtr);
static void miOverlayResizeWindow(WindowPtr, int, int, unsigned int, 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 miOverlayClearToBackground(WindowPtr, int, int, int, int, Bool);
@ -827,7 +827,7 @@ miOverlayHandleExposures(WindowPtr pWin)
miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
WindowPtr pChild; WindowPtr pChild;
ValidatePtr val; ValidatePtr val;
void (*WindowExposures) (WindowPtr, RegionPtr, RegionPtr); WindowExposuresProcPtr WindowExposures;
WindowExposures = pWin->drawable.pScreen->WindowExposures; WindowExposures = pWin->drawable.pScreen->WindowExposures;
if (pPriv->underlayMarked) { if (pPriv->underlayMarked) {
@ -849,8 +849,7 @@ miOverlayHandleExposures(WindowPtr pWin)
} }
RegionUninit(&mival->borderExposed); RegionUninit(&mival->borderExposed);
(*WindowExposures) (pTree->pWin, &mival->exposed, (*WindowExposures) (pTree->pWin, &mival->exposed);
NullRegion);
RegionUninit(&mival->exposed); RegionUninit(&mival->exposed);
} }
free(mival); free(mival);
@ -886,7 +885,7 @@ miOverlayHandleExposures(WindowPtr pWin)
if (RegionNotEmpty(&val->after.borderExposed)) { if (RegionNotEmpty(&val->after.borderExposed)) {
miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER); miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER);
} }
(*WindowExposures) (pChild, &val->after.exposed, NullRegion); (*WindowExposures) (pChild, &val->after.exposed);
} }
RegionUninit(&val->after.borderExposed); RegionUninit(&val->after.borderExposed);
RegionUninit(&val->after.exposed); RegionUninit(&val->after.exposed);
@ -980,42 +979,23 @@ miOverlayMoveWindow(WindowPtr pWin,
#endif #endif
static void static void
miOverlayWindowExposures(WindowPtr pWin, miOverlayWindowExposures(WindowPtr pWin, RegionPtr prgn)
RegionPtr prgn, RegionPtr other_exposed)
{ {
RegionPtr exposures = prgn; RegionPtr exposures = prgn;
if ((prgn && !RegionNil(prgn)) || if (prgn && !RegionNil(prgn)) {
(exposures && !RegionNil(exposures)) || other_exposed) {
RegionRec expRec; RegionRec expRec;
int clientInterested; int clientInterested =
(pWin->eventMask | wOtherEventMasks(pWin)) & ExposureMask;
clientInterested = (pWin->eventMask | wOtherEventMasks(pWin)) & if (clientInterested && (RegionNumRects(prgn) > RECTLIMIT)) {
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; ScreenPtr pScreen = pWin->drawable.pScreen;
miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
BoxRec box; BoxRec box;
box = *RegionExtents(exposures); box = *RegionExtents(prgn);
if (exposures == prgn) { exposures = &expRec;
exposures = &expRec; RegionInit(exposures, &box, 1);
RegionInit(exposures, &box, 1); RegionReset(prgn, &box);
RegionReset(prgn, &box);
}
else {
RegionReset(exposures, &box);
RegionUnion(prgn, prgn, exposures);
}
/* This is the only reason why we are replacing mi's version /* This is the only reason why we are replacing mi's version
of this file */ of this file */
@ -1027,21 +1007,14 @@ miOverlayWindowExposures(WindowPtr pWin,
else else
RegionIntersect(prgn, prgn, &pWin->clipList); RegionIntersect(prgn, prgn, &pWin->clipList);
} }
if (prgn && !RegionNil(prgn)) miPaintWindow(pWin, prgn, PW_BACKGROUND);
miPaintWindow(pWin, prgn, PW_BACKGROUND); if (clientInterested)
if (clientInterested && exposures && !RegionNil(exposures))
miSendExposures(pWin, exposures, miSendExposures(pWin, exposures,
pWin->drawable.x, pWin->drawable.y); pWin->drawable.x, pWin->drawable.y);
if (exposures == &expRec) { if (exposures == &expRec)
RegionUninit(exposures); RegionUninit(exposures);
} RegionEmpty(prgn);
else if (exposures && exposures != prgn && exposures != other_exposed)
RegionDestroy(exposures);
if (prgn)
RegionEmpty(prgn);
} }
else if (exposures && exposures != prgn)
RegionDestroy(exposures);
} }
typedef struct { typedef struct {
@ -1491,11 +1464,7 @@ miOverlaySetShape(WindowPtr pWin, int kind)
if (WasViewable) { 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) if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pWin->parent, NullWindow, (*pScreen->PostValidateTree) (pWin->parent, NullWindow,
@ -1592,7 +1561,6 @@ miOverlayClearToBackground(WindowPtr pWin,
miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
BoxRec box; BoxRec box;
RegionRec reg; RegionRec reg;
RegionPtr pBSReg = NullRegion;
ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen); miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
RegionPtr clipList; RegionPtr clipList;
@ -1636,12 +1604,10 @@ miOverlayClearToBackground(WindowPtr pWin,
RegionIntersect(&reg, &reg, clipList); RegionIntersect(&reg, &reg, clipList);
if (generateExposures) if (generateExposures)
(*pScreen->WindowExposures) (pWin, &reg, pBSReg); (*pScreen->WindowExposures) (pWin, &reg);
else if (pWin->backgroundState != None) else if (pWin->backgroundState != None)
miPaintWindow(pWin, &reg, PW_BACKGROUND); miPaintWindow(pWin, &reg, PW_BACKGROUND);
RegionUninit(&reg); RegionUninit(&reg);
if (pBSReg)
RegionDestroy(pBSReg);
} }
/****************************************************************/ /****************************************************************/

3
mi/miscrinit.c
View File

@ -259,13 +259,12 @@ miScreenInit(ScreenPtr pScreen, void *pbits, /* pointer to screen bits */
/* CreateColormap, DestroyColormap, InstallColormap, UninstallColormap */ /* CreateColormap, DestroyColormap, InstallColormap, UninstallColormap */
/* ListInstalledColormaps, StoreColors, ResolveColor */ /* ListInstalledColormaps, StoreColors, ResolveColor */
/* BitmapToRegion */ /* BitmapToRegion */
pScreen->SendGraphicsExpose = miSendGraphicsExpose;
pScreen->BlockHandler = (ScreenBlockHandlerProcPtr) NoopDDA; pScreen->BlockHandler = (ScreenBlockHandlerProcPtr) NoopDDA;
pScreen->WakeupHandler = (ScreenWakeupHandlerProcPtr) NoopDDA; pScreen->WakeupHandler = (ScreenWakeupHandlerProcPtr) NoopDDA;
pScreen->MarkWindow = miMarkWindow; pScreen->MarkWindow = miMarkWindow;
pScreen->MarkOverlappedWindows = miMarkOverlappedWindows; pScreen->MarkOverlappedWindows = miMarkOverlappedWindows;
pScreen->MoveWindow = miMoveWindow; pScreen->MoveWindow = miMoveWindow;
pScreen->ResizeWindow = miSlideAndSizeWindow; pScreen->ResizeWindow = miResizeWindow;
pScreen->GetLayerWindow = miGetLayerWindow; pScreen->GetLayerWindow = miGetLayerWindow;
pScreen->HandleExposures = miHandleValidateExposures; pScreen->HandleExposures = miHandleValidateExposures;
pScreen->ReparentWindow = (ReparentWindowProcPtr) 0; pScreen->ReparentWindow = (ReparentWindowProcPtr) 0;

52
mi/mivaltree.c
View File

@ -99,8 +99,10 @@ Equipment Corporation.
#include "mi.h" #include "mi.h"
#include "regionstr.h" #include "regionstr.h"
#include "mivalidate.h" #include "mivalidate.h"
#include "globals.h" #include "globals.h"
#ifdef COMPOSITE
#include "compint.h"
#endif
/* /*
* Compute the visibility of a shaped window * Compute the visibility of a shaped window
@ -160,17 +162,6 @@ miShapedWindowIn(RegionPtr universe, RegionPtr bounding,
return rgnOUT; return rgnOUT;
} }
static GetRedirectBorderClipProcPtr miGetRedirectBorderClipProc;
static SetRedirectBorderClipProcPtr miSetRedirectBorderClipProc;
void
miRegisterRedirectBorderClipProc(SetRedirectBorderClipProcPtr setBorderClip,
GetRedirectBorderClipProcPtr getBorderClip)
{
miSetRedirectBorderClipProc = setBorderClip;
miGetRedirectBorderClipProc = getBorderClip;
}
/* /*
* Manual redirected windows are treated as transparent; they do not obscure * Manual redirected windows are treated as transparent; they do not obscure
* siblings or parent windows * siblings or parent windows
@ -242,11 +233,9 @@ miComputeClips(WindowPtr pParent,
* In redirected drawing case, reset universe to borderSize * In redirected drawing case, reset universe to borderSize
*/ */
if (pParent->redirectDraw != RedirectDrawNone) { if (pParent->redirectDraw != RedirectDrawNone) {
if (miSetRedirectBorderClipProc) { if (TreatAsTransparent(pParent))
if (TreatAsTransparent(pParent)) RegionEmpty(universe);
RegionEmpty(universe); compSetRedirectBorderClip (pParent, universe);
(*miSetRedirectBorderClipProc) (pParent, universe);
}
RegionCopy(universe, &pParent->borderSize); RegionCopy(universe, &pParent->borderSize);
} }
#endif #endif
@ -516,6 +505,17 @@ miTreeObscured(WindowPtr pParent)
} }
} }
static RegionPtr
getBorderClip(WindowPtr pWin)
{
#ifdef COMPOSITE
if (pWin->redirectDraw != RedirectDrawNone)
return compGetRedirectBorderClip(pWin);
else
#endif
return &pWin->borderClip;
}
/* /*
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
* miValidateTree -- * miValidateTree --
@ -609,14 +609,7 @@ miValidateTree(WindowPtr pParent, /* Parent to validate */
forward = TRUE; forward = TRUE;
for (pWin = pChild; pWin; pWin = pWin->nextSib) { for (pWin = pChild; pWin; pWin = pWin->nextSib) {
if (pWin->valdata) { if (pWin->valdata) {
RegionPtr pBorderClip = &pWin->borderClip; RegionAppend(&totalClip, getBorderClip(pWin));
#ifdef COMPOSITE
if (pWin->redirectDraw != RedirectDrawNone &&
miGetRedirectBorderClipProc)
pBorderClip = (*miGetRedirectBorderClipProc) (pWin);
#endif
RegionAppend(&totalClip, pBorderClip);
if (pWin->viewable) if (pWin->viewable)
viewvals++; viewvals++;
} }
@ -627,14 +620,7 @@ miValidateTree(WindowPtr pParent, /* Parent to validate */
pWin = pParent->lastChild; pWin = pParent->lastChild;
while (1) { while (1) {
if (pWin->valdata) { if (pWin->valdata) {
RegionPtr pBorderClip = &pWin->borderClip; RegionAppend(&totalClip, getBorderClip(pWin));
#ifdef COMPOSITE
if (pWin->redirectDraw != RedirectDrawNone &&
miGetRedirectBorderClipProc)
pBorderClip = (*miGetRedirectBorderClipProc) (pWin);
#endif
RegionAppend(&totalClip, pBorderClip);
if (pWin->viewable) if (pWin->viewable)
viewvals++; viewvals++;
} }

41
mi/miwindow.c
View File

@ -111,7 +111,7 @@ miClearToBackground(WindowPtr pWin,
RegionIntersect(&reg, &reg, &pWin->clipList); RegionIntersect(&reg, &reg, &pWin->clipList);
if (generateExposures) if (generateExposures)
(*pWin->drawable.pScreen->WindowExposures) (pWin, &reg, NULL); (*pWin->drawable.pScreen->WindowExposures) (pWin, &reg);
else if (pWin->backgroundState != None) else if (pWin->backgroundState != None)
miPaintWindow(pWin, &reg, PW_BACKGROUND); miPaintWindow(pWin, &reg, PW_BACKGROUND);
RegionUninit(&reg); RegionUninit(&reg);
@ -221,7 +221,7 @@ miHandleValidateExposures(WindowPtr pWin)
if (RegionNotEmpty(&val->after.borderExposed)) if (RegionNotEmpty(&val->after.borderExposed))
miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER); miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER);
RegionUninit(&val->after.borderExposed); RegionUninit(&val->after.borderExposed);
(*WindowExposures) (pChild, &val->after.exposed, NullRegion); (*WindowExposures) (pChild, &val->after.exposed);
RegionUninit(&val->after.exposed); RegionUninit(&val->after.exposed);
free(val); free(val);
pChild->valdata = NULL; pChild->valdata = NULL;
@ -292,9 +292,9 @@ miMoveWindow(WindowPtr pWin, int x, int y, WindowPtr pNextSib, VTKind kind)
RegionDestroy(oldRegion); RegionDestroy(oldRegion);
/* XXX need to retile border if ParentRelative origin */ /* XXX need to retile border if ParentRelative origin */
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, NULL, kind);
} }
if (anyMarked && pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, NullWindow, kind);
} }
if (pWin->realized) if (pWin->realized)
WindowsRestructured(); WindowsRestructured();
@ -337,9 +337,8 @@ miRecomputeExposures(WindowPtr pWin, void *value)
} }
void void
miSlideAndSizeWindow(WindowPtr pWin, miResizeWindow(WindowPtr pWin, int x, int y, unsigned int w, unsigned int h,
int x, int y, WindowPtr pSib)
unsigned int w, unsigned int h, WindowPtr pSib)
{ {
WindowPtr pParent; WindowPtr pParent;
Bool WasViewable = (Bool) (pWin->viewable); Bool WasViewable = (Bool) (pWin->viewable);
@ -608,11 +607,12 @@ miSlideAndSizeWindow(WindowPtr pWin,
RegionDestroy(pRegion); RegionDestroy(pRegion);
if (destClip) if (destClip)
RegionDestroy(destClip); RegionDestroy(destClip);
if (anyMarked) if (anyMarked) {
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (anyMarked && pScreen->PostValidateTree) if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange, (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange,
VTOther); VTOther);
}
} }
if (pWin->realized) if (pWin->realized)
WindowsRestructured(); WindowsRestructured();
@ -664,17 +664,14 @@ miSetShape(WindowPtr pWin, int kind)
if (WasViewable) { if (WasViewable) {
anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL); anyMarked |= (*pScreen->MarkOverlappedWindows) (pWin, pWin, NULL);
if (anyMarked) if (anyMarked) {
(*pScreen->ValidateTree) (pLayerWin->parent, NullWindow, (*pScreen->ValidateTree) (pLayerWin->parent, NullWindow,
VTOther); VTOther);
}
if (WasViewable) {
if (anyMarked)
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (anyMarked && pScreen->PostValidateTree) if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, NullWindow, (*pScreen->PostValidateTree) (pLayerWin->parent, NULL,
VTOther); VTOther);
}
} }
} }
if (pWin->realized) if (pWin->realized)
@ -726,10 +723,10 @@ miChangeBorderWidth(WindowPtr pWin, unsigned int width)
if (anyMarked) { if (anyMarked) {
(*pScreen->ValidateTree) (pLayerWin->parent, pLayerWin, VTOther); (*pScreen->ValidateTree) (pLayerWin->parent, pLayerWin, VTOther);
(*pScreen->HandleExposures) (pLayerWin->parent); (*pScreen->HandleExposures) (pLayerWin->parent);
if (pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
VTOther);
} }
if (anyMarked && pScreen->PostValidateTree)
(*pScreen->PostValidateTree) (pLayerWin->parent, pLayerWin,
VTOther);
} }
if (pWin->realized) if (pWin->realized)
WindowsRestructured(); WindowsRestructured();

65
miext/rootless/rootlessValTree.c
View File

@ -106,64 +106,6 @@ Equipment Corporation.
int RootlessMiValidateTree(WindowPtr pRoot, WindowPtr pChild, VTKind kind); int RootlessMiValidateTree(WindowPtr pRoot, WindowPtr pChild, VTKind kind);
/*
* Compute the visibility of a shaped window
*/
static int
RootlessShapedWindowIn(RegionPtr universe,
RegionPtr bounding, BoxPtr rect, int x, int y)
{
BoxRec box;
register BoxPtr boundBox;
int nbox;
Bool someIn, someOut;
register int t, x1, y1, x2, y2;
nbox = RegionNumRects(bounding);
boundBox = RegionRects(bounding);
someIn = someOut = FALSE;
x1 = rect->x1;
y1 = rect->y1;
x2 = rect->x2;
y2 = rect->y2;
while (nbox--) {
if ((t = boundBox->x1 + x) < x1)
t = x1;
box.x1 = t;
if ((t = boundBox->y1 + y) < y1)
t = y1;
box.y1 = t;
if ((t = boundBox->x2 + x) > x2)
t = x2;
box.x2 = t;
if ((t = boundBox->y2 + y) > y2)
t = y2;
box.y2 = t;
if (box.x1 > box.x2)
box.x2 = box.x1;
if (box.y1 > box.y2)
box.y2 = box.y1;
switch (RegionContainsRect(universe, &box)) {
case rgnIN:
if (someOut)
return rgnPART;
someIn = TRUE;
break;
case rgnOUT:
if (someIn)
return rgnPART;
someOut = TRUE;
break;
default:
return rgnPART;
}
boundBox++;
}
if (someIn)
return rgnIN;
return rgnOUT;
}
#define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \ #define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
HasBorder(w) && \ HasBorder(w) && \
(w)->backgroundState == ParentRelative) (w)->backgroundState == ParentRelative)
@ -229,10 +171,9 @@ RootlessComputeClips(WindowPtr pParent, ScreenPtr pScreen,
RegionPtr pBounding; RegionPtr pBounding;
if ((pBounding = wBoundingShape(pParent))) { if ((pBounding = wBoundingShape(pParent))) {
switch (RootlessShapedWindowIn(universe, switch (miShapedWindowIn(universe, pBounding, &borderSize,
pBounding, &borderSize, pParent->drawable.x,
pParent->drawable.x, pParent->drawable.y)) {
pParent->drawable.y)) {
case rgnIN: case rgnIN:
newVis = VisibilityUnobscured; newVis = VisibilityUnobscured;
break; break;