dix: Drop the third argument from WindowExposuresProcPtr

nwnk · sunweaver · commit 6de61739df59 · 2017-11-21T16:09:10.000+01:00
Backport from X.org:

    dix: Drop the third argument from WindowExposuresProcPtr

    A careful read shows that it was always NULL.  It hasn't always been; as
    the DDX spec indicates, it was the "occluded region that has backing
    store", but since that backing store code is long gone, we can nuke it.

    mi{,Overlay}WindowExposures get slightly simpler here, and will get even
    simpler in just a moment.

    Reviewed-by: Julien Cristau &lt;jcristau@debian.org&gt;
    Signed-off-by: Adam Jackson &lt;ajax@redhat.com&gt;

    Backported to NX by: Mike Gabriel &lt;mike.gabriel@das-netzwerkteam.de&gt;
diff --git a/nx-X11/programs/Xserver/dix/window.c b/nx-X11/programs/Xserver/dix/window.c
@@ -2760,7 +2760,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 	    (*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);
 	RegionNull(&temp);
 	RegionCopy(&temp, &pWin->clipList);
-	(*pScreen->WindowExposures) (pWin, &temp, NullRegion);
+	(*pScreen->WindowExposures) (pWin, &temp);
 	RegionUninit(&temp);
     }
 
diff --git a/nx-X11/programs/Xserver/fb/fboverlay.c b/nx-X11/programs/Xserver/fb/fboverlay.c
@@ -270,13 +270,12 @@ fbOverlayCopyWindow(WindowPtr	pWin,
 
 void
 fbOverlayWindowExposures (WindowPtr	pWin,
-			  RegionPtr	prgn,
-			  RegionPtr	other_exposed)
+			  RegionPtr	prgn)
 {
     fbOverlayUpdateLayerRegion (pWin->drawable.pScreen,
 				fbOverlayWindowLayer (pWin),
 				prgn);
-    miWindowExposures(pWin, prgn, other_exposed);
+    miWindowExposures(pWin, prgn);
 }
 
 void
diff --git a/nx-X11/programs/Xserver/fb/fboverlay.h b/nx-X11/programs/Xserver/fb/fboverlay.h
@@ -89,8 +89,7 @@ fbOverlayCopyWindow(WindowPtr	pWin,
     
 void
 fbOverlayWindowExposures (WindowPtr	pWin,
-			  RegionPtr	prgn,
-			  RegionPtr	other_exposed);
+			  RegionPtr	prgn);
 
 void
 fbOverlayPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
@@ -3120,7 +3120,7 @@ void nxagentSendBackgroundExpose(WindowPtr pWin, PixmapPtr pBackground, RegionPt
   
   RegionTranslate(&expose, pWin -> drawable.x, pWin -> drawable.y);
 
-  miWindowExposures(pWin, &expose, &expose);
+  miWindowExposures(pWin, &expose);
 
 nxagentSendBackgroundExposeEnd:
 
@@ -3230,7 +3230,7 @@ int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr)
 
       RegionSubtract(remoteExposeRgn, remoteExposeRgn, exposeRgn);
 
-      miWindowExposures(pWin, exposeRgn, exposeRgn);
+      miWindowExposures(pWin, exposeRgn);
     }
 
     RegionDestroy(exposeRgn);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Events.c b/nx-X11/programs/Xserver/hw/nxagent/Events.c
@@ -2483,7 +2483,7 @@ FIXME: This can be maybe optimized by consuming the
 
     if (index == -1)
     {
-      miWindowExposures(pWin, &sum, NullRegion);
+      miWindowExposures(pWin, &sum);
     }
     else
     {
@@ -2545,6 +2545,10 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
 
   pWin = nxagentWindowPtr(X -> xgraphicsexpose.drawable);
 
+  if (pWin == 0) {
+    return 1;
+  }
+
   /*
    * Rectangle affected by GraphicsExpose
    * event.
@@ -2563,6 +2567,14 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
    * must be relative to the screen.
    */
 
+//  #ifdef TEST
+  fprintf(stderr, "nxagentHandleGraphicsExposeEvent: graphics expose event with expose region rectangle "
+              "x1 [%d], y1 [%d] and x2 [%d] y2 [%d]. and drawable [%ld] with x [%d] and y[%d].\n",
+                  rect.x1, rect.y1, rect.x2, rect.y2,
+                      X -> xgraphicsexpose.drawable,
+                          pWin -> drawable.x, pWin -> drawable.y);
+//  #endif
+
   RegionTranslate(exposeRegion, pWin -> drawable.x, pWin -> drawable.y);
 
   RegionUnion(nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, exposeRegion);
@@ -4036,7 +4048,7 @@ void nxagentSynchronizeExpose(void)
                         RegionNumRects(nxagentExposeQueueHead.remoteRegion));
         #endif
 
