[Xquartz-changes] xserver: Branch 'server-1.9-apple' - 22 commits

Jeremy Huddleston jeremyhu at freedesktop.org
Tue Jun 22 14:57:42 PDT 2010


Rebased ref, commits from common ancestor:
commit 22e3acec7cf6880b25a8da79b4012227ab6f2854
Author: Jeremy Huddleston <jeremyhu at apple.com>
Date:   Fri Feb 12 19:48:52 2010 -0800

    fb: Revert fb changes that broke XQuartz
    
    http://bugs.freedesktop.org/show_bug.cgi?id=26124
    
    Revert "Fix source pictures getting random transforms after 2d6a8f668342a5190cdf43b5."
    Revert "fb: Adjust transform or composite coordinates for pixman operations"
    
    http://bugs.freedesktop.org/26124
    
    This reverts commit a72c65e9176c51de95db2fdbf4c5d946a4911695.
    This reverts commit a6bd5d2e482a5aa84acb3d4932e2a166d8670ef1.
    
    Signed-off-by: Jeremy Huddleston <jeremyhu at apple.com>

diff --git a/fb/fb.h b/fb/fb.h
index a06f98b..3b9efea 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -2080,11 +2080,8 @@ fbFillRegionSolid (DrawablePtr	pDrawable,
 		   FbBits	xor);
 
 extern _X_EXPORT pixman_image_t *
-image_from_pict (PicturePtr	pict,
-		 Bool		has_clip,
-		 int		*xoff,
-		 int		*yoff);
-
+image_from_pict (PicturePtr pict,
+		 Bool       has_clip);
 extern _X_EXPORT void free_pixman_pict (PicturePtr, pixman_image_t *);
 
 #endif /* _FB_H_ */
diff --git a/fb/fbpict.c b/fb/fbpict.c
index 26cdc0d..f2ddb63 100644
--- a/fb/fbpict.c
+++ b/fb/fbpict.c
@@ -156,24 +156,19 @@ fbComposite (CARD8      op,
 	     CARD16     height)
 {
     pixman_image_t *src, *mask, *dest;
-    int src_xoff, src_yoff;
-    int msk_xoff, msk_yoff;
-    int dst_xoff, dst_yoff;
     
     miCompositeSourceValidate (pSrc, xSrc - xDst, ySrc - yDst, width, height);
     if (pMask)
 	miCompositeSourceValidate (pMask, xMask - xDst, yMask - yDst, width, height);
     
-    src = image_from_pict (pSrc, FALSE, &src_xoff, &src_yoff);
-    mask = image_from_pict (pMask, FALSE, &msk_xoff, &msk_yoff);
-    dest = image_from_pict (pDst, TRUE, &dst_xoff, &dst_yoff);
+    src = image_from_pict (pSrc, TRUE);
+    mask = image_from_pict (pMask, TRUE);
+    dest = image_from_pict (pDst, TRUE);
 
     if (src && dest && !(pMask && !mask))
     {
 	pixman_image_composite (op, src, mask, dest,
-				xSrc + src_xoff, ySrc + src_yoff,
-				xMask + msk_xoff, yMask + msk_yoff,
-				xDst + dst_xoff, yDst + dst_yoff,
+				xSrc, ySrc, xMask, yMask, xDst, yDst,
 				width, height);
     }
 
@@ -271,22 +266,22 @@ create_conical_gradient_image (PictGradient *gradient)
 
 static pixman_image_t *
 create_bits_picture (PicturePtr pict,
-		     Bool       has_clip,
-		     int	*xoff,
-		     int	*yoff)
+		     Bool       has_clip)
 {
-    PixmapPtr pixmap;
     FbBits *bits;
     FbStride stride;
-    int bpp;
+    int bpp, xoff, yoff;
     pixman_image_t *image;
     
-    fbGetDrawablePixmap (pict->pDrawable, pixmap, *xoff, *yoff);
-    fbGetPixmapBitsData(pixmap, bits, stride, bpp);
+    fbGetDrawable (pict->pDrawable, bits, stride, bpp, xoff, yoff);
+
+    bits = (FbBits*)((CARD8*)bits +
+		     (pict->pDrawable->y + yoff) * stride * sizeof(FbBits) +
+		     (pict->pDrawable->x + xoff) * (bpp / 8));
 
     image = pixman_image_create_bits (
 	pict->format,
-	pixmap->drawable.width, pixmap->drawable.height,
+	pict->pDrawable->width, pict->pDrawable->height,
 	(uint32_t *)bits, stride * sizeof (FbStride));
     
     
@@ -312,52 +307,30 @@ create_bits_picture (PicturePtr pict,
 	if (pict->clientClipType != CT_NONE)
 	    pixman_image_set_has_client_clip (image, TRUE);
 
-	if (*xoff || *yoff)
-	    pixman_region_translate (pict->pCompositeClip, *xoff, *yoff);
+	pixman_region_translate (pict->pCompositeClip, - pict->pDrawable->x, - pict->pDrawable->y);
 
 	pixman_image_set_clip_region (image, pict->pCompositeClip);
 
-	if (*xoff || *yoff)
-	    pixman_region_translate (pict->pCompositeClip, -*xoff, -*yoff);
+	pixman_region_translate (pict->pCompositeClip, pict->pDrawable->x, pict->pDrawable->y);
     }
     
     /* Indexed table */
     if (pict->pFormat->index.devPrivate)
 	pixman_image_set_indexed (image, pict->pFormat->index.devPrivate);
 
-    /* Add in drawable origin to position within the image */
-    *xoff += pict->pDrawable->x;
-    *yoff += pict->pDrawable->y;
-
     return image;
 }
 
 static void
