Initial revision

20 files changed, 7522 insertions, 0 deletions

diff --git a/miext/rootless/accel/rlAccel.h b/miext/rootless/accel/rlAccel.h
new file mode 100644
index 000000000..56afd7331
--- /dev/null
+++ b/miext/rootless/accel/rlAccel.h
@@ -0,0 +1,135 @@
+/*
+ * Rootless Acceleration Code
+ */
+/*
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlAccel.h,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+/*
+ * rlBlt.c
+ */
+void
+rlBlt (FbBits   *srcLine,
+       FbStride	srcStride,
+       int	srcX,
+
+       ScreenPtr pDstScreen,
+       FbBits   *dstLine,
+       FbStride dstStride,
+       int	dstX,
+
+       int	width,
+       int	height,
+
+       int	alu,
+       FbBits	pm,
+       int	bpp,
+
+       Bool	reverse,
+       Bool	upsidedown);
+
+/*
+ * rlCopy.c
+ */
+RegionPtr
+rlCopyArea (DrawablePtr	pSrcDrawable,
+	    DrawablePtr	pDstDrawable,
+	    GCPtr	pGC,
+	    int		xIn, 
+	    int		yIn,
+	    int		widthSrc, 
+	    int		heightSrc,
+	    int		xOut, 
+	    int		yOut);
+
+/*
+ * rlFill.c
+ */
+void
+rlFill (DrawablePtr pDrawable,
+	GCPtr	    pGC,
+	int	    x,
+	int	    y,
+	int	    width,
+	int	    height);
+
+void
+rlSolidBoxClipped (DrawablePtr	pDrawable,
+		   RegionPtr	pClip,
+		   int		x1,
+		   int		y1,
+		   int		x2,
+		   int		y2,
+		   FbBits	and,
+		   FbBits	xor);
+
+/*
+ * rlFillRect.c
+ */
+void
+rlPolyFillRect(DrawablePtr  pDrawable, 
+	       GCPtr	    pGC, 
+	       int	    nrect,
+	       xRectangle   *prect);
+
+/*
+ * rlFillSpans.c
+ */
+void
+rlFillSpans (DrawablePtr    pDrawable,
+	     GCPtr	    pGC,
+	     int	    n,
+	     DDXPointPtr    ppt,
+	     int	    *pwidth,
+	     int	    fSorted);
+
+/*
+ * rlGlyph.c
+ */
+void
+rlImageGlyphBlt (DrawablePtr	pDrawable,
+		 GCPtr		pGC,
+		 int		x, 
+		 int		y,
+		 unsigned int	nglyph,
+		 CharInfoPtr	*ppciInit,
+		 pointer	pglyphBase);
+
+/*
+ * rlSolid.c
+ */
+void
+rlSolid (ScreenPtr  pScreen,
+         FbBits	    *dst,
+	 FbStride   dstStride,
+	 int	    dstX,
+	 int	    bpp,
+
+	 int	    width,
+	 int	    height,
+
+	 FbBits	    and,
+	 FbBits	    xor);
diff --git a/miext/rootless/accel/rlBlt.c b/miext/rootless/accel/rlBlt.c
new file mode 100644
index 000000000..ba6fdf227
--- /dev/null
+++ b/miext/rootless/accel/rlBlt.c
@@ -0,0 +1,366 @@
+/*
+ * Accelerated rootless blit
+ */
+/*
+ * This code is largely copied from fbBlt.c.
+ *
+ * Copyright © 1998 Keith Packard
+ * Copyright (c) 2002 Apple Computer, Inc. All Rights Reserved.
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlBlt.c,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+#include "fb.h"
+#include "rootlessCommon.h"
+#include "rlAccel.h"
+
+
+void
+rlBlt (FbBits   *srcLine,
+       FbStride	srcStride,
+       int	srcX,
+
+       ScreenPtr pDstScreen,
+       FbBits   *dstLine,
+       FbStride dstStride,
+       int	dstX,
+
+       int	width,
+       int	height,
+
+       int	alu,
+       FbBits	pm,
+       int	bpp,
+
+       Bool	reverse,
+       Bool	upsidedown)
+{
+    FbBits  *src, *dst;
+    int	    leftShift, rightShift;
+    FbBits  startmask, endmask;
+    FbBits  bits, bits1;
+    int	    n, nmiddle;
+    Bool    destInvarient;
+    int	    startbyte, endbyte;
+    FbDeclareMergeRop ();
+
+#ifdef FB_24BIT
+    if (bpp == 24 && !FbCheck24Pix (pm))
+    {
+	fbBlt24 (srcLine, srcStride, srcX, dstLine, dstStride, dstX,
+		 width, height, alu, pm, reverse, upsidedown);
+	return;
+    }
+#endif
+    FbInitializeMergeRop(alu, pm);
+    destInvarient = FbDestInvarientMergeRop();
+    if (upsidedown)
+    {
+	srcLine += (height - 1) * (srcStride);
+	dstLine += (height - 1) * (dstStride);
+	srcStride = -srcStride;
+	dstStride = -dstStride;
+    }
+    FbMaskBitsBytes (dstX, width, destInvarient, startmask, startbyte,
+		     nmiddle, endmask, endbyte);
+
+    /*
+     * Beginning of the rootless acceleration code
+     */
+    if (!startmask && !endmask && alu == GXcopy &&
+        height * nmiddle * sizeof(*dst) > rootless_CopyBytes_threshold)
+    {
+	if (pm == FB_ALLONES && SCREENREC(pDstScreen)->imp->CopyBytes)
+	{
+	    SCREENREC(pDstScreen)->imp->CopyBytes(
+                            nmiddle * sizeof(*dst), height,
+                            (char *) srcLine + (srcX >> 3),
+                            srcStride * sizeof (*src),
+                            (char *) dstLine + (dstX >> 3),
+                            dstStride * sizeof (*dst));
+	    return;
+	}
+
+	/* FIXME: the pm test here isn't super-wonderful - just because
+	   we don't care about the top eight bits doesn't necessarily
+	   mean we want them set to 255. But doing this does give a
+	   factor of two performance improvement when copying from a
+	   pixmap to a window, which is pretty common.. */
+
+	else if (bpp == 32 && sizeof(FbBits) == 4 &&
+                 pm == 0x00FFFFFFUL && !reverse &&
+                 SCREENREC(pDstScreen)->imp->CompositePixels)
+	{
+	    /* need to copy XRGB to ARGB. */
+
+	    void *src[2], *dest[2];
+	    unsigned int src_rowbytes[2], dest_rowbytes[2];
+            unsigned int fn;
+
+	    src[0] = (char *) srcLine + (srcX >> 3);
+	    src[1] = NULL;
+	    src_rowbytes[0] = srcStride * sizeof(*src);
+	    src_rowbytes[1] = 0;
+
+	    dest[0] = (char *) dstLine + (dstX >> 3);
+	    dest[1] = dest[0];
+	    dest_rowbytes[0] = dstStride * sizeof(*dst);
+	    dest_rowbytes[1] = dest_rowbytes[0];
+
+	    fn = RL_COMPOSITE_FUNCTION(RL_COMPOSITE_SRC, RL_DEPTH_ARGB8888,
+                                       RL_DEPTH_NIL, RL_DEPTH_ARGB8888);
+
+            if (SCREENREC(pDstScreen)->imp->CompositePixels(
+                                nmiddle, height,
+                                fn, src, src_rowbytes,
+                                NULL, 0, dest, dest_rowbytes) == Success)
+            {
+                return;
+            }
+	}
+    }
+    /* End of the rootless acceleration code */
+
+    if (reverse)
+    {
+	srcLine += ((srcX + width - 1) >> FB_SHIFT) + 1;
+	dstLine += ((dstX + width - 1) >> FB_SHIFT) + 1;
+	srcX = (srcX + width - 1) & FB_MASK;
+	dstX = (dstX + width - 1) & FB_MASK;
+    }
+    else
+    {
+	srcLine += srcX >> FB_SHIFT;
+	dstLine += dstX >> FB_SHIFT;
+	srcX &= FB_MASK;
+	dstX &= FB_MASK;
+    }
+    if (srcX == dstX)
+    {
+	while (height--)
+	{
+	    src = srcLine;
+	    srcLine += srcStride;
+	    dst = dstLine;
+	    dstLine += dstStride;
+	    if (reverse)
+	    {
+		if (endmask)
+		{
+		    bits = *--src;
+		    --dst;
+		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
+		}
+		n = nmiddle;
+		if (destInvarient)
+		{
+		    while (n--)
+			*--dst = FbDoDestInvarientMergeRop(*--src);
+		}
+		else
+		{
+		    while (n--)
+		    {
+			bits = *--src;
+			--dst;
+			*dst = FbDoMergeRop (bits, *dst);
+		    }
+		}
+		if (startmask)
+		{
+		    bits = *--src;
+		    --dst;
+		    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
+		}
+	    }
+	    else
+	    {
+		if (startmask)
+		{
+		    bits = *src++;
+		    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
+		    dst++;
+		}
+		n = nmiddle;
+		if (destInvarient)
+		{
+#if 0
+		    /*
+		     * This provides some speedup on screen->screen blts
+		     * over the PCI bus, usually about 10%.  But fb
+		     * isn't usually used for this operation...
+		     */
+		    if (_ca2 + 1 == 0 && _cx2 == 0)
+		    {
+			FbBits	t1, t2, t3, t4;
+			while (n >= 4)
+			{
+			    t1 = *src++;
+			    t2 = *src++;
+			    t3 = *src++;
+			    t4 = *src++;
+			    *dst++ = t1;
+			    *dst++ = t2;
+			    *dst++ = t3;
+			    *dst++ = t4;
+			    n -= 4;
+			}
+		    }
+#endif
+		    while (n--)
+			*dst++ = FbDoDestInvarientMergeRop(*src++);
+		}
+		else
+		{
+		    while (n--)
+		    {
+			bits = *src++;
+			*dst = FbDoMergeRop (bits, *dst);
+			dst++;
+		    }
+		}
+		if (endmask)
+		{
+		    bits = *src;
+		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
+		}
+	    }
+	}
+    }
+    else
+    {
+	if (srcX > dstX)
+	{
+	    leftShift = srcX - dstX;
+	    rightShift = FB_UNIT - leftShift;
+	}
+	else
+	{
+	    rightShift = dstX - srcX;
+	    leftShift = FB_UNIT - rightShift;
+	}
+	while (height--)
+	{
+	    src = srcLine;
+	    srcLine += srcStride;
+	    dst = dstLine;
+	    dstLine += dstStride;
+	    
+	    bits1 = 0;
+	    if (reverse)
+	    {
+		if (srcX < dstX)
+		    bits1 = *--src;
+		if (endmask)
+		{
+		    bits = FbScrRight(bits1, rightShift);
+		    if (FbScrRight(endmask, leftShift))
+		    {
+			bits1 = *--src;
+			bits |= FbScrLeft(bits1, leftShift);
+		    }
+		    --dst;
+		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
+		}
+		n = nmiddle;
+		if (destInvarient)
+		{
+		    while (n--)
+		    {
+			bits = FbScrRight(bits1, rightShift);
+			bits1 = *--src;
+			bits |= FbScrLeft(bits1, leftShift);
+			--dst;
+			*dst = FbDoDestInvarientMergeRop(bits);
+		    }
+		}
+		else
+		{
+		    while (n--)
+		    {
+			bits = FbScrRight(bits1, rightShift);
+			bits1 = *--src;
+			bits |= FbScrLeft(bits1, leftShift);
+			--dst;
+			*dst = FbDoMergeRop(bits, *dst);
+		    }
+		}
+		if (startmask)
+		{
+		    bits = FbScrRight(bits1, rightShift);
+		    if (FbScrRight(startmask, leftShift))
+		    {
+			bits1 = *--src;
+			bits |= FbScrLeft(bits1, leftShift);
+		    }
+		    --dst;
+		    FbDoLeftMaskByteMergeRop (dst, bits, startbyte, startmask);
+		}
+	    }
+	    else
+	    {
+		if (srcX > dstX)
+		    bits1 = *src++;
+		if (startmask)
+		{
+		    bits = FbScrLeft(bits1, leftShift);
+		    bits1 = *src++;
+		    bits |= FbScrRight(bits1, rightShift);
+		    FbDoLeftMaskByteMergeRop (dst, bits, startbyte, startmask);
+		    dst++;
+		}
+		n = nmiddle;
+		if (destInvarient)
+		{
+		    while (n--)
+		    {
+			bits = FbScrLeft(bits1, leftShift);
+			bits1 = *src++;
+			bits |= FbScrRight(bits1, rightShift);
+			*dst = FbDoDestInvarientMergeRop(bits);
+			dst++;
+		    }
+		}
+		else
+		{
+		    while (n--)
+		    {
+			bits = FbScrLeft(bits1, leftShift);
+			bits1 = *src++;
+			bits |= FbScrRight(bits1, rightShift);
+			*dst = FbDoMergeRop(bits, *dst);
+			dst++;
+		    }
+		}
+		if (endmask)
+		{
+		    bits = FbScrLeft(bits1, leftShift);
+		    if (FbScrLeft(endmask, rightShift))
+		    {
+			bits1 = *src;
+			bits |= FbScrRight(bits1, rightShift);
+		    }
+		    FbDoRightMaskByteMergeRop (dst, bits, endbyte, endmask);
+		}
+	    }
+	}
+    }
+}
diff --git a/miext/rootless/accel/rlCopy.c b/miext/rootless/accel/rlCopy.c
new file mode 100644
index 000000000..cbd58b4cf
--- /dev/null
+++ b/miext/rootless/accel/rlCopy.c
@@ -0,0 +1,103 @@
+/*
+ * This code is largely copied from fbcopy.c.
+ *
+ * Copyright © 1998 Keith Packard
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlCopy.c,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+#include "fb.h"
+#include "rlAccel.h"
+
+
+void
+rlCopyNtoN (DrawablePtr	pSrcDrawable,
+	    DrawablePtr	pDstDrawable,
+	    GCPtr	pGC,
+	    BoxPtr	pbox,
+	    int		nbox,
+	    int		dx,
+	    int		dy,
+	    Bool	reverse,
+	    Bool	upsidedown,
+	    Pixel	bitplane,
+	    void	*closure)
+{
+    CARD8	alu = pGC ? pGC->alu : GXcopy;
+    FbBits	pm = pGC ? fbGetGCPrivate(pGC)->pm : FB_ALLONES;
+    FbBits	*src;
+    FbStride	srcStride;
+    int		srcBpp;
+    int		srcXoff, srcYoff;
+    FbBits	*dst;
+    FbStride	dstStride;
+    int		dstBpp;
+    int		dstXoff, dstYoff;
+    
+    fbGetDrawable (pSrcDrawable, src, srcStride, srcBpp, srcXoff, srcYoff);
+    fbGetDrawable (pDstDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
+    
+    while (nbox--)
+    {
+	rlBlt (src + (pbox->y1 + dy + srcYoff) * srcStride,
+	       srcStride,
+	       (pbox->x1 + dx + srcXoff) * srcBpp,
+    
+	       pDstDrawable->pScreen,
+               dst + (pbox->y1 + dstYoff) * dstStride,
+	       dstStride,
+	       (pbox->x1 + dstXoff) * dstBpp,
+    
+	       (pbox->x2 - pbox->x1) * dstBpp,
+	       (pbox->y2 - pbox->y1),
+    
+	       alu,
+	       pm,
+	       dstBpp,
+    
+	       reverse,
+	       upsidedown);
+	pbox++;
+    }
+}
+
+RegionPtr
+rlCopyArea (DrawablePtr	pSrcDrawable,
+	    DrawablePtr	pDstDrawable,
+	    GCPtr	pGC,
+	    int		xIn, 
+	    int		yIn,
+	    int		widthSrc, 
+	    int		heightSrc,
+	    int		xOut, 
+	    int		yOut)
+{
+    fbCopyProc	copy;
+    
+#ifdef FB_24_32BIT
+    if (pSrcDrawable->bitsPerPixel != pDstDrawable->bitsPerPixel)
+	copy = fb24_32CopyMtoN;
+    else
+#endif
+	copy = rlCopyNtoN;
+    return fbDoCopy (pSrcDrawable, pDstDrawable, pGC, xIn, yIn,
+		     widthSrc, heightSrc, xOut, yOut, copy, 0, 0);
+}
diff --git a/miext/rootless/accel/rlFill.c b/miext/rootless/accel/rlFill.c
new file mode 100644
index 000000000..7fd7adfa8
--- /dev/null
+++ b/miext/rootless/accel/rlFill.c
@@ -0,0 +1,217 @@
+/*
+ * This code is largely copied from fbfill.c.
+ *
+ * Copyright © 1998 Keith Packard
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlFill.c,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+#include "fb.h"
+#include "rlAccel.h"
+
+
+void
+rlFill (DrawablePtr pDrawable,
+	GCPtr	    pGC,
+	int	    x,
+	int	    y,
+	int	    width,
+	int	    height)
+{
+    FbBits	    *dst;
+    FbStride	    dstStride;
+    int		    dstBpp;
+    int		    dstXoff, dstYoff;
+    FbGCPrivPtr	    pPriv = fbGetGCPrivate(pGC);
+    
+    fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
+
+    switch (pGC->fillStyle) {
+    case FillSolid:
+	rlSolid (pDrawable->pScreen,
+                 dst + (y + dstYoff) * dstStride, 
+		 dstStride, 
+		 (x + dstXoff) * dstBpp,
+		 dstBpp,
+		 width * dstBpp, height,
+		 pPriv->and, pPriv->xor);
+	break;
+    case FillStippled:
+    case FillOpaqueStippled: {
+	PixmapPtr   pStip = pGC->stipple;
+	int	    stipWidth = pStip->drawable.width;
+	int	    stipHeight = pStip->drawable.height;
+	
+	if (dstBpp == 1)
+	{
+	    int		alu;
+	    FbBits	*stip;
+	    FbStride    stipStride;
+	    int		stipBpp;
+	    int		stipXoff, stipYoff; /* XXX assumed to be zero */
+
+	    if (pGC->fillStyle == FillStippled)
+		alu = FbStipple1Rop(pGC->alu,pGC->fgPixel);
+	    else
+		alu = FbOpaqueStipple1Rop(pGC->alu,pGC->fgPixel,pGC->bgPixel);
+	    fbGetDrawable (&pStip->drawable, stip, stipStride, stipBpp, stipXoff, stipYoff);
+	    fbTile (dst + (y + dstYoff) * dstStride,
+		    dstStride,
+		    x + dstXoff,
+		    width, height,
+		    stip,
+		    stipStride,
+		    stipWidth,
+		    stipHeight,
+		    alu,
+		    pPriv->pm,
+		    dstBpp,
+		    
+		    (pGC->patOrg.x + pDrawable->x + dstXoff),
+		    pGC->patOrg.y + pDrawable->y + dstYoff - y);
+	}
+	else
+	{
+	    FbStip	*stip;
+	    FbStride    stipStride;
+	    int		stipBpp;
+	    int		stipXoff, stipYoff; /* XXX assumed to be zero */
+	    FbBits	fgand, fgxor, bgand, bgxor;
+
+	    fgand = pPriv->and;
+	    fgxor = pPriv->xor;
+	    if (pGC->fillStyle == FillStippled)
+	    {
+		bgand = fbAnd(GXnoop,(FbBits) 0,FB_ALLONES);
+		bgxor = fbXor(GXnoop,(FbBits) 0,FB_ALLONES);
+	    }
+	    else
+	    {
+		bgand = pPriv->bgand;
+		bgxor = pPriv->bgxor;
+	    }
+
+	    fbGetStipDrawable (&pStip->drawable, stip, stipStride, stipBpp, stipXoff, stipYoff);
+	    fbStipple (dst + (y + dstYoff) * dstStride, 
+		       dstStride, 
+		       (x + dstXoff) * dstBpp,
+		       dstBpp,
+		       width * dstBpp, height,
+		       stip,
+		       stipStride,
+		       stipWidth,
+		       stipHeight,
+		       pPriv->evenStipple,
+		       fgand, fgxor,
+		       bgand, bgxor,
+		       pGC->patOrg.x + pDrawable->x + dstXoff,
+		       pGC->patOrg.y + pDrawable->y + dstYoff - y);
+	}
+	break;
+    }
+    case FillTiled: {
+	PixmapPtr   pTile = pGC->tile.pixmap;
+	FbBits	    *tile;
+	FbStride    tileStride;
+	int	    tileBpp;
+	int	    tileWidth;
+	int	    tileHeight;
+	int	    tileXoff, tileYoff; /* XXX assumed to be zero */
+	
+	fbGetDrawable (&pTile->drawable, tile, tileStride, tileBpp, tileXoff, tileYoff);
+	tileWidth = pTile->drawable.width;
+	tileHeight = pTile->drawable.height;
+	fbTile (dst + (y + dstYoff) * dstStride, 
+		dstStride, 
+		(x + dstXoff) * dstBpp, 
+		width * dstBpp, height,
+		tile,
+		tileStride,
+		tileWidth * tileBpp,
+		tileHeight,
+		pGC->alu,
+		pPriv->pm,
+		dstBpp,
+		(pGC->patOrg.x + pDrawable->x + dstXoff) * dstBpp,
+		pGC->patOrg.y + pDrawable->y + dstYoff - y);
+	break;
+    }
+    }
+    fbValidateDrawable (pDrawable);
+}
+
+void
+rlSolidBoxClipped (DrawablePtr	pDrawable,
+		   RegionPtr	pClip,
+		   int		x1,
+		   int		y1,
+		   int		x2,
+		   int		y2,
+		   FbBits	and,
+		   FbBits	xor)
+{
+    FbBits	*dst;
+    FbStride	dstStride;
+    int		dstBpp;
+    int		dstXoff, dstYoff;
+    BoxPtr	pbox;
+    int		nbox;
+    int		partX1, partX2, partY1, partY2;
+
+    fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
+    
+    for (nbox = REGION_NUM_RECTS(pClip), pbox = REGION_RECTS(pClip); 
+	 nbox--; 
+	 pbox++)
+    {
+	partX1 = pbox->x1;
+	if (partX1 < x1)
+	    partX1 = x1;
+	
+	partX2 = pbox->x2;
+	if (partX2 > x2)
+	    partX2 = x2;
+	
+	if (partX2 <= partX1)
+	    continue;
+	
+	partY1 = pbox->y1;
+	if (partY1 < y1)
+	    partY1 = y1;
+	
+	partY2 = pbox->y2;
+	if (partY2 > y2)
+	    partY2 = y2;
+	
+	if (partY2 <= partY1)
+	    continue;
+	
+	rlSolid (pDrawable->pScreen,
+                 dst + (partY1 + dstYoff) * dstStride,
+		 dstStride,
+		 (partX1 + dstXoff) * dstBpp,
+		 dstBpp,
+
+		 (partX2 - partX1) * dstBpp,
+		 (partY2 - partY1),
+		 and, xor);
+    }
+}
diff --git a/miext/rootless/accel/rlFillRect.c b/miext/rootless/accel/rlFillRect.c
new file mode 100644
index 000000000..2ce9eae2b
--- /dev/null
+++ b/miext/rootless/accel/rlFillRect.c
@@ -0,0 +1,114 @@
+/*
+ * This code is largely copied from fbfillrect.c.
+ *
+ * Copyright © 1998 Keith Packard
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlFillRect.c,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+#include "fb.h"
+#include "rlAccel.h"
+
+
+void
+rlPolyFillRect(DrawablePtr  pDrawable, 
+	       GCPtr	    pGC, 
+	       int	    nrect,
+	       xRectangle   *prect)
+{
+    RegionPtr	    pClip = fbGetCompositeClip(pGC);
+    register BoxPtr pbox;
+    BoxPtr	    pextent;
+    int		    extentX1, extentX2, extentY1, extentY2;
+    int		    fullX1, fullX2, fullY1, fullY2;
+    int		    partX1, partX2, partY1, partY2;
+    int		    xorg, yorg;
+    int		    n;
+
+    xorg = pDrawable->x;
+    yorg = pDrawable->y;
+    
+    pextent = REGION_EXTENTS(pGC->pScreen, pClip);
+    extentX1 = pextent->x1;
+    extentY1 = pextent->y1;
+    extentX2 = pextent->x2;
+    extentY2 = pextent->y2;
+    while (nrect--)
+    {
+	fullX1 = prect->x + xorg;
+	fullY1 = prect->y + yorg;
+	fullX2 = fullX1 + (int) prect->width;
+	fullY2 = fullY1 + (int) prect->height;
+	prect++;
+	
+	if (fullX1 < extentX1)
+	    fullX1 = extentX1;
+
+	if (fullY1 < extentY1)
+	    fullY1 = extentY1;
+
+	if (fullX2 > extentX2)
+	    fullX2 = extentX2;
+	
+	if (fullY2 > extentY2)
+	    fullY2 = extentY2;
+
+	if ((fullX1 >= fullX2) || (fullY1 >= fullY2))
+	    continue;
+	n = REGION_NUM_RECTS (pClip);
+	if (n == 1)
+	{
+	    rlFill (pDrawable,
+		    pGC,
+		    fullX1, fullY1, fullX2-fullX1, fullY2-fullY1);
+	}
+	else
+	{
+	    pbox = REGION_RECTS(pClip);
+	    /* 
+	     * clip the rectangle to each box in the clip region
+	     * this is logically equivalent to calling Intersect()
+	     */
+	    while(n--)
+	    {
+		partX1 = pbox->x1;
+		if (partX1 < fullX1)
+		    partX1 = fullX1;
+		partY1 = pbox->y1;
+		if (partY1 < fullY1)
+		    partY1 = fullY1;
+		partX2 = pbox->x2;
+		if (partX2 > fullX2)
+		    partX2 = fullX2;
+		partY2 = pbox->y2;
+		if (partY2 > fullY2)
+		    partY2 = fullY2;
+    
+		pbox++;
+		
+		if (partX1 < partX2 && partY1 < partY2)
+		    rlFill (pDrawable, pGC,
+			    partX1, partY1,
+			    partX2 - partX1, partY2 - partY1);
+	    }
+	}
+    }
+}
diff --git a/miext/rootless/accel/rlFillSpans.c b/miext/rootless/accel/rlFillSpans.c
new file mode 100644
index 000000000..fd5ee35f5
--- /dev/null
+++ b/miext/rootless/accel/rlFillSpans.c
@@ -0,0 +1,102 @@
+/*
+ * This code is largely copied from fbfillsp.c.
+ *
+ * Copyright © 1998 Keith Packard
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlFillSpans.c,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+#include "fb.h"
+#include "rlAccel.h"
+
+
+void
+rlFillSpans (DrawablePtr    pDrawable,
+	     GCPtr	    pGC,
+	     int	    n,
+	     DDXPointPtr    ppt,
+	     int	    *pwidth,
+	     int	    fSorted)
+{
+    RegionPtr	    pClip = fbGetCompositeClip(pGC);
+    BoxPtr	    pextent, pbox;
+    int		    nbox;
+    int		    extentX1, extentX2, extentY1, extentY2;
+    int		    fullX1, fullX2, fullY1;
+    int		    partX1, partX2;
+    
+    pextent = REGION_EXTENTS(pGC->pScreen, pClip);
+    extentX1 = pextent->x1;
+    extentY1 = pextent->y1;
+    extentX2 = pextent->x2;
+    extentY2 = pextent->y2;
+    while (n--)
+    {
+	fullX1 = ppt->x;
+	fullY1 = ppt->y;
+	fullX2 = fullX1 + (int) *pwidth;
+	ppt++;
+	pwidth++;
+	
+	if (fullY1 < extentY1 || extentY2 <= fullY1)
+	    continue;
+	
+	if (fullX1 < extentX1)
+	    fullX1 = extentX1;
+
+	if (fullX2 > extentX2)
+	    fullX2 = extentX2;
+	
+	if (fullX1 >= fullX2)
+	    continue;
+	
+	nbox = REGION_NUM_RECTS (pClip);
+	if (nbox == 1)
+	{
+	    rlFill (pDrawable,
+		    pGC,
+		    fullX1, fullY1, fullX2-fullX1, 1);
+	}
+	else
+	{
+	    pbox = REGION_RECTS(pClip);
+	    while(nbox--)
+	    {
+		if (pbox->y1 <= fullY1 && fullY1 < pbox->y2)
+		{
+		    partX1 = pbox->x1;
+		    if (partX1 < fullX1)
+			partX1 = fullX1;
+		    partX2 = pbox->x2;
+		    if (partX2 > fullX2)
+			partX2 = fullX2;
+		    if (partX2 > partX1)
+		    {
+			rlFill (pDrawable, pGC,
+				partX1, fullY1,
+				partX2 - partX1, 1);
+		    }
+		}
+		pbox++;
+	    }
+	}
+    }
+}
diff --git a/miext/rootless/accel/rlGlyph.c b/miext/rootless/accel/rlGlyph.c
new file mode 100644
index 000000000..2bf2da64b
--- /dev/null
+++ b/miext/rootless/accel/rlGlyph.c
@@ -0,0 +1,166 @@
+/*
+ * This code is largely copied from fbglyph.c.
+ *
+ * Copyright © 1998 Keith Packard
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlGlyph.c,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+#include "fb.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "rlAccel.h"
+
+      
+void
+rlImageGlyphBlt (DrawablePtr	pDrawable,
+		 GCPtr		pGC,
+		 int		x, 
+		 int		y,
+		 unsigned int	nglyph,
+		 CharInfoPtr	*ppciInit,
+		 pointer	pglyphBase)
+{
+    FbGCPrivPtr	    pPriv = fbGetGCPrivate(pGC);
+    CharInfoPtr	    *ppci;
+    CharInfoPtr	    pci;
+    unsigned char   *pglyph;		/* pointer bits in glyph */
+    int		    gWidth, gHeight;	/* width and height of glyph */
+    FbStride	    gStride;		/* stride of glyph */
+    Bool	    opaque;
+    int		    n;
+    int		    gx, gy;
+#ifndef FBNOPIXADDR
+    void	    (*glyph) (FbBits *,
+			      FbStride,
+			      int,
+			      FbStip *,
+			      FbBits,
+			      int,
+			      int);
+    FbBits	    *dst = 0;
+    FbStride	    dstStride = 0;
+    int		    dstBpp = 0;
+    int		    dstXoff = 0, dstYoff = 0;
+    
+    glyph = 0;
+    if (pPriv->and == 0)
+    {
+	fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
+	switch (dstBpp) {
+	case 8:	    glyph = fbGlyph8; break;
+	case 16:    glyph = fbGlyph16; break;
+#ifdef FB_24BIT
+	case 24:    glyph = fbGlyph24; break;
+#endif
+	case 32:    glyph = fbGlyph32; break;
+	}
+    }
+#endif
+    
+    x += pDrawable->x;
+    y += pDrawable->y;
+
+    if (TERMINALFONT (pGC->font)
+#ifndef FBNOPIXADDR
+	&& !glyph
+#endif
+	)
+    {
+	opaque = TRUE;
+    }
+    else
+    {
+	int		xBack, widthBack;
+	int		yBack, heightBack;
+	
+	ppci = ppciInit;
+	n = nglyph;
+	widthBack = 0;
+	while (n--)
+	    widthBack += (*ppci++)->metrics.characterWidth;
+	
+        xBack = x;
+	if (widthBack < 0)
+	{
+	    xBack += widthBack;
+	    widthBack = -widthBack;
+	}
+	yBack = y - FONTASCENT(pGC->font);
+	heightBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font);
+	rlSolidBoxClipped (pDrawable,
+			   fbGetCompositeClip(pGC),
+			   xBack,
+			   yBack,
+			   xBack + widthBack,
+			   yBack + heightBack,
+			   fbAnd(GXcopy,pPriv->bg,pPriv->pm),
+			   fbXor(GXcopy,pPriv->bg,pPriv->pm));
+	opaque = FALSE;
+    }
+
+    ppci = ppciInit;
+    while (nglyph--)
+    {
+	pci = *ppci++;
+	pglyph = FONTGLYPHBITS(pglyphBase, pci);
+	gWidth = GLYPHWIDTHPIXELS(pci);
+	gHeight = GLYPHHEIGHTPIXELS(pci);
+	if (gWidth && gHeight)
+	{
+	    gx = x + pci->metrics.leftSideBearing;
+	    gy = y - pci->metrics.ascent; 
+#ifndef FBNOPIXADDR
+	    if (glyph && gWidth <= sizeof (FbStip) * 8 &&
+		fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight))
+	    {
+		(*glyph) (dst + (gy + dstYoff) * dstStride,
+			  dstStride,
+			  dstBpp,
+			  (FbStip *) pglyph,
+			  pPriv->fg,
+			  gx + dstXoff,
+			  gHeight);
+	    }
+	    else
+#endif
+	    {
+		gStride = GLYPHWIDTHBYTESPADDED(pci) / sizeof (FbStip);
+		fbPutXYImage (pDrawable,
+			      fbGetCompositeClip(pGC),
+			      pPriv->fg,
+			      pPriv->bg,
+			      pPriv->pm,
+			      GXcopy,
+			      opaque,
+    
+			      gx,
+			      gy,
+			      gWidth, gHeight,
+    
+			      (FbStip *) pglyph,
+			      gStride,
+			      0);
+	    }
+	}
+	x += pci->metrics.characterWidth;
+    }
+}
diff --git a/miext/rootless/accel/rlSolid.c b/miext/rootless/accel/rlSolid.c
new file mode 100644
index 000000000..e2249569b
--- /dev/null
+++ b/miext/rootless/accel/rlSolid.c
@@ -0,0 +1,108 @@
+/*
+ * Accelerated rootless fill
+ */
+/*
+ * This code is largely copied from fbsolid.c.
+ *
+ * Copyright © 1998 Keith Packard
+ * Copyright (c) 2002 Apple Computer, Inc. All Rights Reserved.
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/accel/rlSolid.c,v 1.1 2003/10/24 00:33:15 torrey Exp $ */
+
+#include "fb.h"
+#include "rootlessCommon.h"
+
+
+void
+rlSolid (ScreenPtr  pScreen,
+         FbBits	    *dst,
+	 FbStride   dstStride,
+	 int	    dstX,
+	 int	    bpp,
+
+	 int	    width,
+	 int	    height,
+
+	 FbBits	    and,
+	 FbBits	    xor)
+{
+    FbBits  startmask, endmask;
+    int	    n, nmiddle;
+    int	    startbyte, endbyte;
+
+#ifdef FB_24BIT
+    if (bpp == 24 && (!FbCheck24Pix(and) || !FbCheck24Pix(xor)))
+    {
+	fbSolid24 (dst, dstStride, dstX, width, height, and, xor);
+	return;
+    }
+#endif
+	
+    dst += dstX >> FB_SHIFT;
+    dstX &= FB_MASK;
+    FbMaskBitsBytes(dstX, width, and == 0, startmask, startbyte, 
+		    nmiddle, endmask, endbyte);
+
+    /*
+     * Beginning of the rootless acceleration code
+     */
+    if (!startmask && !endmask && !and &&
+        height * nmiddle * sizeof (*dst) > rootless_FillBytes_threshold &&
+        SCREENREC(pScreen)->imp->FillBytes)
+    {
+	if (bpp <= 8)
+	    xor |= xor << 8;
+	if (bpp <= 16)
+	    xor |= xor << 16;
+
+	SCREENREC(pScreen)->imp->FillBytes(nmiddle * sizeof (*dst), height,
+                                           xor, (char *) dst + (dstX >> 3),
+                                           dstStride * sizeof (*dst));
+	return;
+    }
+    /* End of the rootless acceleration code */
+
+    if (startmask)
+	dstStride--;
+    dstStride -= nmiddle;
+    while (height--)
+    {
+	if (startmask)
+	{
+	    FbDoLeftMaskByteRRop(dst,startbyte,startmask,and,xor);
+	    dst++;
+	}
+	n = nmiddle;
+	if (!and)
+	    while (n--)
+		*dst++ = xor;
+	else
+	    while (n--)
+	    {
+		*dst = FbDoRRop (*dst, and, xor);
+		dst++;
+	    }
+	if (endmask)
+	    FbDoRightMaskByteRRop(dst,endbyte,endmask,and,xor);
+	dst += dstStride;
+    }
+}
diff --git a/miext/rootless/rootless.h b/miext/rootless/rootless.h
new file mode 100644
index 000000000..2b375706f
--- /dev/null
+++ b/miext/rootless/rootless.h
@@ -0,0 +1,399 @@
+/*
+ * External interface to generic rootless mode
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootless.h,v 1.6 2003/10/24 00:33:14 torrey Exp $ */
+
+#ifndef _ROOTLESS_H
+#define _ROOTLESS_H
+
+#include "rootlessConfig.h"
+#include "mi.h"
+#include "gcstruct.h"
+
+/*
+   Each top-level rootless window has a one-to-one correspondence to a physical
+   on-screen window. The physical window is refered to as a "frame".
+ */
+
+typedef void * RootlessFrameID;
+
+/*
+ * RootlessWindowRec
+ *  This structure stores the per-frame data used by the rootless code.
+ *  Each top-level X window has one RootlessWindowRec associated with it.
+ */
+typedef struct _RootlessWindowRec {
+    // Position and size includes the window border
+    // Position is in per-screen coordinates
+    int x, y;
+    unsigned int width, height;
+    unsigned int borderWidth;
+
+    RootlessFrameID wid;	// implementation specific frame id
+    WindowPtr win;		// underlying X window
+
+    // Valid only when drawing (ie. is_drawing is set)
+    char *pixelData;
+    int bytesPerRow;
+
+    PixmapPtr pixmap;
+    PixmapPtr oldPixmap;
+
+#ifdef ROOTLESS_TRACK_DAMAGE
+    RegionRec damage;
+#endif
+
+    unsigned int is_drawing :1;	// Currently drawing?
+    unsigned int is_reorder_pending :1;
+} RootlessWindowRec, *RootlessWindowPtr;
+
+
+/* Offset for screen-local to global coordinate transforms */
+#ifdef ROOTLESS_GLOBAL_COORDS
+extern int rootlessGlobalOffsetX;
+extern int rootlessGlobalOffsetY;
+#endif
+
+/* The minimum number of bytes or pixels for which to use the
+   implementation's accelerated functions. */
+extern unsigned int rootless_CopyBytes_threshold;
+extern unsigned int rootless_FillBytes_threshold;
+extern unsigned int rootless_CompositePixels_threshold;
+extern unsigned int rootless_CopyWindow_threshold;
+
+/* Operations used by CompositePixels */
+enum rl_composite_op_enum {
+    RL_COMPOSITE_SRC = 0,
+    RL_COMPOSITE_OVER,
+};
+
+/* Data formats for depth field and composite functions */
+enum rl_depth_enum {
+    RL_DEPTH_NIL = 0,			/* null source when compositing */
+    RL_DEPTH_ARGB8888,
+    RL_DEPTH_RGB555,
+    RL_DEPTH_A8,			/* for masks when compositing */
+    RL_DEPTH_INDEX8,
+};
+
+/* Macro to form the composite function for CompositePixels */
+#define RL_COMPOSITE_FUNCTION(op, src_depth, mask_depth, dest_depth) \
+    (((op) << 24) | ((src_depth) << 16) \
+     | ((mask_depth) << 8) | ((dest_depth) << 0))
+
+/* Gravity for window contents during resizing */
+enum rl_gravity_enum {
+    RL_GRAVITY_NONE             = 0,	/* no gravity, fill everything */
+    RL_GRAVITY_NORTH_WEST       = 1,	/* anchor to top-left corner */
+    RL_GRAVITY_NORTH_EAST       = 2,	/* anchor to top-right corner */
+    RL_GRAVITY_SOUTH_EAST       = 3,	/* anchor to bottom-right corner */
+    RL_GRAVITY_SOUTH_WEST       = 4,	/* anchor to bottom-left corner */
+};
+
+
+/*------------------------------------------
+   Rootless Implementation Functions
+  ------------------------------------------*/
+
+/*
+ * Create a new frame.
+ *  The frame is created unmapped.
+ *
+ *  pFrame      RootlessWindowPtr for this frame should be completely
+ *              initialized before calling except for pFrame->wid, which
+ *              is set by this function.
+ *  pScreen     Screen on which to place the new frame
+ *  newX, newY  Position of the frame. These will be identical to pFrame-x,
+ *              pFrame->y unless ROOTLESS_GLOBAL_COORDS is set.
+ *  pNewShape   Shape for the frame (in frame-local coordinates). NULL for
+ *              unshaped frames.
+ */
+typedef Bool (*RootlessCreateFrameProc)
+    (RootlessWindowPtr pFrame, ScreenPtr pScreen, int newX, int newY,
+     RegionPtr pNewShape);
+
+/*
+ * Destroy a frame.
+ *  Drawing is stopped and all updates are flushed before this is called.
+ *
+ *  wid         Frame id
+ */
+typedef void (*RootlessDestroyFrameProc)
+    (RootlessFrameID wid);
+
+/*
+ * Move a frame on screen.
+ *  Drawing is stopped and all updates are flushed before this is called.
+ *
+ *  wid         Frame id
+ *  pScreen     Screen to move the new frame to
+ *  newX, newY  New position of the frame
+ */
+typedef void (*RootlessMoveFrameProc) 
+    (RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY);
+
+/*
+ * Resize and move a frame.
+ *  Drawing is stopped and all updates are flushed before this is called.
+ *
+ *  wid         Frame id
+ *  pScreen     Screen to move the new frame to
+ *  newX, newY  New position of the frame
+ *  newW, newH  New size of the frame
+ *  gravity     Gravity for window contents (rl_gravity_enum). This is always
+ *              RL_GRAVITY_NONE unless ROOTLESS_RESIZE_GRAVITY is set.
+ */
+typedef void (*RootlessResizeFrameProc)
+    (RootlessFrameID wid, ScreenPtr pScreen,
+     int newX, int newY, unsigned int newW, unsigned int newH,
+     unsigned int gravity);
+
+/*
+ * Change frame ordering (AKA stacking, layering).
+ *  Drawing is stopped before this is called. Unmapped frames are mapped by
+ *  setting their ordering.
+ *
+ *  wid         Frame id
+ *  nextWid     Frame id of frame that is now above this one or NULL if this
+ *              frame is at the top.
+ */
+typedef void (*RootlessRestackFrameProc)
+    (RootlessFrameID wid, RootlessFrameID nextWid);
+
+/*
+ * Change frame's shape.
+ *  Drawing is stopped before this is called.
+ *
+ *  wid         Frame id
+ *  pNewShape   New shape for the frame (in frame-local coordinates)
+ *              or NULL if now unshaped.
+ */
+typedef void (*RootlessReshapeFrameProc)
+    (RootlessFrameID wid, RegionPtr pNewShape);
+
+/*
+ * Unmap a frame.
+ *
+ *  wid         Frame id
+ */
+typedef void (*RootlessUnmapFrameProc)
+    (RootlessFrameID wid);
+
+/*
+ * Start drawing to a frame.
+ *  Prepare a frame for direct access to its backing buffer.
+ *
+ *  wid         Frame id
+ *  pixelData   Address of the backing buffer (returned)
+ *  bytesPerRow Width in bytes of the backing buffer (returned)
+ */
+typedef void (*RootlessStartDrawingProc)
+    (RootlessFrameID wid, char **pixelData, int *bytesPerRow);
+
+/*
+ * Stop drawing to a frame.
+ *  No drawing to the frame's backing buffer will occur until drawing
+ *  is started again.
+ *
+ *  wid         Frame id
+ *  flush       Flush drawing updates for this frame to the screen. This
+ *              will always be FALSE if ROOTLESS_TRACK_DAMAGE is set.
+ */
+typedef void (*RootlessStopDrawingProc)
+    (RootlessFrameID wid, Bool flush);
+
+/*
+ * Flush drawing updates to the screen.
+ *  Drawing is stopped before this is called.
+ *
+ *  wid         Frame id
+ *  pDamage     Region containing all the changed pixels in frame-lcoal
+ *              coordinates. This is clipped to the window's clip. This
+ *              will be NULL if ROOTLESS_TRACK_DAMAGE is not set.
+ */
+typedef void (*RootlessUpdateRegionProc)
+    (RootlessFrameID wid, RegionPtr pDamage);
+
+/*
+ * Mark damaged rectangles as requiring redisplay to screen.
+ *  This will only be called if ROOTLESS_TRACK_DAMAGE is not set.
+ *
+ *  wid         Frame id
+ *  nrects      Number of damaged rectangles
+ *  rects       Array of damaged rectangles in frame-local coordinates
+ *  shift_x,    Vector to shift rectangles by
+ *   shift_y
+ */
+typedef void (*RootlessDamageRectsProc)
+    (RootlessFrameID wid, int nrects, const BoxRec *rects,
+     int shift_x, int shift_y);
+
+/*
+ * Switch the window associated with a frame. (Optional)
+ *  When a framed window is reparented, the frame is resized and set to
+ *  use the new top-level parent. If defined this function will be called
+ *  afterwards for implementation specific bookkeeping.
+ *
+ *  pFrame      Frame whose window has switched
+ *  oldWin      Previous window wrapped by this frame
+ */
+typedef void (*RootlessSwitchWindowProc)
+    (RootlessWindowPtr pFrame, WindowPtr oldWin);
+
+/*
+ * Copy bytes. (Optional)
+ *  Source and destinate may overlap and the right thing should happen.
+ *
+ *  width       Bytes to copy per row
+ *  height      Number of rows
+ *  src         Source data
+ *  srcRowBytes Width of source in bytes
+ *  dst         Destination data
+ *  dstRowBytes Width of destination in bytes
+ */
+typedef void (*RootlessCopyBytesProc)
+    (unsigned int width, unsigned int height,
+     const void *src, unsigned int srcRowBytes,
+     void *dst, unsigned int dstRowBytes);
+
+/*
+ * Fill memory with 32-bit pattern. (Optional)
+ *
+ *  width       Bytes to fill per row
+ *  height      Number of rows
+ *  value       32-bit pattern to fill with
+ *  dst         Destination data
+ *  dstRowBytes Width of destination in bytes
+ */
+typedef void (*RootlessFillBytesProc)
+    (unsigned int width, unsigned int height, unsigned int value,
+     void *dst, unsigned int dstRowBytes);
+
+/*
+ * Composite pixels from source and mask to destination. (Optional)
+ *
+ *  width, height   Size of area to composite to in pizels
+ *  function        Composite function built with RL_COMPOSITE_FUNCTION
+ *  src             Source data
+ *  srcRowBytes     Width of source in bytes (Passing NULL means source
+ *                  is a single pixel.
+ *  mask            Mask data
+ *  maskRowBytes    Width of mask in bytes
+ *  dst             Destination data
+ *  dstRowBytes     Width of destination in bytes
+ *
+ *  For src and dst, the first element of the array is the color data. If
+ *  the second element is non-null it implies there is alpha data (which
+ *  may be meshed or planar). Data without alpha is assumed to be opaque.
+ *
+ *  An X11 error code is returned.
+ */
+typedef int (*RootlessCompositePixelsProc)
+    (unsigned int width, unsigned int height, unsigned int function,
+     void *src[2], unsigned int srcRowBytes[2],
+     void *mask, unsigned int maskRowBytes,
+     void *dst[2], unsigned int dstRowBytes[2]);
+
+/*
+ * Copy area in frame to another part of frame. (Optional)
+ *
+ *  wid         Frame id
+ *  dstNrects   Number of rectangles to copy
+ *  dstRects    Array of rectangles to copy
+ *  dx, dy      Number of pixels away to copy area
+ */
+typedef void (*RootlessCopyWindowProc)
+    (RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,
+     int dx, int dy);
+
+/*
+ * Rootless implementation function list
+ */
+typedef struct _RootlessFrameProcs {
+    RootlessCreateFrameProc CreateFrame;
+    RootlessDestroyFrameProc DestroyFrame;
+
+    RootlessMoveFrameProc MoveFrame;
+    RootlessResizeFrameProc ResizeFrame;
+    RootlessRestackFrameProc RestackFrame;
+    RootlessReshapeFrameProc ReshapeFrame;
+    RootlessUnmapFrameProc UnmapFrame;
+
+    RootlessStartDrawingProc StartDrawing;
+    RootlessStopDrawingProc StopDrawing;
+    RootlessUpdateRegionProc UpdateRegion;
+#ifndef ROOTLESS_TRACK_DAMAGE
+    RootlessDamageRectsProc DamageRects;
+#endif
+
+    /* Optional frame functions */
+    RootlessSwitchWindowProc SwitchWindow;
+
+    /* Optional acceleration functions */
+    RootlessCopyBytesProc CopyBytes;
+    RootlessFillBytesProc FillBytes;
+    RootlessCompositePixelsProc CompositePixels;
+    RootlessCopyWindowProc CopyWindow;
+} RootlessFrameProcsRec, *RootlessFrameProcsPtr;
+
+
+/*
+ * Initialize rootless mode on the given screen.
+ */
+Bool RootlessInit(ScreenPtr pScreen, RootlessFrameProcsPtr procs);
+
+/*
+ * Return the frame ID for the physical window displaying the given window. 
+ *
+ *  create      If true and the window has no frame, attempt to create one
+ */
+RootlessFrameID RootlessFrameForWindow(WindowPtr pWin, Bool create);
+
+/*
+ * Return the top-level parent of a window.
+ *  The root is the top-level parent of itself, even though the root is
+ *  not otherwise considered to be a top-level window.
+ */
+WindowPtr TopLevelParent(WindowPtr pWindow);
+
+/*
+ * Prepare a window for direct access to its backing buffer.
+ */
+void RootlessStartDrawing(WindowPtr pWindow);
+
+/*
+ * Finish drawing to a window's backing buffer.
+ *
+ *  flush       If true and ROOTLESS_TRACK_DAMAGE is set, damaged areas
+ *              are flushed to the screen.
+ */
+void RootlessStopDrawing(WindowPtr pWindow, Bool flush);
+
+
+#endif /* _ROOTLESS_H */
diff --git a/miext/rootless/rootlessCommon.c b/miext/rootless/rootlessCommon.c
new file mode 100644
index 000000000..bc6259ea6
--- /dev/null
+++ b/miext/rootless/rootlessCommon.c
@@ -0,0 +1,380 @@
+/*
+ * Common rootless definitions and code
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessCommon.c,v 1.5 2003/11/10 18:22:50 tsi Exp $ */
+
+#include "rootlessCommon.h"
+
+unsigned int rootless_CopyBytes_threshold = 0;
+unsigned int rootless_FillBytes_threshold = 0;
+unsigned int rootless_CompositePixels_threshold = 0;
+unsigned int rootless_CopyWindow_threshold = 0;
+#ifdef ROOTLESS_GLOBAL_COORDS
+int rootlessGlobalOffsetX = 0;
+int rootlessGlobalOffsetY = 0;
+#endif
+
+RegionRec rootlessHugeRoot = {{-32767, -32767, 32767, 32767}, NULL};
+
+/* Following macro from miregion.c */
+
+/*  true iff two Boxes overlap */
+#define EXTENTCHECK(r1,r2) \
+      (!( ((r1)->x2 <= (r2)->x1)  || \
+          ((r1)->x1 >= (r2)->x2)  || \
+          ((r1)->y2 <= (r2)->y1)  || \
+          ((r1)->y1 >= (r2)->y2) ) )
+
+
+/*
+ * TopLevelParent
+ *  Returns the top-level parent of pWindow.
+ *  The root is the top-level parent of itself, even though the root is
+ *  not otherwise considered to be a top-level window.
+ */
+WindowPtr
+TopLevelParent(WindowPtr pWindow)
+{
+    WindowPtr top;
+
+    if (IsRoot(pWindow))
+        return pWindow;
+
+    top = pWindow;
+    while (top && ! IsTopLevel(top))
+        top = top->parent;
+
+    return top;
+}
+
+
+/*
+ * IsFramedWindow
+ *  Returns TRUE if this window is visible inside a frame
+ *  (e.g. it is visible and has a top-level or root parent)
+ */
+Bool
+IsFramedWindow(WindowPtr pWin)
+{
+    WindowPtr top;
+
+    if (!pWin->realized)
+        return FALSE;
+    top = TopLevelParent(pWin);
+
+    return (top && WINREC(top));
+}
+
+
+/*
+ * RootlessStartDrawing
+ *  Prepare a window for direct access to its backing buffer.
+ *  Each top-level parent has a Pixmap representing its backing buffer,
+ *  which all of its children inherit.
+ */
+void RootlessStartDrawing(WindowPtr pWindow)
+{
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    WindowPtr top = TopLevelParent(pWindow);
+    RootlessWindowRec *winRec;
+
+    if (top == NULL)
+        return;
+    winRec = WINREC(top);
+    if (winRec == NULL)
+        return;
+
+    // Make sure the window's top-level parent is prepared for drawing.
+    if (!winRec->is_drawing) {
+        int bw = wBorderWidth(top);
+
+        SCREENREC(pScreen)->imp->StartDrawing(winRec->wid, &winRec->pixelData,
+                                              &winRec->bytesPerRow);
+
+        winRec->pixmap =
+            GetScratchPixmapHeader(pScreen, winRec->width, winRec->height,
+                                   top->drawable.depth,
+                                   top->drawable.bitsPerPixel,
+                                   winRec->bytesPerRow,
+                                   winRec->pixelData);
+        SetPixmapBaseToScreen(winRec->pixmap,
+                              top->drawable.x - bw, top->drawable.y - bw);
+
+        winRec->is_drawing = TRUE;
+    }
+
+    winRec->oldPixmap = pScreen->GetWindowPixmap(pWindow);
+    pScreen->SetWindowPixmap(pWindow, winRec->pixmap);
+}
+
+
+/*
+ * RootlessStopDrawing
+ *  Stop drawing to a window's backing buffer. If flush is true,
+ *  damaged regions are flushed to the screen.
+ */
+void RootlessStopDrawing(WindowPtr pWindow, Bool flush)
+{
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    WindowPtr top = TopLevelParent(pWindow);
+    RootlessWindowRec *winRec;
+
+    if (top == NULL)
+        return;
+    winRec = WINREC(top);
+    if (winRec == NULL)
+        return;
+
+    if (winRec->is_drawing) {
+        SCREENREC(pScreen)->imp->StopDrawing(winRec->wid, flush);
+
+        FreeScratchPixmapHeader(winRec->pixmap);
+        pScreen->SetWindowPixmap(pWindow, winRec->oldPixmap);
+        winRec->pixmap = NULL;
+
+        winRec->is_drawing = FALSE;
+    }
+    else if (flush) {
+        SCREENREC(pScreen)->imp->UpdateRegion(winRec->wid, NULL);
+    }
+
+    if (flush && winRec->is_reorder_pending) {
+	winRec->is_reorder_pending = FALSE;
+	RootlessReorderWindow(pWindow);
+    }
+}
+
+
+/*
+ * RootlessDamageRegion
+ *  Mark a damaged region as requiring redisplay to screen.
+ *  pRegion is in GLOBAL coordinates.
+ */
+void
+RootlessDamageRegion(WindowPtr pWindow, RegionPtr pRegion)
+{
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    RootlessWindowRec *winRec;
+    RegionRec clipped;
+    WindowPtr pTop;
+    BoxPtr b1, b2;
+
+    RL_DEBUG_MSG("Damaged win 0x%x ", pWindow);
+
+    pTop = TopLevelParent(pWindow);
+    if (pTop == NULL)
+	return;
+
+    winRec = WINREC(pTop);
+    if (winRec == NULL)
+	return;
+
+    /* We need to intersect the drawn region with the clip of the window
+       to avoid marking places we didn't actually draw (which can cause
+       problems when the window has an extra client-side backing store)
+
+       But this is a costly operation and since we'll normally just be
+       drawing inside the clip, go to some lengths to avoid the general
+       case intersection. */
+
+    b1 = REGION_EXTENTS(pScreen, &pWindow->borderClip);
+    b2 = REGION_EXTENTS(pScreen, pRegion);
+
+    if (EXTENTCHECK(b1, b2)) {
+	/* Regions may overlap. */
+
+	if (REGION_NUM_RECTS(pRegion) == 1) {
+	    int in;
+
+	    /* Damaged region only has a single rect, so we can
+	       just compare that against the region */
+
+	    in = RECT_IN_REGION(pScreen, &pWindow->borderClip,
+                                REGION_RECTS (pRegion));
+	    if (in == rgnIN) {
+		/* clip totally contains pRegion */
+
+#ifdef ROOTLESS_TRACK_DAMAGE
+                REGION_UNION(pScreen, &winRec->damage,
+                             &winRec->damage, (pRegion));
+#else
+		SCREENREC(pScreen)->imp->DamageRects(winRec->wid,
+                                REGION_NUM_RECTS(pRegion),
+				REGION_RECTS(pRegion),
+				-winRec->x, -winRec->y);
+#endif
+
+		RootlessQueueRedisplay(pTop->drawable.pScreen);
+		goto out;
+	    }
+	    else if (in == rgnOUT) {
+		/* clip doesn't contain pRegion */
+
+		goto out;
+	    }
+	}
+
+	/* clip overlaps pRegion, need to intersect */
+
+	REGION_NULL(pScreen, &clipped);
+	REGION_INTERSECT(pScreen, &clipped, &pWindow->borderClip, pRegion);
+
+#ifdef ROOTLESS_TRACK_DAMAGE
+        REGION_UNION(pScreen, &winRec->damage,
+                     &winRec->damage, (pRegion));
+#else
+        SCREENREC(pScreen)->imp->DamageRects(winRec->wid,
+                        REGION_NUM_RECTS(&clipped),
+                        REGION_RECTS(&clipped),
+                        -winRec->x, -winRec->y);
+#endif
+
+	REGION_UNINIT(pScreen, &clipped);
+
+	RootlessQueueRedisplay(pTop->drawable.pScreen);
+    }
+
+out:
+#ifdef ROOTLESSDEBUG
+    {
+        BoxRec *box = REGION_RECTS(pRegion), *end;
+        int numBox = REGION_NUM_RECTS(pRegion);
+
+        for (end = box+numBox; box < end; box++) {
+            RL_DEBUG_MSG("Damage rect: %i, %i, %i, %i\n",
+                         box->x1, box->x2, box->y1, box->y2);
+        }
+    }
+#endif
+    return;
+}
+
+
+/*
+ * RootlessDamageBox
+ *  Mark a damaged box as requiring redisplay to screen.
+ *  pRegion is in GLOBAL coordinates.
+ */
+void
+RootlessDamageBox(WindowPtr pWindow, BoxPtr pBox)
+{
+    RegionRec region;
+
+    REGION_INIT(pWindow->drawable.pScreen, &region, pBox, 1);
+
+    RootlessDamageRegion(pWindow, &region);
+
+    REGION_UNINIT(pWindow->drawable.pScreen, &region);	/* no-op */
+}
+
+
+/*
+ * RootlessDamageRect
+ *  Mark a damaged rectangle as requiring redisplay to screen.
+ *  (x, y, w, h) is in window-local coordinates.
+ */
+void
+RootlessDamageRect(WindowPtr pWindow, int x, int y, int w, int h)
+{
+    BoxRec box;
+    RegionRec region;
+
+    x += pWindow->drawable.x;
+    y += pWindow->drawable.y;
+
+    box.x1 = x;
+    box.x2 = x + w;
+    box.y1 = y;
+    box.y2 = y + h;
+
+    REGION_INIT(pWindow->drawable.pScreen, &region, &box, 1);
+
+    RootlessDamageRegion(pWindow, &region);
+
+    REGION_UNINIT(pWindow->drawable.pScreen, &region);	/* no-op */
+}
+
+
+/*
+ * RootlessRedisplay
+ *  Stop drawing and redisplay the damaged region of a window.
+ */
+void
+RootlessRedisplay(WindowPtr pWindow)
+{
+#ifdef ROOTLESS_TRACK_DAMAGE
+
+    RootlessWindowRec *winRec = WINREC(pWindow);
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+
+    RootlessStopDrawing(pWindow, FALSE);
+
+    if (REGION_NOTEMPTY(pScreen, &winRec->damage)) {
+        RL_DEBUG_MSG("Redisplay Win 0x%x, %i x %i @ (%i, %i)\n",
+                     pWindow, winRec->width, winRec->height,
+                     winRec->x, winRec->y);
+
+        // move region to window local coords
+        REGION_TRANSLATE(pScreen, &winRec->damage,
+                         -winRec->x, -winRec->y);
+
+        SCREENREC(pScreen)->imp->UpdateRegion(winRec->wid, &winRec->damage);
+
+        REGION_EMPTY(pScreen, &winRec->damage);
+    }
+
+#else	/* !ROOTLESS_TRACK_DAMAGE */
+
+    RootlessStopDrawing(pWindow, TRUE);
+
+#endif
+}
+
+
+/*
+ * RootlessRedisplayScreen
+ *  Walk every window on a screen and redisplay the damaged regions.
+ */
+void
+RootlessRedisplayScreen(ScreenPtr pScreen)
+{
+    WindowPtr root = WindowTable[pScreen->myNum];
+
+    if (root != NULL) {
+        WindowPtr win;
+
+        RootlessRedisplay(root);
+        for (win = root->firstChild; win; win = win->nextSib) {
+            if (WINREC(win) != NULL) {
+                RootlessRedisplay(win);
+            }
+        }
+    }
+}
diff --git a/miext/rootless/rootlessCommon.h b/miext/rootless/rootlessCommon.h
new file mode 100644
index 000000000..973ec6291
--- /dev/null
+++ b/miext/rootless/rootlessCommon.h
@@ -0,0 +1,254 @@
+/*
+ * Common internal rootless definitions and code
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessCommon.h,v 1.4 2003/09/16 00:36:20 torrey Exp $ */
+
+#ifndef _ROOTLESSCOMMON_H
+#define _ROOTLESSCOMMON_H
+
+#include "rootless.h"
+#include "fb.h"
+
+#ifdef RENDER
+#include "picturestr.h"
+#endif
+
+
+// Debug output, or not.
+#ifdef ROOTLESSDEBUG
+#define RL_DEBUG_MSG ErrorF
+#else
+#define RL_DEBUG_MSG(a, ...)
+#endif
+
+
+// Global variables
+extern int rootlessGCPrivateIndex;
+extern int rootlessScreenPrivateIndex;
+extern int rootlessWindowPrivateIndex;
+
+
+// RootlessGCRec: private per-gc data
+typedef struct {
+    GCFuncs *originalFuncs;
+    GCOps *originalOps;
+} RootlessGCRec;
+
+
+// RootlessScreenRec: per-screen private data
+typedef struct _RootlessScreenRec {
+    // Rootless implementation functions
+    RootlessFrameProcsPtr imp;
+
+    // Wrapped screen functions
+    CreateScreenResourcesProcPtr CreateScreenResources;
+    CloseScreenProcPtr CloseScreen;
+
+    CreateWindowProcPtr CreateWindow;
+    DestroyWindowProcPtr DestroyWindow;
+    RealizeWindowProcPtr RealizeWindow;
+    UnrealizeWindowProcPtr UnrealizeWindow;
+    MoveWindowProcPtr MoveWindow;
+    ResizeWindowProcPtr ResizeWindow;
+    RestackWindowProcPtr RestackWindow;
+    ReparentWindowProcPtr ReparentWindow;
+    ChangeBorderWidthProcPtr ChangeBorderWidth;
+    PositionWindowProcPtr PositionWindow;
+    ChangeWindowAttributesProcPtr ChangeWindowAttributes;
+
+    CreateGCProcPtr CreateGC;
+    PaintWindowBackgroundProcPtr PaintWindowBackground;
+    PaintWindowBorderProcPtr PaintWindowBorder;
+    CopyWindowProcPtr CopyWindow;
+    GetImageProcPtr GetImage;
+    SourceValidateProcPtr SourceValidate;
+
+    MarkOverlappedWindowsProcPtr MarkOverlappedWindows;
+    ValidateTreeProcPtr ValidateTree;
+
+#ifdef SHAPE
+    SetShapeProcPtr SetShape;
+#endif
+
+#ifdef RENDER
+    CompositeProcPtr Composite;
+    GlyphsProcPtr Glyphs;
+#endif
+
+    void *pixmap_data;
+    unsigned int pixmap_data_size;
+
+    void *redisplay_timer;
+    unsigned int redisplay_timer_set :1;
+    unsigned int redisplay_queued :1;
+    unsigned int redisplay_expired :1;
+} RootlessScreenRec, *RootlessScreenPtr;
+
+
+#undef MIN
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+#undef MAX
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+
+// "Definition of the Porting Layer for the X11 Sample Server" says
+// unwrap and rewrap of screen functions is unnecessary, but
+// screen->CreateGC changes after a call to cfbCreateGC.
+
+#define SCREEN_UNWRAP(screen, fn) \
+    screen->fn = SCREENREC(screen)->fn;
+
+#define SCREEN_WRAP(screen, fn) \
+    SCREENREC(screen)->fn = screen->fn; \
+    screen->fn = Rootless##fn
+
+
+// Accessors for screen and window privates
+
+#define SCREENREC(pScreen) \
+   ((RootlessScreenRec *)(pScreen)->devPrivates[rootlessScreenPrivateIndex].ptr)
+
+#define WINREC(pWin) \
+    ((RootlessWindowRec *)(pWin)->devPrivates[rootlessWindowPrivateIndex].ptr)
+
+
+// Call a rootless implementation function.
+// Many rootless implementation functions are allowed to be NULL.
+#define CallFrameProc(pScreen, proc, params) \
+    if (SCREENREC(pScreen)->frameProcs.proc) { \
+        RL_DEBUG_MSG("calling frame proc " #proc " "); \
+        SCREENREC(pScreen)->frameProcs.proc params; \
+    }
+
+
+// BoxRec manipulators
+// Copied from shadowfb
+
+#define TRIM_BOX(box, pGC) { \
+    BoxPtr extents = &pGC->pCompositeClip->extents;\
+    if(box.x1 < extents->x1) box.x1 = extents->x1; \
+    if(box.x2 > extents->x2) box.x2 = extents->x2; \
+    if(box.y1 < extents->y1) box.y1 = extents->y1; \
+    if(box.y2 > extents->y2) box.y2 = extents->y2; \
+}
+
+#define TRANSLATE_BOX(box, pDraw) { \
+    box.x1 += pDraw->x; \
+    box.x2 += pDraw->x; \
+    box.y1 += pDraw->y; \
+    box.y2 += pDraw->y; \
+}
+
+#define TRIM_AND_TRANSLATE_BOX(box, pDraw, pGC) { \
+    TRANSLATE_BOX(box, pDraw); \
+    TRIM_BOX(box, pGC); \
+}
+
+#define BOX_NOT_EMPTY(box) \
+    (((box.x2 - box.x1) > 0) && ((box.y2 - box.y1) > 0))
+
+
+// HUGE_ROOT and NORMAL_ROOT
+// We don't want to clip windows to the edge of the screen.
+// HUGE_ROOT temporarily makes the root window really big.
+// This is needed as a wrapper around any function that calls
+// SetWinSize or SetBorderSize which clip a window against its
+// parents, including the root.
+
+extern RegionRec rootlessHugeRoot;
+
+#define HUGE_ROOT(pWin)                         \
+    do {                                        \
+        WindowPtr w = pWin;                     \
+        while (w->parent)                       \
+            w = w->parent;                      \
+        saveRoot = w->winSize;                  \
+        w->winSize = rootlessHugeRoot;          \
+    } while (0)
+
+#define NORMAL_ROOT(pWin)                       \
+    do {                                        \
+        WindowPtr w = pWin;                     \
+        while (w->parent)                       \
+            w = w->parent;                      \
+        w->winSize = saveRoot;                  \
+    } while (0)
+
+
+// Returns TRUE if this window is a top-level window (i.e. child of the root)
+// The root is not a top-level window.
+#define IsTopLevel(pWin) \
+    ((pWin)  &&  (pWin)->parent  &&  !(pWin)->parent->parent)
+
+// Returns TRUE if this window is a root window
+#define IsRoot(pWin) \
+    ((pWin) == WindowTable[(pWin)->drawable.pScreen->myNum])
+
+
+/*
+ * SetPixmapBaseToScreen
+ *  Move the given pixmap's base address to where pixel (0, 0)
+ *  would be if the pixmap's actual data started at (x, y).
+ *  Can't access the bits before the first word of the drawable's data in
+ *  rootless mode, so make sure our base address is always 32-bit aligned.
+ */
+#define SetPixmapBaseToScreen(pix, _x, _y) {				\
+    PixmapPtr   _pPix = (PixmapPtr) (pix);				\
+    _pPix->devPrivate.ptr = (char *) (_pPix->devPrivate.ptr) -		\
+                            ((int)(_x) * _pPix->drawable.bitsPerPixel/8 + \
+                             (int)(_y) * _pPix->devKind);		\
+    if (_pPix->drawable.bitsPerPixel != FB_UNIT) {			\
+        unsigned _diff = ((unsigned) _pPix->devPrivate.ptr) & 		\
+                         (FB_UNIT / CHAR_BIT - 1);			\
+	_pPix->devPrivate.ptr = (char *) (_pPix->devPrivate.ptr) - 	\
+                                _diff;					\
+        _pPix->drawable.x = _diff /					\
+                            (_pPix->drawable.bitsPerPixel / CHAR_BIT);	\
+    }									\
+}
+
+
+// Returns TRUE if this window is visible inside a frame
+// (e.g. it is visible and has a top-level or root parent)
+Bool IsFramedWindow(WindowPtr pWin);
+
+// Routines that cause regions to get redrawn.
+// DamageRegion and DamageRect are in global coordinates.
+// DamageBox is in window-local coordinates.
+void RootlessDamageRegion(WindowPtr pWindow, RegionPtr pRegion);
+void RootlessDamageRect(WindowPtr pWindow, int x, int y, int w, int h);
+void RootlessDamageBox(WindowPtr pWindow, BoxPtr pBox);
+void RootlessRedisplay(WindowPtr pWindow);
+void RootlessRedisplayScreen(ScreenPtr pScreen);
+
+void RootlessQueueRedisplay (ScreenPtr pScreen);
+
+// Move the window to it's correct place in the physical stacking order.
+void RootlessReorderWindow (WindowPtr pWin);
+
+#endif /* _ROOTLESSCOMMON_H */
diff --git a/miext/rootless/rootlessConfig.h b/miext/rootless/rootlessConfig.h
new file mode 100644
index 000000000..1a1a48a4a
--- /dev/null
+++ b/miext/rootless/rootlessConfig.h
@@ -0,0 +1,50 @@
+/*
+ * Platform specific rootless configuration
+ */
+/*
+ * Copyright (c) 2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessConfig.h,v 1.2 2003/10/24 00:33:14 torrey Exp $ */
+
+#ifndef _ROOTLESSCONFIG_H
+#define _ROOTLESSCONFIG_H
+
+#ifdef __DARWIN__
+
+# define ROOTLESS_ACCEL TRUE
+# define ROOTLESS_GLOBAL_COORDS TRUE
+# define ROOTLESS_PROTECT_ALPHA TRUE
+# define ROOTLESS_REDISPLAY_DELAY 10
+# define ROOTLESS_RESIZE_GRAVITY TRUE
+# undef  ROOTLESS_TRACK_DAMAGE
+
+/* Bit mask for alpha channel with a particular number of bits per
+   pixel. Note that we only care for 32bpp data. Mac OS X uses planar
+   alpha for 16bpp. */
+# define RootlessAlphaMask(bpp) ((bpp) == 32 ? 0xFF000000 : 0)
+
+#endif /* __DARWIN__ */
+
+#endif /* _ROOTLESSCONFIG_H */
diff --git a/miext/rootless/rootlessGC.c b/miext/rootless/rootlessGC.c
new file mode 100644
index 000000000..8c70135a1
--- /dev/null
+++ b/miext/rootless/rootlessGC.c
@@ -0,0 +1,1515 @@
+/*
+ * Graphics Context support for generic rootless X server
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessGC.c,v 1.2 2003/10/24 00:33:14 torrey Exp $ */
+
+#include "mi.h"
+#include "scrnintstr.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "dixfontstr.h"
+#include "mivalidate.h"
+#include "fb.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "rootlessCommon.h"
+
+#if ROOTLESS_ACCEL
+#include "rlAccel.h"
+#endif
+
+
+// GC functions
+static void RootlessValidateGC(GCPtr pGC, unsigned long changes,
+                               DrawablePtr pDrawable);
+static void RootlessChangeGC(GCPtr pGC, unsigned long mask);
+static void RootlessCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
+static void RootlessDestroyGC(GCPtr pGC);
+static void RootlessChangeClip(GCPtr pGC, int type, pointer pvalue,
+                               int nrects);
+static void RootlessDestroyClip(GCPtr pGC);
+static void RootlessCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
+
+GCFuncs rootlessGCFuncs = {
+    RootlessValidateGC,
+    RootlessChangeGC,
+    RootlessCopyGC,
+    RootlessDestroyGC,
+    RootlessChangeClip,
+    RootlessDestroyClip,
+    RootlessCopyClip,
+};
+
+// GC operations
+static void RootlessFillSpans();
+static void RootlessSetSpans();
+static void RootlessPutImage();
+static RegionPtr RootlessCopyArea();
+static RegionPtr RootlessCopyPlane();
+static void RootlessPolyPoint();
+static void RootlessPolylines();
+static void RootlessPolySegment();
+static void RootlessPolyRectangle();
+static void RootlessPolyArc();
+static void RootlessFillPolygon();
+static void RootlessPolyFillRect();
+static void RootlessPolyFillArc();
+static int RootlessPolyText8();
+static int RootlessPolyText16();
+static void RootlessImageText8();
+static void RootlessImageText16();
+static void RootlessImageGlyphBlt();
+static void RootlessPolyGlyphBlt();
+static void RootlessPushPixels();
+
+static GCOps rootlessGCOps = {
+    RootlessFillSpans,
+    RootlessSetSpans,
+    RootlessPutImage,
+    RootlessCopyArea,
+    RootlessCopyPlane,
+    RootlessPolyPoint,
+    RootlessPolylines,
+    RootlessPolySegment,
+    RootlessPolyRectangle,
+    RootlessPolyArc,
+    RootlessFillPolygon,
+    RootlessPolyFillRect,
+    RootlessPolyFillArc,
+    RootlessPolyText8,
+    RootlessPolyText16,
+    RootlessImageText8,
+    RootlessImageText16,
+    RootlessImageGlyphBlt,
+    RootlessPolyGlyphBlt,
+    RootlessPushPixels
+#ifdef NEED_LINEHELPER
+    , NULL
+#endif
+};
+
+/*
+   There are two issues we must contend with when drawing. These are
+   controlled with ROOTLESS_PROTECT_ALPHA and ROOTLESS_ACCEL.
+
+   If ROOTLESS_PROTECT_ALPHA is set, we have to make sure that the alpha
+   channel of the on screen windows is always opaque. fb makes this harder
+   than it would otherwise be by noticing that a planemask of 0x00ffffff
+   includes all bits when depth==24, and so it "optimizes" the planemask to
+   0xffffffff. We work around this by temporarily setting depth=bpp while
+   changing the GC.
+
+   So the normal situation (in 32 bit mode) is that the planemask is
+   0x00ffffff and thus fb leaves the alpha channel alone. The rootless
+   implementation is responsible for setting the alpha channel opaque
+   initially.
+
+   Unfortunately drawing with a planemask that doesn't have all bits set
+   normally causes fb to fall off its fastest paths when blitting and
+   filling.  So we try to recognize when we can relax the planemask back to
+   0xffffffff, and do that for the duration of the drawing operation,
+   setting the alpha channel in fg/bg pixels to opaque at the same time. We
+   can do this when drawing op is GXcopy. We can also do this when copying
+   from another window since its alpha channel must also be opaque.
+
+   The other issue to consider is that the rootless implementation may
+   provide accelerated drawing functions if ROOTLESS_ACCEL is set. For some
+   drawing primitives we swap in rootless acceleration functions, which use
+   the accelerated drawing functions where possible.
+
+   Where both alpha protection and acceleration is used, it is even a bigger
+   win to relax the planemask to all ones because most accelerated drawing
+   functions can only be used in this case. However, even if we can't set
+   the planemask to all ones, we can still use the accelerated
+   CompositePixels function for GXcopy if it is a forward copy. This is
+   mainly intended for copying from pixmaps to windows. The CompositePixels
+   operation used sets alpha to 0xFF during the copy.
+
+   The three macros below are used to implement this, potentially accelerated
+   drawing ops look something like this:
+
+   OP {
+       GC_SAVE(gc);
+       GCOP_UNWRAP(gc);
+
+       ...
+
+       if (can_accel_xxx(..) && otherwise-suitable)
+            GC_UNSET_PM(gc, dst);
+
+       gc->funcs->OP(gc, ...);
+
+       GC_RESTORE(gc, dst);
+       GCOP_WRAP(gc);
+   }
+
+ */
+
+#define GC_SAVE(pGC) 				\
+    unsigned long _save_fg = (pGC)->fgPixel;	\
+    unsigned long _save_bg = (pGC)->bgPixel;	\
+    unsigned long _save_pm = (pGC)->planemask;	\
+    Bool _changed = FALSE
+
+#define GC_RESTORE(pGC, pDraw)					\
+    do {							\
+        if (_changed) {						\
+            unsigned int depth = (pDraw)->depth;		\
+            (pGC)->fgPixel = _save_fg;				\
+            (pGC)->bgPixel = _save_bg;				\
+            (pGC)->planemask = _save_pm;			\
+            (pDraw)->depth = (pDraw)->bitsPerPixel;		\
+            VALIDATE_GC(pGC, GCForeground | GCBackground |	\
+                        GCPlaneMask, pDraw);			\
+            (pDraw)->depth = depth;				\
+        }							\
+    } while (0)
+
+#define GC_UNSET_PM(pGC, pDraw)						\
+    do {								\
+        unsigned int mask = RootlessAlphaMask ((pDraw)->bitsPerPixel);	\
+        if (((pGC)->planemask & mask) != mask) {			\
+            unsigned int depth = (pDraw)->depth;			\
+            (pGC)->fgPixel |= mask;					\
+            (pGC)->bgPixel |= mask;					\
+            (pGC)->planemask |= mask;					\
+            (pDraw)->depth = (pDraw)->bitsPerPixel;			\
+            VALIDATE_GC(pGC, GCForeground |				\
+                        GCBackground | GCPlaneMask, pDraw);		\
+            (pDraw)->depth = depth;					\
+            _changed = TRUE;						\
+        }								\
+    } while (0)
+
+#define VALIDATE_GC(pGC, changes, pDrawable)				\
+    do {								\
+        pGC->funcs->ValidateGC(pGC, changes, pDrawable);		\
+        if (((WindowPtr) pDrawable)->viewable) {			\
+            gcrec->originalOps = pGC->ops;				\
+        }								\
+    } while(0)
+
+static RootlessWindowRec *
+canAccelBlit (DrawablePtr pDraw, GCPtr pGC)
+{
+    WindowPtr pTop;
+    RootlessWindowRec *winRec;
+    unsigned int pm;
+
+    if (pGC->alu != GXcopy)
+        return NULL;
+
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return NULL;
+
+    pm = ~RootlessAlphaMask(pDraw->bitsPerPixel);
+    if ((pGC->planemask & pm) != pm)
+        return NULL;
+
+    pTop = TopLevelParent((WindowPtr) pDraw);
+    if (pTop == NULL)
+        return NULL;
+
+    winRec = WINREC(pTop);
+    if (winRec == NULL)
+        return NULL;
+
+    return winRec;
+}
+
+static inline RootlessWindowRec *
+canAccelFill(DrawablePtr pDraw, GCPtr pGC)
+{
+    if (pGC->fillStyle != FillSolid)
+        return NULL;
+
+    return canAccelBlit(pDraw, pGC);
+}
+
+static unsigned int
+boxBytes(DrawablePtr pDraw, BoxRec *box)
+{
+    unsigned int pixels;
+
+    pixels = (box->x2 - box->x1) * (box->y2 - box->y1);
+
+    return pixels * (pDraw->bitsPerPixel >> 3);
+}
+
+
+/*
+ * Screen function to create a graphics context
+ */
+Bool
+RootlessCreateGC(GCPtr pGC)
+{
+    RootlessGCRec *gcrec;
+    RootlessScreenRec *s;
+    Bool result;
+
+    SCREEN_UNWRAP(pGC->pScreen, CreateGC);
+    s = (RootlessScreenRec *) pGC->pScreen->
+            devPrivates[rootlessScreenPrivateIndex].ptr;
+    result = s->CreateGC(pGC);
+
+#if ROOTLESS_ACCEL
+    pGC->ops->FillSpans = rlFillSpans;
+    pGC->ops->CopyArea = rlCopyArea;
+    pGC->ops->PolyFillRect = rlPolyFillRect;
+    pGC->ops->ImageGlyphBlt = rlImageGlyphBlt;
+#endif
+
+    gcrec = (RootlessGCRec *) pGC->devPrivates[rootlessGCPrivateIndex].ptr;
+    gcrec->originalOps = NULL; // don't wrap ops yet
+    gcrec->originalFuncs = pGC->funcs;
+    pGC->funcs = &rootlessGCFuncs;
+
+    SCREEN_WRAP(pGC->pScreen, CreateGC);
+    return result;
+}
+
+
+/*
+ * GC funcs
+ *
+ * These wrap lower level GC funcs.
+ * ValidateGC wraps the GC ops iff dest is viewable.
+ * All the others just unwrap and call.
+ */
+
+// GCFUNC_UNRAP assumes funcs have been wrapped and 
+// does not assume ops have been wrapped
+#define GCFUNC_UNWRAP(pGC) \
+    RootlessGCRec *gcrec = (RootlessGCRec *) \
+        (pGC)->devPrivates[rootlessGCPrivateIndex].ptr; \
+    (pGC)->funcs = gcrec->originalFuncs; \
+    if (gcrec->originalOps) { \
+        (pGC)->ops = gcrec->originalOps; \
+}
+
+#define GCFUNC_WRAP(pGC) \
+    gcrec->originalFuncs = (pGC)->funcs; \
+    (pGC)->funcs = &rootlessGCFuncs; \
+    if (gcrec->originalOps) { \
+        gcrec->originalOps = (pGC)->ops; \
+        (pGC)->ops = &rootlessGCOps; \
+}
+
+
+static void
+RootlessValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
+{
+    GCFUNC_UNWRAP(pGC);
+
+    gcrec->originalOps = NULL;
+
+    if (pDrawable->type == DRAWABLE_WINDOW)
+    {
+#ifdef ROOTLESS_PROTECT_ALPHA
+        unsigned int depth = pDrawable->depth;
+
+        // We force a planemask so fb doesn't overwrite the alpha channel.
+        // Left to its own devices, fb will optimize away the planemask.
+        pDrawable->depth = pDrawable->bitsPerPixel;
+        pGC->planemask &= ~RootlessAlphaMask(pDrawable->bitsPerPixel);
+        VALIDATE_GC(pGC, changes | GCPlaneMask, pDrawable);
+        pDrawable->depth = depth;
+#else
+        VALIDATE_GC(pGC, changes, pDrawable);
+#endif
+    } else {
+        pGC->funcs->ValidateGC(pGC, changes, pDrawable);
+    }
+
+    GCFUNC_WRAP(pGC);
+}
+
+static void RootlessChangeGC(GCPtr pGC, unsigned long mask)
+{
+    GCFUNC_UNWRAP(pGC);
+    pGC->funcs->ChangeGC(pGC, mask);
+    GCFUNC_WRAP(pGC);
+}
+
+static void RootlessCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
+{
+    GCFUNC_UNWRAP(pGCDst);
+    pGCDst->funcs->CopyGC(pGCSrc, mask, pGCDst);
+    GCFUNC_WRAP(pGCDst);
+}
+
+static void RootlessDestroyGC(GCPtr pGC)
+{
+    GCFUNC_UNWRAP(pGC);
+    pGC->funcs->DestroyGC(pGC);
+    GCFUNC_WRAP(pGC);
+}
+
+static void RootlessChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects)
+{
+    GCFUNC_UNWRAP(pGC);
+    pGC->funcs->ChangeClip(pGC, type, pvalue, nrects);
+    GCFUNC_WRAP(pGC);
+}
+
+static void RootlessDestroyClip(GCPtr pGC)
+{
+    GCFUNC_UNWRAP(pGC);
+    pGC->funcs->DestroyClip(pGC);
+    GCFUNC_WRAP(pGC);
+}
+
+static void RootlessCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
+{
+    GCFUNC_UNWRAP(pgcDst);
+    pgcDst->funcs->CopyClip(pgcDst, pgcSrc);
+    GCFUNC_WRAP(pgcDst);
+}
+
+
+/*
+ * GC ops
+ *
+ * We can't use shadowfb because shadowfb assumes one pixmap
+ * and our root window is a special case.
+ * However, much of this code is copied from shadowfb.
+ */
+
+// assumes both funcs and ops are wrapped
+#define GCOP_UNWRAP(pGC) \
+    RootlessGCRec *gcrec = (RootlessGCRec *) \
+        (pGC)->devPrivates[rootlessGCPrivateIndex].ptr; \
+    GCFuncs *saveFuncs = pGC->funcs; \
+    (pGC)->funcs = gcrec->originalFuncs; \
+    (pGC)->ops = gcrec->originalOps;
+
+#define GCOP_WRAP(pGC) \
+    gcrec->originalOps = (pGC)->ops; \
+    (pGC)->funcs = saveFuncs; \
+    (pGC)->ops = &rootlessGCOps;
+
+/* Turn drawing on the root into a no-op */
+#define GC_IS_ROOT(pDst) ((pDst)->type == DRAWABLE_WINDOW \
+                            && IsRoot ((WindowPtr) (pDst)))
+
+#define GC_SKIP_ROOT(pDst)			\
+    do {					\
+        if (GC_IS_ROOT (pDst))			\
+            return;				\
+    } while (0)
+
+
+static void
+RootlessFillSpans(DrawablePtr dst, GCPtr pGC, int nInit,
+                  DDXPointPtr pptInit, int *pwidthInit, int sorted)
+{
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("fill spans start ");
+
+    if (nInit <= 0) {
+        pGC->ops->FillSpans(dst, pGC, nInit, pptInit, pwidthInit, sorted);
+    } else {
+        DDXPointPtr ppt = pptInit;
+        int *pwidth = pwidthInit;
+        int i = nInit;
+        BoxRec box;
+
+        box.x1 = ppt->x;
+        box.x2 = box.x1 + *pwidth;
+        box.y2 = box.y1 = ppt->y;
+
+        while (--i) {
+            ppt++;
+            pwidth++;
+            if (box.x1 > ppt->x)
+                box.x1 = ppt->x;
+            if (box.x2 < (ppt->x + *pwidth))
+                box.x2 = ppt->x + *pwidth;
+            if (box.y1 > ppt->y)
+                box.y1 = ppt->y;
+            else if (box.y2 < ppt->y)
+                box.y2 = ppt->y;
+        }
+
+        box.y2++;
+
+        RootlessStartDrawing((WindowPtr) dst);
+
+        if (canAccelFill(dst, pGC) &&
+            boxBytes(dst, &box) >= rootless_FillBytes_threshold)
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+        pGC->ops->FillSpans(dst, pGC, nInit, pptInit, pwidthInit, sorted);
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("fill spans end\n");
+}
+
+static void
+RootlessSetSpans(DrawablePtr dst, GCPtr pGC, char *pSrc,
+                 DDXPointPtr pptInit, int *pwidthInit,
+                 int nspans, int sorted)
+{
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("set spans start ");
+
+    if (nspans <= 0) {
+        pGC->ops->SetSpans(dst, pGC, pSrc, pptInit, pwidthInit,
+                           nspans, sorted);
+    } else {
+        DDXPointPtr ppt = pptInit;
+        int *pwidth = pwidthInit;
+        int i = nspans;
+        BoxRec box;
+
+        box.x1 = ppt->x;
+        box.x2 = box.x1 + *pwidth;
+        box.y2 = box.y1 = ppt->y;
+
+        while (--i) {
+            ppt++;
+            pwidth++;
+            if (box.x1 > ppt->x)
+                box.x1 = ppt->x;
+            if (box.x2 < (ppt->x + *pwidth))
+                box.x2 = ppt->x + *pwidth;
+            if (box.y1 > ppt->y)
+                box.y1 = ppt->y;
+            else if (box.y2 < ppt->y)
+                box.y2 = ppt->y;
+        }
+
+        box.y2++;
+
+        RootlessStartDrawing((WindowPtr) dst);
+        pGC->ops->SetSpans(dst, pGC, pSrc, pptInit, pwidthInit,
+                           nspans, sorted);
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("set spans end\n");
+}
+
+static void
+RootlessPutImage(DrawablePtr dst, GCPtr pGC,
+                 int depth, int x, int y, int w, int h,
+                 int leftPad, int format, char *pBits)
+{
+    BoxRec box;
+
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("put image start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->PutImage(dst, pGC, depth, x,y,w,h, leftPad, format, pBits);
+
+    box.x1 = x + dst->x;
+    box.x2 = box.x1 + w;
+    box.y1 = y + dst->y;
+    box.y2 = box.y1 + h;
+
+    TRIM_BOX(box, pGC);
+    if (BOX_NOT_EMPTY(box))
+        RootlessDamageBox ((WindowPtr) dst, &box);
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("put image end\n");
+}
+
+/* changed area is *dest* rect */
+static RegionPtr
+RootlessCopyArea(DrawablePtr pSrc, DrawablePtr dst, GCPtr pGC,
+                 int srcx, int srcy, int w, int h,
+                 int dstx, int dsty)
+{
+    RegionPtr result;
+    BoxRec box;
+
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+
+    if (GC_IS_ROOT(dst) || GC_IS_ROOT(pSrc))
+        return NULL;			/* nothing exposed */
+
+    RL_DEBUG_MSG("copy area start (src 0x%x, dst 0x%x)", pSrc, dst);
+
+    if (pSrc->type == DRAWABLE_WINDOW && IsFramedWindow((WindowPtr)pSrc)) {
+        unsigned int bytes;
+
+        /* If both source and dest are windows, and we're doing
+           a simple copy operation, we can remove the alpha-protecting
+           planemask (since source has opaque alpha as well) */
+
+        bytes = w * h * (pSrc->depth >> 3);
+
+        if (bytes >= rootless_CopyBytes_threshold && canAccelBlit(pSrc, pGC))
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+        RootlessStartDrawing((WindowPtr) pSrc);
+    }
+    RootlessStartDrawing((WindowPtr) dst);
+    result = pGC->ops->CopyArea(pSrc, dst, pGC, srcx, srcy, w, h, dstx, dsty);
+
+    box.x1 = dstx + dst->x;
+    box.x2 = box.x1 + w;
+    box.y1 = dsty + dst->y;
+    box.y2 = box.y1 + h;
+
+    TRIM_BOX(box, pGC);
+    if (BOX_NOT_EMPTY(box))
+        RootlessDamageBox ((WindowPtr) dst, &box);
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("copy area end\n");
+    return result;
+}
+
+/* changed area is *dest* rect */
+static RegionPtr RootlessCopyPlane(DrawablePtr pSrc, DrawablePtr dst,
+                                   GCPtr pGC, int srcx, int srcy,
+                                   int w, int h, int dstx, int dsty,
+                                   unsigned long plane)
+{
+    RegionPtr result;
+    BoxRec box;
+
+    GCOP_UNWRAP(pGC);
+
+    if (GC_IS_ROOT(dst) || GC_IS_ROOT(pSrc))
+        return NULL;			/* nothing exposed */
+
+    RL_DEBUG_MSG("copy plane start ");
+
+    if (pSrc->type == DRAWABLE_WINDOW && IsFramedWindow((WindowPtr)pSrc)) {
+        RootlessStartDrawing((WindowPtr) pSrc);
+    }
+    RootlessStartDrawing((WindowPtr) dst);
+    result = pGC->ops->CopyPlane(pSrc, dst, pGC, srcx, srcy, w, h,
+                                 dstx, dsty, plane);
+
+    box.x1 = dstx + dst->x;
+    box.x2 = box.x1 + w;
+    box.y1 = dsty + dst->y;
+    box.y2 = box.y1 + h;
+
+    TRIM_BOX(box, pGC);
+    if (BOX_NOT_EMPTY(box))
+        RootlessDamageBox ((WindowPtr) dst, &box);
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("copy plane end\n");
+    return result;
+}
+
+// Options for size of changed area:
+//  0 = box per point
+//  1 = big box around all points
+//  2 = accumulate point in 20 pixel radius
+#define ROOTLESS_CHANGED_AREA 1
+#define abs(a) ((a) > 0 ? (a) : -(a))
+
+/* changed area is box around all points */
+static void RootlessPolyPoint(DrawablePtr dst, GCPtr pGC,
+                              int mode, int npt, DDXPointPtr pptInit)
+{
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("polypoint start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->PolyPoint(dst, pGC, mode, npt, pptInit);
+
+    if (npt > 0) {
+#if ROOTLESS_CHANGED_AREA==0
+        // box per point
+        BoxRec box;
+
+        while (npt) {
+            box.x1 = pptInit->x;
+            box.y1 = pptInit->y;
+            box.x2 = box.x1 + 1;
+            box.y2 = box.y1 + 1;
+
+            TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+            if (BOX_NOT_EMPTY(box))
+                RootlessDamageBox ((WindowPtr) dst, &box);
+
+            npt--;
+            pptInit++;
+        }
+
+#elif ROOTLESS_CHANGED_AREA==1
+        // one big box
+        BoxRec box;
+
+        box.x2 = box.x1 = pptInit->x;
+        box.y2 = box.y1 = pptInit->y;
+        while (--npt) {
+            pptInit++;
+            if (box.x1 > pptInit->x)
+                box.x1 = pptInit->x;
+            else if (box.x2 < pptInit->x)
+                box.x2 = pptInit->x;
+            if (box.y1 > pptInit->y)
+                box.y1 = pptInit->y;
+            else if (box.y2 < pptInit->y)
+                box.y2 = pptInit->y;
+        }
+
+        box.x2++;
+        box.y2++;
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+
+#elif ROOTLESS_CHANGED_AREA==2
+        // clever(?) method: accumulate point in 20-pixel radius
+        BoxRec box;
+        int firstx, firsty;
+
+        box.x2 = box.x1 = firstx = pptInit->x;
+        box.y2 = box.y1 = firsty = pptInit->y;
+        while (--npt) {
+            pptInit++;
+            if (abs(pptInit->x - firstx) > 20 ||
+                abs(pptInit->y - firsty) > 20) {
+                box.x2++;
+                box.y2++;
+                TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+                if (BOX_NOT_EMPTY(box))
+                    RootlessDamageBox ((WindowPtr) dst, &box);
+                box.x2 = box.x1 = firstx = pptInit->x;
+                box.y2 = box.y1 = firsty = pptInit->y;
+            } else {
+                if (box.x1 > pptInit->x) box.x1 = pptInit->x;
+                else if (box.x2 < pptInit->x) box.x2 = pptInit->x;
+                if (box.y1 > pptInit->y) box.y1 = pptInit->y;
+                else if (box.y2 < pptInit->y) box.y2 = pptInit->y;
+            }
+        }
+        box.x2++;
+        box.y2++;
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox((WindowPtr) dst, &box);
+#endif  /* ROOTLESS_CHANGED_AREA */
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("polypoint end\n");
+}
+
+#undef ROOTLESS_CHANGED_AREA
+
+/* changed area is box around each line */
+static void RootlessPolylines(DrawablePtr dst, GCPtr pGC,
+                              int mode, int npt, DDXPointPtr pptInit)
+{
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("poly lines start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->Polylines(dst, pGC, mode, npt, pptInit);
+
+    if (npt > 0) {
+        BoxRec box;
+        int extra = pGC->lineWidth >> 1;
+
+        box.x2 = box.x1 = pptInit->x;
+        box.y2 = box.y1 = pptInit->y;
+
+        if (npt > 1) {
+            if (pGC->joinStyle == JoinMiter)
+                extra = 6 * pGC->lineWidth;
+            else if (pGC->capStyle == CapProjecting)
+                extra = pGC->lineWidth;
+        }
+
+        if (mode == CoordModePrevious) {
+            int x = box.x1;
+            int y = box.y1;
+
+            while (--npt) {
+                pptInit++;
+                x += pptInit->x;
+                y += pptInit->y;
+                if (box.x1 > x)
+                    box.x1 = x;
+                else if (box.x2 < x)
+                    box.x2 = x;
+                if (box.y1 > y)
+                    box.y1 = y;
+                else if (box.y2 < y)
+                    box.y2 = y;
+            }
+        } else {
+            while (--npt) {
+                pptInit++;
+                if (box.x1 > pptInit->x)
+                    box.x1 = pptInit->x;
+                else if (box.x2 < pptInit->x)
+                    box.x2 = pptInit->x;
+                if (box.y1 > pptInit->y)
+                    box.y1 = pptInit->y;
+                else if (box.y2 < pptInit->y)
+                    box.y2 = pptInit->y;
+            }
+        }
+
+        box.x2++;
+        box.y2++;
+
+        if (extra) {
+            box.x1 -= extra;
+            box.x2 += extra;
+            box.y1 -= extra;
+            box.y2 += extra;
+        }
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("poly lines end\n");
+}
+
+/* changed area is box around each line segment */
+static void RootlessPolySegment(DrawablePtr dst, GCPtr pGC,
+                                int nseg, xSegment *pSeg)
+{
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("poly segment start (win 0x%x)", dst);
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->PolySegment(dst, pGC, nseg, pSeg);
+
+    if (nseg > 0) {
+        BoxRec box;
+        int extra = pGC->lineWidth;
+
+        if (pGC->capStyle != CapProjecting)
+        extra >>= 1;
+
+        if (pSeg->x2 > pSeg->x1) {
+            box.x1 = pSeg->x1;
+            box.x2 = pSeg->x2;
+        } else {
+            box.x2 = pSeg->x1;
+            box.x1 = pSeg->x2;
+        }
+
+        if (pSeg->y2 > pSeg->y1) {
+            box.y1 = pSeg->y1;
+            box.y2 = pSeg->y2;
+        } else {
+            box.y2 = pSeg->y1;
+            box.y1 = pSeg->y2;
+        }
+
+        while (--nseg) {
+            pSeg++;
+            if (pSeg->x2 > pSeg->x1) {
+                if (pSeg->x1 < box.x1) box.x1 = pSeg->x1;
+                if (pSeg->x2 > box.x2) box.x2 = pSeg->x2;
+            } else {
+                if (pSeg->x2 < box.x1) box.x1 = pSeg->x2;
+                if (pSeg->x1 > box.x2) box.x2 = pSeg->x1;
+            }
+            if (pSeg->y2 > pSeg->y1) {
+                if (pSeg->y1 < box.y1) box.y1 = pSeg->y1;
+                if (pSeg->y2 > box.y2) box.y2 = pSeg->y2;
+            } else {
+                if (pSeg->y2 < box.y1) box.y1 = pSeg->y2;
+                if (pSeg->y1 > box.y2) box.y2 = pSeg->y1;
+            }
+        }
+
+        box.x2++;
+        box.y2++;
+
+        if (extra) {
+            box.x1 -= extra;
+            box.x2 += extra;
+            box.y1 -= extra;
+            box.y2 += extra;
+        }
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("poly segment end\n");
+}
+
+/* changed area is box around each line (not entire rects) */
+static void RootlessPolyRectangle(DrawablePtr dst, GCPtr pGC,
+                                  int nRects, xRectangle *pRects)
+{
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("poly rectangle start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->PolyRectangle(dst, pGC, nRects, pRects);
+
+    if (nRects > 0) {
+        BoxRec box;
+        int offset1, offset2, offset3;
+
+        offset2 = pGC->lineWidth;
+        if (!offset2) offset2 = 1;
+        offset1 = offset2 >> 1;
+        offset3 = offset2 - offset1;
+
+        while (nRects--) {
+            box.x1 = pRects->x - offset1;
+            box.y1 = pRects->y - offset1;
+            box.x2 = box.x1 + pRects->width + offset2;
+            box.y2 = box.y1 + offset2;
+            TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+            if (BOX_NOT_EMPTY(box))
+                RootlessDamageBox ((WindowPtr) dst, &box);
+
+            box.x1 = pRects->x - offset1;
+            box.y1 = pRects->y + offset3;
+            box.x2 = box.x1 + offset2;
+            box.y2 = box.y1 + pRects->height - offset2;
+            TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+            if (BOX_NOT_EMPTY(box))
+                RootlessDamageBox ((WindowPtr) dst, &box);
+
+            box.x1 = pRects->x + pRects->width - offset1;
+            box.y1 = pRects->y + offset3;
+            box.x2 = box.x1 + offset2;
+            box.y2 = box.y1 + pRects->height - offset2;
+            TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+            if (BOX_NOT_EMPTY(box))
+                RootlessDamageBox ((WindowPtr) dst, &box);
+
+            box.x1 = pRects->x - offset1;
+            box.y1 = pRects->y + pRects->height - offset1;
+            box.x2 = box.x1 + pRects->width + offset2;
+            box.y2 = box.y1 + offset2;
+            TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+            if (BOX_NOT_EMPTY(box))
+                RootlessDamageBox ((WindowPtr) dst, &box);
+
+            pRects++;
+        }
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("poly rectangle end\n");
+}
+
+
+/* changed area is box around each arc (assumes all arcs are 360 degrees) */
+static void RootlessPolyArc(DrawablePtr dst, GCPtr pGC, int narcs, xArc *parcs)
+{
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("poly arc start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->PolyArc(dst, pGC, narcs, parcs);
+
+    if (narcs > 0) {
+        int extra = pGC->lineWidth >> 1;
+        BoxRec box;
+
+        box.x1 = parcs->x;
+        box.x2 = box.x1 + parcs->width;
+        box.y1 = parcs->y;
+        box.y2 = box.y1 + parcs->height;
+
+        /* should I break these up instead ? */
+
+        while (--narcs) {
+            parcs++;
+            if (box.x1 > parcs->x)
+                box.x1 = parcs->x;
+            if (box.x2 < (parcs->x + parcs->width))
+                box.x2 = parcs->x + parcs->width;
+            if (box.y1 > parcs->y)
+                box.y1 = parcs->y;
+            if (box.y2 < (parcs->y + parcs->height))
+                box.y2 = parcs->y + parcs->height;
+        }
+
+        if (extra) {
+            box.x1 -= extra;
+            box.x2 += extra;
+            box.y1 -= extra;
+            box.y2 += extra;
+        }
+
+        box.x2++;
+        box.y2++;
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("poly arc end\n");
+}
+
+
+/* changed area is box around each poly */
+static void RootlessFillPolygon(DrawablePtr dst, GCPtr pGC,
+                                int shape, int mode, int count,
+                                DDXPointPtr pptInit)
+{
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("fill poly start (win 0x%x, fillStyle 0x%x)", dst,
+                 pGC->fillStyle);
+
+    if (count <= 2) {
+        pGC->ops->FillPolygon(dst, pGC, shape, mode, count, pptInit);
+    } else {
+        DDXPointPtr ppt = pptInit;
+        int i = count;
+        BoxRec box;
+
+        box.x2 = box.x1 = ppt->x;
+        box.y2 = box.y1 = ppt->y;
+
+        if (mode != CoordModeOrigin) {
+            int x = box.x1;
+            int y = box.y1;
+
+            while (--i) {
+                ppt++;
+                x += ppt->x;
+                y += ppt->y;
+                if (box.x1 > x)
+                    box.x1 = x;
+                else if (box.x2 < x)
+                    box.x2 = x;
+                if (box.y1 > y)
+                    box.y1 = y;
+                else if (box.y2 < y)
+                    box.y2 = y;
+            }
+        } else {
+            while (--i) {
+                ppt++;
+                if (box.x1 > ppt->x)
+                    box.x1 = ppt->x;
+                else if (box.x2 < ppt->x)
+                    box.x2 = ppt->x;
+                if (box.y1 > ppt->y)
+                    box.y1 = ppt->y;
+                else if (box.y2 < ppt->y)
+                    box.y2 = ppt->y;
+            }
+        }
+
+        box.x2++;
+        box.y2++;
+
+        RootlessStartDrawing((WindowPtr) dst);
+
+        if (canAccelFill(dst, pGC) &&
+            boxBytes(dst, &box) >= rootless_FillBytes_threshold)
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+        pGC->ops->FillPolygon(dst, pGC, shape, mode, count, pptInit);
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("fill poly end\n");
+}
+
+/* changed area is the rects */
+static void RootlessPolyFillRect(DrawablePtr dst, GCPtr pGC,
+                                 int nRectsInit, xRectangle *pRectsInit)
+{
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("fill rect start (win 0x%x, fillStyle 0x%x)", dst,
+                 pGC->fillStyle);
+
+    if (nRectsInit <= 0) {
+        pGC->ops->PolyFillRect(dst, pGC, nRectsInit, pRectsInit);
+    } else {
+        BoxRec box;
+        xRectangle *pRects = pRectsInit;
+        int nRects = nRectsInit;
+
+        box.x1 = pRects->x;
+        box.x2 = box.x1 + pRects->width;
+        box.y1 = pRects->y;
+        box.y2 = box.y1 + pRects->height;
+
+        while (--nRects) {
+            pRects++;
+            if (box.x1 > pRects->x)
+                box.x1 = pRects->x;
+            if (box.x2 < (pRects->x + pRects->width))
+                box.x2 = pRects->x + pRects->width;
+            if (box.y1 > pRects->y)
+                box.y1 = pRects->y;
+            if (box.y2 < (pRects->y + pRects->height))
+                box.y2 = pRects->y + pRects->height;
+        }
+
+        RootlessStartDrawing((WindowPtr) dst);
+ 
+        if (canAccelFill(dst, pGC) &&
+            boxBytes(dst, &box) >= rootless_FillBytes_threshold)
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+       pGC->ops->PolyFillRect(dst, pGC, nRectsInit, pRectsInit);
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("fill rect end\n");
+}
+
+
+/* changed area is box around each arc (assuming arcs are all 360 degrees) */
+static void RootlessPolyFillArc(DrawablePtr dst, GCPtr pGC,
+                                int narcsInit, xArc *parcsInit)
+{
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("fill arc start ");
+
+    if (narcsInit > 0) {
+        BoxRec box;
+        int narcs = narcsInit;
+        xArc *parcs = parcsInit;
+
+        box.x1 = parcs->x;
+        box.x2 = box.x1 + parcs->width;
+        box.y1 = parcs->y;
+        box.y2 = box.y1 + parcs->height;
+
+        /* should I break these up instead ? */
+
+        while (--narcs) {
+            parcs++;
+            if (box.x1 > parcs->x)
+                box.x1 = parcs->x;
+            if (box.x2 < (parcs->x + parcs->width))
+                box.x2 = parcs->x + parcs->width;
+            if (box.y1 > parcs->y)
+                box.y1 = parcs->y;
+            if (box.y2 < (parcs->y + parcs->height))
+                box.y2 = parcs->y + parcs->height;
+        }
+
+        RootlessStartDrawing((WindowPtr) dst);
+
+        if (canAccelFill(dst, pGC) &&
+            boxBytes(dst, &box) >= rootless_FillBytes_threshold)
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+        pGC->ops->PolyFillArc(dst, pGC, narcsInit, parcsInit);
+
+        TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    } else {
+        pGC->ops->PolyFillArc(dst, pGC, narcsInit, parcsInit);
+    }
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("fill arc end\n");
+}
+
+
+static void RootlessImageText8(DrawablePtr dst, GCPtr pGC,
+                               int x, int y, int count, char *chars)
+{
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("imagetext8 start ");
+
+    if (count > 0) {
+        int top, bot, Min, Max;
+        BoxRec box;
+
+        top = max(FONTMAXBOUNDS(pGC->font, ascent), FONTASCENT(pGC->font));
+        bot = max(FONTMAXBOUNDS(pGC->font, descent), FONTDESCENT(pGC->font));
+
+        Min = count * FONTMINBOUNDS(pGC->font, characterWidth);
+        if (Min > 0) Min = 0;
+        Max = count * FONTMAXBOUNDS(pGC->font, characterWidth);
+        if (Max < 0) Max = 0;
+
+        /* ugh */
+        box.x1 = dst->x + x + Min +
+        FONTMINBOUNDS(pGC->font, leftSideBearing);
+        box.x2 = dst->x + x + Max +
+        FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+        box.y1 = dst->y + y - top;
+        box.y2 = dst->y + y + bot;
+
+        RootlessStartDrawing((WindowPtr) dst);
+
+        if (canAccelFill(dst, pGC) &&
+            boxBytes(dst, &box) >= rootless_FillBytes_threshold)
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+        pGC->ops->ImageText8(dst, pGC, x, y, count, chars);
+
+        TRIM_BOX(box, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    } else {
+        pGC->ops->ImageText8(dst, pGC, x, y, count, chars);
+    }
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("imagetext8 end\n");
+}
+
+static int RootlessPolyText8(DrawablePtr dst, GCPtr pGC,
+                             int x, int y, int count, char *chars)
+{
+    int width; // the result, sorta
+
+    GCOP_UNWRAP(pGC);
+
+    if (GC_IS_ROOT(dst))
+        return 0;
+
+    RL_DEBUG_MSG("polytext8 start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    width = pGC->ops->PolyText8(dst, pGC, x, y, count, chars);
+    width -= x;
+
+    if (width > 0) {
+        BoxRec box;
+
+        /* ugh */
+        box.x1 = dst->x + x + FONTMINBOUNDS(pGC->font, leftSideBearing);
+        box.x2 = dst->x + x + FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+        if (count > 1) {
+            if (width > 0) box.x2 += width;
+            else box.x1 += width;
+        }
+
+        box.y1 = dst->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+        box.y2 = dst->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+        TRIM_BOX(box, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("polytext8 end\n");
+    return (width + x);
+}
+
+static void RootlessImageText16(DrawablePtr dst, GCPtr pGC,
+                                int x, int y, int count, unsigned short *chars)
+{
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("imagetext16 start ");
+
+    if (count > 0) {
+        int top, bot, Min, Max;
+        BoxRec box;
+
+        top = max(FONTMAXBOUNDS(pGC->font, ascent), FONTASCENT(pGC->font));
+        bot = max(FONTMAXBOUNDS(pGC->font, descent), FONTDESCENT(pGC->font));
+
+        Min = count * FONTMINBOUNDS(pGC->font, characterWidth);
+        if (Min > 0) Min = 0;
+        Max = count * FONTMAXBOUNDS(pGC->font, characterWidth);
+        if (Max < 0) Max = 0;
+
+        /* ugh */
+        box.x1 = dst->x + x + Min +
+            FONTMINBOUNDS(pGC->font, leftSideBearing);
+        box.x2 = dst->x + x + Max +
+            FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+        box.y1 = dst->y + y - top;
+        box.y2 = dst->y + y + bot;
+
+        RootlessStartDrawing((WindowPtr) dst);
+
+        if (canAccelFill(dst, pGC) &&
+            boxBytes(dst, &box) >= rootless_FillBytes_threshold)
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+        pGC->ops->ImageText16(dst, pGC, x, y, count, chars);
+
+        TRIM_BOX(box, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    } else {
+        pGC->ops->ImageText16(dst, pGC, x, y, count, chars);
+    }
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("imagetext16 end\n");
+}
+
+static int RootlessPolyText16(DrawablePtr dst, GCPtr pGC,
+                            int x, int y, int count, unsigned short *chars)
+{
+    int width; // the result, sorta
+
+    GCOP_UNWRAP(pGC);
+
+    if (GC_IS_ROOT(dst))
+        return 0;
+
+    RL_DEBUG_MSG("polytext16 start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    width = pGC->ops->PolyText16(dst, pGC, x, y, count, chars);
+    width -= x;
+
+    if (width > 0) {
+        BoxRec box;
+
+        /* ugh */
+        box.x1 = dst->x + x + FONTMINBOUNDS(pGC->font, leftSideBearing);
+        box.x2 = dst->x + x + FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+        if (count > 1) {
+            if (width > 0) box.x2 += width;
+            else box.x1 += width;
+        }
+
+        box.y1 = dst->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+        box.y2 = dst->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+        TRIM_BOX(box, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("polytext16 end\n");
+    return width + x;
+}
+
+static void RootlessImageGlyphBlt(DrawablePtr dst, GCPtr pGC,
+                                  int x, int y, unsigned int nglyphInit,
+                                  CharInfoPtr *ppciInit, pointer unused)
+{
+    GC_SAVE(pGC);
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("imageglyph start ");
+
+    if (nglyphInit > 0) {
+        int top, bot, width = 0;
+        BoxRec box;
+        unsigned int nglyph = nglyphInit;
+        CharInfoPtr *ppci = ppciInit;
+
+        top = max(FONTMAXBOUNDS(pGC->font, ascent), FONTASCENT(pGC->font));
+        bot = max(FONTMAXBOUNDS(pGC->font, descent), FONTDESCENT(pGC->font));
+
+        box.x1 = ppci[0]->metrics.leftSideBearing;
+        if (box.x1 > 0) box.x1 = 0;
+        box.x2 = ppci[nglyph - 1]->metrics.rightSideBearing -
+            ppci[nglyph - 1]->metrics.characterWidth;
+        if (box.x2 < 0) box.x2 = 0;
+
+        box.x2 += dst->x + x;
+        box.x1 += dst->x + x;
+
+        while (nglyph--) {
+            width += (*ppci)->metrics.characterWidth;
+            ppci++;
+        }
+
+        if (width > 0)
+            box.x2 += width;
+        else
+            box.x1 += width;
+
+        box.y1 = dst->y + y - top;
+        box.y2 = dst->y + y + bot;
+
+        RootlessStartDrawing((WindowPtr) dst);
+
+        if (canAccelFill(dst, pGC) &&
+            boxBytes(dst, &box) >= rootless_FillBytes_threshold)
+        {
+            GC_UNSET_PM(pGC, dst);
+        }
+
+        pGC->ops->ImageGlyphBlt(dst, pGC, x, y, nglyphInit, ppciInit, unused);
+
+        TRIM_BOX(box, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    } else {
+        pGC->ops->ImageGlyphBlt(dst, pGC, x, y, nglyphInit, ppciInit, unused);
+    }
+
+    GC_RESTORE(pGC, dst);
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("imageglyph end\n");
+}
+
+static void RootlessPolyGlyphBlt(DrawablePtr dst, GCPtr pGC,
+                                 int x, int y, unsigned int nglyph,
+                                 CharInfoPtr *ppci, pointer pglyphBase)
+{
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("polyglyph start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->PolyGlyphBlt(dst, pGC, x, y, nglyph, ppci, pglyphBase);
+
+    if (nglyph > 0) {
+        BoxRec box;
+
+        /* ugh */
+        box.x1 = dst->x + x + ppci[0]->metrics.leftSideBearing;
+        box.x2 = dst->x + x + ppci[nglyph - 1]->metrics.rightSideBearing;
+
+        if (nglyph > 1) {
+            int width = 0;
+
+            while (--nglyph) {
+                width += (*ppci)->metrics.characterWidth;
+                ppci++;
+            }
+
+            if (width > 0) box.x2 += width;
+            else box.x1 += width;
+        }
+
+        box.y1 = dst->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+        box.y2 = dst->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+        TRIM_BOX(box, pGC);
+        if (BOX_NOT_EMPTY(box))
+            RootlessDamageBox ((WindowPtr) dst, &box);
+    }
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("polyglyph end\n");
+}
+
+
+/* changed area is in dest */
+static void
+RootlessPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr dst,
+                   int dx, int dy, int xOrg, int yOrg)
+{
+    BoxRec box;
+
+    GCOP_UNWRAP(pGC);
+    GC_SKIP_ROOT(dst);
+    RL_DEBUG_MSG("push pixels start ");
+
+    RootlessStartDrawing((WindowPtr) dst);
+    pGC->ops->PushPixels(pGC, pBitMap, dst, dx, dy, xOrg, yOrg);
+
+    box.x1 = xOrg + dst->x;
+    box.x2 = box.x1 + dx;
+    box.y1 = yOrg + dst->y;
+    box.y2 = box.y1 + dy;
+
+    TRIM_BOX(box, pGC);
+    if (BOX_NOT_EMPTY(box))
+        RootlessDamageBox ((WindowPtr) dst, &box);
+
+    GCOP_WRAP(pGC);
+    RL_DEBUG_MSG("push pixels end\n");
+}
diff --git a/miext/rootless/rootlessScreen.c b/miext/rootless/rootlessScreen.c
new file mode 100644
index 000000000..beb737df1
--- /dev/null
+++ b/miext/rootless/rootlessScreen.c
@@ -0,0 +1,666 @@
+/*
+ * Screen routines for generic rootless X server
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessScreen.c,v 1.3 2003/06/30 01:45:13 torrey Exp $ */
+
+
+#include "mi.h"
+#include "scrnintstr.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "propertyst.h"
+#include "mivalidate.h"
+#include "picturestr.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "rootlessCommon.h"
+#include "rootlessWindow.h"
+
+/* In milliseconds */
+#ifndef ROOTLESS_REDISPLAY_DELAY
+#define ROOTLESS_REDISPLAY_DELAY 10
+#endif
+
+extern int RootlessMiValidateTree(WindowPtr pRoot, WindowPtr pChild,
+                                  VTKind kind);
+extern Bool RootlessCreateGC(GCPtr pGC);
+
+// Initialize globals
+int rootlessGCPrivateIndex = -1;
+int rootlessScreenPrivateIndex = -1;
+int rootlessWindowPrivateIndex = -1;
+
+
+/*
+ * RootlessUpdateScreenPixmap
+ *  miCreateScreenResources does not like a null framebuffer pointer,
+ *  it leaves the screen pixmap with an uninitialized data pointer.
+ *  Thus, rootless implementations typically set the framebuffer width
+ *  to zero so that miCreateScreenResources does not allocate a screen
+ *  pixmap for us. We allocate our own screen pixmap here since we need
+ *  the screen pixmap to be valid (e.g. CopyArea from the root window).
+ */
+void
+RootlessUpdateScreenPixmap(ScreenPtr pScreen)
+{
+    RootlessScreenRec *s = SCREENREC(pScreen);
+    PixmapPtr pPix;
+    unsigned int rowbytes;
+
+    pPix = (*pScreen->GetScreenPixmap)(pScreen);
+    if (pPix == NULL) {
+        pPix = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScreen->rootDepth);
+        (*pScreen->SetScreenPixmap)(pPix);
+    }
+
+    rowbytes = PixmapBytePad(pScreen->width, pScreen->rootDepth);
+
+    if (s->pixmap_data_size < rowbytes) {
+        if (s->pixmap_data != NULL)
+            xfree(s->pixmap_data);
+
+        s->pixmap_data_size = rowbytes;
+        s->pixmap_data = xalloc(s->pixmap_data_size);
+        if (s->pixmap_data == NULL)
+            return;
+
+        memset(s->pixmap_data, 0xFF, s->pixmap_data_size);
+
+        pScreen->ModifyPixmapHeader(pPix, pScreen->width, pScreen->height,
+                                    pScreen->rootDepth,
+                                    BitsPerPixel(pScreen->rootDepth),
+                                    0, s->pixmap_data);
+        /* ModifyPixmapHeader ignores zero arguments, so install rowbytes
+           by hand. */
+        pPix->devKind = 0;
+    }
+}
+
+
+/*
+ * RootlessCreateScreenResources
+ *  Rootless implementations typically set a null framebuffer pointer, which
+ *  causes problems with miCreateScreenResources. We fix things up here.
+ */
+static Bool
+RootlessCreateScreenResources(ScreenPtr pScreen)
+{
+    Bool ret = TRUE;
+
+    SCREEN_UNWRAP(pScreen, CreateScreenResources);
+
+    if (pScreen->CreateScreenResources != NULL)
+        ret = (*pScreen->CreateScreenResources)(pScreen);
+
+    SCREEN_WRAP(pScreen, CreateScreenResources);
+
+    if (!ret)
+        return ret;
+
+    /* Make sure we have a valid screen pixmap. */
+
+    RootlessUpdateScreenPixmap(pScreen);
+
+    return ret;
+}
+
+
+static Bool
+RootlessCloseScreen(int i, ScreenPtr pScreen)
+{
+    RootlessScreenRec *s;
+
+    s = SCREENREC(pScreen);
+
+    // fixme unwrap everything that was wrapped?
+    pScreen->CloseScreen = s->CloseScreen;
+
+    if (s->pixmap_data != NULL) {
+        xfree (s->pixmap_data);
+        s->pixmap_data = NULL;
+        s->pixmap_data_size = 0;
+    }
+
+    xfree(s);
+    return pScreen->CloseScreen(i, pScreen);
+}
+
+
+static void
+RootlessGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
+                 unsigned int format, unsigned long planeMask, char *pdstLine)
+{
+    ScreenPtr pScreen = pDrawable->pScreen;
+    SCREEN_UNWRAP(pScreen, GetImage);
+
+    if (pDrawable->type == DRAWABLE_WINDOW) {
+        int x0, y0, x1, y1;
+        RootlessWindowRec *winRec;
+
+        // Many apps use GetImage to sync with the visible frame buffer
+        // FIXME: entire screen or just window or all screens?
+        RootlessRedisplayScreen(pScreen);
+
+        // RedisplayScreen stops drawing, so we need to start it again
+        RootlessStartDrawing((WindowPtr)pDrawable);
+
+        /* Check that we have some place to read from. */
+        winRec = WINREC(TopLevelParent((WindowPtr) pDrawable));
+        if (winRec == NULL)
+            goto out;
+
+        /* Clip to top-level window bounds. */
+        /* FIXME: fbGetImage uses the width parameter to calculate the
+           stride of the destination pixmap. If w is clipped, the data
+           returned will be garbage, although we will not crash. */
+
+        x0 = pDrawable->x + sx;
+        y0 = pDrawable->y + sy;
+        x1 = x0 + w;
+        y1 = y0 + h;
+
+        x0 = MAX (x0, winRec->x);
+        y0 = MAX (y0, winRec->y);
+        x1 = MIN (x1, winRec->x + winRec->width);
+        y1 = MIN (y1, winRec->y + winRec->height);
+
+        sx = x0 - pDrawable->x;
+        sy = y0 - pDrawable->y;
+        w = x1 - x0;
+        h = y1 - y0;
+
+        if (w <= 0 || h <= 0)
+            goto out;
+    }
+
+    pScreen->GetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
+
+out:
+    SCREEN_WRAP(pScreen, GetImage);
+}
+
+
+/*
+ * RootlessSourceValidate
+ *  CopyArea and CopyPlane use a GC tied to the destination drawable.
+ *  StartDrawing/StopDrawing wrappers won't be called if source is
+ *  a visible window but the destination isn't. So, we call StartDrawing
+ *  here and leave StopDrawing for the block handler.
+ */
+static void
+RootlessSourceValidate(DrawablePtr pDrawable, int x, int y, int w, int h)
+{
+    SCREEN_UNWRAP(pDrawable->pScreen, SourceValidate);
+    if (pDrawable->type == DRAWABLE_WINDOW) {
+        WindowPtr pWin = (WindowPtr)pDrawable;
+        RootlessStartDrawing(pWin);
+    }
+    if (pDrawable->pScreen->SourceValidate) {
+        pDrawable->pScreen->SourceValidate(pDrawable, x, y, w, h);
+    }
+    SCREEN_WRAP(pDrawable->pScreen, SourceValidate);
+}
+
+#ifdef RENDER
+
+static void
+RootlessComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
+                  INT16 xSrc, INT16 ySrc, INT16  xMask, INT16  yMask,
+                  INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
+{
+    ScreenPtr pScreen = pDst->pDrawable->pScreen;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    WindowPtr srcWin, dstWin, maskWin = NULL;
+
+    if (pMask) {                        // pMask can be NULL
+        maskWin = (pMask->pDrawable->type == DRAWABLE_WINDOW) ?
+                  (WindowPtr)pMask->pDrawable :  NULL;
+    }
+    srcWin  = (pSrc->pDrawable->type  == DRAWABLE_WINDOW) ?
+              (WindowPtr)pSrc->pDrawable  :  NULL;
+    dstWin  = (pDst->pDrawable->type == DRAWABLE_WINDOW) ?
+              (WindowPtr)pDst->pDrawable  :  NULL;
+
+    // SCREEN_UNWRAP(ps, Composite);
+    ps->Composite = SCREENREC(pScreen)->Composite;
+
+    if (srcWin  && IsFramedWindow(srcWin))
+        RootlessStartDrawing(srcWin);
+    if (maskWin && IsFramedWindow(maskWin))
+        RootlessStartDrawing(maskWin);
+    if (dstWin  && IsFramedWindow(dstWin))
+        RootlessStartDrawing(dstWin);
+
+    ps->Composite(op, pSrc, pMask, pDst,
+                  xSrc, ySrc, xMask, yMask,
+                  xDst, yDst, width, height);
+
+    if (dstWin  && IsFramedWindow(dstWin)) {
+        RootlessDamageRect(dstWin, xDst, yDst, width, height);
+    }
+
+    ps->Composite = RootlessComposite;
+    // SCREEN_WRAP(ps, Composite);
+}
+
+
+static void
+RootlessGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+               PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
+               int nlist, GlyphListPtr list, GlyphPtr *glyphs)
+{
+    ScreenPtr pScreen = pDst->pDrawable->pScreen;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    int x, y;
+    int n;
+    GlyphPtr glyph;
+    WindowPtr srcWin, dstWin;
+
+    srcWin = (pSrc->pDrawable->type == DRAWABLE_WINDOW) ?
+             (WindowPtr)pSrc->pDrawable  :  NULL;
+    dstWin = (pDst->pDrawable->type == DRAWABLE_WINDOW) ?
+             (WindowPtr)pDst->pDrawable  :  NULL;
+
+    if (srcWin && IsFramedWindow(srcWin)) RootlessStartDrawing(srcWin);
+    if (dstWin && IsFramedWindow(dstWin)) RootlessStartDrawing(dstWin);
+
+    //SCREEN_UNWRAP(ps, Glyphs);
+    ps->Glyphs = SCREENREC(pScreen)->Glyphs;
+    ps->Glyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
+    ps->Glyphs = RootlessGlyphs;
+    //SCREEN_WRAP(ps, Glyphs);
+
+    if (dstWin && IsFramedWindow(dstWin)) {
+        x = xSrc;
+        y = ySrc;
+
+        while (nlist--) {
+            x += list->xOff;
+            y += list->yOff;
+            n = list->len;
+
+            /* Calling DamageRect for the bounding box of each glyph is
+               inefficient. So compute the union of all glyphs in a list
+               and damage that. */
+
+            if (n > 0) {
+                BoxRec box;
+
+                glyph = *glyphs++;
+
+                box.x1 = x - glyph->info.x;
+                box.y1 = y - glyph->info.y;
+                box.x2 = box.x1 + glyph->info.width;
+                box.y2 = box.y2 + glyph->info.height;
+
+                x += glyph->info.xOff;
+                y += glyph->info.yOff;
+
+                while (--n > 0) {
+                    short x1, y1, x2, y2;
+
+                    glyph = *glyphs++;
+
+                    x1 = x - glyph->info.x;
+                    y1 = y - glyph->info.y;
+                    x2 = x1 + glyph->info.width;
+                    y2 = y1 + glyph->info.height;
+
+                    box.x1 = MAX (box.x1, x1);
+                    box.y1 = MAX (box.y1, y1);
+                    box.x2 = MAX (box.x2, x2);
+                    box.y2 = MAX (box.y2, y2);
+
+                    x += glyph->info.xOff;
+                    y += glyph->info.yOff;
+                }
+
+                RootlessDamageBox(dstWin, &box);
+            }
+            list++;
+        }
+    }
+}
+
+#endif // RENDER
+
+
+/*
+ * RootlessValidateTree
+ *  ValidateTree is modified in two ways:
+ *   - top-level windows don't clip each other
+ *   - windows aren't clipped against root.
+ *  These only matter when validating from the root.
+ */
+static int
+RootlessValidateTree(WindowPtr pParent, WindowPtr pChild, VTKind kind)
+{
+    int result;
+    RegionRec saveRoot;
+    ScreenPtr pScreen = pParent->drawable.pScreen;
+
+    SCREEN_UNWRAP(pScreen, ValidateTree);
+    RL_DEBUG_MSG("VALIDATETREE start ");
+
+    // Use our custom version to validate from root
+    if (IsRoot(pParent)) {
+        RL_DEBUG_MSG("custom ");
+        result = RootlessMiValidateTree(pParent, pChild, kind);
+    } else {
+        HUGE_ROOT(pParent);
+        result = pScreen->ValidateTree(pParent, pChild, kind);
+        NORMAL_ROOT(pParent);
+    }
+
+    SCREEN_WRAP(pScreen, ValidateTree);
+    RL_DEBUG_MSG("VALIDATETREE end\n");
+
+    return result;
+}
+
+
+/*
+ * RootlessMarkOverlappedWindows
+ *  MarkOverlappedWindows is modified to ignore overlapping
+ *  top-level windows.
+ */
+static Bool
+RootlessMarkOverlappedWindows(WindowPtr pWin, WindowPtr pFirst,
+                              WindowPtr *ppLayerWin)
+{
+    RegionRec saveRoot;
+    Bool result;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    SCREEN_UNWRAP(pScreen, MarkOverlappedWindows);
+    RL_DEBUG_MSG("MARKOVERLAPPEDWINDOWS start ");
+
+    HUGE_ROOT(pWin);
+    if (IsRoot(pWin)) {
+        // root - mark nothing
+        RL_DEBUG_MSG("is root not marking ");
+        result = FALSE;
+    }
+    else if (! IsTopLevel(pWin)) {
+        // not top-level window - mark normally
+        result = pScreen->MarkOverlappedWindows(pWin, pFirst, ppLayerWin);
+    }
+    else {
+        //top-level window - mark children ONLY - NO overlaps with sibs (?)
+        // This code copied from miMarkOverlappedWindows()
+
+        register WindowPtr pChild;
+        Bool anyMarked = FALSE;
+        void (* MarkWindow)() = pScreen->MarkWindow;
+
+        RL_DEBUG_MSG("is top level! ");
+        /* single layered systems are easy */
+        if (ppLayerWin) *ppLayerWin = pWin;
+
+        if (pWin == pFirst) {
+            /* Blindly mark pWin and all of its inferiors.   This is a slight
+             * overkill if there are mapped windows that outside pWin's border,
+             * but it's better than wasting time on RectIn checks.
+             */
+            pChild = pWin;
+            while (1) {
+                if (pChild->viewable) {
+                    if (REGION_BROKEN (pScreen, &pChild->winSize))
+                        SetWinSize (pChild);
+                    if (REGION_BROKEN (pScreen, &pChild->borderSize))
+                        SetBorderSize (pChild);
+                    (* MarkWindow)(pChild);
+                    if (pChild->firstChild) {
+                        pChild = pChild->firstChild;
+                        continue;
+                    }
+                }
+                while (!pChild->nextSib && (pChild != pWin))
+                    pChild = pChild->parent;
+                if (pChild == pWin)
+                    break;
+                pChild = pChild->nextSib;
+            }
+            anyMarked = TRUE;
+            pFirst = pFirst->nextSib;
+        }
+        if (anyMarked)
+            (* MarkWindow)(pWin->parent);
+        result = anyMarked;
+    }
+    NORMAL_ROOT(pWin);
+    SCREEN_WRAP(pScreen, MarkOverlappedWindows);
+    RL_DEBUG_MSG("MARKOVERLAPPEDWINDOWS end\n");
+
+    return result;
+}
+
+
+static CARD32
+RootlessRedisplayCallback(OsTimerPtr timer, CARD32 time, void *arg)
+{
+    RootlessScreenRec *screenRec = arg;
+
+    if (!screenRec->redisplay_queued) {
+        /* No update needed. Stop the timer. */
+
+        screenRec->redisplay_timer_set = FALSE;
+        return 0;
+    }
+
+    screenRec->redisplay_queued = FALSE;
+
+    /* Mark that we should redisplay before waiting for I/O next time */
+    screenRec->redisplay_expired = TRUE;
+
+    /* Reinstall the timer immediately, so we get as close to our
+       redisplay interval as possible. */
+
+    return ROOTLESS_REDISPLAY_DELAY;
+}
+
+
+/*
+ * RootlessQueueRedisplay
+ *  Queue a redisplay after a timer delay to ensure we do not redisplay
+ *  too frequently.
+ */
+void
+RootlessQueueRedisplay(ScreenPtr pScreen)
+{
+    RootlessScreenRec *screenRec = SCREENREC(pScreen);
+
+    screenRec->redisplay_queued = TRUE;
+
+    if (screenRec->redisplay_timer_set)
+        return;
+
+    screenRec->redisplay_timer = TimerSet(screenRec->redisplay_timer,
+                                          0, ROOTLESS_REDISPLAY_DELAY,
+                                          RootlessRedisplayCallback,
+                                          screenRec);
+    screenRec->redisplay_timer_set = TRUE;
+}
+
+
+/*
+ * RootlessBlockHandler
+ *  If the redisplay timer has expired, flush drawing before blocking
+ *  on select().
+ */
+static void
+RootlessBlockHandler(pointer pbdata, OSTimePtr pTimeout, pointer pReadmask)
+{
+    ScreenPtr pScreen = pbdata;
+    RootlessScreenRec *screenRec = SCREENREC(pScreen);
+
+    if (screenRec->redisplay_expired) {
+        screenRec->redisplay_expired = FALSE;
+
+        RootlessRedisplayScreen(pScreen);
+    }
+}
+
+
+static void
+RootlessWakeupHandler(pointer data, int i, pointer LastSelectMask)
+{
+    // nothing here
+}
+
+
+static Bool
+RootlessAllocatePrivates(ScreenPtr pScreen)
+{
+    RootlessScreenRec *s;
+    static unsigned long rootlessGeneration = 0;
+
+    if (rootlessGeneration != serverGeneration) {
+        rootlessScreenPrivateIndex = AllocateScreenPrivateIndex();
+        if (rootlessScreenPrivateIndex == -1) return FALSE;
+        rootlessGCPrivateIndex = AllocateGCPrivateIndex();
+        if (rootlessGCPrivateIndex == -1) return FALSE;
+        rootlessWindowPrivateIndex = AllocateWindowPrivateIndex();
+        if (rootlessWindowPrivateIndex == -1) return FALSE;
+        rootlessGeneration = serverGeneration;
+    }
+
+    // no allocation needed for screen privates
+    if (!AllocateGCPrivate(pScreen, rootlessGCPrivateIndex,
+                           sizeof(RootlessGCRec)))
+        return FALSE;
+    if (!AllocateWindowPrivate(pScreen, rootlessWindowPrivateIndex, 0))
+        return FALSE;
+
+    s = xalloc(sizeof(RootlessScreenRec));
+    if (! s) return FALSE;
+    SCREENREC(pScreen) = s;
+
+    s->pixmap_data = NULL;
+    s->pixmap_data_size = 0;
+
+    s->redisplay_timer = NULL;
+    s->redisplay_timer_set = FALSE;
+
+    return TRUE;
+}
+
+
+static void
+RootlessWrap(ScreenPtr pScreen)
+{
+    RootlessScreenRec *s = (RootlessScreenRec*)
+            pScreen->devPrivates[rootlessScreenPrivateIndex].ptr;
+
+#define WRAP(a) \
+    if (pScreen->a) { \
+        s->a = pScreen->a; \
+    } else { \
+        RL_DEBUG_MSG("null screen fn " #a "\n"); \
+        s->a = NULL; \
+    } \
+    pScreen->a = Rootless##a
+
+    WRAP(CreateScreenResources);
+    WRAP(CloseScreen);
+    WRAP(CreateGC);
+    WRAP(PaintWindowBackground);
+    WRAP(PaintWindowBorder);
+    WRAP(CopyWindow);
+    WRAP(GetImage);
+    WRAP(SourceValidate);
+    WRAP(CreateWindow);
+    WRAP(DestroyWindow);
+    WRAP(RealizeWindow);
+    WRAP(UnrealizeWindow);
+    WRAP(MoveWindow);
+    WRAP(PositionWindow);
+    WRAP(ResizeWindow);
+    WRAP(RestackWindow);
+    WRAP(ReparentWindow);
+    WRAP(ChangeBorderWidth);
+    WRAP(MarkOverlappedWindows);
+    WRAP(ValidateTree);
+    WRAP(ChangeWindowAttributes);
+
+#ifdef SHAPE
+    WRAP(SetShape);
+#endif
+
+#ifdef RENDER
+    {
+        // Composite and Glyphs don't use normal screen wrapping
+        PictureScreenPtr ps = GetPictureScreen(pScreen);
+        s->Composite = ps->Composite;
+        ps->Composite = RootlessComposite;
+        s->Glyphs = ps->Glyphs;
+        ps->Glyphs = RootlessGlyphs;
+    }
+#endif
+
+    // WRAP(ClearToBackground); fixme put this back? useful for shaped wins?
+    // WRAP(RestoreAreas); fixme put this back?
+
+#undef WRAP
+}
+
+
+/*
+ * RootlessInit
+ *  Called by the rootless implementation to initialize the rootless layer.
+ *  Rootless wraps lots of stuff and needs a bunch of devPrivates.
+ */
+Bool RootlessInit(ScreenPtr pScreen, RootlessFrameProcsPtr procs)
+{
+    RootlessScreenRec *s;
+
+    if (!RootlessAllocatePrivates(pScreen))
+        return FALSE;
+
+    s = (RootlessScreenRec*)
+        pScreen->devPrivates[rootlessScreenPrivateIndex].ptr;
+
+    s->imp = procs;
+
+    RootlessWrap(pScreen);
+
+    if (!RegisterBlockAndWakeupHandlers(RootlessBlockHandler,
+                                        RootlessWakeupHandler,
+                                        (pointer) pScreen))
+    {
+        return FALSE;
+    }
+
+    return TRUE;
+}
diff --git a/miext/rootless/rootlessValTree.c b/miext/rootless/rootlessValTree.c
new file mode 100644
index 000000000..a95917939
--- /dev/null
+++ b/miext/rootless/rootlessValTree.c
@@ -0,0 +1,638 @@
+/*
+ * Calculate window clip lists for rootless mode
+ *
+ * This file is very closely based on mivaltree.c.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessValTree.c,v 1.2 2003/11/10 18:22:50 tsi Exp $ */
+
+/*
+ * mivaltree.c --
+ *	Functions for recalculating window clip lists. Main function
+ *	is miValidateTree.
+ *
+
+Copyright 1987, 1988, 1989, 1998  The Open Group
+
+All Rights Reserved.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+ *
+ * Copyright 1987, 1988, 1989 by 
+ * Digital Equipment Corporation, Maynard, Massachusetts,
+ * 
+ *                         All Rights Reserved
+ * 
+ * Permission to use, copy, modify, and distribute this software and its 
+ * documentation for any purpose and without fee is hereby granted, 
+ * provided that the above copyright notice appear in all copies and that
+ * both that copyright notice and this permission notice appear in 
+ * supporting documentation, and that the name of Digital not be
+ * used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  
+ * 
+ * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ * 
+ ******************************************************************/
+
+/* The panoramix components contained the following notice */
+/****************************************************************
+*                                                               *
+*    Copyright (c) Digital Equipment Corporation, 1991, 1997    *
+*                                                               *
+*   All Rights Reserved.  Unpublished rights  reserved  under   *
+*   the copyright laws of the United States.                    *
+*                                                               *
+*   The software contained on this media  is  proprietary  to   *
+*   and  embodies  the  confidential  technology  of  Digital   *
+*   Equipment Corporation.  Possession, use,  duplication  or   *
+*   dissemination of the software and media is authorized only  *
+*   pursuant to a valid written license from Digital Equipment  *
+*   Corporation.                                                *
+*                                                               *
+*   RESTRICTED RIGHTS LEGEND   Use, duplication, or disclosure  *
+*   by the U.S. Government is subject to restrictions  as  set  *
+*   forth in Subparagraph (c)(1)(ii)  of  DFARS  252.227-7013,  *
+*   or  in  FAR 52.227-19, as applicable.                       *
+*                                                               *
+*****************************************************************/
+
+ /* 
+  * Aug '86: Susan Angebranndt -- original code
+  * July '87: Adam de Boor -- substantially modified and commented
+  * Summer '89: Joel McCormack -- so fast you wouldn't believe it possible.
+  *             In particular, much improved code for window mapping and
+  *             circulating.
+  *		Bob Scheifler -- avoid miComputeClips for unmapped windows,
+  *				 valdata changes
+  */
+#include    "X.h"
+#include    "scrnintstr.h"
+#include    "validate.h"
+#include    "windowstr.h"
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "mivalidate.h"
+
+#include    "globals.h"
+
+#ifdef SHAPE
+/*
+ * Compute the visibility of a shaped window
+ */
+int
+RootlessShapedWindowIn (pScreen, universe, bounding, rect, x, y)
+    ScreenPtr	pScreen;
+    RegionPtr	universe, bounding;
+    BoxPtr	rect;
+    register int x, y;
+{
+    BoxRec  box;
+    register BoxPtr  boundBox;
+    int	    nbox;
+    Bool    someIn, someOut;
+    register int t, x1, y1, x2, y2;
+
+    nbox = REGION_NUM_RECTS (bounding);
+    boundBox = REGION_RECTS (bounding);
+    someIn = someOut = FALSE;
+    x1 = rect->x1;
+    y1 = rect->y1;
+    x2 = rect->x2;
+    y2 = rect->y2;
+    while (nbox--)
+    {
+	if ((t = boundBox->x1 + x) < x1)
+	    t = x1;
+	box.x1 = t;
+	if ((t = boundBox->y1 + y) < y1)
+	    t = y1;
+	box.y1 = t;
+	if ((t = boundBox->x2 + x) > x2)
+	    t = x2;
+	box.x2 = t;
+	if ((t = boundBox->y2 + y) > y2)
+	    t = y2;
+	box.y2 = t;
+	if (box.x1 > box.x2)
+	    box.x2 = box.x1;
+	if (box.y1 > box.y2)
+	    box.y2 = box.y1;
+	switch (RECT_IN_REGION(pScreen, universe, &box))
+	{
+	case rgnIN:
+	    if (someOut)
+		return rgnPART;
+	    someIn = TRUE;
+	    break;
+	case rgnOUT:
+	    if (someIn)
+		return rgnPART;
+	    someOut = TRUE;
+	    break;
+	default:
+	    return rgnPART;
+	}
+	boundBox++;
+    }
+    if (someIn)
+	return rgnIN;
+    return rgnOUT;
+}
+#endif
+
+#define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
+				    HasBorder(w) && \
+				    (w)->backgroundState == ParentRelative)
+
+
+/*
+ *-----------------------------------------------------------------------
+ * RootlessComputeClips --
+ *	Recompute the clipList, borderClip, exposed and borderExposed
+ *	regions for pParent and its children. Only viewable windows are
+ *	taken into account.
+ *
+ * Results:
+ *	None.
+ *
+ * Side Effects:
+ *	clipList, borderClip, exposed and borderExposed are altered.
+ *	A VisibilityNotify event may be generated on the parent window.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void
+RootlessComputeClips (pParent, pScreen, universe, kind, exposed)
+    register WindowPtr	pParent;
+    register ScreenPtr	pScreen;
+    register RegionPtr	universe;
+    VTKind		kind;
+    RegionPtr		exposed; /* for intermediate calculations */
+{
+    int			dx,
+			dy;
+    RegionRec		childUniverse;
+    register WindowPtr	pChild;
+    int     	  	oldVis, newVis;
+    BoxRec		borderSize;
+    RegionRec		childUnion;
+    Bool		overlap;
+    RegionPtr		borderVisible;
+    Bool		resized;
+    /*
+     * Figure out the new visibility of this window.
+     * The extent of the universe should be the same as the extent of
+     * the borderSize region. If the window is unobscured, this rectangle
+     * will be completely inside the universe (the universe will cover it
+     * completely). If the window is completely obscured, none of the
+     * universe will cover the rectangle.
+     */
+    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 = pParent->visibility;
+    switch (RECT_IN_REGION( pScreen, universe, &borderSize)) 
+    {
+    case rgnIN:
+	    newVis = VisibilityUnobscured;
+	    break;
+	case rgnPART:
+	    newVis = VisibilityPartiallyObscured;
+#ifdef SHAPE
+	    {
+		RegionPtr   pBounding;
+
+		if ((pBounding = wBoundingShape (pParent)))
+		{
+		    switch (RootlessShapedWindowIn (pScreen, universe, 
+						    pBounding, &borderSize,
+						    pParent->drawable.x,
+						    pParent->drawable.y))
+		    {
+		    case rgnIN:
+			newVis = VisibilityUnobscured;
+			break;
+		    case rgnOUT:
+			newVis = VisibilityFullyObscured;
+			break;
+		    }
+		}
+	    }
+#endif
+	    break;
+	default:
+	    newVis = VisibilityFullyObscured;
+	    break;
+    }
+
+    pParent->visibility = newVis;
+    if (oldVis != newVis &&
+	((pParent->eventMask | wOtherEventMasks(pParent)) & VisibilityChangeMask))
+	SendVisibilityNotify(pParent);
+
+    dx = pParent->drawable.x - pParent->valdata->before.oldAbsCorner.x;
+    dy = pParent->drawable.y - pParent->valdata->before.oldAbsCorner.y;
+
+    /*
+     * avoid computations when dealing with simple operations
+     */
+
+    switch (kind) {
+    case VTMap:
+    case VTStack:
+    case VTUnmap:
+	break;
+    case VTMove:
+	if ((oldVis == newVis) &&
+	    ((oldVis == VisibilityFullyObscured) ||
+	     (oldVis == VisibilityUnobscured)))
+	{
+	    pChild = pParent;
+	    while (1)
+	    {
+		if (pChild->viewable)
+		{
+		    if (pChild->visibility != VisibilityFullyObscured)
+		    {
+			REGION_TRANSLATE( pScreen, &pChild->borderClip,
+						      dx, dy);
+			REGION_TRANSLATE( pScreen, &pChild->clipList,
+						      dx, dy);
+			pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+			if (pScreen->ClipNotify)
+			    (* pScreen->ClipNotify) (pChild, dx, dy);
+
+		    }
+		    if (pChild->valdata)
+		    {
+			REGION_NULL(pScreen,
+				    &pChild->valdata->after.borderExposed);
+			if (HasParentRelativeBorder(pChild))
+			  {
+			    REGION_SUBTRACT(pScreen,
+					 &pChild->valdata->after.borderExposed,
+					 &pChild->borderClip,
+					 &pChild->winSize);
+			}
+			REGION_NULL(pScreen, &pChild->valdata->after.exposed);
+		    }
+		    if (pChild->firstChild)
+		    {
+			pChild = pChild->firstChild;
+			continue;
+		    }
+		}
+		while (!pChild->nextSib && (pChild != pParent))
+		    pChild = pChild->parent;
+		if (pChild == pParent)
+		    break;
+		pChild = pChild->nextSib;
+	    }
+	    return;
+	}
+	/* fall through */
+    default:
+    	/*
+     	 * To calculate exposures correctly, we have to translate the old
+     	 * borderClip and clipList regions to the window's new location so there
+     	 * is a correspondence between pieces of the new and old clipping regions.
+     	 */
+    	if (dx || dy) 
+    	{
+	    /*
+	     * We translate the old clipList because that will be exposed or copied
+	     * if gravity is right.
+	     */
+	    REGION_TRANSLATE( pScreen, &pParent->borderClip, dx, dy);
+	    REGION_TRANSLATE( pScreen, &pParent->clipList, dx, dy);
+    	} 
+	break;
+    case VTBroken:
+	REGION_EMPTY (pScreen, &pParent->borderClip);
+	REGION_EMPTY (pScreen, &pParent->clipList);
+	break;
+    }
+
+    borderVisible = pParent->valdata->before.borderVisible;
+    resized = pParent->valdata->before.resized;
+    REGION_NULL(pScreen, &pParent->valdata->after.borderExposed);
+    REGION_NULL(pScreen, &pParent->valdata->after.exposed);
+
+    /*
+     * Since the borderClip must not be clipped by the children, we do
+     * the border exposure first...
+     *
+     * 'universe' is the window's borderClip. To figure the exposures, remove
+     * the area that used to be exposed from the new.
+     * This leaves a region of pieces that weren't exposed before.
+     */
+
+    if (HasBorder (pParent))
+    {
+    	if (borderVisible)
+    	{
+	    /*
+	     * when the border changes shape, the old visible portions
+	     * of the border will be saved by DIX in borderVisible --
+	     * use that region and destroy it
+	     */
+	    REGION_SUBTRACT( pScreen, exposed, universe, borderVisible);
+	    REGION_DESTROY( pScreen, borderVisible);
+    	}
+    	else
+    	{
+	    REGION_SUBTRACT( pScreen, exposed, universe, &pParent->borderClip);
+    	}
+	if (HasParentRelativeBorder(pParent) && (dx || dy)) {
+	    REGION_SUBTRACT( pScreen, &pParent->valdata->after.borderExposed,
+				  universe,
+				  &pParent->winSize);
+	} else {
+	    REGION_SUBTRACT( pScreen, &pParent->valdata->after.borderExposed,
+			       exposed, &pParent->winSize);
+	}
+
+    	REGION_COPY( pScreen, &pParent->borderClip, universe);
+    
+    	/*
+     	 * To get the right clipList for the parent, and to make doubly sure
+     	 * that no child overlaps the parent's border, we remove the parent's
+     	 * border from the universe before proceeding.
+     	 */
+    
+    	REGION_INTERSECT( pScreen, universe, universe, &pParent->winSize);
+    }
+    else
+    	REGION_COPY( pScreen, &pParent->borderClip, universe);
+    
+    if ((pChild = pParent->firstChild) && pParent->mapped)
+    {
+	REGION_NULL(pScreen, &childUniverse);
+	REGION_NULL(pScreen, &childUnion);
+	if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||
+	    ((pChild->drawable.y == pParent->lastChild->drawable.y) &&
+	     (pChild->drawable.x < pParent->lastChild->drawable.x)))
+	{
+	    for (; pChild; pChild = pChild->nextSib)
+	    {
+		if (pChild->viewable)
+		    REGION_APPEND( pScreen, &childUnion, &pChild->borderSize);
+	    }
+	}
+	else
+	{
+	    for (pChild = pParent->lastChild; pChild; pChild = pChild->prevSib)
+	    {
+		if (pChild->viewable)
+		    REGION_APPEND( pScreen, &childUnion, &pChild->borderSize);
+	    }
+	}
+	REGION_VALIDATE( pScreen, &childUnion, &overlap);
+
+	for (pChild = pParent->firstChild;
+	     pChild;
+	     pChild = pChild->nextSib)
+ 	{
+	    if (pChild->viewable) {
+		/*
+		 * If the child is viewable, we want to remove its extents
+		 * from the current universe, but we only re-clip it if
+		 * it's been marked.
+		 */
+		if (pChild->valdata) {
+		    /*
+		     * Figure out the new universe from the child's
+		     * perspective and recurse.
+		     */
+		    REGION_INTERSECT( pScreen, &childUniverse,
+					    universe,
+					    &pChild->borderSize);
+		    RootlessComputeClips (pChild, pScreen, &childUniverse, 
+					  kind, exposed);
+		}
+		/*
+		 * Once the child has been processed, we remove its extents
+		 * from the current universe, thus denying its space to any
+		 * other sibling.
+		 */
+		if (overlap)
+		    REGION_SUBTRACT( pScreen, universe, universe,
+					  &pChild->borderSize);
+	    }
+	}
+	if (!overlap)
+	    REGION_SUBTRACT( pScreen, universe, universe, &childUnion);
+	REGION_UNINIT( pScreen, &childUnion);
+	REGION_UNINIT( pScreen, &childUniverse);
+    } /* if any children */
+
+    /*
+     * 'universe' now contains the new clipList for the parent window.
+     *
+     * To figure the exposure of the window we subtract the old clip from the
+     * new, just as for the border.
+     */
+
+    if (oldVis == VisibilityFullyObscured ||
+	oldVis == VisibilityNotViewable)
+    {
+	REGION_COPY( pScreen, &pParent->valdata->after.exposed, universe);
+    }
+    else if (newVis != VisibilityFullyObscured &&
+	     newVis != VisibilityNotViewable)
+    {
+    	REGION_SUBTRACT( pScreen, &pParent->valdata->after.exposed,
+			       universe, &pParent->clipList);
+    }
+
+    /*
+     * One last thing: backing storage. We have to try to save what parts of
+     * the window are about to be obscured. We can just subtract the universe
+     * from the old clipList and get the areas that were in the old but aren't
+     * in the new and, hence, are about to be obscured.
+     */
+    if (pParent->backStorage && !resized)
+    {
+	REGION_SUBTRACT( pScreen, exposed, &pParent->clipList, universe);
+	(* pScreen->SaveDoomedAreas)(pParent, exposed, dx, dy);
+    }
+    
+    /* HACK ALERT - copying contents of regions, instead of regions */
+    {
+	RegionRec   tmp;
+
+	tmp = pParent->clipList;
+	pParent->clipList = *universe;
+	*universe = tmp;
+    }
+
+#ifdef NOTDEF
+    REGION_COPY( pScreen, &pParent->clipList, universe);
+#endif
+
+    pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+
+    if (pScreen->ClipNotify)
+	(* pScreen->ClipNotify) (pParent, dx, dy);
+}
+
+static void
+RootlessTreeObscured(pParent)
+    register WindowPtr pParent;
+{
+    register WindowPtr pChild;
+    register int    oldVis;
+
+    pChild = pParent;
+    while (1)
+    {
+	if (pChild->viewable)
+	{
+	    oldVis = pChild->visibility;
+	    if (oldVis != (pChild->visibility = VisibilityFullyObscured) &&
+		((pChild->eventMask | wOtherEventMasks(pChild)) & VisibilityChangeMask))
+		SendVisibilityNotify(pChild);
+	    if (pChild->firstChild)
+	    {
+		pChild = pChild->firstChild;
+		continue;
+	    }
+	}
+	while (!pChild->nextSib && (pChild != pParent))
+	    pChild = pChild->parent;
+	if (pChild == pParent)
+	    break;
+	pChild = pChild->nextSib;
+    }
+}
+
+/*
+ *-----------------------------------------------------------------------
+ * RootlessMiValidateTree --
+ *	Recomputes the clip list for pParent and all its inferiors.
+ *
+ * Results:
+ *	Always returns 1.
+ *
+ * Side Effects:
+ *	The clipList, borderClip, exposed, and borderExposed regions for
+ *	each marked window are altered.
+ *
+ * Notes:
+ *	This routine assumes that all affected windows have been marked
+ *	(valdata created) and their winSize and borderSize regions
+ *	adjusted to correspond to their new positions. The borderClip and
+ *	clipList regions should not have been touched.
+ *
+ *	The top-most level is treated differently from all lower levels
+ *	because pParent is unchanged. For the top level, we merge the
+ *	regions taken up by the marked children back into the clipList
+ *	for pParent, thus forming a region from which the marked children
+ *	can claim their areas. For lower levels, where the old clipList
+ *	and borderClip are invalid, we can't do this and have to do the
+ *	extra operations done in miComputeClips, but this is much faster
+ *	e.g. when only one child has moved...
+ *
+ *-----------------------------------------------------------------------
+ */
+/* 
+   Quartz version: used for validate from root in rootless mode.
+   We need to make sure top-level windows don't clip each other, 
+   and that top-level windows aren't clipped to the root window.
+*/
+/*ARGSUSED*/
+// fixme this is ugly
+// Xprint/ValTree.c doesn't work, but maybe that method can?
+int
+RootlessMiValidateTree (pRoot, pChild, kind)
+    WindowPtr	  	pRoot;      /* Parent to validate */
+    WindowPtr	  	pChild;     /* First child of pRoot that was
+				     * affected */
+    VTKind    	  	kind;       /* What kind of configuration caused call */
+{
+    RegionRec	  	childClip;  /* The new borderClip for the current
+				     * child */
+    RegionRec		exposed;    /* For intermediate calculations */
+    register ScreenPtr	pScreen;
+    register WindowPtr	pWin;
+
+    pScreen = pRoot->drawable.pScreen;
+    if (pChild == NullWindow)
+	pChild = pRoot->firstChild;
+
+    REGION_NULL(pScreen, &childClip);
+    REGION_NULL(pScreen, &exposed);
+
+    if (REGION_BROKEN (pScreen, &pRoot->clipList) &&
+	!REGION_BROKEN (pScreen, &pRoot->borderClip))
+    {
+        // fixme this might not work, but hopefully doesn't happen anyway.
+        kind = VTBroken;
+        REGION_EMPTY (pScreen, &pRoot->clipList);
+        ErrorF("ValidateTree: BUSTED!\n");
+    }
+
+    /* 
+     * Recursively compute the clips for all children of the root. 
+     * They don't clip against each other or the root itself, so 
+     * childClip is always reset to that child's size.
+     */
+
+    for (pWin = pChild;
+	 pWin != NullWindow;
+	 pWin = pWin->nextSib)
+    {
+        if (pWin->viewable) {
+            if (pWin->valdata) {
+                REGION_COPY( pScreen, &childClip, &pWin->borderSize);
+                RootlessComputeClips (pWin, pScreen, &childClip, kind, &exposed);
+            } else if (pWin->visibility == VisibilityNotViewable) {
+                RootlessTreeObscured(pWin);
+            }
+        } else {
+            if (pWin->valdata) {
+                REGION_EMPTY( pScreen, &pWin->clipList);
+                if (pScreen->ClipNotify)
+                    (* pScreen->ClipNotify) (pWin, 0, 0);
+                REGION_EMPTY( pScreen, &pWin->borderClip);
+                pWin->valdata = (ValidatePtr)NULL;
+            }
+        }
+    }
+
+    REGION_UNINIT(pScreen, &childClip);
+
+    /* The root is never clipped by its children, so nothing on the root 
+       is ever exposed by moving or mapping its children. */
+    REGION_NULL(pScreen, &pRoot->valdata->after.exposed);
+    REGION_NULL(pScreen, &pRoot->valdata->after.borderExposed);
+
+    return 1;
+}
diff --git a/miext/rootless/rootlessWindow.c b/miext/rootless/rootlessWindow.c
new file mode 100644
index 000000000..ac0f9f0b1
--- /dev/null
+++ b/miext/rootless/rootlessWindow.c
@@ -0,0 +1,1435 @@
+/*
+ * Rootless window management
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessWindow.c,v 1.10 2003/11/13 20:26:31 torrey Exp $ */
+
+#include "rootlessCommon.h"
+#include "rootlessWindow.h"
+
+#include "fb.h"
+
+
+#ifdef ROOTLESS_GLOBAL_COORDS
+#define SCREEN_TO_GLOBAL_X \
+    (dixScreenOrigins[pScreen->myNum].x + rootlessGlobalOffsetX)
+#define SCREEN_TO_GLOBAL_Y \
+    (dixScreenOrigins[pScreen->myNum].y + rootlessGlobalOffsetY)
+#else
+#define SCREEN_TO_GLOBAL_X 0
+#define SCREEN_TO_GLOBAL_Y 0
+#endif
+
+
+/*
+ * RootlessCreateWindow
+ *  For now, don't create a physical window until either the window is
+ *  realized, or we really need it (e.g. to attach VRAM surfaces to).
+ *  Do reset the window size so it's not clipped by the root window.
+ */
+Bool
+RootlessCreateWindow(WindowPtr pWin)
+{
+    Bool result;
+    RegionRec saveRoot;
+
+    WINREC(pWin) = NULL;
+
+    SCREEN_UNWRAP(pWin->drawable.pScreen, CreateWindow);
+
+    if (!IsRoot(pWin)) {
+        /* win/border size set by DIX, not by wrapped CreateWindow, so
+           correct it here. Don't HUGE_ROOT when pWin is the root! */
+
+        HUGE_ROOT(pWin);
+        SetWinSize(pWin);
+        SetBorderSize(pWin);
+    }
+
+    result = pWin->drawable.pScreen->CreateWindow(pWin);
+
+    if (pWin->parent) {
+        NORMAL_ROOT(pWin);
+    }
+
+    SCREEN_WRAP(pWin->drawable.pScreen, CreateWindow);
+
+    return result;
+}
+
+
+/*
+ * RootlessDestroyFrame
+ *  Destroy the physical window associated with the given window.
+ */
+static void
+RootlessDestroyFrame(WindowPtr pWin, RootlessWindowPtr winRec)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    SCREENREC(pScreen)->imp->DestroyFrame(winRec->wid);
+
+#ifdef ROOTLESS_TRACK_DAMAGE
+    REGION_UNINIT(pScreen, &winRec->damage);
+#endif
+
+    xfree(winRec);
+    WINREC(pWin) = NULL;
+}
+
+
+/*
+ * RootlessDestroyWindow
+ *  Destroy the physical window associated with the given window.
+ */
+Bool
+RootlessDestroyWindow(WindowPtr pWin)
+{
+    RootlessWindowRec *winRec = WINREC(pWin);
+    Bool result;
+
+    if (winRec != NULL) {
+        RootlessDestroyFrame(pWin, winRec);
+    }
+
+    SCREEN_UNWRAP(pWin->drawable.pScreen, DestroyWindow);
+    result = pWin->drawable.pScreen->DestroyWindow(pWin);
+    SCREEN_WRAP(pWin->drawable.pScreen, DestroyWindow);
+
+    return result;
+}
+
+
+#ifdef SHAPE
+
+static Bool
+RootlessGetShape(WindowPtr pWin, RegionPtr pShape)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    if (wBoundingShape(pWin) == NULL)
+        return FALSE;
+
+    /* wBoundingShape is relative to *inner* origin of window.
+       Translate by borderWidth to get the outside-relative position. */
+
+    REGION_NULL(pScreen, pShape);
+    REGION_COPY(pScreen, pShape, wBoundingShape(pWin));
+    REGION_TRANSLATE(pScreen, pShape, pWin->borderWidth, pWin->borderWidth);
+
+    return TRUE;
+}
+
+
+/*
+ * RootlessReshapeFrame
+ *  Set the frame shape.
+ */
+static void RootlessReshapeFrame(WindowPtr pWin)
+{
+    RootlessWindowRec *winRec = WINREC(pWin);
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RegionRec newShape;
+    RegionPtr pShape;
+
+    // If the window is not yet framed, do nothing
+    if (winRec == NULL)
+        return;
+
+    if (IsRoot(pWin))
+        return;
+
+    RootlessStopDrawing(pWin, FALSE);
+
+    pShape = RootlessGetShape(pWin, &newShape) ? &newShape : NULL;
+
+#ifdef ROOTLESSDEBUG
+    RL_DEBUG_MSG("reshaping...");
+    if (pShape != NULL) {
+        RL_DEBUG_MSG("numrects %d, extents %d %d %d %d ",
+                     REGION_NUM_RECTS(&newShape),
+                     newShape.extents.x1, newShape.extents.y1,
+                     newShape.extents.x2, newShape.extents.y2);
+    } else {
+        RL_DEBUG_MSG("no shape ");
+    }
+#endif
+
+    SCREENREC(pScreen)->imp->ReshapeFrame(winRec->wid, pShape);
+
+    if (pShape != NULL)
+        REGION_UNINIT(pScreen, &newShape);
+}
+
+
+/*
+ * RootlessSetShape
+ *  Shape is usually set before a window is mapped and the window will
+ *  not have a frame associated with it. In this case, the frame will be
+ *  shaped when the window is framed.
+ */
+void
+RootlessSetShape(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    SCREEN_UNWRAP(pScreen, SetShape);
+    pScreen->SetShape(pWin);
+    SCREEN_WRAP(pScreen, SetShape);
+
+    RootlessReshapeFrame(pWin);
+}
+
+#endif // SHAPE
+
+
+/* Disallow ParentRelative background on top-level windows
+   because the root window doesn't really have the right background
+   and fb will try to draw on the root instead of on the window.
+   ParentRelative prevention is also in PaintWindowBackground/Border()
+   so it is no longer really needed here. */
+Bool
+RootlessChangeWindowAttributes(WindowPtr pWin, unsigned long vmask)
+{
+    Bool result;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    RL_DEBUG_MSG("change window attributes start ");
+
+    SCREEN_UNWRAP(pScreen, ChangeWindowAttributes);
+    result = pScreen->ChangeWindowAttributes(pWin, vmask);
+    SCREEN_WRAP(pScreen, ChangeWindowAttributes);
+
+    if (WINREC(pWin)) {
+        // disallow ParentRelative background state
+        if (pWin->backgroundState == ParentRelative) {
+            XID pixel = 0;
+            ChangeWindowAttributes(pWin, CWBackPixel, &pixel, serverClient);
+        }
+    }
+
+    RL_DEBUG_MSG("change window attributes end\n");
+    return result;
+}
+
+
+/*
+ * RootlessPositionWindow
+ *  This is a hook for when DIX moves or resizes a window.
+ *  Update the frame position now although the physical window is moved
+ *  in RootlessMoveWindow. (x, y) are *inside* position. After this,
+ *  mi and fb are expecting the pixmap to be at the new location.
+ */
+Bool
+RootlessPositionWindow(WindowPtr pWin, int x, int y)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RootlessWindowRec *winRec = WINREC(pWin);
+    Bool result;
+
+    RL_DEBUG_MSG("positionwindow start (win 0x%x @ %i, %i)\n", pWin, x, y);
+
+    if (winRec) {
+        if (winRec->is_drawing) {
+            // Reset frame's pixmap and move it to the new position.
+            int bw = wBorderWidth(pWin);
+
+            winRec->pixmap->devPrivate.ptr = winRec->pixelData;
+            SetPixmapBaseToScreen(winRec->pixmap, x - bw, y - bw);
+
+#ifdef ROOTLESS_TRACK_DAMAGE
+            // Move damaged region to correspond to new window position
+            if (REGION_NOTEMPTY(pScreen, &winRec->damage)) {
+                REGION_TRANSLATE(pScreen, &winRec->damage,
+                                 x - bw - winRec->x,
+                                 y - bw - winRec->y);
+            }
+#endif
+        }
+    }
+
+    SCREEN_UNWRAP(pScreen, PositionWindow);
+    result = pScreen->PositionWindow(pWin, x, y);
+    SCREEN_WRAP(pScreen, PositionWindow);
+
+    RL_DEBUG_MSG("positionwindow end\n");
+    return result;
+}
+
+
+/*
+ * RootlessInitializeFrame
+ *  Initialize some basic attributes of the frame. Note that winRec
+ *  may already have valid data in it, so don't overwrite anything
+ *  valuable.
+ */
+static void
+RootlessInitializeFrame(WindowPtr pWin, RootlessWindowRec *winRec)
+{
+    DrawablePtr d = &pWin->drawable;
+    int bw = wBorderWidth(pWin);
+
+    winRec->win = pWin;
+
+    winRec->x = d->x - bw;
+    winRec->y = d->y - bw;
+    winRec->width = d->width + 2*bw;
+    winRec->height = d->height + 2*bw;
+    winRec->borderWidth = bw;
+
+#ifdef ROOTLESS_TRACK_DAMAGE
+    REGION_NULL(pScreen, &winRec->damage);
+#endif
+}
+
+
+/*
+ * RootlessEnsureFrame
+ *  Make sure the given window is framed. If the window doesn't have a
+ *  physical window associated with it, attempt to create one. If that
+ *  is unsuccessful, return NULL.
+ */
+static RootlessWindowRec *
+RootlessEnsureFrame(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RootlessWindowRec *winRec;
+#ifdef SHAPE
+    RegionRec shape;
+    RegionPtr pShape = NULL;
+#endif
+
+    if (WINREC(pWin) != NULL)
+        return WINREC(pWin);
+
+    if (!IsTopLevel(pWin))
+        return NULL;
+
+    if (pWin->drawable.class != InputOutput)
+        return NULL;
+
+    winRec = xalloc(sizeof(RootlessWindowRec));
+
+    if (!winRec)
+        return NULL;
+
+    RootlessInitializeFrame(pWin, winRec);
+
+    winRec->is_drawing = FALSE;
+    winRec->is_reorder_pending = FALSE;
+    winRec->pixmap = NULL;
+    winRec->wid = NULL;
+
+    WINREC(pWin) = winRec;
+
+#ifdef SHAPE
+    // Set the frame's shape if the window is shaped
+    if (RootlessGetShape(pWin, &shape))
+        pShape = &shape;
+#endif
+
+    RL_DEBUG_MSG("creating frame ");
+
+    if (!SCREENREC(pScreen)->imp->CreateFrame(winRec, pScreen,
+                                              winRec->x + SCREEN_TO_GLOBAL_X,
+                                              winRec->y + SCREEN_TO_GLOBAL_Y,
+                                              pShape))
+    {
+        RL_DEBUG_MSG("implementation failed to create frame!\n");
+        xfree(winRec);
+        WINREC(pWin) = NULL;
+        return NULL;
+    }
+
+#ifdef SHAPE
+    if (pShape != NULL)
+        REGION_UNINIT(pScreen, &shape);
+#endif
+
+    return winRec;
+}
+
+
+/*
+ * RootlessRealizeWindow
+ *  The frame is usually created here and not in CreateWindow so that
+ *  windows do not eat memory until they are realized.
+ */
+Bool
+RootlessRealizeWindow(WindowPtr pWin)
+{
+    Bool result;
+    RegionRec saveRoot;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    RL_DEBUG_MSG("realizewindow start (win 0x%x) ", pWin);
+
+    if ((IsTopLevel(pWin) && pWin->drawable.class == InputOutput)) {
+        RootlessWindowRec *winRec;
+
+        winRec = RootlessEnsureFrame(pWin);
+        if (winRec == NULL)
+            return FALSE;
+
+        winRec->is_reorder_pending = TRUE;
+
+        RL_DEBUG_MSG("Top level window ");
+
+        // Disallow ParentRelative background state on top-level windows.
+        // This might have been set before the window was mapped.
+        if (pWin->backgroundState == ParentRelative) {
+            XID pixel = 0;
+            ChangeWindowAttributes(pWin, CWBackPixel, &pixel, serverClient);
+        }
+    }
+
+    if (!IsRoot(pWin)) HUGE_ROOT(pWin);
+    SCREEN_UNWRAP(pScreen, RealizeWindow);
+    result = pScreen->RealizeWindow(pWin);
+    SCREEN_WRAP(pScreen, RealizeWindow);
+    if (!IsRoot(pWin)) NORMAL_ROOT(pWin);
+
+    RL_DEBUG_MSG("realizewindow end\n");
+    return result;
+}
+
+
+/*
+ * RootlessFrameForWindow
+ *  Returns the frame ID for the physical window displaying the given window. 
+ *  If CREATE is true and the window has no frame, attempt to create one.
+ */
+RootlessFrameID
+RootlessFrameForWindow(WindowPtr pWin, Bool create)
+{
+    WindowPtr pTopWin;
+    RootlessWindowRec *winRec;
+
+    pTopWin = TopLevelParent(pWin);
+    if (pTopWin == NULL)
+        return NULL;
+
+    winRec = WINREC(pTopWin);
+
+    if (winRec == NULL && create && pWin->drawable.class == InputOutput) {
+        winRec = RootlessEnsureFrame(pTopWin);
+    }
+
+    if (winRec == NULL)
+        return NULL;
+
+    return winRec->wid;
+}
+
+
+/*
+ * RootlessUnrealizeWindow
+ *  Unmap the physical window.
+ */
+Bool
+RootlessUnrealizeWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RootlessWindowRec *winRec = WINREC(pWin);
+    Bool result;
+
+    RL_DEBUG_MSG("unrealizewindow start ");
+
+    if (winRec) {
+        RootlessStopDrawing(pWin, FALSE);
+
+        SCREENREC(pScreen)->imp->UnmapFrame(winRec->wid);
+
+        winRec->is_reorder_pending = FALSE;
+    }
+
+    SCREEN_UNWRAP(pScreen, UnrealizeWindow);
+    result = pScreen->UnrealizeWindow(pWin);
+    SCREEN_WRAP(pScreen, UnrealizeWindow);
+
+    RL_DEBUG_MSG("unrealizewindow end\n");
+    return result;
+}
+
+
+/*
+ * RootlessReorderWindow
+ *  Reorder the window associated with the given frame so that it's
+ *  physically above the window below it in the X stacking order.
+ */
+void
+RootlessReorderWindow(WindowPtr pWin)
+{
+    RootlessWindowRec *winRec = WINREC(pWin);
+
+    if (winRec != NULL && !winRec->is_reorder_pending) {
+        WindowPtr newPrevW;
+        RootlessWindowRec *newPrev;
+        RootlessFrameID newPrevID;
+        ScreenPtr pScreen = pWin->drawable.pScreen;
+
+        RootlessStopDrawing(pWin, FALSE);
+
+        /* Find the next window above this one that has a mapped frame. */
+
+        newPrevW = pWin->prevSib;
+        while (newPrevW && (WINREC(newPrevW) == NULL || !newPrevW->realized))
+            newPrevW = newPrevW->prevSib;
+
+        newPrev = newPrevW != NULL ? WINREC(newPrevW) : NULL;
+        newPrevID = newPrev != NULL ? newPrev->wid : 0;
+
+        /* If it exists, reorder the frame above us first. */
+
+        if (newPrev && newPrev->is_reorder_pending) {
+            newPrev->is_reorder_pending = FALSE;
+            RootlessReorderWindow(newPrevW);
+        }
+
+        SCREENREC(pScreen)->imp->RestackFrame(winRec->wid, newPrevID);
+    }
+}
+
+
+/*
+ * RootlessRestackWindow
+ *  This is a hook for when DIX changes the window stacking order.
+ *  The window has already been inserted into its new position in the
+ *  DIX window stack. We need to change the order of the physical
+ *  window to match.
+ */
+void
+RootlessRestackWindow(WindowPtr pWin, WindowPtr pOldNextSib)
+{
+    RegionRec saveRoot;
+    RootlessWindowRec *winRec = WINREC(pWin);
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    RL_DEBUG_MSG("restackwindow start ");
+    if (winRec)
+        RL_DEBUG_MSG("restack top level \n");
+
+    HUGE_ROOT(pWin);
+    SCREEN_UNWRAP(pScreen, RestackWindow);
+
+    if (pScreen->RestackWindow)
+        pScreen->RestackWindow(pWin, pOldNextSib);
+
+    SCREEN_WRAP(pScreen, RestackWindow);
+    NORMAL_ROOT(pWin);
+
+    if (winRec && pWin->viewable) {
+        RootlessReorderWindow(pWin);
+    }
+
+    RL_DEBUG_MSG("restackwindow end\n");
+}
+
+
+/*
+ * Specialized window copy procedures
+ */
+
+// Globals needed during window resize and move.
+static pointer gResizeDeathBits = NULL;
+static int gResizeDeathCount = 0;
+static PixmapPtr gResizeDeathPix[2] = {NULL, NULL};
+static BoxRec gResizeDeathBounds[2];
+static CopyWindowProcPtr gResizeOldCopyWindowProc = NULL;
+
+/*
+ * RootlessNoCopyWindow
+ *  CopyWindow() that doesn't do anything. For MoveWindow() of
+ *  top-level windows.
+ */
+static void
+RootlessNoCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg,
+                     RegionPtr prgnSrc)
+{
+    // some code expects the region to be translated
+    int dx = ptOldOrg.x - pWin->drawable.x;
+    int dy = ptOldOrg.y - pWin->drawable.y;
+
+    RL_DEBUG_MSG("ROOTLESSNOCOPYWINDOW ");
+
+    REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
+}
+
+
+/*
+ * RootlessResizeCopyWindow
+ *  CopyWindow used during ResizeWindow for gravity moves. Based on
+ *  fbCopyWindow. The original always draws on the root pixmap, which
+ *  we don't have. Instead, draw on the parent window's pixmap.
+ *  Resize version: the old location's pixels are in gResizeCopyWindowSource.
+ */
+static void
+RootlessResizeCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg,
+                         RegionPtr prgnSrc)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RegionRec   rgnDst;
+    int         dx, dy;
+
+    RL_DEBUG_MSG("resizecopywindowFB start (win 0x%x) ", pWin);
+
+    /* Don't unwrap pScreen->CopyWindow.
+       The bogus rewrap with RootlessCopyWindow causes a crash if
+       CopyWindow is called again during the same resize. */
+
+    if (gResizeDeathCount == 0)
+        return;
+
+    RootlessStartDrawing(pWin);
+
+    dx = ptOldOrg.x - pWin->drawable.x;
+    dy = ptOldOrg.y - pWin->drawable.y;
+    REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
+    REGION_NULL(pScreen, &rgnDst);
+    REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
+
+    if (gResizeDeathCount == 1) {
+        /* Simple case, we only have a single source pixmap. */
+
+        fbCopyRegion(&gResizeDeathPix[0]->drawable,
+                     &pScreen->GetWindowPixmap(pWin)->drawable, 0,
+                     &rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
+    }
+    else {
+        int i;
+        RegionRec clip, clipped;
+
+        /* More complex case, N source pixmaps (usually two). So we
+           intersect the destination with each source and copy those bits. */
+
+        for (i = 0; i < gResizeDeathCount; i++) {
+            REGION_INIT(pScreen, &clip, gResizeDeathBounds + 0, 1);
+            REGION_NULL(pScreen, &clipped);
+            REGION_INTERSECT(pScreen, &rgnDst, &clip, &clipped);
+
+            fbCopyRegion(&gResizeDeathPix[i]->drawable,
+                         &pScreen->GetWindowPixmap(pWin)->drawable, 0,
+                         &clipped, dx, dy, fbCopyWindowProc, 0, 0);
+
+            REGION_UNINIT(pScreen, &clipped);
+            REGION_UNINIT(pScreen, &clip);
+        }
+    }
+
+    /* Don't update - resize will update everything */
+    REGION_UNINIT(pScreen, &rgnDst);
+
+    fbValidateDrawable(&pWin->drawable);
+
+    RL_DEBUG_MSG("resizecopywindowFB end\n");
+}
+
+
+/*
+ * RootlessCopyWindow
+ *  Update *new* location of window. Old location is redrawn with
+ *  PaintWindowBackground/Border. Cloned from fbCopyWindow.
+ *  The original always draws on the root pixmap, which we don't have.
+ *  Instead, draw on the parent window's pixmap.
+ */
+void
+RootlessCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RegionRec   rgnDst;
+    int         dx, dy;
+    BoxPtr extents;
+    int area;
+
+    RL_DEBUG_MSG("copywindowFB start (win 0x%x) ", pWin);
+
+    SCREEN_UNWRAP(pScreen, CopyWindow);
+
+    dx = ptOldOrg.x - pWin->drawable.x;
+    dy = ptOldOrg.y - pWin->drawable.y;
+    REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
+
+    REGION_NULL(pScreen, &rgnDst);
+    REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
+
+    extents = REGION_EXTENTS(pScreen, &rgnDst);
+    area = (extents->x2 - extents->x1) * (extents->y2 - extents->y1);
+
+    /* If the area exceeds threshold, use the implementation's
+       accelerated version. */
+    if (area > rootless_CopyWindow_threshold &&
+        SCREENREC(pScreen)->imp->CopyWindow)
+    {
+        RootlessWindowRec *winRec;
+        WindowPtr top;
+
+        top = TopLevelParent(pWin);
+        if (top == NULL) {
+            RL_DEBUG_MSG("no parent\n");
+            return;
+        }
+
+        winRec = WINREC(top);
+        if (winRec == NULL) {
+            RL_DEBUG_MSG("not framed\n");
+            return;
+        }
+
+        /* Move region to window local coords */
+        REGION_TRANSLATE(pScreen, &rgnDst, -winRec->x, -winRec->y);
+
+        RootlessStopDrawing(pWin, FALSE);
+
+        SCREENREC(pScreen)->imp->CopyWindow(winRec->wid,
+                                            REGION_NUM_RECTS(&rgnDst),
+                                            REGION_RECTS(&rgnDst),
+                                            dx, dy);
+    }
+    else {
+        RootlessStartDrawing(pWin);
+
+        fbCopyRegion((DrawablePtr) pWin, (DrawablePtr) pWin,
+                     0, &rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
+
+        /* prgnSrc has been translated to dst position */
+        RootlessDamageRegion(pWin, prgnSrc);
+    }
+
+    REGION_UNINIT(pScreen, &rgnDst);
+    fbValidateDrawable(&pWin->drawable);
+
+    SCREEN_WRAP(pScreen, CopyWindow);
+
+    RL_DEBUG_MSG("copywindowFB end\n");
+}
+
+
+/*
+ * Window resize procedures
+ */
+
+enum {
+    WIDTH_SMALLER = 1,
+    HEIGHT_SMALLER = 2,
+};
+
+
+/*
+ * ResizeWeighting
+ *  Choose gravity to avoid local copies. Do that by looking for
+ *  a corner that doesn't move _relative to the screen_.
+ */
+static inline unsigned int
+ResizeWeighting(int oldX1, int oldY1, int oldX2, int oldY2, int oldBW,
+                int newX1, int newY1, int newX2, int newY2, int newBW)
+{
+#ifdef ROOTLESS_RESIZE_GRAVITY
+    if (newBW != oldBW)
+        return RL_GRAVITY_NONE;
+
+    if (newX1 == oldX1 && newY1 == oldY1)
+        return RL_GRAVITY_NORTH_WEST;
+    else if (newX1 == oldX1 && newY2 == oldY2)
+        return RL_GRAVITY_SOUTH_WEST;
+    else if (newX2 == oldX2 && newY2 == oldY2)
+        return RL_GRAVITY_SOUTH_EAST;
+    else if (newX2 == oldX2 && newY1 == oldY1)
+        return RL_GRAVITY_NORTH_EAST;
+    else
+        return RL_GRAVITY_NONE;
+#else
+    return RL_GRAVITY_NONE;
+#endif
+}
+
+
+/*
+ * StartFrameResize
+ *  Prepare to resize a top-level window. The old window's pixels are
+ *  saved and the implementation is told to change the window size.
+ *  (x,y,w,h) is outer frame of window (outside border)
+ */
+static Bool
+StartFrameResize(WindowPtr pWin, Bool gravity,
+                 int oldX, int oldY, int oldW, int oldH, int oldBW,
+                 int newX, int newY, int newW, int newH, int newBW)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RootlessWindowRec *winRec = WINREC(pWin);
+    Bool need_window_source = FALSE, resize_after = FALSE;
+
+    BoxRec rect;
+    int oldX2, newX2;
+    int oldY2, newY2;
+    unsigned int weight;
+
+    oldX2 = oldX + oldW, newX2 = newX + newW;
+    oldY2 = oldY + oldH, newY2 = newY + newH;
+
+    /* Decide which resize weighting to use */
+    weight = ResizeWeighting(oldX, oldY, oldW, oldH, oldBW,
+                             newX, newY, newW, newH, newBW);
+
+    /* Compute intersection between old and new rects */
+    rect.x1 = max(oldX, newX);
+    rect.y1 = max(oldY, newY);
+    rect.x2 = min(oldX2, newX2);
+    rect.y2 = min(oldY2, newY2);
+
+    RL_DEBUG_MSG("RESIZE TOPLEVEL WINDOW with gravity %i ", gravity);
+    RL_DEBUG_MSG("%d %d %d %d %d   %d %d %d %d %d\n",
+                 oldX, oldY, oldW, oldH, oldBW,
+                 newX, newY, newW, newH, newBW);
+
+    RootlessRedisplay(pWin);
+
+    /* If gravity is true, then we need to have a way of recovering all
+       the original bits in the window for when X rearranges the contents
+       based on the various gravity settings. The obvious way is to just
+       snapshot the entire backing store before resizing it, but that
+       it slow on large windows.
+
+       So the optimization here is to use the implementation's resize
+       weighting options (if available) to allow us to reason about what
+       is left in the backing store after the resize. We can then only
+       copy what won't be there after the resize, and do a two-stage copy
+       operation.
+
+       Most of these optimizations are only applied when the top-left
+       corner of the window is fixed, since that's the common case. They
+       could probably be extended with some thought. */
+
+    gResizeDeathCount = 0;
+
+    if (gravity && weight == RL_GRAVITY_NORTH_WEST) {
+        unsigned int code = 0;
+
+        /* Top left corner is anchored. We never need to copy the
+           entire window. */
+
+        need_window_source = TRUE;
+
+        /* These comparisons were chosen to avoid setting bits when the sizes
+        are the same. (So the fastest case automatically gets taken when
+        dimensions are unchanging.) */
+
+        if (newW < oldW)
+            code |= WIDTH_SMALLER;
+        if (newH < oldH)
+            code |= HEIGHT_SMALLER;
+
+        if (((code ^ (code >> 1)) & 1) == 0) {
+            /* Both dimensions are either getting larger, or both
+               are getting smaller. No need to copy anything. */
+
+            if (code == (WIDTH_SMALLER | HEIGHT_SMALLER)) {
+                /* Since the window is getting smaller, we can do gravity
+                   repair on it with it's current size, then resize it
+                   afterwards. */
+
+                resize_after = TRUE;
+            }
+
+            gResizeDeathCount = 1;
+        }
+        else {
+            unsigned int copy_rowbytes, Bpp;
+            unsigned int copy_rect_width, copy_rect_height;
+            BoxRec copy_rect;
+
+            /* We can get away with a partial copy. 'rect' is the
+               intersection between old and new bounds, so copy
+               everything to the right of or below the intersection. */
+
+            RootlessStartDrawing(pWin);
+
+            if (code == WIDTH_SMALLER) {
+                copy_rect.x1 = rect.x2;
+                copy_rect.y1 = rect.y1;
+                copy_rect.x2 = oldX2;
+                copy_rect.y2 = oldY2;
+            }
+            else if (code == HEIGHT_SMALLER) {
+                copy_rect.x1 = rect.x1;
+                copy_rect.y1 = rect.y2;
+                copy_rect.x2 = oldX2;
+                copy_rect.y2 = oldY2;
+            }
+            else
+                abort();
+
+            Bpp = winRec->win->drawable.bitsPerPixel / 8;
+            copy_rect_width = copy_rect.x2 - copy_rect.x1;
+            copy_rect_height = copy_rect.y2 - copy_rect.y1;
+            copy_rowbytes = ((copy_rect_width * Bpp) + 31) & ~31;
+            gResizeDeathBits = xalloc(copy_rowbytes
+                                      * copy_rect_height);
+
+            if (copy_rect_width * copy_rect_height >
+                        rootless_CopyBytes_threshold &&
+                SCREENREC(pScreen)->imp->CopyBytes)
+            {
+                SCREENREC(pScreen)->imp->CopyBytes(
+                    copy_rect_width * Bpp, copy_rect_height,
+                    ((char *) winRec->pixelData)
+                    + ((copy_rect.y1 - oldY) * winRec->bytesPerRow)
+                    + (copy_rect.x1 - oldX) * Bpp, winRec->bytesPerRow,
+                    gResizeDeathBits, copy_rowbytes);
+            } else {
+                fbBlt((FbBits *) (winRec->pixelData
+                      + ((copy_rect.y1 - oldY) * winRec->bytesPerRow)
+                      + (copy_rect.x1 - oldX) * Bpp),
+                      winRec->bytesPerRow / sizeof(FbBits), 0,
+                      (FbBits *) gResizeDeathBits,
+                      copy_rowbytes / sizeof(FbBits), 0,
+                      copy_rect_width * Bpp, copy_rect_height,
+                      GXcopy, FB_ALLONES, Bpp, 0, 0);
+            }
+
+            gResizeDeathBounds[1] = copy_rect;
+            gResizeDeathPix[1]
+                = GetScratchPixmapHeader(pScreen, copy_rect_width,
+                                         copy_rect_height,
+                                         winRec->win->drawable.depth,
+                                         winRec->win->drawable.bitsPerPixel,
+                                         winRec->bytesPerRow,
+                                         (void *) gResizeDeathBits);
+
+            SetPixmapBaseToScreen(gResizeDeathPix[1],
+                                  copy_rect.x1, copy_rect.y1);
+
+            gResizeDeathCount = 2;
+        }
+    }
+    else if (gravity) {
+        /* The general case. Just copy everything. */
+
+        RootlessStartDrawing(pWin);
+
+        gResizeDeathBits = xalloc(winRec->bytesPerRow * winRec->height);
+
+        memcpy(gResizeDeathBits, winRec->pixelData,
+               winRec->bytesPerRow * winRec->height);
+
+        gResizeDeathBounds[0] = (BoxRec) {oldX, oldY, oldX2, oldY2};
+        gResizeDeathPix[0]
+            = GetScratchPixmapHeader(pScreen, winRec->width,
+                                     winRec->height,
+                                     winRec->win->drawable.depth,
+                                     winRec->win->drawable.bitsPerPixel,
+                                     winRec->bytesPerRow,
+                                     (void *) gResizeDeathBits);
+
+        SetPixmapBaseToScreen(gResizeDeathPix[0], oldX, oldY);
+        gResizeDeathCount = 1;
+    }
+
+    RootlessStopDrawing(pWin, FALSE);
+
+    winRec->x = newX;
+    winRec->y = newY;
+    winRec->width = newW;
+    winRec->height = newH;
+    winRec->borderWidth = newBW;
+
+    /* Unless both dimensions are getting smaller, Resize the frame
+       before doing gravity repair */
+
+    if (!resize_after) {
+        SCREENREC(pScreen)->imp->ResizeFrame(winRec->wid, pScreen,
+                                             newX + SCREEN_TO_GLOBAL_X,
+                                             newY + SCREEN_TO_GLOBAL_Y,
+                                             newW, newH, weight);
+    }
+
+    RootlessStartDrawing(pWin);
+
+    /* If necessary, create a source pixmap pointing at the current
+       window bits. */
+
+    if (need_window_source) {
+        gResizeDeathBounds[0] = (BoxRec) {oldX, oldY, oldX2, oldY2};
+        gResizeDeathPix[0]
+            = GetScratchPixmapHeader(pScreen, oldW, oldH,
+                                     winRec->win->drawable.depth,
+                                     winRec->win->drawable.bitsPerPixel,
+                                     winRec->bytesPerRow, winRec->pixelData);
+
+        SetPixmapBaseToScreen(gResizeDeathPix[0], oldX, oldY);
+    }
+
+    /* Use custom CopyWindow when moving gravity bits around
+       ResizeWindow assumes the old window contents are in the same
+       pixmap, but here they're in deathPix instead. */
+
+    if (gravity) {
+        gResizeOldCopyWindowProc = pScreen->CopyWindow;
+        pScreen->CopyWindow = RootlessResizeCopyWindow;
+    }
+
+    /* If we can't rely on the window server preserving the bits we
+       need in the position we need, copy the pixels in the
+       intersection from src to dst. ResizeWindow assumes these pixels
+       are already present when making gravity adjustments. pWin
+       currently has new-sized pixmap but is in old position.
+
+       FIXME: border width change! (?) */
+
+    if (gravity && weight == RL_GRAVITY_NONE) {
+        PixmapPtr src, dst;
+
+        assert(gResizeDeathCount == 1);
+
+        src = gResizeDeathPix[0];
+        dst = pScreen->GetWindowPixmap(pWin);
+
+        RL_DEBUG_MSG("Resize copy rect %d %d %d %d\n",
+                     rect.x1, rect.y1, rect.x2, rect.y2);
+
+        /* rect is the intersection of the old location and new location */
+        if (BOX_NOT_EMPTY(rect) && src != NULL && dst != NULL) {
+            /* The window drawable still has the old frame position, which
+               means that DST doesn't actually point at the origin of our
+               physical backing store when adjusted by the drawable.x,y
+               position. So sneakily adjust it temporarily while copying.. */
+
+            ((PixmapPtr) dst)->devPrivate.ptr = winRec->pixelData;
+            SetPixmapBaseToScreen(dst, newX, newY);
+
+            fbCopyWindowProc(&src->drawable, &dst->drawable, NULL,
+                             &rect, 1, 0, 0, FALSE, FALSE, 0, 0);
+
+            ((PixmapPtr) dst)->devPrivate.ptr = winRec->pixelData;
+            SetPixmapBaseToScreen(dst, oldX, oldY);
+        }
+    }
+
+    return resize_after;
+}
+
+
+static void
+FinishFrameResize(WindowPtr pWin, Bool gravity, int oldX, int oldY,
+                  unsigned int oldW, unsigned int oldH, unsigned int oldBW,
+                  int newX, int newY, unsigned int newW, unsigned int newH,
+                  unsigned int newBW, Bool resize_now)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RootlessWindowRec *winRec = WINREC(pWin);
+    BoxRec box;
+    int i;
+
+    RootlessStopDrawing(pWin, FALSE);
+
+    if (resize_now) {
+        unsigned int weight;
+
+        /* We didn't resize anything earlier, so do it now, now that
+           we've finished gravitating the bits. */
+
+        weight = ResizeWeighting(oldX, oldY, oldW, oldH, oldBW,
+                                 newX, newY, newW, newH, newBW);
+
+        SCREENREC(pScreen)->imp->ResizeFrame(winRec->wid, pScreen,
+                                             newX + SCREEN_TO_GLOBAL_X,
+                                             newY + SCREEN_TO_GLOBAL_Y,
+                                             newW, newH, weight);
+    }
+
+    /* Redraw everything. FIXME: there must be times when we don't need
+       to do this. Perhaps when top-left weighting and no gravity? */
+
+    box.x1 = 0;
+    box.y1 = 0;
+    box.x2 = winRec->width;
+    box.y2 = winRec->height;
+
+    RootlessDamageBox(pWin, &box);
+
+    for (i = 0; i < 2; i++) {
+        if (gResizeDeathPix[i] != NULL) {
+            FreeScratchPixmapHeader(gResizeDeathPix[i]);
+            gResizeDeathPix[i] = NULL;
+        }
+    }
+
+    if (gResizeDeathBits != NULL) {
+        xfree(gResizeDeathBits);
+        gResizeDeathBits = NULL;
+    }
+
+    if (gravity) {
+        pScreen->CopyWindow = gResizeOldCopyWindowProc;
+    }
+}
+
+
+/*
+ * RootlessMoveWindow
+ *  If kind==VTOther, window border is resizing (and borderWidth is
+ *  already changed!!@#$)  This case works like window resize, not move.
+ */
+void
+RootlessMoveWindow(WindowPtr pWin, int x, int y, WindowPtr pSib, VTKind kind)
+{
+    RootlessWindowRec *winRec = WINREC(pWin);
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    CopyWindowProcPtr oldCopyWindowProc = NULL;
+    int oldX = 0, oldY = 0, newX = 0, newY = 0;
+    unsigned int oldW = 0, oldH = 0, oldBW = 0;
+    unsigned int newW = 0, newH = 0, newBW = 0;
+    Bool resize_after = FALSE;
+    RegionRec saveRoot;
+
+    RL_DEBUG_MSG("movewindow start \n");
+
+    if (winRec) {
+        if (kind == VTMove) {
+            oldX = winRec->x;
+            oldY = winRec->y;
+            RootlessRedisplay(pWin);
+            RootlessStartDrawing(pWin);
+        } else {
+            RL_DEBUG_MSG("movewindow border resizing ");
+
+            oldBW = winRec->borderWidth;
+            oldX = winRec->x;
+            oldY = winRec->y;
+            oldW = winRec->width;
+            oldH = winRec->height;
+
+            newBW = wBorderWidth(pWin);
+            newX = x;
+            newY = y;
+            newW = pWin->drawable.width  + 2*newBW;
+            newH = pWin->drawable.height + 2*newBW;
+
+            resize_after = StartFrameResize(pWin, FALSE,
+                                            oldX, oldY, oldW, oldH, oldBW,
+                                            newX, newY, newW, newH, newBW);
+        }
+    }
+
+    HUGE_ROOT(pWin);
+    SCREEN_UNWRAP(pScreen, MoveWindow);
+
+    if (winRec) {
+        oldCopyWindowProc = pScreen->CopyWindow;
+        pScreen->CopyWindow = RootlessNoCopyWindow;
+    }
+    pScreen->MoveWindow(pWin, x, y, pSib, kind);
+    if (winRec) {
+        pScreen->CopyWindow = oldCopyWindowProc;
+    }
+
+    NORMAL_ROOT(pWin);
+    SCREEN_WRAP(pScreen, MoveWindow);
+
+    if (winRec) {
+        if (kind == VTMove) {
+            winRec->x = x;
+            winRec->y = y;
+            RootlessStopDrawing(pWin, FALSE);
+            SCREENREC(pScreen)->imp->MoveFrame(winRec->wid, pScreen,
+                                               x + SCREEN_TO_GLOBAL_X,
+                                               y + SCREEN_TO_GLOBAL_Y);
+        } else {
+            FinishFrameResize(pWin, FALSE, oldX, oldY, oldW, oldH, oldBW,
+                              newX, newY, newW, newH, newBW, resize_after);
+        }
+    }
+
+    RL_DEBUG_MSG("movewindow end\n");
+}
+
+
+/*
+ * RootlessResizeWindow
+ *  Note: (x, y, w, h) as passed to this procedure don't match the frame
+ *  definition. (x,y) is corner of very outer edge, *outside* border.
+ *  w,h is width and height *inside* border, *ignoring* border width.
+ *  The rect (x, y, w, h) doesn't mean anything. (x, y, w+2*bw, h+2*bw)
+ *  is total rect and (x+bw, y+bw, w, h) is inner rect.
+ */
+void
+RootlessResizeWindow(WindowPtr pWin, int x, int y,
+                     unsigned int w, unsigned int h, WindowPtr pSib)
+{
+    RootlessWindowRec *winRec = WINREC(pWin);
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    int oldX = 0, oldY = 0, newX = 0, newY = 0;
+    unsigned int oldW = 0, oldH = 0, oldBW = 0, newW = 0, newH = 0, newBW = 0;
+    Bool resize_after = FALSE;
+    RegionRec saveRoot;
+
+    RL_DEBUG_MSG("resizewindow start (win 0x%x) ", pWin);
+
+    if (winRec) {
+        oldBW = winRec->borderWidth;
+        oldX = winRec->x;
+        oldY = winRec->y;
+        oldW = winRec->width;
+        oldH = winRec->height;
+
+        newBW = oldBW;
+        newX = x;
+        newY = y;
+        newW = w + 2*newBW;
+        newH = h + 2*newBW;
+
+        resize_after = StartFrameResize(pWin, TRUE,
+                                        oldX, oldY, oldW, oldH, oldBW,
+                                        newX, newY, newW, newH, newBW);
+    }
+
+    HUGE_ROOT(pWin);
+    SCREEN_UNWRAP(pScreen, ResizeWindow);
+    pScreen->ResizeWindow(pWin, x, y, w, h, pSib);
+    SCREEN_WRAP(pScreen, ResizeWindow);
+    NORMAL_ROOT(pWin);
+
+    if (winRec) {
+        FinishFrameResize(pWin, TRUE, oldX, oldY, oldW, oldH, oldBW,
+                          newX, newY, newW, newH, newBW, resize_after);
+    }
+
+    RL_DEBUG_MSG("resizewindow end\n");
+}
+
+
+/*
+ * RootlessReparentWindow
+ *  Called after a window has been reparented. Generally windows are not
+ *  framed until they are mapped. However, a window may be framed early by the
+ *  implementation calling RootlessFrameForWindow. (e.g. this could be needed
+ *  to attach a VRAM surface to it.) If the window is subsequently reparented
+ *  by the window manager before being mapped, we need to give the frame to
+ *  the new top-level window.
+ */
+void
+RootlessReparentWindow(WindowPtr pWin, WindowPtr pPriorParent)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RootlessWindowRec *winRec = WINREC(pWin);
+    WindowPtr pTopWin;
+
+    /* Check that window is not top-level now, but used to be. */
+    if (IsRoot(pWin) || IsRoot(pWin->parent)
+	|| IsTopLevel(pWin) || winRec == NULL)
+    {
+	goto out;
+    }
+
+    /* If the formerly top-level window has a frame, we want to give the
+       frame to its new top-level parent. If we can't do that, we'll just
+       have to jettison it... */
+
+    pTopWin = TopLevelParent(pWin);
+    assert(pTopWin != pWin);
+
+    if (WINREC(pTopWin) != NULL) {
+	/* We're screwed. */
+	RootlessDestroyFrame(pWin, winRec);
+    } else {
+	if (!pTopWin->realized && pWin->realized) {
+            SCREENREC(pScreen)->imp->UnmapFrame(winRec->wid);
+	}
+
+	/* Switch the frame record from one to the other. */
+
+	WINREC(pWin) = NULL;
+	WINREC(pTopWin) = winRec;
+
+	RootlessInitializeFrame(pTopWin, winRec);
+	RootlessReshapeFrame(pTopWin);
+
+        SCREENREC(pScreen)->imp->ResizeFrame(winRec->wid, pScreen,
+                                             winRec->x + SCREEN_TO_GLOBAL_X,
+                                             winRec->y + SCREEN_TO_GLOBAL_Y,
+                                             winRec->width, winRec->height,
+                                             RL_GRAVITY_NONE);
+
+        if (SCREENREC(pScreen)->imp->SwitchWindow) {
+            SCREENREC(pScreen)->imp->SwitchWindow(winRec, pWin);
+        }
+
+	if (pTopWin->realized && !pWin->realized)
+	    winRec->is_reorder_pending = TRUE;
+    }
+
+out:
+    if (SCREENREC(pScreen)->ReparentWindow) {
+        SCREEN_UNWRAP(pScreen, ReparentWindow);
+        pScreen->ReparentWindow(pWin, pPriorParent);
+        SCREEN_WRAP(pScreen, ReparentWindow);
+    }
+}
+
+
+/*
+ * SetPixmapOfAncestors
+ *  Set the Pixmaps on all ParentRelative windows up the ancestor chain.
+ */
+static void
+SetPixmapOfAncestors(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    WindowPtr topWin = TopLevelParent(pWin);
+    RootlessWindowRec *topWinRec = WINREC(topWin);
+
+    while (pWin->backgroundState == ParentRelative) {
+        if (pWin == topWin) {
+            // disallow ParentRelative background state on top level
+            XID pixel = 0;
+            ChangeWindowAttributes(pWin, CWBackPixel, &pixel, serverClient);
+            RL_DEBUG_MSG("Cleared ParentRelative on 0x%x.\n", pWin);
+            break;
+        }
+
+        pWin = pWin->parent;
+        pScreen->SetWindowPixmap(pWin, topWinRec->pixmap);
+    }
+}
+
+
+/*
+ * RootlessPaintWindowBackground
+ */
+void
+RootlessPaintWindowBackground(WindowPtr pWin, RegionPtr pRegion, int what)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+ 
+    if (IsRoot(pWin))
+        return;
+
+    RL_DEBUG_MSG("paintwindowbackground start (win 0x%x, framed %i) ",
+                 pWin, IsFramedWindow(pWin));
+
+    if (IsFramedWindow(pWin)) {
+        RootlessStartDrawing(pWin);
+        RootlessDamageRegion(pWin, pRegion);
+
+        // For ParentRelative windows, we have to make sure the window
+        // pixmap is set correctly all the way up the ancestor chain.
+        if (pWin->backgroundState == ParentRelative) {
+            SetPixmapOfAncestors(pWin);
+        }
+    }
+
+    SCREEN_UNWRAP(pScreen, PaintWindowBackground);
+    pScreen->PaintWindowBackground(pWin, pRegion, what);
+    SCREEN_WRAP(pScreen, PaintWindowBackground);
+
+    RL_DEBUG_MSG("paintwindowbackground end\n");
+}
+
+
+/*
+ * RootlessPaintWindowBorder
+ */
+void
+RootlessPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
+{
+    RL_DEBUG_MSG("paintwindowborder start (win 0x%x) ", pWin);
+
+    if (IsFramedWindow(pWin)) {
+        RootlessStartDrawing(pWin);
+        RootlessDamageRegion(pWin, pRegion);
+
+        // For ParentRelative windows with tiled borders, we have to make
+        // sure the window pixmap is set correctly all the way up the
+        // ancestor chain.
+        if (!pWin->borderIsPixel &&
+            pWin->backgroundState == ParentRelative)
+        {
+            SetPixmapOfAncestors(pWin);
+        }
+    }
+
+    SCREEN_UNWRAP(pWin->drawable.pScreen, PaintWindowBorder);
+    pWin->drawable.pScreen->PaintWindowBorder(pWin, pRegion, what);
+    SCREEN_WRAP(pWin->drawable.pScreen, PaintWindowBorder);
+
+    RL_DEBUG_MSG("paintwindowborder end\n");
+}
+
+
+/*
+ * RootlessChangeBorderWidth
+ *  FIXME: untested!
+ *  pWin inside corner stays the same; pWin->drawable.[xy] stays the same
+ *  Frame moves and resizes.
+ */
+void
+RootlessChangeBorderWidth(WindowPtr pWin, unsigned int width)
+{
+    RegionRec saveRoot;
+    Bool resize_after = FALSE;
+
+    RL_DEBUG_MSG("change border width ");
+
+    if (width != wBorderWidth(pWin)) {
+        RootlessWindowRec *winRec = WINREC(pWin);
+        int oldX = 0, oldY = 0, newX = 0, newY = 0;
+        unsigned int oldW = 0, oldH = 0, oldBW = 0;
+        unsigned int newW = 0, newH = 0, newBW = 0;
+
+        if (winRec) {
+            oldBW = winRec->borderWidth;
+            oldX = winRec->x;
+            oldY = winRec->y;
+            oldW = winRec->width;
+            oldH = winRec->height;
+
+            newBW = width;
+            newX = pWin->drawable.x - newBW;
+            newY = pWin->drawable.y - newBW;
+            newW = pWin->drawable.width  + 2*newBW;
+            newH = pWin->drawable.height + 2*newBW;
+
+            resize_after = StartFrameResize(pWin, FALSE,
+                                            oldX, oldY, oldW, oldH, oldBW,
+                                            newX, newY, newW, newH, newBW);
+        }
+
+        HUGE_ROOT(pWin);
+        SCREEN_UNWRAP(pWin->drawable.pScreen, ChangeBorderWidth);
+        pWin->drawable.pScreen->ChangeBorderWidth(pWin, width);
+        SCREEN_WRAP(pWin->drawable.pScreen, ChangeBorderWidth);
+        NORMAL_ROOT(pWin);
+
+        if (winRec) {
+            FinishFrameResize(pWin, FALSE, oldX, oldY, oldW, oldH, oldBW,
+                              newX, newY, newW, newH, newBW, resize_after);
+        }
+    }
+
+    RL_DEBUG_MSG("change border width end\n");
+}
diff --git a/miext/rootless/rootlessWindow.h b/miext/rootless/rootlessWindow.h
new file mode 100644
index 000000000..f6736f544
--- /dev/null
+++ b/miext/rootless/rootlessWindow.h
@@ -0,0 +1,60 @@
+/*
+ * Rootless window management
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/rootlessWindow.h,v 1.2 2003/06/30 01:45:13 torrey Exp $ */
+
+#ifndef _ROOTLESSWINDOW_H
+#define _ROOTLESSWINDOW_H
+
+#include "rootlessCommon.h"
+
+
+Bool RootlessCreateWindow(WindowPtr pWin);
+Bool RootlessDestroyWindow(WindowPtr pWin);
+
+#ifdef SHAPE
+void RootlessSetShape(WindowPtr pWin);
+#endif // SHAPE
+
+Bool RootlessChangeWindowAttributes(WindowPtr pWin, unsigned long vmask);
+Bool RootlessPositionWindow(WindowPtr pWin, int x, int y);
+Bool RootlessRealizeWindow(WindowPtr pWin);
+Bool RootlessUnrealizeWindow(WindowPtr pWin);
+void RootlessRestackWindow(WindowPtr pWin, WindowPtr pOldNextSib);
+void RootlessCopyWindow(WindowPtr pWin,DDXPointRec ptOldOrg,RegionPtr prgnSrc);
+void RootlessMoveWindow(WindowPtr pWin,int x,int y,WindowPtr pSib,VTKind kind);
+void RootlessResizeWindow(WindowPtr pWin, int x, int y,
+			  unsigned int w, unsigned int h, WindowPtr pSib);
+void RootlessReparentWindow(WindowPtr pWin, WindowPtr pPriorParent);
+void RootlessPaintWindowBackground(WindowPtr pWin, RegionPtr pRegion,
+                                   int what);
+void RootlessPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion,
+                               int what);
+void RootlessChangeBorderWidth(WindowPtr pWin, unsigned int width);
+
+#endif
diff --git a/miext/rootless/safeAlpha/safeAlpha.h b/miext/rootless/safeAlpha/safeAlpha.h
new file mode 100644
index 000000000..440a5ecc9
--- /dev/null
+++ b/miext/rootless/safeAlpha/safeAlpha.h
@@ -0,0 +1,46 @@
+/*
+ * Replacement functions to protect the alpha channel
+ */
+/*
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/safeAlpha/safeAlpha.h,v 1.2 2003/10/18 00:00:34 torrey Exp $ */
+
+#ifndef _SAFEALPHA_H
+#define _SAFEALPHA_H
+
+#include "picturestr.h"
+#include "rootlessCommon.h"
+
+void SafeAlphaPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what);
+
+#ifdef RENDER
+void
+SafeAlphaComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
+                   INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask,
+                   INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
+#endif /* RENDER */
+
+#endif /* _SAFEALPHA_H */
diff --git a/miext/rootless/safeAlpha/safeAlphaPicture.c b/miext/rootless/safeAlpha/safeAlphaPicture.c
new file mode 100644
index 000000000..ad9360c7e
--- /dev/null
+++ b/miext/rootless/safeAlpha/safeAlphaPicture.c
@@ -0,0 +1,595 @@
+/*
+ * Support for RENDER extension while protecting the alpha channel
+ */
+/*
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ * Copyright (c) 2002 Apple Computer, Inc. All Rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* This file is largely based on fbcompose.c and fbpict.c, which contain
+ * the following copyright:
+ *
+ * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
+ */
+ /* $XFree86: xc/programs/Xserver/miext/rootless/safeAlpha/safeAlphaPicture.c,v 1.3 2003/10/24 00:33:15 torrey Exp $ */
+
+#ifdef RENDER
+
+#include "fb.h"
+#include "picturestr.h"
+#include "mipict.h"
+#include "fbpict.h"
+#include "safeAlpha.h"
+
+# define mod(a,b)	((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b))
+
+
+// Replacement for fbStore_x8r8g8b8 that sets the alpha channel
+void
+SafeAlphaStore_x8r8g8b8 (FbCompositeOperand *op, CARD32 value)
+{
+    FbBits  *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
+    ((CARD32 *)line)[offset >> 5] = (value & ~RootlessAlphaMask(32)) |
+                                    RootlessAlphaMask(32);
+}
+
+
+// Defined in fbcompose.c
+extern FbCombineFunc fbCombineFuncU[];
+extern FbCombineFunc fbCombineFuncC[];
+
+/* A bunch of macros from fbpict.c */
+#define cvt0565to8888(s)    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \
+			     ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) | \
+			     ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
+
+#if IMAGE_BYTE_ORDER == MSBFirst
+#define Fetch24(a)  ((unsigned long) (a) & 1 ? \
+		     ((*(a) << 16) | *((CARD16 *) ((a)+1))) : \
+		     ((*((CARD16 *) (a)) << 8) | *((a)+2)))
+#define Store24(a,v) ((unsigned long) (a) & 1 ? \
+		      ((*(a) = (CARD8) ((v) >> 16)), \
+		       (*((CARD16 *) ((a)+1)) = (CARD16) (v))) : \
+		      ((*((CARD16 *) (a)) = (CARD16) ((v) >> 8)), \
+		       (*((a)+2) = (CARD8) (v))))
+#else
+#define Fetch24(a)  ((unsigned long) (a) & 1 ? \
+		     ((*(a)) | (*((CARD16 *) ((a)+1)) << 8)) : \
+		     ((*((CARD16 *) (a))) | (*((a)+2) << 16)))
+#define Store24(a,v) ((unsigned long) (a) & 1 ? \
+		      ((*(a) = (CARD8) (v)), \
+		       (*((CARD16 *) ((a)+1)) = (CARD16) ((v) >> 8))) : \
+		      ((*((CARD16 *) (a)) = (CARD16) (v)),\
+		       (*((a)+2) = (CARD8) ((v) >> 16))))
+#endif
+		      
+#define fbComposeGetSolid(pict, bits) { \
+    FbBits	*__bits__; \
+    FbStride	__stride__; \
+    int		__bpp__; \
+    int		__xoff__,__yoff__; \
+\
+    fbGetDrawable((pict)->pDrawable,__bits__,__stride__,__bpp__,__xoff__,__yoff__); \
+    switch (__bpp__) { \
+    case 32: \
+	(bits) = *(CARD32 *) __bits__; \
+	break; \
+    case 24: \
+	(bits) = Fetch24 ((CARD8 *) __bits__); \
+	break; \
+    case 16: \
+	(bits) = *(CARD16 *) __bits__; \
+	(bits) = cvt0565to8888(bits); \
+	break; \
+    default: \
+	return; \
+    } \
+    /* manage missing src alpha */ \
+    if ((pict)->pFormat->direct.alphaMask == 0) \
+	(bits) |= 0xff000000; \
+}
+
+#define fbComposeGetStart(pict,x,y,type,stride,line,mul) {\
+    FbBits	*__bits__; \
+    FbStride	__stride__; \
+    int		__bpp__; \
+    int		__xoff__,__yoff__; \
+\
+    fbGetDrawable((pict)->pDrawable,__bits__,__stride__,__bpp__,__xoff__,__yoff__); \
+    (stride) = __stride__ * sizeof (FbBits) / sizeof (type); \
+    (line) = ((type *) __bits__) + (stride) * ((y) - __yoff__) + (mul) * ((x) - __xoff__); \
+}
+
+
+/* Optimized version of fbCompositeSolidMask_nx8x8888 */
+void
+SafeAlphaCompositeSolidMask_nx8x8888(
+    CARD8      op,
+    PicturePtr pSrc,
+    PicturePtr pMask,
+    PicturePtr pDst,
+    INT16      xSrc,
+    INT16      ySrc,
+    INT16      xMask,
+    INT16      yMask,
+    INT16      xDst,
+    INT16      yDst,
+    CARD16     width,
+    CARD16     height)
+{
+    CARD32	src, srca;
+    CARD32	*dstLine, *dst, d, dstMask;
+    CARD8	*maskLine, *mask, m;
+    FbStride	dstStride, maskStride;
+    CARD16	w;
+
+    fbComposeGetSolid(pSrc, src);
+
+    dstMask = FbFullMask (pDst->pDrawable->depth);
+    srca = src >> 24;
+    if (src == 0)
+	return;
+
+    fbComposeGetStart (pDst, xDst, yDst, CARD32, dstStride, dstLine, 1);
+    fbComposeGetStart (pMask, xMask, yMask, CARD8, maskStride, maskLine, 1);
+
+    if (dstMask == FB_ALLONES && pDst->pDrawable->bitsPerPixel == 32 &&
+        width * height > rootless_CompositePixels_threshold &&
+        SCREENREC(pDst->pDrawable->pScreen)->imp->CompositePixels)
+    {
+	void *srcp[2], *destp[2];
+	unsigned int dest_rowbytes[2];
+	unsigned int fn;
+
+	srcp[0] = &src; srcp[1] = &src;
+	/* null rowbytes pointer means use first value as a constant */
+	destp[0] = dstLine; destp[1] = dstLine;
+	dest_rowbytes[0] = dstStride * 4; dest_rowbytes[1] = dest_rowbytes[0];
+	fn = RL_COMPOSITE_FUNCTION(RL_COMPOSITE_OVER, RL_DEPTH_ARGB8888,
+                                   RL_DEPTH_A8, RL_DEPTH_ARGB8888);
+
+	if (SCREENREC(pDst->pDrawable->pScreen)->imp->CompositePixels(
+                width, height, fn, srcp, NULL,
+                maskLine, maskStride,
+                destp, dest_rowbytes) == Success)
+	{
+	    return;
+	}
+    }
+
+    while (height--)
+    {
+	dst = dstLine;
+	dstLine += dstStride;
+	mask = maskLine;
+	maskLine += maskStride;
+	w = width;
+
+	while (w--)
+	{
+	    m = *mask++;
+	    if (m == 0xff)
+	    {
+		if (srca == 0xff)
+		    *dst = src & dstMask;
+		else
+		    *dst = fbOver (src, *dst) & dstMask;
+	    }
+	    else if (m)
+	    {
+		d = fbIn (src, m);
+		*dst = fbOver (d, *dst) & dstMask;
+	    }
+	    dst++;
+	}
+    }
+}
+
+
+void
+SafeAlphaCompositeGeneral(
+    CARD8               op,
+    PicturePtr          pSrc,
+    PicturePtr          pMask,
+    PicturePtr          pDst,
+    INT16               xSrc,
+    INT16               ySrc,
+    INT16               xMask,
+    INT16               yMask,
+    INT16               xDst,
+    INT16               yDst,
+    CARD16              width,
+    CARD16              height)
+{
+    FbCompositeOperand	src[4],msk[4],dst[4],*pmsk;
+    FbCompositeOperand	*srcPict, *srcAlpha;
+    FbCompositeOperand	*dstPict, *dstAlpha;
+    FbCompositeOperand	*mskPict = 0, *mskAlpha = 0;
+    FbCombineFunc	f;
+    int			w;
+
+    if (!fbBuildCompositeOperand (pSrc, src, xSrc, ySrc, TRUE, TRUE))
+	return;
+    if (!fbBuildCompositeOperand (pDst, dst, xDst, yDst, FALSE, TRUE))
+	return;
+
+    // Use SafeAlpha operands for on screen picture formats
+    if (pDst->format == PICT_x8r8g8b8) {
+        dst[0].store = SafeAlphaStore_x8r8g8b8;
+    }
+
+    if (pSrc->alphaMap)
+    {
+	srcPict = &src[1];
+	srcAlpha = &src[2];
+    }
+    else
+    {
+	srcPict = &src[0];
+	srcAlpha = 0;
+    }
+    if (pDst->alphaMap)
+    {
+	dstPict = &dst[1];
+	dstAlpha = &dst[2];
+    }
+    else
+    {
+	dstPict = &dst[0];
+	dstAlpha = 0;
+    }
+    f = fbCombineFuncU[op];
+    if (pMask)
+    {
+	if (!fbBuildCompositeOperand (pMask, msk, xMask, yMask, TRUE, TRUE))
+	    return;
+	pmsk = msk;
+	if (pMask->componentAlpha)
+	    f = fbCombineFuncC[op];
+	if (pMask->alphaMap)
+	{
+	    mskPict = &msk[1];
+	    mskAlpha = &msk[2];
+	}
+	else
+	{
+	    mskPict = &msk[0];
+	    mskAlpha = 0;
+	}
+    }
+    else
+	pmsk = 0;
+    while (height--)
+    {
+	w = width;
+	
+	while (w--)
+	{
+	    (*f) (src, pmsk, dst);
+	    (*src->over) (src);
+	    (*dst->over) (dst);
+	    if (pmsk)
+		(*pmsk->over) (pmsk);
+	}
+	(*src->down) (src);
+	(*dst->down) (dst);
+	if (pmsk)
+	    (*pmsk->down) (pmsk);
+    }
+}
+
+
+void
+SafeAlphaComposite(
+    CARD8           op,
+    PicturePtr      pSrc,
+    PicturePtr      pMask,
+    PicturePtr      pDst,
+    INT16           xSrc,
+    INT16           ySrc,
+    INT16           xMask,
+    INT16           yMask,
+    INT16           xDst,
+    INT16           yDst,
+    CARD16          width,
+    CARD16          height)
+{
+    RegionRec	    region;
+    int		    n;
+    BoxPtr	    pbox;
+    CompositeFunc   func;
+    Bool	    srcRepeat = pSrc->repeat;
+    Bool	    maskRepeat = FALSE;
+    Bool            srcAlphaMap = pSrc->alphaMap != 0;
+    Bool	    maskAlphaMap = FALSE;
+    Bool            dstAlphaMap = pDst->alphaMap != 0;
+    int		    x_msk, y_msk, x_src, y_src, x_dst, y_dst;
+    int		    w, h, w_this, h_this;
+    int		    dstDepth = pDst->pDrawable->depth;
+
+    xDst += pDst->pDrawable->x;
+    yDst += pDst->pDrawable->y;
+    xSrc += pSrc->pDrawable->x;
+    ySrc += pSrc->pDrawable->y;
+    if (pMask)
+    {
+	xMask += pMask->pDrawable->x;
+	yMask += pMask->pDrawable->y;
+	maskRepeat = pMask->repeat;
+	maskAlphaMap = pMask->alphaMap != 0;
+    }
+
+    if (!miComputeCompositeRegion (&region,
+				   pSrc,
+				   pMask,
+				   pDst,
+				   xSrc,
+				   ySrc,
+				   xMask,
+				   yMask,
+				   xDst,
+				   yDst,
+				   width,
+				   height))
+	return;
+
+    // To preserve the alpha channel we have a special,
+    // non-optimzied compositor.
+    func = SafeAlphaCompositeGeneral;
+
+    /*
+     * We can use the more optimized fbpict code, but it sets bits above
+     * the depth to zero. Temporarily adjust destination depth if needed.
+     */
+    if (pDst->pDrawable->type == DRAWABLE_WINDOW
+	&& pDst->pDrawable->depth == 24
+	&& pDst->pDrawable->bitsPerPixel == 32)
+    {
+	pDst->pDrawable->depth = 32;
+    }
+
+    if (!pSrc->transform && !(pMask && pMask->transform))
+    if (!maskAlphaMap && !srcAlphaMap && !dstAlphaMap)
+    switch (op) {
+    case PictOpOver:
+	if (pMask)
+	{
+	    if (srcRepeat && 
+		pSrc->pDrawable->width == 1 &&
+		pSrc->pDrawable->height == 1)
+	    {
+		srcRepeat = FALSE;
+		if (PICT_FORMAT_COLOR(pSrc->format)) {
+		    switch (pMask->format) {
+		    case PICT_a8:
+			switch (pDst->format) {
+			case PICT_r5g6b5:
+			case PICT_b5g6r5:
+			    func = fbCompositeSolidMask_nx8x0565;
+			    break;
+			case PICT_r8g8b8:
+			case PICT_b8g8r8:
+			    func = fbCompositeSolidMask_nx8x0888;
+			    break;
+			case PICT_a8r8g8b8:
+			case PICT_x8r8g8b8:
+			case PICT_a8b8g8r8:
+			case PICT_x8b8g8r8:
+			    func = SafeAlphaCompositeSolidMask_nx8x8888;
+			    break;
+			}
+			break;
+		    case PICT_a8r8g8b8:
+			if (pMask->componentAlpha) {
+			    switch (pDst->format) {
+			    case PICT_a8r8g8b8:
+			    case PICT_x8r8g8b8:
+				func = fbCompositeSolidMask_nx8888x8888C;
+				break;
+			    case PICT_r5g6b5:
+				func = fbCompositeSolidMask_nx8888x0565C;
+				break;
+			    }
+			}
+			break;
+		    case PICT_a8b8g8r8:
+			if (pMask->componentAlpha) {
+			    switch (pDst->format) {
+			    case PICT_a8b8g8r8:
+			    case PICT_x8b8g8r8:
+				func = fbCompositeSolidMask_nx8888x8888C;
+				break;
+			    case PICT_b5g6r5:
+				func = fbCompositeSolidMask_nx8888x0565C;
+				break;
+			    }
+			}
+			break;
+		    case PICT_a1:
+			switch (pDst->format) {
+			case PICT_r5g6b5:
+			case PICT_b5g6r5:
+			case PICT_r8g8b8:
+			case PICT_b8g8r8:
+			case PICT_a8r8g8b8:
+			case PICT_x8r8g8b8:
+			case PICT_a8b8g8r8:
+			case PICT_x8b8g8r8:
+			    func = fbCompositeSolidMask_nx1xn;
+			    break;
+			}
+		    }
+		}
+	    }
+	}
+	else
+	{
+	    switch (pSrc->format) {
+	    case PICT_a8r8g8b8:
+	    case PICT_x8r8g8b8:
+		switch (pDst->format) {
+		case PICT_a8r8g8b8:
+		case PICT_x8r8g8b8:
+		    func = fbCompositeSrc_8888x8888;
+		    break;
+		case PICT_r8g8b8:
+		    func = fbCompositeSrc_8888x0888;
+		    break;
+		case PICT_r5g6b5:
+		    func = fbCompositeSrc_8888x0565;
+		    break;
+		}
+		break;
+	    case PICT_a8b8g8r8:
+	    case PICT_x8b8g8r8:
+		switch (pDst->format) {
+		case PICT_a8b8g8r8:
+		case PICT_x8b8g8r8:
+		    func = fbCompositeSrc_8888x8888;
+		    break;
+		case PICT_b8g8r8:
+		    func = fbCompositeSrc_8888x0888;
+		    break;
+		case PICT_b5g6r5:
+		    func = fbCompositeSrc_8888x0565;
+		    break;
+		}
+		break;
+	    case PICT_r5g6b5:
+		switch (pDst->format) {
+		case PICT_r5g6b5:
+		    func = fbCompositeSrc_0565x0565;
+		    break;
+		}
+		break;
+	    case PICT_b5g6r5:
+		switch (pDst->format) {
+		case PICT_b5g6r5:
+		    func = fbCompositeSrc_0565x0565;
+		    break;
+		}
+		break;
+	    }
+	}
+	break;
+    case PictOpAdd:
+	if (pMask == 0)
+	{
+	    switch (pSrc->format) {
+	    case PICT_a8r8g8b8:
+		switch (pDst->format) {
+		case PICT_a8r8g8b8:
+		    func = fbCompositeSrcAdd_8888x8888;
+		    break;
+		}
+		break;
+	    case PICT_a8b8g8r8:
+		switch (pDst->format) {
+		case PICT_a8b8g8r8:
+		    func = fbCompositeSrcAdd_8888x8888;
+		    break;
+		}
+		break;
+	    case PICT_a8:
+		switch (pDst->format) {
+		case PICT_a8:
+		    func = fbCompositeSrcAdd_8000x8000;
+		    break;
+		}
+		break;
+	    case PICT_a1:
+		switch (pDst->format) {
+		case PICT_a1:
+		    func = fbCompositeSrcAdd_1000x1000;
+		    break;
+		}
+		break;
+	    }
+	}
+	break;
+    }
+    n = REGION_NUM_RECTS (&region);
+    pbox = REGION_RECTS (&region);
+    while (n--)
+    {
+	h = pbox->y2 - pbox->y1;
+	y_src = pbox->y1 - yDst + ySrc;
+	y_msk = pbox->y1 - yDst + yMask;
+	y_dst = pbox->y1;
+	while (h)
+	{
+	    h_this = h;
+	    w = pbox->x2 - pbox->x1;
+	    x_src = pbox->x1 - xDst + xSrc;
+	    x_msk = pbox->x1 - xDst + xMask;
+	    x_dst = pbox->x1;
+	    if (maskRepeat)
+	    {
+		y_msk = mod (y_msk, pMask->pDrawable->height);
+		if (h_this > pMask->pDrawable->height - y_msk)
+		    h_this = pMask->pDrawable->height - y_msk;
+	    }
+	    if (srcRepeat)
+	    {
+		y_src = mod (y_src, pSrc->pDrawable->height);
+		if (h_this > pSrc->pDrawable->height - y_src)
+		    h_this = pSrc->pDrawable->height - y_src;
+	    }
+	    while (w)
+	    {
+		w_this = w;
+		if (maskRepeat)
+		{
+		    x_msk = mod (x_msk, pMask->pDrawable->width);
+		    if (w_this > pMask->pDrawable->width - x_msk)
+			w_this = pMask->pDrawable->width - x_msk;
+		}
+		if (srcRepeat)
+		{
+		    x_src = mod (x_src, pSrc->pDrawable->width);
+		    if (w_this > pSrc->pDrawable->width - x_src)
+			w_this = pSrc->pDrawable->width - x_src;
+		}
+		(*func) (op, pSrc, pMask, pDst,
+			 x_src, y_src, x_msk, y_msk, x_dst, y_dst,
+			 w_this, h_this);
+		w -= w_this;
+		x_src += w_this;
+		x_msk += w_this;
+		x_dst += w_this;
+	    }
+	    h -= h_this;
+	    y_src += h_this;
+	    y_msk += h_this;
+	    y_dst += h_this;
+	}
+	pbox++;
+    }
+    REGION_UNINIT (pDst->pDrawable->pScreen, &region);
+
+    // Reset destination depth to its true value
+    pDst->pDrawable->depth = dstDepth;
+}
+
+#endif /* RENDER */
diff --git a/miext/rootless/safeAlpha/safeAlphaWindow.c b/miext/rootless/safeAlpha/safeAlphaWindow.c
new file mode 100644
index 000000000..2c3761875
--- /dev/null
+++ b/miext/rootless/safeAlpha/safeAlphaWindow.c
@@ -0,0 +1,173 @@
+/*
+ * Specialized window functions to protect the alpha channel
+ */
+/*
+ * Copyright (c) 2002-2003 Torrey T. Lyons. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the sale,
+ * use or other dealings in this Software without prior written authorization.
+ */
+/* Portions of this file are based on fbwindow.c, which contains the
+ * following copyright:
+ *
+ * Copyright © 1998 Keith Packard
+ */
+/* $XFree86: xc/programs/Xserver/miext/rootless/safeAlpha/safeAlphaWindow.c,v 1.1 2003/09/16 00:36:20 torrey Exp $ */
+
+#include "fb.h"
+#include "safeAlpha.h"
+
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#endif
+
+/*
+ * SafeAlphaFillRegionTiled
+ *  Fill using a tile while leaving the alpha channel untouched.
+ *  Based on fbfillRegionTiled.
+ */
+void
+SafeAlphaFillRegionTiled(
+    DrawablePtr pDrawable,
+    RegionPtr   pRegion,
+    PixmapPtr   pTile)
+{
+    FbBits      *dst;
+    FbStride    dstStride;
+    int         dstBpp;
+    int         dstXoff, dstYoff;
+    FbBits      *tile;
+    FbStride    tileStride;
+    int         tileBpp;
+    int         tileXoff, tileYoff; /* XXX assumed to be zero */
+    int         tileWidth, tileHeight;
+    int         n = REGION_NUM_RECTS(pRegion);
+    BoxPtr      pbox = REGION_RECTS(pRegion);
+    int         xRot = pDrawable->x;
+    int         yRot = pDrawable->y;
+    FbBits      planeMask;
+
+#ifdef PANORAMIX
+    if(!noPanoramiXExtension)
+    {
+        int index = pDrawable->pScreen->myNum;
+        if(&WindowTable[index]->drawable == pDrawable)
+        {
+            xRot -= panoramiXdataPtr[index].x;
+            yRot -= panoramiXdataPtr[index].y;
+        }
+    }
+#endif
+    fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
+    fbGetDrawable (&pTile->drawable, tile, tileStride, tileBpp,
+                   tileXoff, tileYoff);
+    tileWidth = pTile->drawable.width;
+    tileHeight = pTile->drawable.height;
+    xRot += dstXoff;
+    yRot += dstYoff;
+    planeMask = FB_ALLONES & ~RootlessAlphaMask(dstBpp);
+
+    while (n--)
+    {
+        fbTile (dst + (pbox->y1 + dstYoff) * dstStride,
+                dstStride,
+                (pbox->x1 + dstXoff) * dstBpp,
+                (pbox->x2 - pbox->x1) * dstBpp,
+                pbox->y2 - pbox->y1,
+                tile,
+                tileStride,
+                tileWidth * dstBpp,
+                tileHeight,
+                GXcopy,
+                planeMask,
+                dstBpp,
+                xRot * dstBpp,
+                yRot - pbox->y1);
+        pbox++;
+    }
+}
+
+
+/*
+ * SafeAlphaPaintWindow
+ *  Paint the window while filling in the alpha channel with all on.
+ *  We can't use fbPaintWindow because it zeros the alpha channel.
+ */
+void
+SafeAlphaPaintWindow(
+    WindowPtr pWin,
+    RegionPtr pRegion,
+    int what)
+{
+    switch (what) {
+      case PW_BACKGROUND:
+
+        switch (pWin->backgroundState) {
+            case None:
+                break;
+            case ParentRelative:
+                do {
+                    pWin = pWin->parent;
+                } while (pWin->backgroundState == ParentRelative);
+                (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
+                                                                 what);
+                break;
+            case BackgroundPixmap:
+                SafeAlphaFillRegionTiled (&pWin->drawable,
+                                          pRegion,
+                                          pWin->background.pixmap);
+                break;
+            case BackgroundPixel:
+            {
+                Pixel pixel = pWin->background.pixel |
+                              RootlessAlphaMask(pWin->drawable.bitsPerPixel);
+                fbFillRegionSolid (&pWin->drawable, pRegion, 0,
+                                   fbReplicatePixel (pixel,
+                                        pWin->drawable.bitsPerPixel));
+                break;
+            }
+        }
+    	break;
+      case PW_BORDER:
+        if (pWin->borderIsPixel)
+        {
+            Pixel pixel = pWin->border.pixel |
+                          RootlessAlphaMask(pWin->drawable.bitsPerPixel);
+            fbFillRegionSolid (&pWin->drawable, pRegion, 0,
+                               fbReplicatePixel (pixel,
+                                    pWin->drawable.bitsPerPixel));
+        }
+        else
+        {
+            WindowPtr pBgWin;
+            for (pBgWin = pWin; pBgWin->backgroundState == ParentRelative;
+                 pBgWin = pBgWin->parent);
+    
+            SafeAlphaFillRegionTiled (&pBgWin->drawable,
+                                      pRegion,
+                                      pWin->border.pixmap);
+        }
+        break;
+    }
+    fbValidateDrawable (&pWin->drawable);
+}