-        miWindowExposures(pWin, nxagentExposeQueueHead.remoteRegion, NullRegion);
+        miWindowExposures(pWin, nxagentExposeQueueHead.remoteRegion);
       }
     }
   }
@@ -4271,7 +4283,7 @@ int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
 
       RegionSubtract(remoteExposeRgn, remoteExposeRgn, exposeRgn);
 
-      miWindowExposures(pWin, exposeRgn, NullRegion);
+      miWindowExposures(pWin, exposeRgn);
     }
 
     RegionDestroy(exposeRgn);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
@@ -353,16 +353,15 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 }
 
 void 
-miWindowExposures(pWin, prgn, other_exposed)
+miWindowExposures(pWin, prgn)
     WindowPtr pWin;
-    register RegionPtr prgn, other_exposed;
+    register RegionPtr prgn;
 {
 
     int total;
 
     RegionPtr   exposures = prgn;
-    if ((prgn && !RegionNil(prgn)) || 
-	(exposures && !RegionNil(exposures)) || other_exposed)
+    if ((prgn && !RegionNil(prgn)) || (exposures && !RegionNil(exposures)))
     {
 	RegionRec   expRec;
 	int	    clientInterested;
@@ -371,18 +370,6 @@ miWindowExposures(pWin, prgn, other_exposed)
 	 * Restore from backing-store FIRST.
 	 */
 	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 the number of rectangles is greater
@@ -424,7 +411,7 @@ miWindowExposures(pWin, prgn, other_exposed)
 	{
 	    RegionUninit(exposures);
 	}
-	else if (exposures && exposures != prgn && exposures != other_exposed)
+	else if (exposures && exposures != prgn)
 	    RegionDestroy(exposures);
 	if (prgn)
 	    RegionEmpty(prgn);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
@@ -929,7 +929,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 	    (*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);
 	RegionNull(&temp);
 	RegionCopy(&temp, &pWin->clipList);
-	(*pScreen->WindowExposures) (pWin, &temp, NullRegion);
+	(*pScreen->WindowExposures) (pWin, &temp);
 	RegionUninit(&temp);
     }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Window.c b/nx-X11/programs/Xserver/hw/nxagent/Window.c
@@ -2110,7 +2110,7 @@ void nxagentClipNotify(WindowPtr pWin, int dx, int dy)
 #endif /* NXAGENT_SHAPE */
 }
 