-set_image_properties (pixman_image_t *image, PicturePtr pict, Bool has_clip, int *xoff, int *yoff)
+set_image_properties (pixman_image_t *image, PicturePtr pict)
 {
     pixman_repeat_t repeat;
     pixman_filter_t filter;
     
     if (pict->transform)
     {
-	/* For source images, adjust the transform to account
-	 * for the drawable offset within the pixman image,
-	 * then set the offset to 0 as it will be used
-	 * to compute positions within the transformed image.
-	 */
-	if (!has_clip) {
-	    struct pixman_transform	adjusted;
-
-	    adjusted = *pict->transform;
-	    pixman_transform_translate(&adjusted,
-				       NULL,
-				       pixman_int_to_fixed(*xoff),
-				       pixman_int_to_fixed(*yoff));
-	    pixman_image_set_transform (image, &adjusted);
-	    *xoff = 0;
-	    *yoff = 0;
-	} else
-	    pixman_image_set_transform (image, pict->transform);
+	pixman_image_set_transform (
+	    image, (pixman_transform_t *)pict->transform);
     }
     
     switch (pict->repeatType)
@@ -384,8 +357,7 @@ set_image_properties (pixman_image_t *image, PicturePtr pict, Bool has_clip, int
     
     if (pict->alphaMap)
     {
-	int alpha_xoff, alpha_yoff;
-	pixman_image_t *alpha_map = image_from_pict (pict->alphaMap, FALSE, &alpha_xoff, &alpha_yoff);
+	pixman_image_t *alpha_map = image_from_pict (pict->alphaMap, TRUE);
 	
 	pixman_image_set_alpha_map (
 	    image, alpha_map, pict->alphaOrigin.x, pict->alphaOrigin.y);
@@ -418,7 +390,8 @@ set_image_properties (pixman_image_t *image, PicturePtr pict, Bool has_clip, int
 }
 
 pixman_image_t *
-image_from_pict (PicturePtr pict, Bool has_clip, int *xoff, int *yoff)
+image_from_pict (PicturePtr pict,
+		 Bool has_clip)
 {
     pixman_image_t *image = NULL;
 
@@ -427,7 +400,7 @@ image_from_pict (PicturePtr pict, Bool has_clip, int *xoff, int *yoff)
 
     if (pict->pDrawable)
     {
-	image = create_bits_picture (pict, has_clip, xoff, yoff);
+	image = create_bits_picture (pict, has_clip);
     }
     else if (pict->pSourcePict)
     {
@@ -448,11 +421,10 @@ image_from_pict (PicturePtr pict, Bool has_clip, int *xoff, int *yoff)
 	    else if (sp->type == SourcePictTypeConical)
 		image = create_conical_gradient_image (gradient);
 	}
-	*xoff = *yoff = 0;
     }
     
     if (image)
-	set_image_properties (image, pict, has_clip, xoff, yoff);
+	set_image_properties (image, pict);
     
     return image;
 }
diff --git a/fb/fbtrap.c b/fb/fbtrap.c
index 9f5c39f..9c55236 100644
--- a/fb/fbtrap.c
+++ b/fb/fbtrap.c
@@ -38,8 +38,7 @@ fbAddTraps (PicturePtr	pPicture,
 	    int		ntrap,
 	    xTrap	*traps)
 {
-    int image_xoff, image_yoff;
-    pixman_image_t *image = image_from_pict (pPicture, FALSE, &image_xoff, &image_yoff);
+    pixman_image_t *image = image_from_pict (pPicture, FALSE);
 
     if (!image)
 	return;
@@ -55,8 +54,7 @@ fbRasterizeTrapezoid (PicturePtr    pPicture,
 		      int	    x_off,
 		      int	    y_off)
 {
-    int	mask_xoff, mask_yoff;
-    pixman_image_t *image = image_from_pict (pPicture, FALSE, &mask_xoff, &mask_yoff);
+    pixman_image_t *image = image_from_pict (pPicture, FALSE);
 
     if (!image)
 	return;
commit dfe67c7d7fbf5c8ad901eab212e935ec981fac03
Author: Jeremy Huddleston <jeremyhu at apple.com>
Date:   Fri Apr 30 13:08:25 2010 -0700

    Workaround the GC clipping problem in miPaintWindow and add some debugging output.
    
    Signed-off-by: Jeremy Huddleston <jeremyhu at apple.com>

diff --git a/mi/miexpose.c b/mi/miexpose.c
index 94258b8..4f25c23 100644
--- a/mi/miexpose.c
+++ b/mi/miexpose.c
@@ -521,6 +521,7 @@ void RootlessSetPixmapOfAncestors(WindowPtr pWin);
 void RootlessStartDrawing(WindowPtr pWin);
 void RootlessDamageRegion(WindowPtr pWin, RegionPtr prgn);
 Bool IsFramedWindow(WindowPtr pWin);
+#include "../fb/fb.h"
 #endif 
 
 void
@@ -548,24 +549,37 @@ miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
     Bool	solid = TRUE;
     DrawablePtr	drawable = &pWin->drawable;
 
+#ifdef XQUARTZ_CLIP_DEBUG
+    ErrorF("START %d BS %d (pR = %ld)\n", what, pWin->backgroundState, ParentRelative);
+    ErrorF("      Rgn: %d %d %d %d\n", prgn->extents.x1, prgn->extents.y1,
+	                               prgn->extents.x2 - prgn->extents.x1,
+	                               prgn->extents.y2 - prgn->extents.y1);
+    ErrorF("      Win: %d %d (%d %d) %d %d\n", pWin->origin.x, pWin->origin.y,
+	                                       pWin->winSize.extents.x1, pWin->winSize.extents.y1,
+	                                       pWin->winSize.extents.x2 - pWin->winSize.extents.x1,
+					       pWin->winSize.extents.y2 - pWin->winSize.extents.y1);
+    ErrorF("     Draw: %d %d %d %d\n", pWin->drawable.x, pWin->drawable.y,
+				       pWin->drawable.width, pWin->drawable.height);
+#endif
+
 #ifdef ROOTLESS
     if(!drawable || drawable->type == UNDRAWABLE_WINDOW)
 	return;
-
-    if(IsFramedWindow(pWin)) {
-        RootlessStartDrawing(pWin);
-        RootlessDamageRegion(pWin, prgn);
-    
-        if(pWin->backgroundState == ParentRelative) {
-            if((what == PW_BACKGROUND) || 
-               (what == PW_BORDER && !pWin->borderIsPixel))
-                RootlessSetPixmapOfAncestors(pWin);
-        }
-    }
 #endif
     
     if (what == PW_BACKGROUND)
     {
+#ifdef ROOTLESS
+	if(IsFramedWindow(pWin)) {
+	    RootlessStartDrawing(pWin);
+	    RootlessDamageRegion(pWin, prgn);
+
+	    if(pWin->backgroundState == ParentRelative) {
+		RootlessSetPixmapOfAncestors(pWin);
+	    }
+	}
+#endif
+
 	while (pWin->backgroundState == ParentRelative)
 	    pWin = pWin->parent;
 
@@ -587,6 +601,18 @@ miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
     {
 	PixmapPtr   pixmap;
 
+#ifdef ROOTLESS
+	if(IsFramedWindow(pWin)) {
+	    RootlessStartDrawing(pWin);
+	    RootlessDamageRegion(pWin, prgn);
+	    
+	    if(!pWin->borderIsPixel &&
+		pWin->backgroundState == ParentRelative) {
+		RootlessSetPixmapOfAncestors(pWin);
+	    }
+	}
+#endif
+
 	tile_x_off = drawable->x;
 	tile_y_off = drawable->y;
 	
@@ -595,6 +621,12 @@ miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
 	    return;
 	pixmap = (*pScreen->GetWindowPixmap) ((WindowPtr) drawable);
 	drawable = &pixmap->drawable;
+
+#ifdef XQUARTZ_CLIP_DEBUG
+	ErrorF("     Draw: %d %d %d %d\n",
+	       drawable->x, drawable->y, drawable->width, drawable->height);    
+#endif
+	
 #ifdef COMPOSITE
 	draw_x_off = pixmap->screen_x;
 	draw_y_off = pixmap->screen_y;
@@ -657,6 +689,57 @@ miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
     ChangeGC (NullClient, pGC, gcmask, gcval);
     ValidateGC (drawable, pGC);
 
+#ifdef XQUARTZ_CLIP_DEBUG
+    ErrorF("       GC: %d %d %d %d\n",
+	   pGC->pCompositeClip->extents.x1, pGC->pCompositeClip->extents.y1,
+	   pGC->pCompositeClip->extents.x2 - pGC->pCompositeClip->extents.x1,
+	   pGC->pCompositeClip->extents.y2 - pGC->pCompositeClip->extents.y1);
+#endif
+    
+#ifdef XQUARTZ
+    /* Looks like our clipping isn't set right for some reason:
+     * http://xquartz.macosforge.org/trac/ticket/290
+     */
+    if(what == PW_BORDER) {
+
+#if 0
+	if(solid) {
+#if 1
+	    fbFillRegionSolid(&pWin->drawable,
+			      prgn,
+			      0,
+			      fbReplicatePixel(fill.pixel,
+					       pWin->drawable.bitsPerPixel));
+#else
+	    fbFillRegionSolid(drawable,
+			      prgn,
+			      0,
+			      fbReplicatePixel(fill.pixel,
+					       drawable->bitsPerPixel));
+#endif
+	    return;
+	}
+#endif
+    
+	pGC->pCompositeClip->extents.x1 += prgn->extents.x1;
+	pGC->pCompositeClip->extents.y1 += prgn->extents.y1;
+	pGC->pCompositeClip->extents.x2 += prgn->extents.x1;
+	pGC->pCompositeClip->extents.y2 += prgn->extents.y1;
+	
+	if(pGC->pCompositeClip->extents.x2 > drawable->pScreen->width)
+	    pGC->pCompositeClip->extents.x2 = drawable->pScreen->width;
+	if(pGC->pCompositeClip->extents.y2 > drawable->pScreen->height)
+	    pGC->pCompositeClip->extents.y2 = drawable->pScreen->height;
+    }
+#endif
+
+#ifdef XQUARTZ_CLIP_DEBUG
+    ErrorF("       GC: %d %d %d %d\n",
+	   pGC->pCompositeClip->extents.x1, pGC->pCompositeClip->extents.y1,
+	   pGC->pCompositeClip->extents.x2 - pGC->pCompositeClip->extents.x1,
+	   pGC->pCompositeClip->extents.y2 - pGC->pCompositeClip->extents.y1);    
+#endif
+
     numRects = RegionNumRects(prgn);
     pbox = RegionRects(prgn);
     for (i= numRects; --i >= 0; pbox++, prect++)
commit e702af65ea5495a41e2a2bd54474be1606709baa
Author: Jan Hauffa <hauffa at in.tum.de>
Date:   Wed Jun 16 09:25:41 2010 -0700

    XQuartz: Remove some dead code.
    
    Signed-off-by: Jan Hauffa <hauffa at in.tum.de>
    Reviewed-by: Jeremy Huddleston <jeremyhu at apple.com>
    Signed-off-by: Jeremy Huddleston <jeremyhu at apple.com>

diff --git a/hw/xquartz/quartz.c b/hw/xquartz/quartz.c
index 2828c57..bdaa262 100644
--- a/hw/xquartz/quartz.c
+++ b/hw/xquartz/quartz.c
@@ -67,12 +67,8 @@
 #define FAKE_RANDR 1
 
 // Shared global variables for Quartz modes
-int                     quartzEventWriteFD = -1;
 int                     quartzUseSysBeep = 0;
-int                     quartzUseAGL = 1;
-int                     quartzEnableKeyEquivalents = 1;
 int                     quartzServerVisible = FALSE;
-int                     quartzServerQuitting = FALSE;
 DevPrivateKeyRec        quartzScreenKeyRec;
 int                     aquaMenuBarHeight = 0;
 QuartzModeProcsPtr      quartzProcs = NULL;
diff --git a/hw/xquartz/quartzCocoa.m b/hw/xquartz/quartzCocoa.m
index 4501472..54c900d 100644
--- a/hw/xquartz/quartzCocoa.m
+++ b/hw/xquartz/quartzCocoa.m
@@ -44,17 +44,6 @@
 #include "darwin.h"
 
 /*
- * QuartzFSUseQDCursor
- *  Return whether the screen should use a QuickDraw cursor.
- */
-int QuartzFSUseQDCursor(
-    int depth)  // screen depth
-{
-    return TRUE;
-}
-
-
-/*
  * QuartzBlockHandler
  *  Clean out any autoreleased objects.
  */
diff --git a/hw/xquartz/quartzCommon.h b/hw/xquartz/quartzCommon.h
index c038ed0..eb761ed 100644
--- a/hw/xquartz/quartzCommon.h
+++ b/hw/xquartz/quartzCommon.h
@@ -51,20 +51,13 @@ typedef struct {
 #define QUARTZ_PRIV(pScreen) \
     ((QuartzScreenPtr)dixLookupPrivate(&pScreen->devPrivates, quartzScreenKey))
 
-// Data stored at startup for Cocoa front end
-extern int              quartzEventWriteFD;
-
 // User preferences used by Quartz modes
 extern int              quartzUseSysBeep;
-extern int              focusOnNewWindow;
-extern int              quartzUseAGL;
-extern int              quartzEnableKeyEquivalents;
 extern int              quartzFullscreenDisableHotkeys;
 extern int              quartzOptionSendsAlt;
 
 // Other shared data
 extern int              quartzServerVisible;
-extern int              quartzServerQuitting;
 extern DevPrivateKeyRec quartzScreenKeyRec;
 #define quartzScreenKey (&quartzScreenKeyRec)
 extern int              aquaMenuBarHeight;
@@ -72,14 +65,6 @@ extern int              aquaMenuBarHeight;
 // Name of GLX bundle for native OpenGL
 extern const char      *quartzOpenGLBundle;
 
-void QuartzReadPreferences(void);
-void QuartzMessageMainThread(unsigned msg, void *data, unsigned length);
-void QuartzMessageServerThread(int type, int argc, ...);
-void QuartzSetWindowMenu(int nitems, const char **items,
-                         const char *shortcuts);
-void QuartzFSCapture(void);
-void QuartzFSRelease(void);
-int  QuartzFSUseQDCursor(int depth);
 void QuartzBlockHandler(pointer blockData, OSTimePtr pTimeout, pointer pReadmask);
 void QuartzWakeupHandler(pointer blockData, int result, pointer pReadmask);
 
commit a68a101a730df7f73421555e381a50b074607c5e
Author: Keith Packard <keithp at keithp.com>
Date:   Tue Jun 22 12:13:26 2010 -0700

    Bump to 1.8.99.903 -- 1.9 RC3
    
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/configure.ac b/configure.ac
index 95a9444..1a1f2d3 100644
--- a/configure.ac
+++ b/configure.ac
@@ -26,7 +26,7 @@ dnl
 dnl Process this file with autoconf to create configure.
 
 AC_PREREQ(2.57)
-AC_INIT([xorg-server], 1.8.99.902, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
+AC_INIT([xorg-server], 1.8.99.903, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
 RELEASE_DATE="2010-06-22"
 AC_CONFIG_SRCDIR([Makefile.am])
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
commit 2c0159d21788b16607e6ebe4571b57fe78545c2a
Author: Kristian Høgsberg <krh at bitplanet.net>
Date:   Mon Jun 14 09:25:22 2010 -0400

    list.h: Fix list_for_each_entry_safe()
    
    Can't use next as a macro argument since we're accessing the .next field
    of struct list.
    
    Signed-off-by: Kristian Høgsberg <krh at bitplanet.net>
    Reviewed-by: Keith Packard <keithp at keithp.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/include/list.h b/include/list.h
index 89dc29d..4ce20a8 100644
--- a/include/list.h
+++ b/include/list.h
@@ -94,10 +94,10 @@ list_is_empty(struct list *head)
 	 &pos->member != (head);					\
 	 pos = __container_of(pos->member.next, pos, member))
 
-#define list_for_each_entry_safe(pos, next, head, member)		\
+#define list_for_each_entry_safe(pos, tmp, head, member)		\
     for (pos = __container_of((head)->next, pos, member),		\
-	 next = __container_of(pos->member.next, pos, member);		\
+	 tmp = __container_of(pos->member.next, pos, member);		\
 	 &pos->member != (head);					\
-	 pos = next, next = __container_of(next->member.next, next, member))
+	 pos = tmp, tmp = __container_of(pos->member.next, tmp, member))
 
 #endif
commit e2918b67395a48397bf7db545584cc2d4f4e7ccf
Author: Keith Packard <keithp at keithp.com>
Date:   Tue Jun 22 12:11:20 2010 -0700

    Revert "mi: Remove unused overlay support"
    
    This reverts commit 9120e58556014e514eef9dfe43cdea4b74dc66ae.
    
     Whoops, please revert this patch -- overlay is in use in nvidia drivers,
     and it's too late in release cycle to remove it.
    
     I feel really sorry that I kept this patch in my tree. I will submit
    another one, removing only XAA overlay hooks which are not used at all.

diff --git a/hw/xfree86/loader/sdksyms.sh b/hw/xfree86/loader/sdksyms.sh
index 4245031..13c5ae5 100755
--- a/hw/xfree86/loader/sdksyms.sh
+++ b/hw/xfree86/loader/sdksyms.sh
@@ -231,6 +231,7 @@ cat > sdksyms.c << EOF
 #include "miwideline.h"
 #include "mistruct.h"
 #include "mifpoly.h"
+#include "mioverlay.h"
 
 
 /* randr/Makefile.am */
diff --git a/hw/xfree86/xaa/xaaOverlay.c b/hw/xfree86/xaa/xaaOverlay.c
index 58c4a58..4b52bf6 100644
--- a/hw/xfree86/xaa/xaaOverlay.c
+++ b/hw/xfree86/xaa/xaaOverlay.c
@@ -16,6 +16,7 @@
 #include "xaawrap.h"
 #include "gcstruct.h"
 #include "pixmapstr.h"
+#include "mioverlay.h"
 
 #ifdef PANORAMIX
 #include "panoramiX.h"
@@ -36,6 +37,7 @@ XAACopyWindow8_32(
     ScreenPtr pScreen = pWin->drawable.pScreen;
     XAAInfoRecPtr infoRec = 
 	GET_XAAINFORECPTR_FROM_DRAWABLE((&pWin->drawable));
+    Bool doUnderlay = miOverlayCopyUnderlay(pScreen);
     RegionPtr borderClip = &pWin->borderClip;
     Bool freeReg = FALSE;
 
@@ -54,6 +56,9 @@ XAACopyWindow8_32(
 
     pwinRoot = pScreen->root;
 
+    if(doUnderlay)
+	freeReg = miOverlayCollectUnderlayRegions(pWin, &borderClip);
+
     RegionNull(&rgnDst);
 
     dx = ptOldOrg.x - pWin->drawable.x;
@@ -76,7 +81,7 @@ XAACopyWindow8_32(
 	ppt++; pbox++;
     }
     
-    infoRec->ScratchGC.planemask = 0xff000000;
+    infoRec->ScratchGC.planemask = doUnderlay ? 0x00ffffff : 0xff000000;
     infoRec->ScratchGC.alu = GXcopy;
 
     XAADoBitBlt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
@@ -88,6 +93,25 @@ XAACopyWindow8_32(
 	RegionDestroy(borderClip);
 }
 
+static void
+XAASetColorKey8_32(
+    ScreenPtr pScreen,
+    int nbox,
+    BoxPtr pbox
+){
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
+    ScrnInfoPtr pScrn = infoRec->pScrn;
+
+    /* I'm counting on writes being clipped away while switched away.
+       If this isn't going to be true then I need to be wrapping instead. */
+    if(!infoRec->pScrn->vtSema) return;
+
+    (*infoRec->FillSolidRects)(pScrn, pScrn->colorKey << 24, GXcopy, 
+					0xff000000, nbox, pbox);
+  
+    SET_SYNC_FLAG(infoRec);
+}
+
 void
 XAASetupOverlay8_32Planar(ScreenPtr pScreen)
 {
@@ -96,6 +120,9 @@ XAASetupOverlay8_32Planar(ScreenPtr pScreen)
 
     pScreen->CopyWindow = XAACopyWindow8_32;
 
+    if(!(infoRec->FillSolidRectsFlags & NO_PLANEMASK))
+	miOverlaySetTransFunction(pScreen, XAASetColorKey8_32);
+
     infoRec->FullPlanemask = ~0;
     for(i = 0; i < 32; i++) /* haven't thought about this much */
 	infoRec->FullPlanemasks[i] = ~0;
diff --git a/mi/Makefile.am b/mi/Makefile.am
index 8319226..f6dabda 100644
--- a/mi/Makefile.am
+++ b/mi/Makefile.am
@@ -3,7 +3,7 @@ noinst_LTLIBRARIES = libmi.la
 if XORG
 sdk_HEADERS = micmap.h miline.h mipointer.h mi.h mibstore.h \
               migc.h mipointrst.h mizerarc.h micoord.h mifillarc.h \
-              mispans.h miwideline.h mistruct.h mifpoly.h
+              mispans.h miwideline.h mistruct.h mifpoly.h mioverlay.h
 endif
 
 AM_CFLAGS = $(DIX_CFLAGS)
@@ -33,6 +33,8 @@ libmi_la_SOURCES = 	\
 	migc.h		\
 	miglblt.c	\
 	miline.h	\
+	mioverlay.c	\
+	mioverlay.h	\
 	mipointer.c	\
 	mipointer.h	\
 	mipointrst.h	\
diff --git a/mi/mioverlay.c b/mi/mioverlay.c
new file mode 100644
index 0000000..766c5e7
--- /dev/null
+++ b/mi/mioverlay.c
@@ -0,0 +1,1946 @@
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include "scrnintstr.h"
+#include <X11/extensions/shapeproto.h>
+#include "validate.h"
+#include "windowstr.h"
+#include "mi.h"
+#include "gcstruct.h"
+#include "regionstr.h"
+#include "privates.h"
+#include "mivalidate.h"
+#include "mioverlay.h"
+#include "migc.h"
+
+#include "globals.h"
+
+
+typedef struct {
+   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;
+} miOverlayTreeRec, *miOverlayTreePtr;
+
+typedef struct {
+   miOverlayTreePtr	tree;
+} miOverlayWindowRec, *miOverlayWindowPtr;
+
+typedef struct {
+   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);
+static Bool HasUnderlayChildren(WindowPtr);
+static void MarkUnderlayWindow(WindowPtr);
+static Bool CollectUnderlayChildrenRegions(WindowPtr, RegionPtr);
+
+static Bool miOverlayCloseScreen(int, ScreenPtr);
+static Bool miOverlayCreateWindow(WindowPtr);
+static Bool miOverlayDestroyWindow(WindowPtr);
+static Bool miOverlayUnrealizeWindow(WindowPtr);
+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 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);
+static void miOverlayClearToBackground(WindowPtr, int, int, int, int, Bool);
+
+static void miOverlaySetShape(WindowPtr, int);
+static void miOverlayChangeBorderWidth(WindowPtr, unsigned int);
+
+#define MIOVERLAY_GET_SCREEN_PRIVATE(pScreen) ((miOverlayScreenPtr) \
+	dixLookupPrivate(&(pScreen)->devPrivates, miOverlayScreenKey))
+#define MIOVERLAY_GET_WINDOW_PRIVATE(pWin) ((miOverlayWindowPtr) \
+	dixLookupPrivate(&(pWin)->devPrivates, miOverlayWindowKey))
+#define MIOVERLAY_GET_WINDOW_TREE(pWin) \
+	(MIOVERLAY_GET_WINDOW_PRIVATE(pWin)->tree)
+
+#define IN_UNDERLAY(w) MIOVERLAY_GET_WINDOW_TREE(w)
+#define IN_OVERLAY(w) !MIOVERLAY_GET_WINDOW_TREE(w)
+
+#define MARK_OVERLAY(w) miMarkWindow(w)
+#define MARK_UNDERLAY(w) MarkUnderlayWindow(w)
+
+#define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
+                                    HasBorder(w) && \
+                                    (w)->backgroundState == ParentRelative)
+
+Bool
+miInitOverlay(
+    ScreenPtr pScreen, 
+    miOverlayInOverlayFunc inOverlayFunc,
+    miOverlayTransFunc transFunc
+){
+    miOverlayScreenPtr	pScreenPriv;
+
+    if(!inOverlayFunc || !transFunc) return FALSE;
+
+    if(!dixRegisterPrivateKey(&miOverlayWindowKeyRec, PRIVATE_WINDOW, sizeof(miOverlayWindowRec)))
+	return FALSE;
+
+    if(!dixRegisterPrivateKey(&miOverlayScreenKeyRec, PRIVATE_SCREEN, 0))
+	return FALSE;
+
+    if(!(pScreenPriv = malloc(sizeof(miOverlayScreenRec))))
+	return FALSE;
+
+    dixSetPrivate(&pScreen->devPrivates, miOverlayScreenKey, pScreenPriv);
+
+    pScreenPriv->InOverlay = inOverlayFunc;
+    pScreenPriv->MakeTransparent = transFunc;
+    pScreenPriv->underlayMarked = FALSE;
+
+
+    pScreenPriv->CloseScreen = pScreen->CloseScreen;
+    pScreenPriv->CreateWindow = pScreen->CreateWindow;
+    pScreenPriv->DestroyWindow = pScreen->DestroyWindow;
+    pScreenPriv->UnrealizeWindow = pScreen->UnrealizeWindow;
+    pScreenPriv->RealizeWindow = pScreen->RealizeWindow;
+
+    pScreen->CloseScreen = miOverlayCloseScreen;
+    pScreen->CreateWindow = miOverlayCreateWindow;
+    pScreen->DestroyWindow = miOverlayDestroyWindow;
+    pScreen->UnrealizeWindow = miOverlayUnrealizeWindow;
+    pScreen->RealizeWindow = miOverlayRealizeWindow;
+
+    pScreen->ReparentWindow = miOverlayReparentWindow;
+    pScreen->RestackWindow = miOverlayRestackWindow;
+    pScreen->MarkOverlappedWindows = miOverlayMarkOverlappedWindows;
+    pScreen->MarkUnrealizedWindow = miOverlayMarkUnrealizedWindow;
+    pScreen->ValidateTree = miOverlayValidateTree;
+    pScreen->HandleExposures = miOverlayHandleExposures;
+    pScreen->MoveWindow = miOverlayMoveWindow;
+    pScreen->WindowExposures = miOverlayWindowExposures;
+    pScreen->ResizeWindow = miOverlayResizeWindow;
+    pScreen->MarkWindow = miOverlayMarkWindow;
+    pScreen->ClearToBackground = miOverlayClearToBackground;
+    pScreen->SetShape = miOverlaySetShape;
+    pScreen->ChangeBorderWidth = miOverlayChangeBorderWidth;
+
+    return TRUE;
+}
+
+
+static Bool 
+miOverlayCloseScreen(int i, ScreenPtr 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;
+
+   free(pScreenPriv);
+
+   return (*pScreen->CloseScreen)(i, pScreen);
+}
+
+
+static Bool 
+miOverlayCreateWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    miOverlayWindowPtr pWinPriv = MIOVERLAY_GET_WINDOW_PRIVATE(pWin);
+    miOverlayTreePtr pTree = NULL;
+    Bool result = TRUE;
+
+    pWinPriv->tree = NULL;
+
+    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 (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 
+miOverlayDestroyWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(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(pScreenPriv->DestroyWindow) {
+	pScreen->DestroyWindow = pScreenPriv->DestroyWindow;
+	result = (*pScreen->DestroyWindow)(pWin);
+	pScreen->DestroyWindow = miOverlayDestroyWindow;
+    }
+
+    return result;
+}
+
+static Bool 
+miOverlayUnrealizeWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    Bool result = TRUE;
+
+    if(pTree) pTree->visibility = VisibilityNotViewable;
+
+    if(pScreenPriv->UnrealizeWindow) {
+	pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow;
+	result = (*pScreen->UnrealizeWindow)(pWin);
+	pScreen->UnrealizeWindow = miOverlayUnrealizeWindow;
+    }
+
+    return result;
+}
+
+
+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;
+    }
+
+    /* 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);
+    }
+
+    return result;
+}
+
+
+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);
+    }	
+}
+
+static void 
+miOverlayRestackWindow(WindowPtr pWin, WindowPtr oldNextSib)
+{
+    if(IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) {
+	/* This could probably be more optimal */
+	RebuildTree(pWin);
+    }	
+}
+
+
+static Bool
+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! */
+
+    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(doUnderlay && IN_UNDERLAY(pChild))
+		pTree = MIOVERLAY_GET_WINDOW_TREE(pChild);
+
+	    if(pChild->viewable) {
+                if (RegionBroken(&pChild->winSize))
+                    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;
+	    }
+	}
+    }
+   
+    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);
+                if (RegionBroken(&tChild->pWin->borderSize))
+		    SetBorderSize (tChild->pWin);
+
+		if(RegionContainsRect(&(tChild->pWin->borderSize), box))
+	        {
+		    MARK_UNDERLAY(tChild->pWin);
+		    underMarked = TRUE;
+	        }
+	    }
+
+	    if(tChild->lastChild) {
+		tChild = tChild->lastChild;
+		continue;
+	    }
+
+	    while(!tChild->prevSib && (tChild != tLast))
+		tChild = tChild->parent;
+
+	    if(tChild == tLast) break;
+
+	    tChild = tChild->prevSib;
+	}
+    }
+
+    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
+){
+    ScreenPtr pScreen = pParent->drawable.pScreen;
+    int oldVis, newVis, dx, dy;
+    BoxRec borderSize;
+    RegionPtr borderVisible;
+    RegionRec childUniverse, childUnion;
+    miOverlayTreePtr tParent = MIOVERLAY_GET_WINDOW_TREE(pParent);
+    miOverlayTreePtr tChild;
+    Bool overlap;
+
+    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;
+    borderSize.x2 = dx;
+    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;
+    }
+    tParent->visibility = newVis;
+
+    dx = pParent->drawable.x - tParent->valdata->oldAbsCorner.x;
+    dy = pParent->drawable.y - tParent->valdata->oldAbsCorner.y;
+
+    switch (kind) {
+    case VTMap:
+    case VTStack:
+    case VTUnmap:
+	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 (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 */
+    default:
+    	if (dx || dy)  {
+	    RegionTranslate(&tParent->borderClip, dx, dy);
+	    RegionTranslate(&tParent->clipList, dx, dy);
+    	} 
+	break;
+    case VTBroken:
+	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);
+    }
+    else
+	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);
+    }
+    else if (newVis != VisibilityFullyObscured &&
+	     newVis != VisibilityNotViewable)
+    {
+	RegionSubtract(&tParent->valdata->exposed,
+			       universe, &tParent->clipList);
+    }
+    
+    /* HACK ALERT - copying contents of regions, instead of regions */
+    {
+	RegionRec   tmp;
+
+	tmp = tParent->clipList;
+	tParent->clipList = *universe;
+	*universe = tmp;
+    }
+
+    pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+
+    if (pScreen->ClipNotify)
+        (* pScreen->ClipNotify) (pParent, dx, dy);
+}
+
+
+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(pTree) {
+	MARK_UNDERLAY(pTree->parent->pWin);
+	MIOVERLAY_GET_SCREEN_PRIVATE(
+		pWin->drawable.pScreen)->underlayMarked = TRUE;
+    }
+}
+
+static void
+miOverlayMarkUnrealizedWindow(
+    WindowPtr pChild,
+    WindowPtr pWin,
+    Bool fromConfigure
+){
+    if ((pChild != pWin) || fromConfigure) {
+	miOverlayTreePtr pTree;
+
+        RegionEmpty(&pChild->clipList);
+        if (pChild->drawable.pScreen->ClipNotify)
+            (* 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);
+	    }
+	}
+    }
+}
+
+
+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;
+    miOverlayTreePtr tParent, tChild, tWin;
+    Bool overlap;
+    WindowPtr newParent;
+
+    if(!pPriv->underlayMarked)
+	goto SKIP_UNDERLAY;
+
+    if (!pChild) pChild = pParent->firstChild;
+
+    RegionNull(&totalClip);
+    RegionNull(&childClip);
+    RegionNull(&exposed);
+
+    newParent = pParent;
+
+    while(IN_OVERLAY(newParent))
+    	newParent = newParent->parent;
+
+    tParent = MIOVERLAY_GET_WINDOW_TREE(newParent);
+
+    if(IN_UNDERLAY(pChild))
+	tChild = MIOVERLAY_GET_WINDOW_TREE(pChild);
+    else
+	tChild = tParent->firstChild;
+
+    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);
+        }        
+        RegionEmpty(&tParent->clipList);
+    } 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);
+	
+    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;
+	    }
+	}
+    }
+
+    RegionUninit(&childClip);
+
+    if(!((*pPriv->InOverlay)(newParent))) {
+	RegionNull(&tParent->valdata->exposed);
+	RegionNull(&tParent->valdata->borderExposed);
+    }
+
+    switch (kind) {
+    case VTStack:
+	break;
+    default:
+    	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;
+    }
+
+    RegionUninit(&totalClip);
+    RegionUninit(&exposed);
+
+SKIP_UNDERLAY:
+
+    miValidateTree(pParent, pChild, kind);
+
+    return 1;
+}
+
+
+static void
+miOverlayHandleExposures(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    WindowPtr pChild;
+    ValidatePtr val;
+    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;
+        }
+	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;
+    }
+}
+
+
+static void
+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);
+    short bw;
+    RegionRec overReg, underReg;
+    DDXPointRec oldpt;
+
+    if (!(pParent = pWin->parent))
+       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);
+    }
+    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);
+
+    (*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);
+    }
+    if (pWin->realized)
+	WindowsRestructured ();
+}
+
+#ifndef RECTLIMIT
+#define RECTLIMIT 25
+#endif
+
+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;
+            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
+               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);
+    }
+    else if (exposures && exposures != prgn)
+	RegionDestroy(exposures);
+}
+
+
+typedef struct {
+   RegionPtr over;
+   RegionPtr under;
+} miOverlayTwoRegions; 
+
+static int
+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;
+
+    return WT_WALKCHILDREN;
+}
+
+static void
+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);
+    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);
+    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;
+
+    /* if this is a root window, can't be resized */
+    if (!(pParent = pWin->parent))
+	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);
+		}
+	    }
+	}
+    }
+    pWin->origin.x = x + bw;
+    pWin->origin.y = y + bw;
+    pWin->drawable.height = h;
+    pWin->drawable.width = w;
+
+    x = pWin->drawable.x = newx;
+    y = pWin->drawable.y = newy;
+
+    SetWinSize (pWin);
+    SetBorderSize (pWin);
+
+    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);
+
+    pFirstChange = MoveWindowInStack(pWin, pSib);
+
+    if (WasViewable) {
+	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);
+	    }
+	}
+
+	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);
+    }
+    if (pWin->realized)
+	WindowsRestructured ();
+}
+
+
+static void
+miOverlaySetShape(WindowPtr pWin, int kind)
+{
+    Bool        WasViewable = (Bool)(pWin->viewable);
+    ScreenPtr   pScreen = pWin->drawable.pScreen;
+
+    if (kind != ShapeInput) {
+        if (WasViewable) {
+            (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+            if (HasBorder (pWin)) {
+                RegionPtr borderVisible;
+
+                borderVisible = RegionCreate(NullBox, 1);
+                RegionSubtract(borderVisible,
+                                        &pWin->borderClip, &pWin->winSize);
+                pWin->valdata->before.borderVisible = borderVisible;
+                pWin->valdata->before.resized = TRUE;
+                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;
+                }
+            }
+        }
+
+        SetWinSize (pWin);
+        SetBorderSize (pWin);
+
+        ResizeChildrenWinSize(pWin, 0, 0, 0, 0);
+
+        if (WasViewable) {
+            (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+
+            (*pScreen->ValidateTree)(pWin->parent, NullWindow, VTOther);
+        }
+
+        if (WasViewable) {
+            (*pScreen->HandleExposures)(pWin->parent);
+            if (pScreen->PostValidateTree)
+                (*pScreen->PostValidateTree)(pWin->parent, NullWindow, VTOther);
+        }
+    }
+    if (pWin->realized)
+        WindowsRestructured ();
+    CheckCursorConfinement(pWin);
+}
+
+
+
+static void
+miOverlayChangeBorderWidth(
+    WindowPtr pWin,
+    unsigned int width
+){
+    int oldwidth;
+    ScreenPtr pScreen;
+    Bool WasViewable = (Bool)(pWin->viewable);
+    Bool HadBorder;
+
+    oldwidth = wBorderWidth (pWin);
+    if (oldwidth == width)
+	return;
+    HadBorder = HasBorder(pWin);
+    pScreen = pWin->drawable.pScreen;
+    if (WasViewable && (width < oldwidth))
+	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+    pWin->borderWidth = width;
+    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 (pWin->realized)
+	WindowsRestructured ();
+}
+
+/*  We need this as an addition since the xf86 common code doesn't
+    know about the second tree which is static to this file.  */
+
+void
+miOverlaySetRootClip(ScreenPtr pScreen, Bool enable)
+{
+    WindowPtr pRoot = pScreen->root;
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pRoot);
+
+    MARK_UNDERLAY(pRoot);
+
+    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);
+
+    RegionBreak(&pTree->clipList);
+}
+
+static void 
+miOverlayClearToBackground(
+    WindowPtr pWin,
+    int x, int y,
+    int w, int h,
+    Bool generateExposures
+)
+{
+    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;
+    BoxPtr  extents;
+    int     x1, y1, x2, y2;
+
+    x1 = pWin->drawable.x + x;
+    y1 = pWin->drawable.y + y;
+    if (w)
+        x2 = x1 + (int) w;
+    else
+        x2 = x1 + (int) pWin->drawable.width - (int) x;
+    if (h)
+        y2 = y1 + h;    
+    else
+        y2 = y1 + (int) pWin->drawable.height - (int) y;
+
+    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) 
+        x2 = x1 = y2 = y1 = 0;
+
+    box.x1 = x1; box.x2 = x2;
+    box.y1 = y1; box.y2 = y2;
+
+    RegionInit(&reg, &box, 1);
+
+    RegionIntersect(&reg, &reg, clipList);
+    if (generateExposures)
+        (*pScreen->WindowExposures)(pWin, &reg, pBSReg);
+    else if (pWin->backgroundState != None)
+	miPaintWindow(pWin, &reg, PW_BACKGROUND);
+    RegionUninit(&reg);
+    if (pBSReg)
+        RegionDestroy(pBSReg);
+}
+
+
+/****************************************************************/
+
+/* not used */
+Bool
+miOverlayGetPrivateClips(
+    WindowPtr pWin,
+    RegionPtr *borderClip,
+    RegionPtr *clipList
+){
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+	
+    if(pTree) {
+ 	*borderClip = &(pTree->borderClip);
+	*clipList = &(pTree->clipList);
+	return TRUE;
+    }
+
+    *borderClip = *clipList = NULL;
+
+    return FALSE;
+}
+
+void
+miOverlaySetTransFunction (
+   ScreenPtr pScreen, 
+   miOverlayTransFunc transFunc
+){
+    MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent = transFunc;
+}
+
+Bool
+miOverlayCopyUnderlay(ScreenPtr pScreen)
+{
+    return MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->copyUnderlay;
+}
+
+void
+miOverlayComputeCompositeClip(GCPtr pGC, WindowPtr pWin)
+{
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    RegionPtr       pregWin;
+    Bool            freeTmpClip, freeCompClip;
+
+    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;
+    }
+    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));
+    }
+}
+
+Bool
+miOverlayCollectUnderlayRegions(
+    WindowPtr pWin,
+    RegionPtr *region
+){
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+
+    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
+){
+    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(!parent->firstChild)
+	parent->firstChild = parent->lastChild = pTree;
+    else if(parent->lastChild == prevSib)
+	parent->lastChild = pTree;
+   
+    return pTree;
+}
+
+static void 
+RebuildTree(WindowPtr pWin)
+{
+    miOverlayTreePtr parent, prevSib, tChild;
+    WindowPtr pChild;
+
+    prevSib = tChild = NULL;
+
+    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;
+    }
+}
+
+
+static Bool
+HasUnderlayChildren(WindowPtr pWin)
+{
+    WindowPtr pChild;
+
+    if(!(pChild = pWin->firstChild)) 
+	return FALSE;
+
+    while(1) {
+	if(IN_UNDERLAY(pChild))
+	   return TRUE;
+
+	if(pChild->firstChild) {
+	    pChild = pChild->firstChild;
+	    continue;
+	}
+
+	while(!pChild->nextSib && (pWin != pChild))
+	    pChild = pChild->parent;
+
+	if(pChild == pWin) break;
+
+	pChild = pChild->nextSib;
+    }
+
+    return FALSE;
+}
+
+
+static Bool
+CollectUnderlayChildrenRegions(WindowPtr pWin, RegionPtr pReg)
+{
+    WindowPtr pChild;
+    miOverlayTreePtr pTree;
+    Bool hasUnderlay;
+
+    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(!pChild->nextSib && (pWin != pChild))
+	    pChild = pChild->parent;
+
+	if(pChild == pWin) break;
+
+	pChild = pChild->nextSib;
+    }
+
+    if(hasUnderlay) {
+	Bool overlap;
+	RegionValidate(pReg, &overlap);
+    } 
+
+    return hasUnderlay;
+}
+
+
+static void 
+MarkUnderlayWindow(WindowPtr pWin)
+{
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+
+    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;
+}
diff --git a/mi/mioverlay.h b/mi/mioverlay.h
new file mode 100644
index 0000000..dca65ad
--- /dev/null
+++ b/mi/mioverlay.h
@@ -0,0 +1,32 @@
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef __MIOVERLAY_H
+#define __MIOVERLAY_H
+
+typedef void (*miOverlayTransFunc)(ScreenPtr, int, BoxPtr);
+typedef Bool (*miOverlayInOverlayFunc)(WindowPtr);
+
+extern _X_EXPORT Bool
+miInitOverlay(
+   ScreenPtr pScreen, 
+   miOverlayInOverlayFunc inOverlay,
+   miOverlayTransFunc trans
+);
+
+extern _X_EXPORT Bool
+miOverlayGetPrivateClips(
+    WindowPtr pWin,
+    RegionPtr *borderClip,
+    RegionPtr *clipList
+);
+
+extern _X_EXPORT Bool miOverlayCollectUnderlayRegions(WindowPtr, RegionPtr*);
+extern _X_EXPORT void miOverlayComputeCompositeClip(GCPtr, WindowPtr);
+extern _X_EXPORT Bool miOverlayCopyUnderlay(ScreenPtr);
+extern _X_EXPORT void miOverlaySetTransFunction(ScreenPtr, miOverlayTransFunc);
+extern _X_EXPORT void miOverlaySetRootClip(ScreenPtr, Bool);
+
+#endif /* __MIOVERLAY_H */
commit 7673451ade46ebacfdfc02a5190149210198fdd8
Author: Keith Packard <keithp at keithp.com>
Date:   Tue Jun 22 11:49:30 2010 -0700

    Bump to 1.8.99.902 -- 1.9 RC2
    
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/configure.ac b/configure.ac
index 004a0a4..95a9444 100644
--- a/configure.ac
+++ b/configure.ac
@@ -26,8 +26,8 @@ dnl
 dnl Process this file with autoconf to create configure.
 
 AC_PREREQ(2.57)