-void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
+void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn)
 {
   /*
    * The problem: we want to synthetize the expose events internally, so
@@ -2202,11 +2202,6 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
       RegionUnion(&temp, &temp, pRgn);
     }
 
-    if (other_exposed != NULL)
-    {
-      RegionUnion(&temp, &temp, other_exposed);
-    }
-
     if (RegionNil(&temp) == 0)
     {
       RegionTranslate(&temp,
@@ -2281,12 +2276,11 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
         fprintf(stderr, "nxagentWindowExposures: WARNING! Reached maximum size of collect exposures vector.\n");
         #endif
 
-        if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) ||
-               (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))
+        if (pRgn != NULL && RegionNotEmpty(pRgn) != 0)
         {
-          nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);
+          nxagentUnmarkExposedRegion(pWin, pRgn, NullRegion);
 
-          miWindowExposures(pWin, pRgn, other_exposed);
+          miWindowExposures(pWin, pRgn);
         }
 
         return;
@@ -2296,12 +2290,11 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
     RegionUninit(&temp);
   }
 
-  if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) ||
-         (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))
+  if (pRgn != NULL && RegionNotEmpty(pRgn) != 0)
   {
-    nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);
+    nxagentUnmarkExposedRegion(pWin, pRgn, NullRegion);
 
-    miWindowExposures(pWin, pRgn, other_exposed);
+    miWindowExposures(pWin, pRgn);
   }
 
   return;
@@ -2489,7 +2482,7 @@ static int nxagentForceExposure(WindowPtr pWin, void * ptr)
 
     if (exposedRgn != NULL && RegionNotEmpty(exposedRgn) != 0)
     {
-      miWindowExposures(pWin, exposedRgn, NullRegion);
+      miWindowExposures(pWin, exposedRgn);
     }
 
     RegionDestroy(exposedRgn);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Windows.h b/nx-X11/programs/Xserver/hw/nxagent/Windows.h
@@ -204,7 +204,7 @@ Bool nxagentUnrealizeWindow(WindowPtr pWin);
 
 Bool nxagentCheckIllegalRootMonitoring(WindowPtr pWin, Mask mask);
 
-void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed);
+void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn);
 
 void nxagentPaintWindowBackground(WindowPtr pWin, RegionPtr pRegion, int what);
 
diff --git a/nx-X11/programs/Xserver/include/scrnintstr.h b/nx-X11/programs/Xserver/include/scrnintstr.h
@@ -166,8 +166,7 @@ typedef    void (* PostValidateTreeProcPtr)(
 
 typedef    void (* WindowExposuresProcPtr)(
 	WindowPtr /*pWindow*/,
-	RegionPtr /*prgn*/,
-	RegionPtr /*other_exposed*/);
+	RegionPtr /*prgn*/);
 
 typedef    void (* PaintWindowProcPtr)(
 	WindowPtr /*pWindow*/,
diff --git a/nx-X11/programs/Xserver/mi/mi.h b/nx-X11/programs/Xserver/mi/mi.h
@@ -228,8 +228,7 @@ extern void miSendExposures(
 
 extern void miWindowExposures(
     WindowPtr /*pWin*/,
-    RegionPtr /*prgn*/,
-    RegionPtr /*other_exposed*/
+    RegionPtr /*prgn*/
 );
 
 extern void miPaintWindow(
diff --git a/nx-X11/programs/Xserver/mi/miexpose.c b/nx-X11/programs/Xserver/mi/miexpose.c
@@ -465,13 +465,12 @@ miSendExposures(pWin, pRgn, dx, dy)
 
 #ifndef NXAGENT_SERVER
 void 
-miWindowExposures(pWin, prgn, other_exposed)
+miWindowExposures(pWin, prgn)
     WindowPtr pWin;
-    register RegionPtr prgn, other_exposed;
+    register RegionPtr prgn;
 {
     RegionPtr   exposures = prgn;
-    if ((prgn && !RegionNil(prgn)) || 
-	(exposures && !RegionNil(exposures)) || other_exposed)
+    if ((prgn && !RegionNil(prgn)) || (exposures && !RegionNil(exposures)))
     {
 	RegionRec   expRec;
 	int	    clientInterested;
@@ -480,18 +479,6 @@ miWindowExposures(pWin, prgn, other_exposed)
 	 * Restore from backing-store FIRST.
 	 */
 	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))
 	{
 	    /*
@@ -524,7 +511,7 @@ miWindowExposures(pWin, prgn, other_exposed)
 	{
 	    RegionUninit(exposures);
 	}
-	else if (exposures && exposures != prgn && exposures != other_exposed)
+	else if (exposures && exposures != prgn)
 	    RegionDestroy(exposures);
 	if (prgn)
 	    RegionEmpty(prgn);
diff --git a/nx-X11/programs/Xserver/mi/mioverlay.c b/nx-X11/programs/Xserver/mi/mioverlay.c
@@ -75,7 +75,7 @@ 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 miOverlayWindowExposures(WindowPtr, RegionPtr);
 static void miOverlayResizeWindow(WindowPtr, int, int, unsigned int,
 					unsigned int, WindowPtr);
 static void miOverlayClearToBackground(WindowPtr, int, int, int, int, Bool);
@@ -849,7 +849,7 @@ miOverlayHandleExposures(WindowPtr pWin)
     miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
     WindowPtr pChild;
     ValidatePtr val;
-    void (* WindowExposures)(WindowPtr, RegionPtr, RegionPtr);
+    void (* WindowExposures)(WindowPtr, RegionPtr);
 
     WindowExposures = pWin->drawable.pScreen->WindowExposures;
     if(pPriv->underlayMarked) {
@@ -870,7 +870,7 @@ miOverlayHandleExposures(WindowPtr pWin)
 				pTree->pWin, &mival->borderExposed, PW_BORDER);
 		    RegionUninit(&mival->borderExposed);
 
-		    (*WindowExposures)(pTree->pWin,&mival->exposed,NullRegion);
+		    (*WindowExposures)(pTree->pWin,&mival->exposed);
 		    RegionUninit(&mival->exposed);
 		}
 		free(mival);
@@ -907,7 +907,7 @@ miOverlayHandleExposures(WindowPtr pWin)
 		    (*pChild->drawable.pScreen->PaintWindowBorder)(pChild,
 						    &val->after.borderExposed,
 						    PW_BORDER);
-		(*WindowExposures)(pChild, &val->after.exposed, NullRegion);
+		(*WindowExposures)(pChild, &val->after.exposed);
 	    }
 	    RegionUninit(&val->after.borderExposed);
 	    RegionUninit(&val->after.exposed);
@@ -1019,28 +1019,19 @@ miOverlayMoveWindow(
 static void 
 miOverlayWindowExposures(
     WindowPtr pWin,
-    register RegionPtr prgn,
-    RegionPtr other_exposed
+    register RegionPtr prgn
 ){
     RegionPtr   exposures = prgn;
     ScreenPtr pScreen = pWin->drawable.pScreen;
 
     if ((prgn && !RegionNil(prgn)) || 
-	(exposures && !RegionNil(exposures)) || other_exposed)
+	(exposures && !RegionNil(exposures)))
     {
 	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))
 	{
@@ -1075,7 +1066,7 @@ miOverlayWindowExposures(
 	if (exposures == &expRec) {
 	    RegionUninit(exposures);
 	} 
-	else if (exposures && exposures != prgn && exposures != other_exposed)
+	else if (exposures && exposures != prgn)
 	    RegionDestroy(exposures);
 	if (prgn)
 	    RegionEmpty(prgn);
@@ -1706,7 +1697,6 @@ miOverlayClearToBackground(
     miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
     BoxRec box;
     RegionRec reg;
-    RegionPtr pBSReg = NullRegion;
     ScreenPtr pScreen = pWin->drawable.pScreen;
     miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
     RegionPtr clipList;
@@ -1744,12 +1734,10 @@ miOverlayClearToBackground(
 
     RegionIntersect(&reg, &reg, clipList);
     if (generateExposures)
-        (*pScreen->WindowExposures)(pWin, &reg, pBSReg);
+        (*pScreen->WindowExposures)(pWin, &reg);
     else if (pWin->backgroundState != None)
         (*pScreen->PaintWindowBackground)(pWin, &reg, PW_BACKGROUND);
     RegionUninit(&reg);
-    if (pBSReg)
-        RegionDestroy(pBSReg);
 }
 
 
diff --git a/nx-X11/programs/Xserver/mi/miwindow.c b/nx-X11/programs/Xserver/mi/miwindow.c

Original file line number	Diff line number	Diff line change
`@@ -2760,7 +2760,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)`
`2760`	`2760`	`(*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);`
`2761`	`2761`	`RegionNull(&temp);`
`2762`	`2762`	`RegionCopy(&temp, &pWin->clipList);`
`2763`		`- (*pScreen->WindowExposures) (pWin, &temp, NullRegion);`
	`2763`	`+ (*pScreen->WindowExposures) (pWin, &temp);`
`2764`	`2764`	`RegionUninit(&temp);`
`2765`	`2765`	`}`
`2766`	`2766`
Original file line number	Diff line number	Diff line change
`@@ -270,13 +270,12 @@ fbOverlayCopyWindow(WindowPtr pWin,`
`270`	`270`
`271`	`271`	`void`
`272`	`272`	`fbOverlayWindowExposures (WindowPtr pWin,`
`273`		`- RegionPtr prgn,`
`274`		`- RegionPtr other_exposed)`
	`273`	`+ RegionPtr prgn)`
`275`	`274`	`{`
`276`	`275`	`fbOverlayUpdateLayerRegion (pWin->drawable.pScreen,`
`277`	`276`	`fbOverlayWindowLayer (pWin),`
`278`	`277`	`prgn);`
`279`		`- miWindowExposures(pWin, prgn, other_exposed);`
	`278`	`+ miWindowExposures(pWin, prgn);`
`280`	`279`	`}`
`281`	`280`
`282`	`281`	`void`
Original file line number	Diff line number	Diff line change
`@@ -929,7 +929,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)`
`929`	`929`	`(*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);`
`930`	`930`	`RegionNull(&temp);`
`931`	`931`	`RegionCopy(&temp, &pWin->clipList);`
`932`		`- (*pScreen->WindowExposures) (pWin, &temp, NullRegion);`
	`932`	`+ (*pScreen->WindowExposures) (pWin, &temp);`
`933`	`933`	`RegionUninit(&temp);`
`934`	`934`	`}`
`935`	`935`
Original file line number	Diff line number	Diff line change
`@@ -2110,7 +2110,7 @@ void nxagentClipNotify(WindowPtr pWin, int dx, int dy)`
`2110`	`2110`	`#endif /* NXAGENT_SHAPE */`
`2111`	`2111`	`}`
`2112`	`2112`
`2113`		`-void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)`
	`2113`	`+void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn)`
`2114`	`2114`	`{`
`2115`	`2115`	`/*`
`2116`	`2116`	`* The problem: we want to synthetize the expose events internally, so`
`@@ -2202,11 +2202,6 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo`
`2202`	`2202`	`RegionUnion(&temp, &temp, pRgn);`
`2203`	`2203`	`}`
`2204`	`2204`
`2205`		`- if (other_exposed != NULL)`
`2206`		`- {`
`2207`		`- RegionUnion(&temp, &temp, other_exposed);`
`2208`		`- }`
`2209`		`-`
`2210`	`2205`	`if (RegionNil(&temp) == 0)`
`2211`	`2206`	`{`
`2212`	`2207`	`RegionTranslate(&temp,`
`@@ -2281,12 +2276,11 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo`
`2281`	`2276`	`fprintf(stderr, "nxagentWindowExposures: WARNING! Reached maximum size of collect exposures vector.\n");`
`2282`	`2277`	`#endif`
`2283`	`2278`
`2284`		`- if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) \|\|`
`2285`		`- (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))`
	`2279`	`+ if (pRgn != NULL && RegionNotEmpty(pRgn) != 0)`
`2286`	`2280`	`{`
`2287`		`- nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);`
	`2281`	`+ nxagentUnmarkExposedRegion(pWin, pRgn, NullRegion);`
`2288`	`2282`
`2289`		`- miWindowExposures(pWin, pRgn, other_exposed);`
	`2283`	`+ miWindowExposures(pWin, pRgn);`
`2290`	`2284`	`}`
`2291`	`2285`
`2292`	`2286`	`return;`
`@@ -2296,12 +2290,11 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo`
`2296`	`2290`	`RegionUninit(&temp);`
`2297`	`2291`	`}`
`2298`	`2292`
`2299`		`- if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) \|\|`
`2300`		`- (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))`
	`2293`	`+ if (pRgn != NULL && RegionNotEmpty(pRgn) != 0)`
`2301`	`2294`	`{`
`2302`		`- nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);`
	`2295`	`+ nxagentUnmarkExposedRegion(pWin, pRgn, NullRegion);`
`2303`	`2296`
`2304`		`- miWindowExposures(pWin, pRgn, other_exposed);`
	`2297`	`+ miWindowExposures(pWin, pRgn);`
`2305`	`2298`	`}`
`2306`	`2299`
`2307`	`2300`	`return;`
`@@ -2489,7 +2482,7 @@ static int nxagentForceExposure(WindowPtr pWin, void * ptr)`
`2489`	`2482`
`2490`	`2483`	`if (exposedRgn != NULL && RegionNotEmpty(exposedRgn) != 0)`
`2491`	`2484`	`{`
`2492`		`- miWindowExposures(pWin, exposedRgn, NullRegion);`
	`2485`	`+ miWindowExposures(pWin, exposedRgn);`
`2493`	`2486`	`}`
`2494`	`2487`
`2495`	`2488`	`RegionDestroy(exposedRgn);`