-AC_INIT([xorg-server], 1.8.99.901, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
-RELEASE_DATE="2010-06-15"
+AC_INIT([xorg-server], 1.8.99.902, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
+RELEASE_DATE="2010-06-22"
 AC_CONFIG_SRCDIR([Makefile.am])
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
 AM_MAINTAINER_MODE
commit 8b65f2edb407521e0ac0e207e5d5358986bd46da
Author: Rami Ylimäki <ext-rami.ylimaki at nokia.com>
Date:   Tue Jun 22 14:57:20 2010 +0300

    record: Prevent a crash on recording client disconnect.
    
    Execute the following steps to reproduce the issue.
    
      1. Run at least two recording clients simultaneously.
         $ cnee --record --request-range 1-127 &
         $ cnee --record --request-range 1-127 &
      2. Kill the recording clients.
         $ killall cnee
      3. Give X server something to do so that the clients are closed.
         $ xinput list
         $ xinput list
    
    As a result RecordUninstallHooks accesses NullClient, because
    RecordAClientStateChange doesn't clean the recording clients up
    properly.
    
    Fix RecordUninstallHooks to fail locally on an assertion instead of
    much later in privates code, if NullClient is still accessed because
    of some other bug. Fix RecordAClientStateChange to iterate through all
    contexts so that modifications of the iterated array during iteration
    don't cause contexts to be skipped.
    
    Signed-off-by: Rami Ylimäki <ext-rami.ylimaki at nokia.com>
    Reviewed-by: Keith Packard <keithp at keithp.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/record/record.c b/record/record.c
index 06006f7..6a93d7a 100644
--- a/record/record.c
+++ b/record/record.c
@@ -997,10 +997,11 @@ RecordUninstallHooks(RecordClientsAndProtocolPtr pRCAP, XID oneclient)
 		ClientPtr pClient = clients[CLIENT_ID(client)];
 		int c;
 		Bool otherRCAPwantsProcVector = FALSE;
-		RecordClientPrivatePtr pClientPriv =
-						RecordClientPrivate(pClient);
+		RecordClientPrivatePtr pClientPriv = NULL;
 
-		assert (pClient && RecordClientPrivate(pClient));
+		assert (pClient);
+		pClientPriv = RecordClientPrivate(pClient);
+		assert (pClientPriv);
 		memcpy(pClientPriv->recordVector, pClientPriv->originalVector,
 		       sizeof (pClientPriv->recordVector));
 
@@ -2813,6 +2814,8 @@ RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer callda
     NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
     int i;
     ClientPtr pClient = pci->client;
+    RecordContextPtr *ppAllContextsCopy = NULL;
+    int numContextsCopy = 0;
 
     switch (pClient->clientState)
     {
@@ -2834,10 +2837,17 @@ RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer callda
 
     case ClientStateGone:
     case ClientStateRetained: /* client disconnected */
-	for (i = 0; i < numContexts; i++)
+
+        /* RecordDisableContext modifies contents of ppAllContexts. */
+	numContextsCopy = numContexts;
+	ppAllContextsCopy = malloc(numContextsCopy * sizeof(RecordContextPtr));
+	assert(ppAllContextsCopy);
+	memcpy(ppAllContextsCopy, ppAllContexts, numContextsCopy * sizeof(RecordContextPtr));
+
+	for (i = 0; i < numContextsCopy; i++)
 	{
 	    RecordClientsAndProtocolPtr pRCAP;
-	    RecordContextPtr pContext = ppAllContexts[i];
+	    RecordContextPtr pContext = ppAllContextsCopy[i];
 	    int pos;
 
 	    if (pContext->pRecordingClient == pClient)
@@ -2851,6 +2861,8 @@ RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer callda
 		RecordDeleteClientFromRCAP(pRCAP, pos);
 	    }
 	}
+
+	free(ppAllContextsCopy);
     break;
 
     default:
commit 660f6ab5494a728c3ca7ba00c305e9ff06c8ecb2
Author: Simon Farnsworth <simon.farnsworth at onelan.com>
Date:   Tue Jun 22 10:13:30 2010 +0100

    Don't crash when asked if a client that has disconnected was local
    
    ProcDRI2Dispatch uses LocalClient to determine if it's safe to respond
    to a client that has made DRI2 requests which aren't sensible for
    remote clients (anything but version). When the client has disappeared
    mid-request stream (e.g. as a result of a kill -9, or a client-side
    bug), LocalClient causes the X server to follow suit, as
    ((OsCommPtr)client->osPrivate)->trans_conn is NULL at this point.
    
    The simple and obvious fix is to just return "not local" when
    trans_conn is NULL, which fixes the crash I was seeing; however Keith
    Packard pointed out that just checking trans_conn isn't enough;
    quoting Keith:
    
    "This looks almost right to me -- I reviewed the os code to see when
    _XSERVTransClose is called (which is what frees the trans_conn data) and
    found that every place which called that immediately set trans_conn to
    NULL, except for the call in CloseDownFileDescriptor which is only
    called from CloseDownConnection and which is immediately followed by
    freeing the OsCommRec and setting client->osPrivate to NULL. So, I'd
    suggest checking client->osPrivate in addition to the above check."
    
    Signed-off-by: Simon Farnsworth <simon.farnsworth at onelan.com>
    Reviewed-by: Keith Packard <keithp at keithp.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/os/access.c b/os/access.c
index 5f485c9..0279259 100644
--- a/os/access.c
+++ b/os/access.c
@@ -1123,6 +1123,11 @@ Bool LocalClient(ClientPtr client)
     pointer		addr;
     register HOST	*host;
 
+    if (!client->osPrivate)
+        return FALSE;
+    if (!((OsCommPtr)client->osPrivate)->trans_conn)
+        return FALSE;
+
     if (!_XSERVTransGetPeerAddr (((OsCommPtr)client->osPrivate)->trans_conn,
 	&notused, &alen, &from))
     {
commit 82d41ada993d8cbdcdfea878d1a5b031afe4e593
Author: Dave Airlie <airlied at redhat.com>
Date:   Mon Jun 21 16:33:55 2010 +1000

    composite: fix freeing of old pixmap until after move/resize/cbw (bug 28345)
    
    The fixes for the composite reallocation failure, were freeing the oldpixmap
    straight after reallocating the new one, however this led to some wierd
    effects in e16 compositing, and I think in a few other places. This patch
    moves the freeing of the pixmap into the post wrapped stage. I'm not sure if
    we are actually better off breaking ABI and adding another callback from the
    ConfigureWindow to composite to make sure the old pixmap is always freed,
    but this should be satisfactory as we should always hit one of the freeing
    paths or else its a bug in the DIX.
    
    bug: https://bugs.freedesktop.org/show_bug.cgi?id=28435
    
    Reported-by: Andrew Randrianasulu <randrik at mail.ru>
    Signed-off-by: Dave Airlie <airlied at redhat.com>
    Reviewed-by: Keith Packard <keithp at keithp.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/composite/compinit.c b/composite/compinit.c
index 1b2cd8f..5db9f02 100644
--- a/composite/compinit.c
+++ b/composite/compinit.c
@@ -66,6 +66,9 @@ compCloseScreen (int index, ScreenPtr pScreen)
     pScreen->ChangeWindowAttributes = cs->ChangeWindowAttributes;
     pScreen->ReparentWindow = cs->ReparentWindow;
     pScreen->ConfigNotify = cs->ConfigNotify;
+    pScreen->MoveWindow = cs->MoveWindow;
+    pScreen->ResizeWindow = cs->ResizeWindow;
+    pScreen->ChangeBorderWidth = cs->ChangeBorderWidth;
     
     pScreen->ClipNotify = cs->ClipNotify;
     pScreen->UnrealizeWindow = cs->UnrealizeWindow;
@@ -366,6 +369,15 @@ compScreenInit (ScreenPtr pScreen)
     cs->ConfigNotify = pScreen->ConfigNotify;
     pScreen->ConfigNotify = compConfigNotify;
 
+    cs->MoveWindow = pScreen->MoveWindow;
+    pScreen->MoveWindow = compMoveWindow;
+
+    cs->ResizeWindow = pScreen->ResizeWindow;
+    pScreen->ResizeWindow = compResizeWindow;
+
+    cs->ChangeBorderWidth = pScreen->ChangeBorderWidth;
+    pScreen->ChangeBorderWidth = compChangeBorderWidth;
+
     cs->ReparentWindow = pScreen->ReparentWindow;
     pScreen->ReparentWindow = compReparentWindow;
 
diff --git a/composite/compint.h b/composite/compint.h
index 9c1ffd5..80083b0 100644
--- a/composite/compint.h
+++ b/composite/compint.h
@@ -127,9 +127,14 @@ typedef struct _CompScreen {
     UnrealizeWindowProcPtr	UnrealizeWindow;
     ClipNotifyProcPtr		ClipNotify;
     /*
-     * Called from ConfigureWindow.
+     * Called from ConfigureWindow, these
+     * three track changes to the offscreen storage
+     * geometry
      */
     ConfigNotifyProcPtr         ConfigNotify;
+    MoveWindowProcPtr		MoveWindow;
+    ResizeWindowProcPtr		ResizeWindow;
+    ChangeBorderWidthProcPtr	ChangeBorderWidth;
     /*
      * Reparenting has an effect on Subwindows redirect
      */
@@ -281,6 +286,16 @@ void
 compClipNotify (WindowPtr pWin, int dx, int dy);
 
 void
+compMoveWindow (WindowPtr pWin, int x, int y, WindowPtr pSib, VTKind kind);
+
+void
+compResizeWindow (WindowPtr pWin, int x, int y,
+		  unsigned int w, unsigned int h, WindowPtr pSib);
+
+void
+compChangeBorderWidth (WindowPtr pWin, unsigned int border_width);
+
+void
 compReparentWindow (WindowPtr pWin, WindowPtr pPriorParent);
 
 Bool
diff --git a/composite/compwindow.c b/composite/compwindow.c
index 7d877b1..160b764 100644
--- a/composite/compwindow.c
+++ b/composite/compwindow.c
@@ -334,6 +334,65 @@ compImplicitRedirect (WindowPtr pWin, WindowPtr pParent)
     return FALSE;
 }
 
+static void compFreeOldPixmap(WindowPtr pWin)
+{
+    ScreenPtr		pScreen = pWin->drawable.pScreen;
+    if (pWin->redirectDraw != RedirectDrawNone)
+    {
+	CompWindowPtr	cw = GetCompWindow (pWin);
+	if (cw->pOldPixmap)
+	{
+	    (*pScreen->DestroyPixmap) (cw->pOldPixmap);
+	    cw->pOldPixmap = NullPixmap;
+	}
+    }
+}
+void
+compMoveWindow (WindowPtr pWin, int x, int y, WindowPtr pSib, VTKind kind)
+{
+    ScreenPtr		pScreen = pWin->drawable.pScreen;
+    CompScreenPtr	cs = GetCompScreen (pScreen);
+
+    pScreen->MoveWindow = cs->MoveWindow;
+    (*pScreen->MoveWindow) (pWin, x, y, pSib, kind);
+    cs->MoveWindow = pScreen->MoveWindow;
+    pScreen->MoveWindow = compMoveWindow;
+
+    compFreeOldPixmap(pWin);
+    compCheckTree (pScreen);
+}
+
+void
+compResizeWindow (WindowPtr pWin, int x, int y,
+		  unsigned int w, unsigned int h, WindowPtr pSib)
+{
+    ScreenPtr		pScreen = pWin->drawable.pScreen;
+    CompScreenPtr	cs = GetCompScreen (pScreen);
+
+    pScreen->ResizeWindow = cs->ResizeWindow;
+    (*pScreen->ResizeWindow) (pWin, x, y, w, h, pSib);
+    cs->ResizeWindow = pScreen->ResizeWindow;
+    pScreen->ResizeWindow = compResizeWindow;
+
+    compFreeOldPixmap(pWin);
+    compCheckTree (pWin->drawable.pScreen);
+}
+
+void
+compChangeBorderWidth (WindowPtr pWin, unsigned int bw)
+{
+    ScreenPtr		pScreen = pWin->drawable.pScreen;
+    CompScreenPtr	cs = GetCompScreen (pScreen);
+
+    pScreen->ChangeBorderWidth = cs->ChangeBorderWidth;
+    (*pScreen->ChangeBorderWidth) (pWin, bw);
+    cs->ChangeBorderWidth = pScreen->ChangeBorderWidth;
+    pScreen->ChangeBorderWidth = compChangeBorderWidth;
+
+    compFreeOldPixmap(pWin);
+    compCheckTree (pWin->drawable.pScreen);
+}
+
 void
 compReparentWindow (WindowPtr pWin, WindowPtr pPriorParent)
 {
@@ -705,7 +764,6 @@ compConfigNotify(WindowPtr pWin, int x, int y, int w, int h,
     CompScreenPtr	cs = GetCompScreen (pScreen);
     Bool                ret = 0;
     WindowPtr		pParent = pWin->parent;
-    CompWindowPtr       cw;
     int			draw_x, draw_y;
     Bool alloc_ret;
 
@@ -728,14 +786,6 @@ compConfigNotify(WindowPtr pWin, int x, int y, int w, int h,
     draw_x = pParent->drawable.x + x + bw;
     draw_y = pParent->drawable.y + y + bw;
     alloc_ret = compReallocPixmap (pWin, draw_x, draw_y, w, h, bw);
-    
-    cw = GetCompWindow (pWin);
-    if (cw->pOldPixmap)
-    {
-	(*pScreen->DestroyPixmap) (cw->pOldPixmap);
-	cw->pOldPixmap = NullPixmap;
-    }
-    compCheckTree (pScreen);
 
     if (alloc_ret == FALSE)
 	return BadAlloc;
commit c6bc52cb6663138d1273447cb7661fa6e958f539
Author: Dave Airlie <airlied at redhat.com>
Date:   Mon Jun 21 14:08:50 2010 +1000

    dri2: avoid crash with old dri drivers.
    
    I built latest server and copied over a mesa 7.8 dri2 driver to use with it,
    and it crashed in here starting compiz. Looks like we need to validate the
    flush extension is registered before calling invalidate.
    
    Signed-off-by: Dave Airlie <airlied at redhat.com>
    Reviewed-by: Michel Dänzer <michel at daenzer.net>
    Reviewed-by: Keith Packard <keithp at keithp.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/glx/glxdri2.c b/glx/glxdri2.c
index 177c73c..970a51a 100644
--- a/glx/glxdri2.c
+++ b/glx/glxdri2.c
@@ -435,7 +435,8 @@ __glXDRIinvalidateBuffers(DrawablePtr pDraw, void *priv)
     __GLXDRIdrawable *private = priv;
     __GLXDRIscreen *screen = private->screen;
 
-    (*screen->flush->invalidate)(private->driDrawable);
+    if (screen->flush)
+	(*screen->flush->invalidate)(private->driDrawable);
 #endif
 }
 
commit 80d1a548d6ce73c2ff097536c1bc7044bf74965d
Author: Dave Airlie <airlied at redhat.com>
Date:   Mon Jun 21 10:05:08 2010 +1000

    rotation: fix cursor and overlap of one pixel.
    
    Commit 77c7a64e8885696665556c9fbcb3cffb552e367a was introduced to fix
    a cursor off by one on Intel hw, however it also move the whole crtc
    into an off by one position and you could see gnom-eshell overlapping.
    
    This commit reverts that and instead fixes the cursor hotspot
    translation to work like pixman does. We add 0.5 to the cursor vector
    before translating, and floor the value afterwards.
    
    Thanks to Soeren (ssp) for pointing out where the real problem was
    after explaning how pixman translates points.
    
    Signed-off-by: Dave Airlie <airlied at redhat.com>
    Reviewed-by: Keith Packard <keithp at keithp.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/hw/xfree86/modes/xf86Cursors.c b/hw/xfree86/modes/xf86Cursors.c
index 038f1c8..6b2ae97 100644
--- a/hw/xfree86/modes/xf86Cursors.c
+++ b/hw/xfree86/modes/xf86Cursors.c
@@ -325,10 +325,13 @@ xf86_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
 						  xf86CursorScreenKey);
 	struct pict_f_vector   v;
 
-	v.v[0] = x + ScreenPriv->HotX; v.v[1] = y + ScreenPriv->HotY; v.v[2] = 1;
+	v.v[0] = (x + ScreenPriv->HotX) + 0.5;
+	v.v[1] = (y + ScreenPriv->HotY) + 0.5;
+	v.v[2] = 1;
 	pixman_f_transform_point (&crtc->f_framebuffer_to_crtc, &v);
-	x = floor (v.v[0] + 0.5);
-	y = floor (v.v[1] + 0.5);
+	/* cursor will have 0.5 added to it already so floor is sufficent */
+	x = floor (v.v[0]);
+	y = floor (v.v[1]);
 	/*
 	 * Transform position of cursor upper left corner
 	 */
diff --git a/randr/rrtransform.c b/randr/rrtransform.c
index a470e1e..e162049 100644
--- a/randr/rrtransform.c
+++ b/randr/rrtransform.c
@@ -183,21 +183,21 @@ RRTransformCompute (int			    x,
 	    break;
 	case RR_Rotate_90:
 	    f_rot_cos = 0;	    f_rot_sin = 1;
-	    f_rot_dx  = height-1;   f_rot_dy  = 0;
+	    f_rot_dx  = height;	    f_rot_dy  = 0;
 	    rot_cos = F ( 0);	    rot_sin = F ( 1);
-	    rot_dx =  F (height-1); rot_dy  = F (0);
+	    rot_dx =  F ( height);  rot_dy  = F (0);
 	    break;
 	case RR_Rotate_180:
 	    f_rot_cos = -1;	    f_rot_sin = 0;
-	    f_rot_dx  = width - 1;  f_rot_dy  = height - 1;
+	    f_rot_dx  = width;	    f_rot_dy  = height;
 	    rot_cos = F (-1);	    rot_sin = F ( 0);
-	    rot_dx  = F (width-1);  rot_dy  = F ( height-1);
+	    rot_dx  = F (width);   rot_dy  = F ( height);
 	    break;
 	case RR_Rotate_270:
 	    f_rot_cos = 0;	    f_rot_sin = -1;
-	    f_rot_dx  = 0;	    f_rot_dy  = width-1;
+	    f_rot_dx  = 0;	    f_rot_dy  = width;
 	    rot_cos = F ( 0);	    rot_sin = F (-1);
-	    rot_dx  = F ( 0);	    rot_dy  = F ( width-1);
+	    rot_dx  = F ( 0);	    rot_dy  = F ( width);
 	    break;
 	}
 	
@@ -220,11 +220,11 @@ RRTransformCompute (int			    x,
 	    f_scale_x = -1;
 	    scale_x = F(-1);
 	    if (rotation & (RR_Rotate_0|RR_Rotate_180)) {
-		f_scale_dx = width-1;
-		scale_dx = F(width-1);
+		f_scale_dx = width;
+		scale_dx = F(width);
 	    } else {
-		f_scale_dx = height-1;
-		scale_dx = F(height-1);
+		f_scale_dx = height;
+		scale_dx = F(height);
 	    }
 	}
 	if (rotation & RR_Reflect_Y)
@@ -232,11 +232,11 @@ RRTransformCompute (int			    x,
 	    f_scale_y = -1;
 	    scale_y = F(-1);
 	    if (rotation & (RR_Rotate_0|RR_Rotate_180)) {
-		f_scale_dy = height-1;
-		scale_dy = F(height-1);
+		f_scale_dy = height;
+		scale_dy = F(height);
 	    } else {
-		f_scale_dy = width-1;
-		scale_dy = F(width-1);
+		f_scale_dy = width;
+		scale_dy = F(width);
 	    }
 	}
 	
commit 32c706c4ffd7433dbfc79dba8785b1510d2f053f
Author: Gaetan Nadon <memsize at videotron.ca>
Date:   Sun Jun 20 20:37:26 2010 -0400

    config: declare xserver private dependencies in xorg-server.pc
    
    Any module (drivers) depending on xserver also depends on some of the
    server private dependencies. Any driver including xf86.h depends on
    xext, kbproto, inputproto and randr.
    
    These dependencies are in separate packages, so anything can happen,
    removal, wrong version, etc... and the driver fails during compilation.
    Having the private dependencies declared will ensure all packages the
    server depends on are present and at the correct version.
    
    Currently each module attempts to check for server dependencies with
    various degrees of accuracy. With this patch, the driver will only need
    to check for its own explicit dependencies.
    
    Now that xproto is included in Requires.private it is removed from Requires.
    All the cflags from both Requires and Requires.private are returned
    to caller to pkg-config.
    
    Reviewed-by: Dan Nicholson <dbn.lists at gmail.com>
    Signed-off-by: Gaetan Nadon <memsize at videotron.ca>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/configure.ac b/configure.ac
index d41191f..004a0a4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -793,9 +793,13 @@ WINDOWSWMPROTO="windowswmproto"
 APPLEWMPROTO="applewmproto >= 1.4"
 
 dnl Core modules for most extensions, et al.
-REQUIRED_MODULES="[randrproto >= 1.2.99.3] [renderproto >= 0.11] [fixesproto >= 4.1] [damageproto >= 1.1] [xcmiscproto >= 1.2.0] [xextproto >= 7.0.99.3] [xproto >= 7.0.17] [xtrans >= 1.2.2] [bigreqsproto >= 1.1.0] fontsproto [inputproto >= 1.9.99.902] [kbproto >= 1.0.3]"
+SDK_REQUIRED_MODULES="[xproto >= 7.0.17] [randrproto >= 1.2.99.3] [renderproto >= 0.11] [xextproto >= 7.0.99.3] [inputproto >= 1.9.99.902] [kbproto >= 1.0.3] fontsproto"
+REQUIRED_MODULES="[fixesproto >= 4.1] [damageproto >= 1.1] [xcmiscproto >= 1.2.0] [xtrans >= 1.2.2] [bigreqsproto >= 1.1.0] $SDK_REQUIRED_MODULES"
 REQUIRED_LIBS="xfont xau"
 
+# Make SDK_REQUIRED_MODULES available for inclusion in xorg-server.pc
+AC_SUBST(SDK_REQUIRED_MODULES)
+
 dnl List of libraries that require a specific version
 LIBAPPLEWM="applewm >= 1.4"
 LIBDMX="dmx >= 1.0.99.1"
@@ -947,6 +951,7 @@ if test "x$XV" = xyes; then
 	AC_DEFINE(XV, 1, [Support Xv extension])
 	AC_DEFINE(XvExtension, 1, [Build Xv extension])
 	REQUIRED_MODULES="$REQUIRED_MODULES $VIDEOPROTO"
+	SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $VIDEOPROTO"
 else
 	XVMC=no
 fi
@@ -1036,6 +1041,7 @@ case "$DRI2,$HAVE_DRI2PROTO" in
 	yes,yes | auto,yes)
 		AC_DEFINE(DRI2, 1, [Build DRI2 extension])
 		DRI2=yes
+		SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $DRI2PROTO"
 		;;
 esac
 AM_CONDITIONAL(DRI2, test "x$DRI2" = xyes)
@@ -1074,6 +1080,7 @@ if test "x$XINERAMA" = xyes; then
 	AC_DEFINE(XINERAMA, 1, [Support Xinerama extension])
 	AC_DEFINE(PANORAMIX, 1, [Internal define for Xinerama])
 	REQUIRED_MODULES="$REQUIRED_MODULES $XINERAMAPROTO"
+	SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $XINERAMAPROTO"
 fi
 
 AM_CONDITIONAL(XACE, [test "x$XACE" = xyes])
diff --git a/xorg-server.pc.in b/xorg-server.pc.in
index 44f886a..fb238b5 100644
--- a/xorg-server.pc.in
+++ b/xorg-server.pc.in
@@ -15,6 +15,7 @@ abi_extension=@abi_extension@
 Name: xorg-server
 Description: Modular X.Org X Server
 Version: @PACKAGE_VERSION@
-Requires: pixman-1 pciaccess xproto >= 7.0.17
+Requires: pixman-1 pciaccess
+Requires.private: @SDK_REQUIRED_MODULES@
 Cflags: -I${sdkdir} @symbol_visibility@
 Libs: -L${libdir}
commit 37734ba79ca3a9bad1c1e29d89710c8f9c299210
Author: Colin Harrison <colin.harrison at virgin.net>
Date:   Wed Jun 16 18:07:04 2010 +0100

    XWin: Fixes for devPrivates API change
    
    Fix some typos in devPrivates API changes in XWin code.
    Move allocation of private keys as it's no longer valid to do them during OsVendorInit()
    
    Signed-off-by: Jon TURNEY <jon.turney at dronecode.org.uk>
    Reviewed-by: Jamey Sharp <jamey at minilop.net>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/hw/xwin/win.h b/hw/xwin/win.h
index 05913d7..8c4b67f 100644
--- a/hw/xwin/win.h
+++ b/hw/xwin/win.h
@@ -631,7 +631,7 @@ extern int			g_fdMessageQueue;
 extern DevPrivateKeyRec		g_iScreenPrivateKeyRec;
 #define g_iScreenPrivateKey  	(&g_iScreenPrivateKeyRec)
 extern DevPrivateKeyRec		g_iCmapPrivateKeyRec;
-#define g_iCmapPrivateKeyRec 	(&g_iCmapPrivateKeyRec)
+#define g_iCmapPrivateKey 	(&g_iCmapPrivateKeyRec)
 extern DevPrivateKeyRec		g_iGCPrivateKeyRec;
 #define g_iGCPrivateKey 	(&g_iGCPrivateKeyRec)
 extern DevPrivateKeyRec		g_iPixmapPrivateKeyRec;
diff --git a/hw/xwin/winallpriv.c b/hw/xwin/winallpriv.c
index 6ecbff6..ef42d71 100644
--- a/hw/xwin/winallpriv.c
+++ b/hw/xwin/winallpriv.c
@@ -74,25 +74,32 @@ winAllocatePrivates (ScreenPtr pScreen)
   /* Intialize private structure members */
   pScreenPriv->fActive = TRUE;
 
+  /* Register our screen private */
+  if (!dixRegisterPrivateKey(g_iScreenPrivateKey, PRIVATE_SCREEN, 0))
+    {
+      ErrorF ("winAllocatePrivates - AllocateScreenPrivate () failed\n");
+      return FALSE;
+    }
+
   /* Save the screen private pointer */
   winSetScreenPriv (pScreen, pScreenPriv);
 
   /* Reserve GC memory for our privates */
-  if (!dixRequestPrivateKey(g_iGCPrivateKey, PRIVATE_GC, sizeof (winPrivGCRec)))
+  if (!dixRegisterPrivateKey(g_iGCPrivateKey, PRIVATE_GC, sizeof (winPrivGCRec)))
     {
       ErrorF ("winAllocatePrivates - AllocateGCPrivate () failed\n");
       return FALSE;
     }
 
   /* Reserve Pixmap memory for our privates */
-  if (!dixRequestPrivateKey(g_iPixmapPrivateKey, PRIVATE_PIXMAP, sizeof (winPrivPixmapRec)))
+  if (!dixRegisterPrivateKey(g_iPixmapPrivateKey, PRIVATE_PIXMAP, sizeof (winPrivPixmapRec)))
     {
       ErrorF ("winAllocatePrivates - AllocatePixmapPrivates () failed\n");
       return FALSE;
     }
 
   /* Reserve Window memory for our privates */
-  if (!dixRequestPrivateKey(g_iWindowPrivateKey, PRIVATE_WINDOW, sizeof (winPrivWinRec)))
+  if (!dixRegisterPrivateKey(g_iWindowPrivateKey, PRIVATE_WINDOW, sizeof (winPrivWinRec)))
     {
       ErrorF ("winAllocatePrivates () - AllocateWindowPrivates () failed\n");
        return FALSE;
@@ -161,6 +168,13 @@ winAllocateCmapPrivates (ColormapPtr pCmap)
   /* Initialize the memory of the private structure */
   ZeroMemory (pCmapPriv, sizeof (winPrivCmapRec));
 
+  /* Register our colourmap private */
+  if (!dixRegisterPrivateKey(g_iCmapPrivateKey, PRIVATE_COLORMAP, 0))
+    {
+      ErrorF ("winAllocateCmapPrivates - AllocateCmapPrivate () failed\n");
+      return FALSE;
+    }
+
   /* Save the cmap private pointer */
   winSetCmapPriv (pCmap, pCmapPriv);
 
diff --git a/hw/xwin/winglobals.c b/hw/xwin/winglobals.c
index 2cc53f2..f3f01d7 100644
--- a/hw/xwin/winglobals.c
+++ b/hw/xwin/winglobals.c
@@ -126,13 +126,6 @@ Atom			g_atomLastOwnedSelection = None;
 void
 winInitializeGlobals (void)
 {
-  if (!dixRegisterPrivateKey(&g_iScreenPrivateKeyRec, PRIVATE_SCREEN, 0) ||
-      !dixRegisterPrivateKey(&g_iCmapPrivateKeyRec, PRIVATE_COLORMAP, 0) ||
-      !dixRegisterPrivateKey(&g_iGCPrivateKeyRec, PRIVATE_GC, 0) ||
-      !dixRegisterPrivateKey(&g_iPixmapPrivateKeyRec, PRIVATE_PIXMAP, 0) ||
-      !dixRegisterPrivateKey(&g_iWindowPrivateKeyRec, PRIVATE_WINDOW, 0)) {
-      FatalError("cannot register private key");
-  }
   g_dwCurrentThreadID = GetCurrentThreadId ();
   g_hwndKeyboardFocus = NULL;
 #ifdef XWIN_CLIPBOARD
commit f7dae972aac28c5792566e997c40254e787d246a
Author: Ville Syrjälä <ville.syrjala at nokia.com>
Date:   Tue Jun 15 23:25:34 2010 +0300

    xv: Don't send port notify when SetPortAttribute fails
    
    Currently a port notify event is sent even if SetPortAttribute
    fails. Furthermore the value field in the event will contain the
    value that was specified in the failed request. So any client
    interested in the actual value of the attribute will have to
    double check the current value with GetPortAttribute after
    receiving a port notify event.
    
    Fix the problem by sending port notifications only when
    SetPortAttribute succeeds.
    
    Signed-off-by: Ville Syrjälä <ville.syrjala at nokia.com>
    Reviewed-by: Keith Packard <keithp at keithp.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/Xext/xvmain.c b/Xext/xvmain.c
index 1b80b12..12b4c51 100644
--- a/Xext/xvmain.c
+++ b/Xext/xvmain.c
@@ -1133,12 +1133,13 @@ XvdiSetPortAttribute(
   Atom attribute,
   INT32 value
 ){
+  int status;
 
+  status = (* pPort->pAdaptor->ddSetPortAttribute)(client, pPort, attribute, value);
+  if (status == Success)
     XvdiSendPortNotify(pPort, attribute, value);
 
-  return 
-    (* pPort->pAdaptor->ddSetPortAttribute)(client, pPort, attribute, value);
-
+  return status;
 }
 
 int
commit c20166739603f86888f28ca2c65f5cf474d0d8c9
Author: Mikhail Gusarov <dottedmag at dottedmag.net>
Date:   Sat Jun 12 01:05:07 2010 +0700

    os: Remove unused dev_tty_from_init variable
    
    Signed-off-by: Mikhail Gusarov <dottedmag at dottedmag.net>
    Reviewed-by: Jamey Sharp <jamey at minilop.net>

diff --git a/os/utils.c b/os/utils.c
index f6bcecb..51455cc 100644
--- a/os/utils.c
+++ b/os/utils.c
@@ -205,8 +205,6 @@ int auditTrailLevel = 1;
 #define HAS_SAVED_IDS_AND_SETEUID
 #endif
 
-static char *dev_tty_from_init = NULL;	/* since we need to parse it anyway */
-
 OsSigHandlerPtr
 OsSignal(int sig, OsSigHandlerPtr handler)
 {
@@ -879,8 +877,7 @@ ProcessCommandLine(int argc, char *argv[])
 	}
 	else if (strncmp (argv[i], "tty", 3) == 0)
 	{
-	    /* just in case any body is interested */
-	    dev_tty_from_init = argv[i];
+            /* init supplies us with this useless information */
 	}
 #ifdef XDMCP
 	else if ((skip = XdmcpOptions(argc, argv, i)) != i)
commit 2e15f1903dac8473285ad2937c079a08cf7c5d31
Author: Mikhail Gusarov <dottedmag at dottedmag.net>
Date:   Sat Jun 12 00:53:38 2010 +0700

    os: Remove unused pread/pwrite/lockit functions
    
    Signed-off-by: Mikhail Gusarov <dottedmag at dottedmag.net>
    Reviewed-by: Jamey Sharp <jamey at minilop.net>

diff --git a/os/utils.c b/os/utils.c
index 92bfad3..f6bcecb 100644
--- a/os/utils.c
+++ b/os/utils.c
@@ -1858,53 +1858,3 @@ error:
     free(list);
     return NULL;
 }
-
-#ifdef __SCO__
-#include <fcntl.h>
-
-static void
-lockit (int fd, short what)
-{
-  struct flock lck;
-
-  lck.l_whence = 0;
-  lck.l_start = 0;
-  lck.l_len = 1;
-  lck.l_type = what;
-
-  (void)fcntl (fd, F_SETLKW, &lck);
-}
-
-/* SCO OpenServer 5 lacks pread/pwrite. Emulate them. */
-ssize_t
-pread (int fd, void *buf, size_t nbytes, off_t offset)
-{
-  off_t saved;
-  ssize_t ret;
-
-  lockit (fd, F_RDLCK);
-  saved = lseek (fd, 0, SEEK_CUR);
-  lseek (fd, offset, SEEK_SET);
-  ret = read (fd, buf, nbytes);
-  lseek (fd, saved, SEEK_SET);
-  lockit (fd, F_UNLCK);
-
-  return ret;
-}
-
-ssize_t
-pwrite (int fd, const void *buf, size_t nbytes, off_t offset)
-{
-  off_t saved;
-  ssize_t ret;
-
-  lockit (fd, F_WRLCK);
-  saved = lseek (fd, 0, SEEK_CUR);
-  lseek (fd, offset, SEEK_SET);
-  ret = write (fd, buf, nbytes);
-  lseek (fd, saved, SEEK_SET);
-  lockit (fd, F_UNLCK);
-
-  return ret;
-}
-#endif /* __SCO__ */
commit 9120e58556014e514eef9dfe43cdea4b74dc66ae
Author: Mikhail Gusarov <dottedmag at dottedmag.net>
Date:   Sat Jun 12 00:30:27 2010 +0700

    mi: Remove unused overlay support
    
    The only reference to it in server and drivers is in XAA overlay code which
    would segfault as no miInitOverlay is called ever. No segfaults were observed
    "in wild", so XAA overlay is probably also unused.
    
    XAA code is modified to act as if miOverlayCopyUnderlay always returned false,
    because XAACopyWindow8_32 could only set doUnderlay to true if it's called from
    miOverlayMoveWindow or miOverlayResizeWindow, which can only be called if
    miInitOverlay has hooked those functions, and no driver (on fd.o) or server code
    calls that.
    
    Signed-off-by: Mikhail Gusarov <dottedmag at dottedmag.net>
    Reviewed-by: Jamey Sharp <jamey at minilop.net>

diff --git a/hw/xfree86/loader/sdksyms.sh b/hw/xfree86/loader/sdksyms.sh
index 13c5ae5..4245031 100755
--- a/hw/xfree86/loader/sdksyms.sh
+++ b/hw/xfree86/loader/sdksyms.sh
@@ -231,7 +231,6 @@ cat > sdksyms.c << EOF
 #include "miwideline.h"
 #include "mistruct.h"
 #include "mifpoly.h"
-#include "mioverlay.h"
 
 
 /* randr/Makefile.am */
diff --git a/hw/xfree86/xaa/xaaOverlay.c b/hw/xfree86/xaa/xaaOverlay.c
index 4b52bf6..58c4a58 100644
--- a/hw/xfree86/xaa/xaaOverlay.c
+++ b/hw/xfree86/xaa/xaaOverlay.c
@@ -16,7 +16,6 @@
 #include "xaawrap.h"
 #include "gcstruct.h"
 #include "pixmapstr.h"
-#include "mioverlay.h"
 
 #ifdef PANORAMIX
 #include "panoramiX.h"
@@ -37,7 +36,6 @@ XAACopyWindow8_32(
     ScreenPtr pScreen = pWin->drawable.pScreen;
     XAAInfoRecPtr infoRec = 
 	GET_XAAINFORECPTR_FROM_DRAWABLE((&pWin->drawable));
-    Bool doUnderlay = miOverlayCopyUnderlay(pScreen);
     RegionPtr borderClip = &pWin->borderClip;
     Bool freeReg = FALSE;
 
@@ -56,9 +54,6 @@ XAACopyWindow8_32(
 
     pwinRoot = pScreen->root;
 
-    if(doUnderlay)
-	freeReg = miOverlayCollectUnderlayRegions(pWin, &borderClip);
-
     RegionNull(&rgnDst);
 
     dx = ptOldOrg.x - pWin->drawable.x;
@@ -81,7 +76,7 @@ XAACopyWindow8_32(
 	ppt++; pbox++;
     }
     
-    infoRec->ScratchGC.planemask = doUnderlay ? 0x00ffffff : 0xff000000;
+    infoRec->ScratchGC.planemask = 0xff000000;
     infoRec->ScratchGC.alu = GXcopy;
 
     XAADoBitBlt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
@@ -93,25 +88,6 @@ XAACopyWindow8_32(
 	RegionDestroy(borderClip);
 }
 
-static void
-XAASetColorKey8_32(
-    ScreenPtr pScreen,
-    int nbox,
-    BoxPtr pbox
-){
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr pScrn = infoRec->pScrn;
-
-    /* I'm counting on writes being clipped away while switched away.
-       If this isn't going to be true then I need to be wrapping instead. */
-    if(!infoRec->pScrn->vtSema) return;
-
-    (*infoRec->FillSolidRects)(pScrn, pScrn->colorKey << 24, GXcopy, 
-					0xff000000, nbox, pbox);
-  
-    SET_SYNC_FLAG(infoRec);
-}
-
 void
 XAASetupOverlay8_32Planar(ScreenPtr pScreen)
 {
@@ -120,9 +96,6 @@ XAASetupOverlay8_32Planar(ScreenPtr pScreen)
 
     pScreen->CopyWindow = XAACopyWindow8_32;
 
-    if(!(infoRec->FillSolidRectsFlags & NO_PLANEMASK))
-	miOverlaySetTransFunction(pScreen, XAASetColorKey8_32);
-
     infoRec->FullPlanemask = ~0;
     for(i = 0; i < 32; i++) /* haven't thought about this much */
 	infoRec->FullPlanemasks[i] = ~0;
diff --git a/mi/Makefile.am b/mi/Makefile.am
index f6dabda..8319226 100644
--- a/mi/Makefile.am
+++ b/mi/Makefile.am
@@ -3,7 +3,7 @@ noinst_LTLIBRARIES = libmi.la
 if XORG
 sdk_HEADERS = micmap.h miline.h mipointer.h mi.h mibstore.h \
               migc.h mipointrst.h mizerarc.h micoord.h mifillarc.h \
-              mispans.h miwideline.h mistruct.h mifpoly.h mioverlay.h
+              mispans.h miwideline.h mistruct.h mifpoly.h
 endif
 
 AM_CFLAGS = $(DIX_CFLAGS)
@@ -33,8 +33,6 @@ libmi_la_SOURCES = 	\
 	migc.h		\
 	miglblt.c	\
 	miline.h	\
-	mioverlay.c	\
-	mioverlay.h	\
 	mipointer.c	\
 	mipointer.h	\
 	mipointrst.h	\
diff --git a/mi/mioverlay.c b/mi/mioverlay.c
deleted file mode 100644
index 766c5e7..0000000
--- a/mi/mioverlay.c
+++ /dev/null
@@ -1,1946 +0,0 @@
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include <X11/extensions/shapeproto.h>
-#include "validate.h"
-#include "windowstr.h"
-#include "mi.h"
-#include "gcstruct.h"
-#include "regionstr.h"
-#include "privates.h"
-#include "mivalidate.h"
-#include "mioverlay.h"
-#include "migc.h"
-
-#include "globals.h"
-
-
-typedef struct {
-   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;
-} miOverlayTreeRec, *miOverlayTreePtr;
-
-typedef struct {
-   miOverlayTreePtr	tree;
-} miOverlayWindowRec, *miOverlayWindowPtr;
-
-typedef struct {
-   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);
-static Bool HasUnderlayChildren(WindowPtr);
-static void MarkUnderlayWindow(WindowPtr);
-static Bool CollectUnderlayChildrenRegions(WindowPtr, RegionPtr);
-
-static Bool miOverlayCloseScreen(int, ScreenPtr);
-static Bool miOverlayCreateWindow(WindowPtr);
-static Bool miOverlayDestroyWindow(WindowPtr);
-static Bool miOverlayUnrealizeWindow(WindowPtr);
-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 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);
-static void miOverlayClearToBackground(WindowPtr, int, int, int, int, Bool);
-
-static void miOverlaySetShape(WindowPtr, int);
-static void miOverlayChangeBorderWidth(WindowPtr, unsigned int);
-
-#define MIOVERLAY_GET_SCREEN_PRIVATE(pScreen) ((miOverlayScreenPtr) \
-	dixLookupPrivate(&(pScreen)->devPrivates, miOverlayScreenKey))
-#define MIOVERLAY_GET_WINDOW_PRIVATE(pWin) ((miOverlayWindowPtr) \
-	dixLookupPrivate(&(pWin)->devPrivates, miOverlayWindowKey))
-#define MIOVERLAY_GET_WINDOW_TREE(pWin) \
-	(MIOVERLAY_GET_WINDOW_PRIVATE(pWin)->tree)
-
-#define IN_UNDERLAY(w) MIOVERLAY_GET_WINDOW_TREE(w)
-#define IN_OVERLAY(w) !MIOVERLAY_GET_WINDOW_TREE(w)
-
-#define MARK_OVERLAY(w) miMarkWindow(w)
-#define MARK_UNDERLAY(w) MarkUnderlayWindow(w)
-
-#define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
-                                    HasBorder(w) && \
-                                    (w)->backgroundState == ParentRelative)
-
-Bool
-miInitOverlay(
-    ScreenPtr pScreen, 
-    miOverlayInOverlayFunc inOverlayFunc,
-    miOverlayTransFunc transFunc
-){
-    miOverlayScreenPtr	pScreenPriv;
-
-    if(!inOverlayFunc || !transFunc) return FALSE;
-
-    if(!dixRegisterPrivateKey(&miOverlayWindowKeyRec, PRIVATE_WINDOW, sizeof(miOverlayWindowRec)))
-	return FALSE;
-
-    if(!dixRegisterPrivateKey(&miOverlayScreenKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
-
-    if(!(pScreenPriv = malloc(sizeof(miOverlayScreenRec))))
-	return FALSE;
-
-    dixSetPrivate(&pScreen->devPrivates, miOverlayScreenKey, pScreenPriv);
-
-    pScreenPriv->InOverlay = inOverlayFunc;
-    pScreenPriv->MakeTransparent = transFunc;
-    pScreenPriv->underlayMarked = FALSE;
-
-
-    pScreenPriv->CloseScreen = pScreen->CloseScreen;
-    pScreenPriv->CreateWindow = pScreen->CreateWindow;
-    pScreenPriv->DestroyWindow = pScreen->DestroyWindow;
-    pScreenPriv->UnrealizeWindow = pScreen->UnrealizeWindow;
-    pScreenPriv->RealizeWindow = pScreen->RealizeWindow;
-
-    pScreen->CloseScreen = miOverlayCloseScreen;
-    pScreen->CreateWindow = miOverlayCreateWindow;
-    pScreen->DestroyWindow = miOverlayDestroyWindow;
-    pScreen->UnrealizeWindow = miOverlayUnrealizeWindow;
-    pScreen->RealizeWindow = miOverlayRealizeWindow;
-
-    pScreen->ReparentWindow = miOverlayReparentWindow;
-    pScreen->RestackWindow = miOverlayRestackWindow;
-    pScreen->MarkOverlappedWindows = miOverlayMarkOverlappedWindows;
-    pScreen->MarkUnrealizedWindow = miOverlayMarkUnrealizedWindow;
-    pScreen->ValidateTree = miOverlayValidateTree;
-    pScreen->HandleExposures = miOverlayHandleExposures;
-    pScreen->MoveWindow = miOverlayMoveWindow;
-    pScreen->WindowExposures = miOverlayWindowExposures;
-    pScreen->ResizeWindow = miOverlayResizeWindow;
-    pScreen->MarkWindow = miOverlayMarkWindow;
-    pScreen->ClearToBackground = miOverlayClearToBackground;
-    pScreen->SetShape = miOverlaySetShape;
-    pScreen->ChangeBorderWidth = miOverlayChangeBorderWidth;
-
-    return TRUE;
-}
-
-
-static Bool 
-miOverlayCloseScreen(int i, ScreenPtr 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;
-
-   free(pScreenPriv);
-
-   return (*pScreen->CloseScreen)(i, pScreen);
-}
-
-
-static Bool 
-miOverlayCreateWindow(WindowPtr pWin)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
-    miOverlayWindowPtr pWinPriv = MIOVERLAY_GET_WINDOW_PRIVATE(pWin);
-    miOverlayTreePtr pTree = NULL;
-    Bool result = TRUE;
-
-    pWinPriv->tree = NULL;
-
-    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 (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 
-miOverlayDestroyWindow(WindowPtr pWin)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
-    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(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(pScreenPriv->DestroyWindow) {
-	pScreen->DestroyWindow = pScreenPriv->DestroyWindow;
-	result = (*pScreen->DestroyWindow)(pWin);
-	pScreen->DestroyWindow = miOverlayDestroyWindow;
-    }
-
-    return result;
-}
-
-static Bool 
-miOverlayUnrealizeWindow(WindowPtr pWin)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
-    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
-    Bool result = TRUE;
-
-    if(pTree) pTree->visibility = VisibilityNotViewable;
-
-    if(pScreenPriv->UnrealizeWindow) {
-	pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow;
-	result = (*pScreen->UnrealizeWindow)(pWin);
-	pScreen->UnrealizeWindow = miOverlayUnrealizeWindow;
-    }
-
-    return result;
-}
-
-
-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;
-    }
-
-    /* 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);
-    }
-
-    return result;
-}
-
-
-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);
-    }	
-}
-
-static void 
-miOverlayRestackWindow(WindowPtr pWin, WindowPtr oldNextSib)
-{
-    if(IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) {
-	/* This could probably be more optimal */
-	RebuildTree(pWin);
-    }	
-}
-
-
-static Bool
-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! */
-
-    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(doUnderlay && IN_UNDERLAY(pChild))
-		pTree = MIOVERLAY_GET_WINDOW_TREE(pChild);
-
-	    if(pChild->viewable) {
-                if (RegionBroken(&pChild->winSize))
-                    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;
-	    }
-	}
-    }
-   
-    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);
-                if (RegionBroken(&tChild->pWin->borderSize))
-		    SetBorderSize (tChild->pWin);
-
-		if(RegionContainsRect(&(tChild->pWin->borderSize), box))
-	        {
-		    MARK_UNDERLAY(tChild->pWin);
-		    underMarked = TRUE;
-	        }
-	    }
-
-	    if(tChild->lastChild) {
-		tChild = tChild->lastChild;
-		continue;
-	    }
-
-	    while(!tChild->prevSib && (tChild != tLast))
-		tChild = tChild->parent;
-
-	    if(tChild == tLast) break;
-
-	    tChild = tChild->prevSib;
-	}
-    }
-
-    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
-){
-    ScreenPtr pScreen = pParent->drawable.pScreen;
-    int oldVis, newVis, dx, dy;
-    BoxRec borderSize;
-    RegionPtr borderVisible;
-    RegionRec childUniverse, childUnion;
-    miOverlayTreePtr tParent = MIOVERLAY_GET_WINDOW_TREE(pParent);
-    miOverlayTreePtr tChild;
-    Bool overlap;
-
-    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;
-    borderSize.x2 = dx;
-    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;
-    }
-    tParent->visibility = newVis;
-
-    dx = pParent->drawable.x - tParent->valdata->oldAbsCorner.x;
-    dy = pParent->drawable.y - tParent->valdata->oldAbsCorner.y;
-
-    switch (kind) {
-    case VTMap:
-    case VTStack:
-    case VTUnmap:
-	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 (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 */
-    default:
-    	if (dx || dy)  {
-	    RegionTranslate(&tParent->borderClip, dx, dy);
-	    RegionTranslate(&tParent->clipList, dx, dy);
-    	} 
-	break;
-    case VTBroken:
-	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);
-    }
-    else
-	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);
-    }
-    else if (newVis != VisibilityFullyObscured &&
-	     newVis != VisibilityNotViewable)
-    {
-	RegionSubtract(&tParent->valdata->exposed,
-			       universe, &tParent->clipList);
-    }
-    
-    /* HACK ALERT - copying contents of regions, instead of regions */
-    {
-	RegionRec   tmp;
-
-	tmp = tParent->clipList;
-	tParent->clipList = *universe;
-	*universe = tmp;
-    }
-
-    pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-
-    if (pScreen->ClipNotify)
-        (* pScreen->ClipNotify) (pParent, dx, dy);
-}
-
-
-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(pTree) {
-	MARK_UNDERLAY(pTree->parent->pWin);
-	MIOVERLAY_GET_SCREEN_PRIVATE(
-		pWin->drawable.pScreen)->underlayMarked = TRUE;
-    }
-}
-
-static void
-miOverlayMarkUnrealizedWindow(
-    WindowPtr pChild,
-    WindowPtr pWin,
-    Bool fromConfigure
-){
-    if ((pChild != pWin) || fromConfigure) {
-	miOverlayTreePtr pTree;
-
-        RegionEmpty(&pChild->clipList);
-        if (pChild->drawable.pScreen->ClipNotify)
-            (* 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);
-	    }
-	}
-    }
-}
-
-
-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;
-    miOverlayTreePtr tParent, tChild, tWin;
-    Bool overlap;
-    WindowPtr newParent;
-
-    if(!pPriv->underlayMarked)
-	goto SKIP_UNDERLAY;
-
-    if (!pChild) pChild = pParent->firstChild;
-
-    RegionNull(&totalClip);
-    RegionNull(&childClip);
-    RegionNull(&exposed);
-
-    newParent = pParent;
-
-    while(IN_OVERLAY(newParent))
-    	newParent = newParent->parent;
-
-    tParent = MIOVERLAY_GET_WINDOW_TREE(newParent);
-
-    if(IN_UNDERLAY(pChild))
-	tChild = MIOVERLAY_GET_WINDOW_TREE(pChild);
-    else
-	tChild = tParent->firstChild;
-
-    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);
-        }        
-        RegionEmpty(&tParent->clipList);
-    } 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);
-	
-    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;
-	    }
-	}
-    }
-
-    RegionUninit(&childClip);
-
-    if(!((*pPriv->InOverlay)(newParent))) {
-	RegionNull(&tParent->valdata->exposed);
-	RegionNull(&tParent->valdata->borderExposed);
-    }
-
-    switch (kind) {
-    case VTStack:
-	break;
-    default:
-    	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;
-    }
-
-    RegionUninit(&totalClip);
-    RegionUninit(&exposed);
-
-SKIP_UNDERLAY:
-
-    miValidateTree(pParent, pChild, kind);
-
-    return 1;
-}
-
-
-static void
-miOverlayHandleExposures(WindowPtr pWin)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
-    WindowPtr pChild;
-    ValidatePtr val;
-    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;
-        }
-	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;
-    }
-}
-
-
-static void
-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);
-    short bw;
-    RegionRec overReg, underReg;
-    DDXPointRec oldpt;
-
-    if (!(pParent = pWin->parent))
-       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);
-    }
-    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);
-
-    (*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);
-    }
-    if (pWin->realized)
-	WindowsRestructured ();
-}
-
-#ifndef RECTLIMIT
-#define RECTLIMIT 25
-#endif
-
-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;
-            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
-               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);
-    }
-    else if (exposures && exposures != prgn)
-	RegionDestroy(exposures);
-}
-
-
-typedef struct {
-   RegionPtr over;
-   RegionPtr under;
-} miOverlayTwoRegions; 
-
-static int
-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;
-
-    return WT_WALKCHILDREN;
-}
-
-static void
-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);
-    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);
-    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;
-
-    /* if this is a root window, can't be resized */
-    if (!(pParent = pWin->parent))
-	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);
-		}
-	    }
-	}
-    }
-    pWin->origin.x = x + bw;
-    pWin->origin.y = y + bw;
-    pWin->drawable.height = h;
-    pWin->drawable.width = w;
-
-    x = pWin->drawable.x = newx;
-    y = pWin->drawable.y = newy;
-
-    SetWinSize (pWin);
-    SetBorderSize (pWin);
-
-    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);
-
-    pFirstChange = MoveWindowInStack(pWin, pSib);
-
-    if (WasViewable) {
-	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);
-	    }
-	}
-
-	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);
-    }
-    if (pWin->realized)
-	WindowsRestructured ();
-}
-
-
-static void
-miOverlaySetShape(WindowPtr pWin, int kind)
-{
-    Bool        WasViewable = (Bool)(pWin->viewable);
-    ScreenPtr   pScreen = pWin->drawable.pScreen;
-
-    if (kind != ShapeInput) {
-        if (WasViewable) {
-            (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
-
-            if (HasBorder (pWin)) {
-                RegionPtr borderVisible;
-
-                borderVisible = RegionCreate(NullBox, 1);
-                RegionSubtract(borderVisible,
-                                        &pWin->borderClip, &pWin->winSize);
-                pWin->valdata->before.borderVisible = borderVisible;
-                pWin->valdata->before.resized = TRUE;
-                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;
-                }
-            }
-        }
-
-        SetWinSize (pWin);
-        SetBorderSize (pWin);
-
-        ResizeChildrenWinSize(pWin, 0, 0, 0, 0);
-
-        if (WasViewable) {
-            (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
-
-
-            (*pScreen->ValidateTree)(pWin->parent, NullWindow, VTOther);
-        }
-
-        if (WasViewable) {
-            (*pScreen->HandleExposures)(pWin->parent);
-            if (pScreen->PostValidateTree)
-                (*pScreen->PostValidateTree)(pWin->parent, NullWindow, VTOther);
-        }
-    }
-    if (pWin->realized)
-        WindowsRestructured ();
-    CheckCursorConfinement(pWin);
-}
-
-
-
-static void
-miOverlayChangeBorderWidth(
-    WindowPtr pWin,
-    unsigned int width
-){
-    int oldwidth;
-    ScreenPtr pScreen;
-    Bool WasViewable = (Bool)(pWin->viewable);
-    Bool HadBorder;
-
-    oldwidth = wBorderWidth (pWin);
-    if (oldwidth == width)
-	return;
-    HadBorder = HasBorder(pWin);
-    pScreen = pWin->drawable.pScreen;
-    if (WasViewable && (width < oldwidth))
-	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
-
-    pWin->borderWidth = width;
-    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 (pWin->realized)
-	WindowsRestructured ();
-}
-
-/*  We need this as an addition since the xf86 common code doesn't
-    know about the second tree which is static to this file.  */
-
-void
-miOverlaySetRootClip(ScreenPtr pScreen, Bool enable)
-{
-    WindowPtr pRoot = pScreen->root;
-    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pRoot);
-
-    MARK_UNDERLAY(pRoot);
-
-    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);
-
-    RegionBreak(&pTree->clipList);
-}
-
-static void 
-miOverlayClearToBackground(
-    WindowPtr pWin,
-    int x, int y,
-    int w, int h,
-    Bool generateExposures
-)
-{
-    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;
-    BoxPtr  extents;
-    int     x1, y1, x2, y2;
-
-    x1 = pWin->drawable.x + x;
-    y1 = pWin->drawable.y + y;
-    if (w)
-        x2 = x1 + (int) w;
-    else
-        x2 = x1 + (int) pWin->drawable.width - (int) x;
-    if (h)
-        y2 = y1 + h;    
-    else
-        y2 = y1 + (int) pWin->drawable.height - (int) y;
-
-    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) 
-        x2 = x1 = y2 = y1 = 0;
-
-    box.x1 = x1; box.x2 = x2;
-    box.y1 = y1; box.y2 = y2;
-
-    RegionInit(&reg, &box, 1);
-
-    RegionIntersect(&reg, &reg, clipList);
-    if (generateExposures)
-        (*pScreen->WindowExposures)(pWin, &reg, pBSReg);
-    else if (pWin->backgroundState != None)
-	miPaintWindow(pWin, &reg, PW_BACKGROUND);
-    RegionUninit(&reg);
-    if (pBSReg)
-        RegionDestroy(pBSReg);
-}
-
-
-/****************************************************************/
-
-/* not used */
-Bool
-miOverlayGetPrivateClips(
-    WindowPtr pWin,
-    RegionPtr *borderClip,
-    RegionPtr *clipList
-){
-    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
-	
-    if(pTree) {
- 	*borderClip = &(pTree->borderClip);
-	*clipList = &(pTree->clipList);
-	return TRUE;
-    }
-
-    *borderClip = *clipList = NULL;
-
-    return FALSE;
-}
-
-void
-miOverlaySetTransFunction (
-   ScreenPtr pScreen, 
-   miOverlayTransFunc transFunc
-){
-    MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent = transFunc;
-}
-
-Bool
-miOverlayCopyUnderlay(ScreenPtr pScreen)
-{
-    return MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->copyUnderlay;
-}
-
-void
-miOverlayComputeCompositeClip(GCPtr pGC, WindowPtr pWin)
-{
-    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
-    RegionPtr       pregWin;
-    Bool            freeTmpClip, freeCompClip;
-
-    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;
-    }
-    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));
-    }
-}
-
-Bool
-miOverlayCollectUnderlayRegions(
-    WindowPtr pWin,
-    RegionPtr *region
-){
-    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
-
-    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
-){
-    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(!parent->firstChild)
-	parent->firstChild = parent->lastChild = pTree;
-    else if(parent->lastChild == prevSib)
-	parent->lastChild = pTree;
-   
-    return pTree;
-}
-
-static void 
-RebuildTree(WindowPtr pWin)
-{
-    miOverlayTreePtr parent, prevSib, tChild;
-    WindowPtr pChild;
-
-    prevSib = tChild = NULL;
-
-    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;
-    }
-}
-
-
-static Bool
-HasUnderlayChildren(WindowPtr pWin)
-{
-    WindowPtr pChild;
-
-    if(!(pChild = pWin->firstChild)) 
-	return FALSE;
-
-    while(1) {
-	if(IN_UNDERLAY(pChild))
-	   return TRUE;
-
-	if(pChild->firstChild) {
-	    pChild = pChild->firstChild;
-	    continue;
-	}
-
-	while(!pChild->nextSib && (pWin != pChild))
-	    pChild = pChild->parent;
-
-	if(pChild == pWin) break;
-
-	pChild = pChild->nextSib;
-    }
-
-    return FALSE;
-}
-
-
-static Bool
-CollectUnderlayChildrenRegions(WindowPtr pWin, RegionPtr pReg)
-{
-    WindowPtr pChild;
-    miOverlayTreePtr pTree;
-    Bool hasUnderlay;
-
-    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(!pChild->nextSib && (pWin != pChild))
-	    pChild = pChild->parent;
-
-	if(pChild == pWin) break;
-
-	pChild = pChild->nextSib;
-    }
-
-    if(hasUnderlay) {
-	Bool overlap;
-	RegionValidate(pReg, &overlap);
-    } 
-
-    return hasUnderlay;
-}
-
-
-static void 
-MarkUnderlayWindow(WindowPtr pWin)
-{
-    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
-
-    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;
-}
diff --git a/mi/mioverlay.h b/mi/mioverlay.h
deleted file mode 100644
index dca65ad..0000000
--- a/mi/mioverlay.h
+++ /dev/null
@@ -1,32 +0,0 @@
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#ifndef __MIOVERLAY_H
-#define __MIOVERLAY_H
-
-typedef void (*miOverlayTransFunc)(ScreenPtr, int, BoxPtr);
-typedef Bool (*miOverlayInOverlayFunc)(WindowPtr);
-
-extern _X_EXPORT Bool
-miInitOverlay(
-   ScreenPtr pScreen, 
-   miOverlayInOverlayFunc inOverlay,
-   miOverlayTransFunc trans
-);
-
-extern _X_EXPORT Bool
-miOverlayGetPrivateClips(
-    WindowPtr pWin,
-    RegionPtr *borderClip,
-    RegionPtr *clipList
-);
-
-extern _X_EXPORT Bool miOverlayCollectUnderlayRegions(WindowPtr, RegionPtr*);
-extern _X_EXPORT void miOverlayComputeCompositeClip(GCPtr, WindowPtr);
-extern _X_EXPORT Bool miOverlayCopyUnderlay(ScreenPtr);
-extern _X_EXPORT void miOverlaySetTransFunction(ScreenPtr, miOverlayTransFunc);
-extern _X_EXPORT void miOverlaySetRootClip(ScreenPtr, Bool);
-
-#endif /* __MIOVERLAY_H */
commit 91b5aadbdfd9d05ca1ffdeb443e602ecdba1e04d
Author: Mikhail Gusarov <dottedmag at dottedmag.net>
Date:   Fri Jun 11 20:20:00 2010 +0700

    mi: do not use X11/extensions/shape.h header from libXext
    
    Signed-off-by: Mikhail Gusarov <dottedmag at dottedmag.net>
    Tested-by: Dan Nicholson <dbn.lists at gmail.com>

diff --git a/mi/miwindow.c b/mi/miwindow.c
index 51c5cc8..25dd1c0 100644
--- a/mi/miwindow.c
+++ b/mi/miwindow.c
@@ -50,7 +50,7 @@ SOFTWARE.
 #endif
 
 #include <X11/X.h>
-#include <X11/extensions/shape.h>
+#include <X11/extensions/shapeconst.h>
 #include "regionstr.h"
 #include "region.h"
 #include "mi.h"
commit b8615d592700b7be319c04cc0563fdeb5a266534
Author: Alan Coopersmith <alan.coopersmith at oracle.com>
Date:   Sat Jun 12 08:19:16 2010 -0700

    Don't coredump on "X -showopts" (bug 25874)
    
    Don't try walking the xf86ConfigLayout.screens table if it's empty
    https://bugs.freedesktop.org/show_bug.cgi?id=25874
    
    Signed-off-by: Alan Coopersmith <alan.coopersmith at oracle.com>
    Reviewed-by: Tiago Vignatti <tiago.vignatti at nokia.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/hw/xfree86/common/xf86Helper.c b/hw/xfree86/common/xf86Helper.c
index cd48914..07f9f0a 100644
--- a/hw/xfree86/common/xf86Helper.c
+++ b/hw/xfree86/common/xf86Helper.c
@@ -1441,6 +1441,13 @@ xf86MatchDevice(const char *drivername, GDevPtr **sectlist)
 	*sectlist = NULL;
 
     /*
+     * This can happen when running Xorg -showopts and a module like ati
+     * or vmware tries to load its submodules when xf86ConfigLayout is empty
+     */
+    if (!xf86ConfigLayout.screens)
+	return 0;
+
+    /*
      * This is a very important function that matches the device sections
      * as they show up in the config file with the drivers that the server
      * loads at run time.
commit 32fd57509c3e06f63ac6b0ad607767fd2b688e5a
Author: Rami Ylimäki <ext-rami.ylimaki at nokia.com>
Date:   Fri Jun 18 12:40:58 2010 +0300

    record: Register client private to prevent crash.
    
    Running the following command causes an assertion to fail:
            cnee --record --request-range 1-127
    
    3  in dixGetPrivateAddr       at ../../include/privates.h:122
    4  in dixGetPrivate           at ../../include/privates.h:137
    5  in dixLookupPrivate        at ../../include/privates.h:167
    6  in RecordInstallHooks      at ../../record/record.c:911
    7  in ProcRecordEnableContext at ../../record/record.c:2377
    8  in ProcRecordDispatch      at ../../record/record.c:2571
    9  in Dispatch                at ../../dix/dispatch.c:432
    10 in main                    at ../../dix/main.c:289
    
    Signed-off-by: Rami Ylimäki <ext-rami.ylimaki at nokia.com>
    Reviewed-by: Oliver McFadden <oliver.mcfadden at nokia.com>
    Reviewed-by: Tiago Vignatti <tiago.vignatti at nokia.com>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/record/record.c b/record/record.c
index 4117a5a..06006f7 100644
--- a/record/record.c
+++ b/record/record.c
@@ -2895,6 +2895,9 @@ RecordExtensionInit(void)
     if (!RTContext)
 	return;
 
+    if (!dixRegisterPrivateKey(RecordClientPrivateKey, PRIVATE_CLIENT, 0))
+        return;
+
     ppAllContexts = NULL;
     numContexts = numEnabledContexts = numEnabledRCAPs = 0;
 
commit 75beadd766fed7b12a76e59e57c244e297c2d2cb
Author: Mario Kleiner <mario.kleiner at tuebingen.mpg.de>
Date:   Sun Jun 13 18:05:26 2010 +0200

    DRI2/xserver: Don't hang in glXSwapBuffers if drawable moves between crtc's (bug 28383)
    
    Detect if a drawable has been moved from an original crtc to a new crtc
    with a lower current vblank count than the original crtc inbetween
    glXSwapBuffers() calls. Reinitialize drawable's last_swap_target
    before scheduling next swap if such a move has taken place.
    
    last_swap_target defines the baseline for scheduling the next swap.
    If a movement between crtc's is not taken into account, the swap may
    schedule for a vblank count on the new crtc far in the future, resulting
    in a apparent "hang" of the drawable for a long time.
    
    Fixes Bugzilla bug #28383.
    
    Signed-off-by: Mario Kleiner <mario.kleiner at tuebingen.mpg.de>
    Reviewed-by: Jesse Barnes <jbarnes at virtuousgeek.org>
    Signed-off-by: Keith Packard <keithp at keithp.com>

diff --git a/hw/xfree86/dri2/dri2.c b/hw/xfree86/dri2/dri2.c
index a8dedfa..f9ba8e7 100644
--- a/hw/xfree86/dri2/dri2.c
+++ b/hw/xfree86/dri2/dri2.c
@@ -759,6 +759,7 @@ DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
     DRI2DrawablePtr pPriv;
     DRI2BufferPtr   pDestBuffer = NULL, pSrcBuffer = NULL;
     int             ret, i;
+    CARD64          ust, current_msc;
 
     pPriv = DRI2GetDrawable(pDraw);
     if (pPriv == NULL) {
@@ -803,12 +804,26 @@ DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
      * need to schedule a swap for the last swap target + the swap interval.
      */
     if (target_msc == 0 && divisor == 0 && remainder == 0) {
+	/* If the current vblank count of the drawable's crtc is lower
+	 * than the count stored in last_swap_target from a previous swap
+	 * then reinitialize last_swap_target to the current crtc's msc,
+	 * otherwise the swap will hang. This will happen if the drawable
+	 * is moved to a crtc with a lower refresh rate, or a crtc that just
+	 * got enabled.
+	 */
+	if (!(*ds->GetMSC)(pDraw, &ust, &current_msc))
+	    pPriv->last_swap_target = 0;
+
+	if (current_msc < pPriv->last_swap_target)
+	    pPriv->last_swap_target = current_msc;
+
 	/*
 	 * Swap target for this swap is last swap target + swap interval since
 	 * we have to account for the current swap count, interval, and the
 	 * number of pending swaps.
 	 */
 	*swap_target = pPriv->last_swap_target + pPriv->swap_interval;
+
     } else {
 	/* glXSwapBuffersMscOML could have a 0 target_msc, honor it */
 	*swap_target = target_msc;


More information about the Xquartz-changes mailing list