Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

66 files changed, 17696 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/miext/cw/Imakefile b/nx-X11/programs/Xserver/miext/cw/Imakefile
new file mode 100755
index 000000000..39106ac13
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/cw/Imakefile
@@ -0,0 +1,22 @@
+#define IHaveModules
+#include <Server.tmpl>
+
+SRCS = cw.c cw_ops.c cw_render.c
+
+OBJS = cw.o cw_ops.o cw_render.o
+
+   INCLUDES = -I../../mi -I../../fb -I../../render -I../../composite \
+	      -I../../include -I$(XINCLUDESRC) $(EXTRAINCLUDES) \
+	      -I$(EXTINCSRC)
+   LINTLIBS = ../../dix/llib-ldix.ln ../../os/llib-los.ln \
+	     ../../mi/llib-lmi.ln
+
+NormalLibraryObjectRule()
+NormalLibraryTarget(cw,$(OBJS))
+LintLibraryTarget(cw,$(SRCS))
+
+NormalLintTarget($(SRCS))
+
+DependTarget()
+
+InstallDriverSDKNonExecFile(cw.h,$(DRIVERSDKINCLUDEDIR))
diff --git a/nx-X11/programs/Xserver/miext/cw/cw.c b/nx-X11/programs/Xserver/miext/cw/cw.c
new file mode 100644
index 000000000..0fdd6547e
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/cw/cw.c
@@ -0,0 +1,699 @@
+/*
+ * Copyright © 2004 Eric Anholt
+ *
+ * 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 Eric Anholt not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Eric Anholt makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * ERIC ANHOLT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ERIC ANHOLT 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.
+ */
+/* $Header: /cvs/xorg/xc/programs/Xserver/miext/cw/cw.c,v 1.23 2005/10/02 08:28:26 anholt Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "cw.h"
+
+#define CW_DEBUG 1
+
+#if CW_DEBUG
+#define CW_ASSERT(x) do {						\
+    if (!(x)) {								\
+	ErrorF("composite wrapper: assertion failed at %s:%d\n", __FUNC__, \
+	    __LINE__);							\
+    }									\
+} while (0)
+#else
+#define CW_ASSERT(x) do {} while (0)
+#endif
+
+int cwGCIndex;
+int cwScreenIndex;
+int cwWindowIndex;
+#ifdef RENDER
+int cwPictureIndex;
+#endif
+static Bool cwDisabled[MAXSCREENS];
+static unsigned long cwGeneration = 0;
+extern GCOps cwGCOps;
+
+static Bool
+cwCloseScreen (int i, ScreenPtr pScreen);
+
+static void
+cwValidateGC(GCPtr pGC, unsigned long stateChanges, DrawablePtr pDrawable);
+static void
+cwChangeGC(GCPtr pGC, unsigned long mask);
+static void
+cwCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
+static void
+cwDestroyGC(GCPtr pGC);
+static void
+cwChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
+static void
+cwCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
+static void
+cwDestroyClip(GCPtr pGC);
+
+GCFuncs cwGCFuncs = {
+    cwValidateGC,
+    cwChangeGC,
+    cwCopyGC,
+    cwDestroyGC,
+    cwChangeClip,
+    cwDestroyClip,
+    cwCopyClip,
+};
+
+/* Find the real drawable to draw to, and provide offsets that will translate
+ * window coordinates to backing pixmap coordinates.
+ */
+DrawablePtr
+cwGetBackingDrawable(DrawablePtr pDrawable, int *x_off, int *y_off)
+{
+    PixmapPtr	pPixmap;
+    
+    if (pDrawable->type == DRAWABLE_WINDOW && 
+	(pPixmap = getCwPixmap ((WindowPtr) pDrawable)))
+    {
+	*x_off = pDrawable->x - pPixmap->screen_x;
+	*y_off = pDrawable->y - pPixmap->screen_y;
+	return &pPixmap->drawable;
+    } else {
+	*x_off = *y_off = 0;
+	return pDrawable;
+    }
+}
+
+#define FUNC_PROLOGUE(pGC, pPriv) do {					\
+    (pGC)->funcs = (pPriv)->wrapFuncs;					\
+    (pGC)->ops = (pPriv)->wrapOps;					\
+} while (0)
+
+#define FUNC_EPILOGUE(pGC, pPriv) do {					\
+    (pPriv)->wrapFuncs = (pGC)->funcs;					\
+    (pPriv)->wrapOps = (pGC)->ops;					\
+    (pGC)->funcs = &cwGCFuncs;						\
+    (pGC)->ops = &cwGCOps;						\
+} while (0)
+
+
+static Bool
+cwCreateBackingGC(GCPtr pGC, DrawablePtr pDrawable)
+{
+    cwGCRec *pPriv = getCwGC(pGC);
+    int status, x_off, y_off;
+    XID noexpose = xFalse;
+    DrawablePtr pBackingDrawable;
+
+    pBackingDrawable = cwGetBackingDrawable(pDrawable, &x_off, &y_off);
+    pPriv->pBackingGC = CreateGC(pBackingDrawable, GCGraphicsExposures,
+				 &noexpose, &status);
+    if (status != Success)
+	return FALSE;
+
+    pPriv->serialNumber = 0;
+    pPriv->stateChanges = (1 << (GCLastBit + 1)) - 1;
+
+    return TRUE;
+}
+
+static void
+cwDestroyBackingGC(GCPtr pGC)
+{
+    cwGCPtr pPriv;
+
+    pPriv = (cwGCPtr) getCwGC (pGC);
+
+    if (pPriv->pBackingGC) {
+	FreeGC(pPriv->pBackingGC, (XID)0);
+	pPriv->pBackingGC = NULL;
+    }
+}
+
+static void
+cwValidateGC(GCPtr pGC, unsigned long stateChanges, DrawablePtr pDrawable)
+{
+    GCPtr   	  	pBackingGC;
+    cwGCPtr		pPriv;
+    DrawablePtr		pBackingDrawable;
+    int			x_off, y_off;
+
+    pPriv = (cwGCPtr) getCwGC (pGC);
+
+    FUNC_PROLOGUE(pGC, pPriv);
+
+    /*
+     * Must call ValidateGC to ensure pGC->pCompositeClip is valid
+     */
+    (*pGC->funcs->ValidateGC)(pGC, stateChanges, pDrawable);
+
+    if (!cwDrawableIsRedirWindow(pDrawable)) {
+	cwDestroyBackingGC(pGC);
+	FUNC_EPILOGUE(pGC, pPriv);
+	return;
+    } else {
+	if (!pPriv->pBackingGC && !cwCreateBackingGC(pGC, pDrawable)) {
+	    FUNC_EPILOGUE(pGC, pPriv);
+	    return;
+	}
+    }
+
+    pBackingGC = pPriv->pBackingGC;
+    pBackingDrawable = cwGetBackingDrawable(pDrawable, &x_off, &y_off);
+
+    pPriv->stateChanges |= stateChanges;
+
+    /*
+     * Copy the composite clip into the backing GC if either
+     * the drawable clip list has changed or the client has changed
+     * the client clip data
+     */
+    if (pDrawable->serialNumber != pPriv->serialNumber ||
+	(pPriv->stateChanges & (GCClipXOrigin|GCClipYOrigin|GCClipMask)))
+    {
+	XID vals[2];
+	RegionPtr   pCompositeClip;
+
+	pCompositeClip = REGION_CREATE (pScreen, NULL, 0);
+	REGION_COPY (pScreen, pCompositeClip, pGC->pCompositeClip);
+
+	/* Either the drawable has changed, or the clip list in the drawable has
+	 * changed.  Copy the new clip list over and set the new translated
+	 * offset for it.
+	 */
+	
+	(*pBackingGC->funcs->ChangeClip) (pBackingGC, CT_REGION,
+					  (pointer) pCompositeClip, 0);
+	
+	vals[0] = x_off - pDrawable->x;
+	vals[1] = y_off - pDrawable->y;
+	dixChangeGC(NullClient, pBackingGC,
+		    (GCClipXOrigin | GCClipYOrigin), vals, NULL);
+
+	pPriv->serialNumber = pDrawable->serialNumber;
+	/*
+	 * Mask off any client clip changes to make sure
+	 * the clip list set above remains in effect
+	 */
+	pPriv->stateChanges &= ~(GCClipXOrigin|GCClipYOrigin|GCClipMask);
+    }
+
+    if (pPriv->stateChanges) {
+	CopyGC(pGC, pBackingGC, pPriv->stateChanges);
+	pPriv->stateChanges = 0;
+    }
+
+    if ((pGC->patOrg.x + x_off) != pBackingGC->patOrg.x ||
+	(pGC->patOrg.y + y_off) != pBackingGC->patOrg.y)
+    {
+	XID vals[2];
+	vals[0] = pGC->patOrg.x + x_off;
+	vals[1] = pGC->patOrg.y + y_off;
+	dixChangeGC(NullClient, pBackingGC,
+		    (GCTileStipXOrigin | GCTileStipYOrigin), vals, NULL);
+    }
+
+    ValidateGC(pBackingDrawable, pBackingGC);
+
+    FUNC_EPILOGUE(pGC, pPriv);
+}
+
+static void
+cwChangeGC(GCPtr pGC, unsigned long mask)
+{
+    cwGCPtr	pPriv = (cwGCPtr)(pGC)->devPrivates[cwGCIndex].ptr;
+
+    FUNC_PROLOGUE(pGC, pPriv);
+
+    (*pGC->funcs->ChangeGC) (pGC, mask);
+
+    FUNC_EPILOGUE(pGC, pPriv);
+}
+
+static void
+cwCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
+{
+    cwGCPtr	pPriv = (cwGCPtr)(pGCDst)->devPrivates[cwGCIndex].ptr;
+
+    FUNC_PROLOGUE(pGCDst, pPriv);
+
+    (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
+
+    FUNC_EPILOGUE(pGCDst, pPriv);
+}
+
+static void
+cwDestroyGC(GCPtr pGC)
+{
+    cwGCPtr	pPriv = (cwGCPtr)(pGC)->devPrivates[cwGCIndex].ptr;
+
+    FUNC_PROLOGUE(pGC, pPriv);
+
+    cwDestroyBackingGC(pGC);
+
+    (*pGC->funcs->DestroyGC) (pGC);
+
+    /* leave it unwrapped */
+}
+
+static void
+cwChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects)
+{
+    cwGCPtr	pPriv = (cwGCPtr)(pGC)->devPrivates[cwGCIndex].ptr;
+
+    FUNC_PROLOGUE(pGC, pPriv);
+
+    (*pGC->funcs->ChangeClip)(pGC, type, pvalue, nrects);
+
+    FUNC_EPILOGUE(pGC, pPriv);
+}
+
+static void
+cwCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
+{
+    cwGCPtr	pPriv = (cwGCPtr)(pgcDst)->devPrivates[cwGCIndex].ptr;
+
+    FUNC_PROLOGUE(pgcDst, pPriv);
+
+    (*pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
+
+    FUNC_EPILOGUE(pgcDst, pPriv);
+}
+
+static void
+cwDestroyClip(GCPtr pGC)
+{
+    cwGCPtr	pPriv = (cwGCPtr)(pGC)->devPrivates[cwGCIndex].ptr;
+
+    FUNC_PROLOGUE(pGC, pPriv);
+
+    (*pGC->funcs->DestroyClip)(pGC);
+
+    FUNC_EPILOGUE(pGC, pPriv);
+}
+
+/*
+ * Screen wrappers.
+ */
+
+#define SCREEN_PROLOGUE(pScreen, field)				\
+  ((pScreen)->field = getCwScreen(pScreen)->field)
+
+#define SCREEN_EPILOGUE(pScreen, field, wrapper) do {		\
+    getCwScreen(pScreen)->field = (pScreen)->field;		\
+    (pScreen)->field = (wrapper);				\
+} while (0)
+
+static Bool
+cwCreateGC(GCPtr pGC)
+{
+    cwGCPtr	pPriv = getCwGC(pGC);
+    ScreenPtr	pScreen = pGC->pScreen;
+    Bool	ret;
+
+    bzero(pPriv, sizeof(cwGCRec));
+    SCREEN_PROLOGUE(pScreen, CreateGC);
+
+    if ( (ret = (*pScreen->CreateGC)(pGC)) )
+	FUNC_EPILOGUE(pGC, pPriv);
+
+    SCREEN_EPILOGUE(pScreen, CreateGC, cwCreateGC);
+
+    return ret;
+}
+
+static void
+cwGetImage(DrawablePtr pSrc, int x, int y, int w, int h, unsigned int format,
+	   unsigned long planemask, char *pdstLine)
+{
+    ScreenPtr pScreen = pSrc->pScreen;
+    DrawablePtr pBackingDrawable;
+    int src_off_x, src_off_y;
+    
+    SCREEN_PROLOGUE(pScreen, GetImage);
+
+    pBackingDrawable = cwGetBackingDrawable(pSrc, &src_off_x, &src_off_y);
+
+    CW_OFFSET_XY_SRC(x, y);
+
+    (*pScreen->GetImage)(pBackingDrawable, x, y, w, h, format, planemask,
+			 pdstLine);
+
+    SCREEN_EPILOGUE(pScreen, GetImage, cwGetImage);
+}
+
+static void
+cwGetSpans(DrawablePtr pSrc, int wMax, DDXPointPtr ppt, int *pwidth,
+	   int nspans, char *pdstStart)
+{
+    ScreenPtr pScreen = pSrc->pScreen;
+    DrawablePtr pBackingDrawable;
+    int i;
+    int src_off_x, src_off_y;
+    
+    SCREEN_PROLOGUE(pScreen, GetSpans);
+
+    pBackingDrawable = cwGetBackingDrawable(pSrc, &src_off_x, &src_off_y);
+
+    for (i = 0; i < nspans; i++)
+	CW_OFFSET_XY_SRC(ppt[i].x, ppt[i].y);
+
+    (*pScreen->GetSpans)(pBackingDrawable, wMax, ppt, pwidth, nspans,
+			 pdstStart);
+
+    SCREEN_EPILOGUE(pScreen, GetSpans, cwGetSpans);
+}
+
+static void
+cwFillRegionSolid(DrawablePtr pDrawable, RegionPtr pRegion, unsigned long pixel)
+{
+    ScreenPtr pScreen = pDrawable->pScreen;
+    GCPtr     pGC;
+    BoxPtr    pBox;
+    int       nbox, i;
+    ChangeGCVal v[3];
+
+    pGC = GetScratchGC(pDrawable->depth, pScreen);
+    v[0].val = GXcopy;
+    v[1].val = pixel;
+    v[2].val = FillSolid;
+    dixChangeGC(NullClient, pGC, (GCFunction | GCForeground | GCFillStyle),
+		NULL, v);
+    ValidateGC(pDrawable, pGC);
+
+    pBox = REGION_RECTS(pRegion);
+    nbox = REGION_NUM_RECTS(pRegion);
+
+    for (i = 0; i < nbox; i++, pBox++) {
+	xRectangle rect;
+	rect.x      = pBox->x1;
+	rect.y      = pBox->y1;
+	rect.width  = pBox->x2 - pBox->x1;
+	rect.height = pBox->y2 - pBox->y1;
+	(*pGC->ops->PolyFillRect)(pDrawable, pGC, 1, &rect);
+    }
+
+   FreeScratchGC(pGC);
+}
+
+static void
+cwFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
+		  int x_off, int y_off)
+{
+    ScreenPtr pScreen = pDrawable->pScreen;
+    GCPtr     pGC;
+    BoxPtr    pBox;
+    int       nbox, i;
+    ChangeGCVal v[5];
+
+    pGC = GetScratchGC(pDrawable->depth, pScreen);
+    v[0].val = GXcopy;
+    v[1].val = FillTiled;
+    v[2].ptr = (pointer) pTile;
+    v[3].val = x_off;
+    v[4].val = y_off;
+    dixChangeGC(NullClient, pGC, (GCFunction | GCFillStyle | GCTile |
+		GCTileStipXOrigin | GCTileStipYOrigin), NULL, v);
+
+    ValidateGC(pDrawable, pGC);
+
+    pBox = REGION_RECTS(pRegion);
+    nbox = REGION_NUM_RECTS(pRegion);
+
+    for (i = 0; i < nbox; i++, pBox++) {
+	xRectangle rect;
+	rect.x      = pBox->x1;
+	rect.y      = pBox->y1;
+	rect.width  = pBox->x2 - pBox->x1;
+	rect.height = pBox->y2 - pBox->y1;
+	(*pGC->ops->PolyFillRect)(pDrawable, pGC, 1, &rect);
+    }
+
+   FreeScratchGC(pGC);
+}
+
+static void
+cwPaintWindowBackground(WindowPtr pWin, RegionPtr pRegion, int what)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    SCREEN_PROLOGUE(pScreen, PaintWindowBackground);
+
+    if (!cwDrawableIsRedirWindow((DrawablePtr)pWin)) {
+	(*pScreen->PaintWindowBackground)(pWin, pRegion, what);
+    } else {
+	DrawablePtr pBackingDrawable;
+	int x_off, y_off, x_screen, y_screen;
+
+	while (pWin && pWin->backgroundState == ParentRelative)
+	    pWin = pWin->parent;
+
+	pBackingDrawable = cwGetBackingDrawable((DrawablePtr)pWin, &x_off,
+						&y_off);
+
+	x_screen = x_off - pWin->drawable.x;
+	y_screen = y_off - pWin->drawable.y;
+
+	if (pWin && (pWin->backgroundState == BackgroundPixel ||
+		pWin->backgroundState == BackgroundPixmap))
+	{
+	    REGION_TRANSLATE(pScreen, pRegion, x_screen, y_screen);
+
+	    if (pWin->backgroundState == BackgroundPixel) {
+		cwFillRegionSolid(pBackingDrawable, pRegion,
+				  pWin->background.pixel);
+	    } else {
+		cwFillRegionTiled(pBackingDrawable, pRegion,
+				  pWin->background.pixmap, x_off, y_off);
+	    }
+
+	    REGION_TRANSLATE(pScreen, pRegion, -x_screen, -y_screen);
+	}
+    }
+
+    SCREEN_EPILOGUE(pScreen, PaintWindowBackground, cwPaintWindowBackground);
+}
+
+static void
+cwPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    SCREEN_PROLOGUE(pScreen, PaintWindowBorder);
+
+    if (!cwDrawableIsRedirWindow((DrawablePtr)pWin)) {
+	(*pScreen->PaintWindowBorder)(pWin, pRegion,  what);
+    } else {
+	DrawablePtr pBackingDrawable;
+	int x_off, y_off, x_screen, y_screen;
+
+	pBackingDrawable = cwGetBackingDrawable((DrawablePtr)pWin, &x_off,
+						&y_off);
+
+	x_screen = x_off - pWin->drawable.x;
+	y_screen = y_off - pWin->drawable.y;
+
+	REGION_TRANSLATE(pScreen, pRegion, x_screen, y_screen);
+
+	if (pWin->borderIsPixel) {
+	    cwFillRegionSolid(pBackingDrawable, pRegion, pWin->border.pixel);
+	} else {
+	    cwFillRegionTiled(pBackingDrawable, pRegion, pWin->border.pixmap,
+			      x_off, y_off);
+	}
+
+	REGION_TRANSLATE(pScreen, pRegion, -x_screen, -y_screen);
+    }
+
+    SCREEN_EPILOGUE(pScreen, PaintWindowBorder, cwPaintWindowBorder);
+}
+
+static void
+cwCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    SCREEN_PROLOGUE(pScreen, CopyWindow);
+
+    if (!cwDrawableIsRedirWindow((DrawablePtr)pWin)) {
+	(*pScreen->CopyWindow)(pWin, ptOldOrg, prgnSrc);
+    } else {
+	GCPtr	    pGC;
+	BoxPtr	    pExtents;
+	int	    x_off, y_off;
+	int	    dx, dy;
+	PixmapPtr   pBackingPixmap;
+	RegionPtr   pClip;
+	int	    src_x, src_y, dst_x, dst_y, w, h;
+
+	dx = ptOldOrg.x - pWin->drawable.x;
+	dy = ptOldOrg.y - pWin->drawable.y;
+
+	pExtents = REGION_EXTENTS(pScreen, prgnSrc);
+
+	pBackingPixmap = (PixmapPtr) cwGetBackingDrawable((DrawablePtr)pWin,
+							  &x_off, &y_off);
+
+	src_x = pExtents->x1 - pBackingPixmap->screen_x;
+	src_y = pExtents->y1 - pBackingPixmap->screen_y;
+	w = pExtents->x2 - pExtents->x1;
+	h = pExtents->y2 - pExtents->y1;
+	dst_x = src_x - dx;
+	dst_y = src_y - dy;
+			       
+	/* Translate region (as required by API) */
+	REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
+	
+	pGC = GetScratchGC(pBackingPixmap->drawable.depth, pScreen);
+	/*
+	 * Copy region to GC as clip, aligning as dest clip
+	 */
+	pClip = REGION_CREATE (pScreen, NULL, 0);
+	REGION_INTERSECT(pScreen, pClip, &pWin->borderClip, prgnSrc);
+	REGION_TRANSLATE(pScreen, pClip, 
+			 -pBackingPixmap->screen_x,
+			 -pBackingPixmap->screen_y);
+	
+	(*pGC->funcs->ChangeClip) (pGC, CT_REGION, pClip, 0);
+
+	ValidateGC(&pBackingPixmap->drawable, pGC);
+
+	(*pGC->ops->CopyArea) (&pBackingPixmap->drawable,
+			       &pBackingPixmap->drawable, pGC,
+			       src_x, src_y, w, h, dst_x, dst_y);
+
+	(*pGC->funcs->DestroyClip) (pGC);
+
+	FreeScratchGC(pGC);
+    }
+	
+    SCREEN_EPILOGUE(pScreen, CopyWindow, cwCopyWindow);
+}
+
+static PixmapPtr
+cwGetWindowPixmap (WindowPtr pWin)
+{
+    PixmapPtr	pPixmap = getCwPixmap (pWin);
+
+    if (!pPixmap)
+    {
+	ScreenPtr   pScreen = pWin->drawable.pScreen;
+	SCREEN_PROLOGUE(pScreen, GetWindowPixmap);
+	if (pScreen->GetWindowPixmap)
+	    pPixmap = (*pScreen->GetWindowPixmap) (pWin);
+	SCREEN_EPILOGUE(pScreen, GetWindowPixmap, cwGetWindowPixmap);
+    }
+    return pPixmap;
+}
+
+static void
+cwSetWindowPixmap (WindowPtr pWindow, PixmapPtr pPixmap)
+{
+    ScreenPtr	pScreen = pWindow->drawable.pScreen;
+    
+    if (pPixmap == (*pScreen->GetScreenPixmap) (pScreen))
+	pPixmap = NULL;
+    setCwPixmap (pWindow, pPixmap);
+}
+
+/* Screen initialization/teardown */
+void
+miInitializeCompositeWrapper(ScreenPtr pScreen)
+{
+    cwScreenPtr pScreenPriv;
+
+    if (cwDisabled[pScreen->myNum])
+	return;
+
+    if (cwGeneration != serverGeneration)
+    {
+	cwScreenIndex = AllocateScreenPrivateIndex();
+	if (cwScreenIndex < 0)
+	    return;
+	cwGCIndex = AllocateGCPrivateIndex();
+	cwWindowIndex = AllocateWindowPrivateIndex();
+#ifdef RENDER
+	cwPictureIndex = AllocatePicturePrivateIndex();
+#endif
+	cwGeneration = serverGeneration;
+    }
+    if (!AllocateGCPrivate(pScreen, cwGCIndex, sizeof(cwGCRec)))
+	return;
+    if (!AllocateWindowPrivate(pScreen, cwWindowIndex, 0))
+	return;
+#ifdef RENDER
+    if (!AllocatePicturePrivate(pScreen, cwPictureIndex, 0))
+	return;
+#endif
+    pScreenPriv = (cwScreenPtr)xalloc(sizeof(cwScreenRec));
+    if (!pScreenPriv)
+	return;
+
+    pScreen->devPrivates[cwScreenIndex].ptr = (pointer)pScreenPriv;
+    
+    SCREEN_EPILOGUE(pScreen, CloseScreen, cwCloseScreen);
+    SCREEN_EPILOGUE(pScreen, GetImage, cwGetImage);
+    SCREEN_EPILOGUE(pScreen, GetSpans, cwGetSpans);
+    SCREEN_EPILOGUE(pScreen, CreateGC, cwCreateGC);
+    SCREEN_EPILOGUE(pScreen, PaintWindowBackground, cwPaintWindowBackground);
+    SCREEN_EPILOGUE(pScreen, PaintWindowBorder, cwPaintWindowBorder);
+    SCREEN_EPILOGUE(pScreen, CopyWindow, cwCopyWindow);
+
+    SCREEN_EPILOGUE(pScreen, SetWindowPixmap, cwSetWindowPixmap);
+    SCREEN_EPILOGUE(pScreen, GetWindowPixmap, cwGetWindowPixmap);
+
+#ifdef RENDER
+    if (GetPictureScreen (pScreen))
+	cwInitializeRender(pScreen);
+#endif
+}
+
+void
+miDisableCompositeWrapper(ScreenPtr pScreen)
+{
+    cwDisabled[pScreen->myNum] = TRUE;
+}
+
+static Bool
+cwCloseScreen (int i, ScreenPtr pScreen)
+{
+    cwScreenPtr   pScreenPriv;
+#ifdef RENDER
+    PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
+#endif
+
+    pScreenPriv = (cwScreenPtr)pScreen->devPrivates[cwScreenIndex].ptr;
+
+    pScreen->CloseScreen = pScreenPriv->CloseScreen;
+    pScreen->GetImage = pScreenPriv->GetImage;
+    pScreen->GetSpans = pScreenPriv->GetSpans;
+    pScreen->CreateGC = pScreenPriv->CreateGC;
+    pScreen->PaintWindowBackground = pScreenPriv->PaintWindowBackground;
+    pScreen->PaintWindowBorder = pScreenPriv->PaintWindowBorder;
+    pScreen->CopyWindow = pScreenPriv->CopyWindow;
+
+#ifdef RENDER
+    if (ps)
+	cwFiniRender(pScreen);
+#endif
+
+    xfree((pointer)pScreenPriv);
+
+    return (*pScreen->CloseScreen)(i, pScreen);
+}
diff --git a/nx-X11/programs/Xserver/miext/cw/cw.h b/nx-X11/programs/Xserver/miext/cw/cw.h
new file mode 100644
index 000000000..2563aed5e
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/cw/cw.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright © 2004 Eric Anholt
+ *
+ * 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 Eric Anholt not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Eric Anholt makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * ERIC ANHOLT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ERIC ANHOLT 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.
+ */
+/* $Header: /cvs/xorg/xc/programs/Xserver/miext/cw/cw.h,v 1.14 2005/12/09 18:32:46 ajax Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "gcstruct.h"
+#include "picturestr.h"
+
+/*
+ * One of these structures is allocated per GC that gets used with a window with
+ * backing pixmap.
+ */
+
+typedef struct {
+    GCPtr	    pBackingGC;	    /* Copy of the GC but with graphicsExposures
+				     * set FALSE and the clientClip set to
+				     * clip output to the valid regions of the
+				     * backing pixmap. */
+    unsigned long   serialNumber;   /* clientClip computed time */
+    unsigned long   stateChanges;   /* changes in parent gc since last copy */
+    GCOps	    *wrapOps;	    /* wrapped ops */
+    GCFuncs	    *wrapFuncs;	    /* wrapped funcs */
+} cwGCRec, *cwGCPtr;
+
+extern int cwGCIndex;
+
+#define getCwGC(pGC)	((cwGCPtr)(pGC)->devPrivates[cwGCIndex].ptr)
+#define setCwGC(pGC,p)	((pGC)->devPrivates[cwGCIndex].ptr = (pointer) (p))
+
+/*
+ * One of these structures is allocated per Picture that gets used with a
+ * window with a backing pixmap
+ */
+
+typedef struct {
+    PicturePtr	    pBackingPicture;
+    unsigned long   serialNumber;
+    unsigned long   stateChanges;
+} cwPictureRec, *cwPicturePtr;
+
+#define getCwPicture(pPicture)	((cwPicturePtr)(pPicture)->devPrivates[cwPictureIndex].ptr)
+#define setCwPicture(pPicture,p) ((pPicture)->devPrivates[cwPictureIndex].ptr = (pointer) (p))
+
+extern int  cwPictureIndex;
+
+extern int cwWindowIndex;
+
+#define cwWindowPrivate(pWindow)    ((pWindow)->devPrivates[cwWindowIndex].ptr)
+#define getCwPixmap(pWindow)	    ((PixmapPtr) cwWindowPrivate(pWindow))
+#define setCwPixmap(pWindow,pPixmap) (cwWindowPrivate(pWindow) = (pointer) (pPixmap))
+
+#define cwDrawableIsRedirWindow(pDraw)					\
+	((pDraw)->type == DRAWABLE_WINDOW &&				\
+	 getCwPixmap((WindowPtr) (pDraw)) != NULL)
+
+typedef struct {
+    /*
+     * screen func wrappers
+     */
+    CloseScreenProcPtr		CloseScreen;
+    GetImageProcPtr		GetImage;
+    GetSpansProcPtr		GetSpans;
+    CreateGCProcPtr		CreateGC;
+
+    PaintWindowBackgroundProcPtr PaintWindowBackground;
+    PaintWindowBorderProcPtr	PaintWindowBorder;
+    CopyWindowProcPtr		CopyWindow;
+
+    GetWindowPixmapProcPtr	GetWindowPixmap;
+    SetWindowPixmapProcPtr	SetWindowPixmap;
+    
+#ifdef RENDER
+    DestroyPictureProcPtr	DestroyPicture;
+    ChangePictureClipProcPtr	ChangePictureClip;
+    DestroyPictureClipProcPtr	DestroyPictureClip;
+    
+    ChangePictureProcPtr	ChangePicture;
+    ValidatePictureProcPtr	ValidatePicture;
+
+    CompositeProcPtr		Composite;
+    GlyphsProcPtr		Glyphs;
+    CompositeRectsProcPtr	CompositeRects;
+
+    TrapezoidsProcPtr		Trapezoids;
+    TrianglesProcPtr		Triangles;
+    TriStripProcPtr		TriStrip;
+    TriFanProcPtr		TriFan;
+
+    RasterizeTrapezoidProcPtr	RasterizeTrapezoid;
+#endif
+} cwScreenRec, *cwScreenPtr;
+
+extern int cwScreenIndex;
+
+#define getCwScreen(pScreen)	((cwScreenPtr)(pScreen)->devPrivates[cwScreenIndex].ptr)
+#define setCwScreen(pScreen,p)	((cwScreenPtr)(pScreen)->devPrivates[cwScreenIndex].ptr = (p))
+
+#define CW_OFFSET_XYPOINTS(ppt, npt) do { \
+    DDXPointPtr _ppt = (DDXPointPtr)(ppt); \
+    int _i; \
+    for (_i = 0; _i < npt; _i++) { \
+	_ppt[_i].x += dst_off_x; \
+	_ppt[_i].y += dst_off_y; \
+    } \
+} while (0)
+
+#define CW_OFFSET_RECTS(prect, nrect) do { \
+    int _i; \
+    for (_i = 0; _i < nrect; _i++) { \
+	(prect)[_i].x += dst_off_x; \
+	(prect)[_i].y += dst_off_y; \
+    } \
+} while (0)
+
+#define CW_OFFSET_ARCS(parc, narc) do { \
+    int _i; \
+    for (_i = 0; _i < narc; _i++) { \
+	(parc)[_i].x += dst_off_x; \
+	(parc)[_i].y += dst_off_y; \
+    } \
+} while (0)
+
+#define CW_OFFSET_XY_DST(x, y) do { \
+    (x) = (x) + dst_off_x; \
+    (y) = (y) + dst_off_y; \
+} while (0)
+
+#define CW_OFFSET_XY_SRC(x, y) do { \
+    (x) = (x) + src_off_x; \
+    (y) = (y) + src_off_y; \
+} while (0)
+
+/* cw.c */
+DrawablePtr
+cwGetBackingDrawable(DrawablePtr pDrawable, int *x_off, int *y_off);
+
+/* cw_render.c */
+
+void
+cwInitializeRender (ScreenPtr pScreen);
+
+void
+cwFiniRender (ScreenPtr pScreen);
+
+/* cw.c */
+
+void
+miInitializeCompositeWrapper(ScreenPtr pScreen);
+
+/* Must be called before miInitializeCompositeWrapper */
+void
+miDisableCompositeWrapper(ScreenPtr pScreen);
diff --git a/nx-X11/programs/Xserver/miext/cw/cw_ops.c b/nx-X11/programs/Xserver/miext/cw/cw_ops.c
new file mode 100644
index 000000000..567a8c93c
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/cw/cw_ops.c
@@ -0,0 +1,470 @@
+/*
+ * Copyright © 2004 Eric Anholt
+ *
+ * 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 Eric Anholt not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Eric Anholt makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * ERIC ANHOLT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ERIC ANHOLT 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.
+ */
+/* $Header: /cvs/xorg/xc/programs/Xserver/miext/cw/cw_ops.c,v 1.9 2005/07/03 07:02:01 daniels Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "gcstruct.h"
+#include "cw.h"
+
+#define SETUP_BACKING_DST(_pDst, _pGC) \
+    cwGCPtr pGCPrivate = getCwGC (_pGC); \
+    int dst_off_x, dst_off_y; \
+    DrawablePtr pBackingDst = cwGetBackingDrawable(pDst, &dst_off_x, \
+	&dst_off_y); \
+    GCPtr pBackingGC = pGCPrivate->pBackingGC ? pGCPrivate->pBackingGC : _pGC
+
+#define SETUP_BACKING_SRC(pSrc, pGC) \
+    int src_off_x, src_off_y; \
+    DrawablePtr pBackingSrc = cwGetBackingDrawable(pSrc, &src_off_x, \
+	&src_off_y)
+
+#define PROLOGUE(pGC) do { \
+    pGC->funcs = pGCPrivate->wrapFuncs;\
+    pGC->ops = pGCPrivate->wrapOps;\
+} while (0)
+
+#define EPILOGUE(pGC) do { \
+    pGCPrivate->wrapFuncs = (pGC)->funcs; \
+    pGCPrivate->wrapOps = (pGC)->ops; \
+    (pGC)->funcs = &cwGCFuncs; \
+    (pGC)->ops = &cwGCOps; \
+} while (0)
+
+extern GCFuncs cwGCFuncs;
+
+/*
+ * GC ops -- wrap each GC operation with our own function
+ */
+
+static void cwFillSpans(DrawablePtr pDst, GCPtr pGC, int nInit,
+			DDXPointPtr pptInit, int *pwidthInit, int fSorted);
+static void cwSetSpans(DrawablePtr pDst, GCPtr pGC, char *psrc,
+		       DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
+static void cwPutImage(DrawablePtr pDst, GCPtr pGC, int depth,
+		       int x, int y, int w, int h, int leftPad, int format,
+		       char *pBits);
+static RegionPtr cwCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+			    int srcx, int srcy, int w, int h,
+			    int dstx, int dsty);
+static RegionPtr cwCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+			     int srcx, int srcy, int w, int h,
+			     int dstx, int dsty, unsigned long plane);
+static void cwPolyPoint(DrawablePtr pDst, GCPtr pGC, int mode, int npt,
+			xPoint *pptInit);
+static void cwPolylines(DrawablePtr pDst, GCPtr pGC, int mode, int npt,
+			DDXPointPtr pptInit);
+static void cwPolySegment(DrawablePtr pDst, GCPtr pGC, int nseg,
+			  xSegment *pSegs);
+static void cwPolyRectangle(DrawablePtr pDst, GCPtr pGC,
+			    int nrects, xRectangle *pRects);
+static void cwPolyArc(DrawablePtr pDst, GCPtr pGC, int narcs, xArc *parcs);
+static void cwFillPolygon(DrawablePtr pDst, GCPtr pGC, int shape, int mode,
+			  int count, DDXPointPtr pPts);
+static void cwPolyFillRect(DrawablePtr pDst, GCPtr pGC,
+			   int nrectFill, xRectangle *prectInit);
+static void cwPolyFillArc(DrawablePtr pDst, GCPtr pGC,
+			  int narcs, xArc *parcs);
+static int cwPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+		       int count, char *chars);
+static int cwPolyText16(DrawablePtr pDst, GCPtr pGC, int x, int y,
+			int count, unsigned short *chars);
+static void cwImageText8(DrawablePtr pDst, GCPtr pGC, int x, int y,
+			 int count, char *chars);
+static void cwImageText16(DrawablePtr pDst, GCPtr pGC, int x, int y,
+			  int count, unsigned short *chars);
+static void cwImageGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y,
+			    unsigned int nglyph, CharInfoPtr *ppci,
+			    pointer pglyphBase);
+static void cwPolyGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y,
+			   unsigned int nglyph, CharInfoPtr *ppci,
+			   pointer pglyphBase);
+static void cwPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst,
+			 int w, int h, int x, int y);
+
+GCOps cwGCOps = {
+	cwFillSpans,
+	cwSetSpans,
+	cwPutImage,
+	cwCopyArea,
+	cwCopyPlane,
+	cwPolyPoint,
+	cwPolylines,
+	cwPolySegment,
+	cwPolyRectangle,
+	cwPolyArc,
+	cwFillPolygon,
+	cwPolyFillRect,
+	cwPolyFillArc,
+	cwPolyText8,
+	cwPolyText16,
+	cwImageText8,
+	cwImageText16,
+	cwImageGlyphBlt,
+	cwPolyGlyphBlt,
+	cwPushPixels
+};
+
+static void
+cwFillSpans(DrawablePtr pDst, GCPtr pGC, int nspans, DDXPointPtr ppt,
+	    int *pwidth, int fSorted)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XYPOINTS(ppt, nspans);
+
+    (*pBackingGC->ops->FillSpans)(pBackingDst, pBackingGC, nspans, ppt,
+				  pwidth, fSorted);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwSetSpans(DrawablePtr pDst, GCPtr pGC, char *psrc, DDXPointPtr ppt,
+	   int *pwidth, int nspans, int fSorted)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XYPOINTS(ppt, nspans);
+
+    (*pBackingGC->ops->SetSpans)(pBackingDst, pBackingGC, psrc, ppt, pwidth,
+				 nspans, fSorted);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPutImage(DrawablePtr pDst, GCPtr pGC, int depth, int x, int y, int w, int h,
+	   int leftPad, int format, char *pBits)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    (*pBackingGC->ops->PutImage)(pBackingDst, pBackingGC, depth, x, y, w, h,
+				 leftPad, format, pBits);
+
+    EPILOGUE(pGC);
+}
+
+static RegionPtr
+cwCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy,
+	   int w, int h, int dstx, int dsty)
+{
+    int		odstx, odsty;
+    RegionPtr	exposed = NULL;
+    SETUP_BACKING_DST(pDst, pGC);
+    SETUP_BACKING_SRC(pSrc, pGC);
+
+    PROLOGUE(pGC);
+
+    odstx = dstx;
+    odsty = dsty;
+    CW_OFFSET_XY_DST(dstx, dsty);
+    CW_OFFSET_XY_SRC(srcx, srcy);
+
+    exposed = (*pBackingGC->ops->CopyArea)(pBackingSrc, pBackingDst,
+					   pBackingGC, srcx, srcy, w, h,
+					   dstx, dsty);
+
+    if (exposed != NULL)
+	REGION_TRANSLATE(pDst->pScreen, exposed, odstx - dstx, odsty - dsty);
+
+    EPILOGUE(pGC);
+
+    return exposed;
+}
+
+static RegionPtr
+cwCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy,
+	    int w, int h, int dstx, int dsty, unsigned long plane)
+{
+    int		odstx, odsty;
+    RegionPtr	exposed = NULL;
+    SETUP_BACKING_DST(pDst, pGC);
+    SETUP_BACKING_SRC(pSrc, pGC);
+
+    PROLOGUE(pGC);
+
+    odstx = dstx;
+    odsty = dsty;
+    CW_OFFSET_XY_DST(dstx, dsty);
+    CW_OFFSET_XY_SRC(srcx, srcy);
+
+    exposed = (*pBackingGC->ops->CopyPlane)(pBackingSrc, pBackingDst,
+					    pBackingGC, srcx, srcy, w, h,
+					    dstx, dsty, plane);
+
+    if (exposed != NULL)
+	REGION_TRANSLATE(pDst->pScreen, exposed, odstx - dstx, odsty - dsty);
+
+    EPILOGUE(pGC);
+
+    return exposed;
+}
+
+static void
+cwPolyPoint(DrawablePtr pDst, GCPtr pGC, int mode, int npt, xPoint *ppt)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    if (mode == CoordModeOrigin)
+	CW_OFFSET_XYPOINTS(ppt, npt);
+    else
+	CW_OFFSET_XYPOINTS(ppt, 1);
+
+    (*pBackingGC->ops->PolyPoint)(pBackingDst, pBackingGC, mode, npt, ppt);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPolylines(DrawablePtr pDst, GCPtr pGC, int mode, int npt, DDXPointPtr ppt)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    if (mode == CoordModeOrigin)
+	CW_OFFSET_XYPOINTS(ppt, npt);
+    else
+	CW_OFFSET_XYPOINTS(ppt, 1);
+
+    (*pBackingGC->ops->Polylines)(pBackingDst, pBackingGC, mode, npt, ppt);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPolySegment(DrawablePtr pDst, GCPtr pGC, int nseg, xSegment *pSegs)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XYPOINTS(pSegs, nseg * 2);
+
+    (*pBackingGC->ops->PolySegment)(pBackingDst, pBackingGC, nseg, pSegs);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPolyRectangle(DrawablePtr pDst, GCPtr pGC, int nrects, xRectangle *pRects)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_RECTS(pRects, nrects);
+
+    (*pBackingGC->ops->PolyRectangle)(pBackingDst, pBackingGC, nrects, pRects);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPolyArc(DrawablePtr pDst, GCPtr pGC, int narcs, xArc *pArcs)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_RECTS(pArcs, narcs);
+
+    (*pBackingGC->ops->PolyArc)(pBackingDst, pBackingGC, narcs, pArcs);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwFillPolygon(DrawablePtr pDst, GCPtr pGC, int shape, int mode, int npt,
+	      DDXPointPtr ppt)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    if (mode == CoordModeOrigin)
+	CW_OFFSET_XYPOINTS(ppt, npt);
+    else
+	CW_OFFSET_XYPOINTS(ppt, 1);
+
+    (*pBackingGC->ops->FillPolygon)(pBackingDst, pBackingGC, shape, mode, npt,
+				    ppt);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPolyFillRect(DrawablePtr pDst, GCPtr pGC, int nrects, xRectangle *pRects)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_RECTS(pRects, nrects);
+
+    (*pBackingGC->ops->PolyFillRect)(pBackingDst, pBackingGC, nrects, pRects);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPolyFillArc(DrawablePtr pDst, GCPtr pGC, int narcs, xArc *parcs)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_RECTS(parcs, narcs);
+
+    (*pBackingGC->ops->PolyFillArc)(pBackingDst, pBackingGC, narcs, parcs);
+
+    EPILOGUE(pGC);
+}
+
+static int
+cwPolyText8(DrawablePtr pDst, GCPtr pGC, int x, int y, int count, char *chars)
+{
+    int result;
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    result = (*pBackingGC->ops->PolyText8)(pBackingDst, pBackingGC, x, y,
+					   count, chars);
+
+    EPILOGUE(pGC);
+
+    return result;
+}
+
+static int
+cwPolyText16(DrawablePtr pDst, GCPtr pGC, int x, int y, int count,
+	     unsigned short *chars)
+{
+    int result;
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    result = (*pBackingGC->ops->PolyText16)(pBackingDst, pBackingGC, x, y,
+					    count, chars);
+
+    EPILOGUE(pGC);
+    return result;
+}
+
+static void
+cwImageText8(DrawablePtr pDst, GCPtr pGC, int x, int y, int count, char *chars)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    (*pBackingGC->ops->ImageText8)(pBackingDst, pBackingGC, x, y, count,
+				   chars);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwImageText16(DrawablePtr pDst, GCPtr pGC, int x, int y, int count,
+	     unsigned short *chars)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    (*pBackingGC->ops->ImageText16)(pBackingDst, pBackingGC, x, y, count,
+				    chars);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwImageGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y, unsigned int nglyph,
+		CharInfoPtr *ppci, pointer pglyphBase)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    (*pBackingGC->ops->ImageGlyphBlt)(pBackingDst, pBackingGC, x, y, nglyph,
+				      ppci, pglyphBase);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPolyGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y, unsigned int nglyph,
+	       CharInfoPtr *ppci, pointer pglyphBase)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    (*pBackingGC->ops->PolyGlyphBlt)(pBackingDst, pBackingGC, x, y, nglyph,
+				      ppci, pglyphBase);
+
+    EPILOGUE(pGC);
+}
+
+static void
+cwPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst, int w, int h,
+	     int x, int y)
+{
+    SETUP_BACKING_DST(pDst, pGC);
+
+    PROLOGUE(pGC);
+
+    CW_OFFSET_XY_DST(x, y);
+
+    (*pBackingGC->ops->PushPixels)(pBackingGC, pBitMap, pBackingDst, w, h,
+				   x, y);
+
+    EPILOGUE(pGC);
+}
+
diff --git a/nx-X11/programs/Xserver/miext/cw/cw_render.c b/nx-X11/programs/Xserver/miext/cw/cw_render.c
new file mode 100644
index 000000000..74c52afb0
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/cw/cw_render.c
@@ -0,0 +1,501 @@
+/*
+ * Copyright © 2004 Eric Anholt
+ *
+ * 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 Eric Anholt not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Eric Anholt makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * ERIC ANHOLT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ERIC ANHOLT 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.
+ */
+/* $Header: /cvs/xorg/xc/programs/Xserver/miext/cw/cw_render.c,v 1.14 2005/07/03 07:02:01 daniels Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "cw.h"
+
+#ifdef RENDER
+
+#define cwPsDecl(pScreen)	\
+    PictureScreenPtr	ps = GetPictureScreen (pScreen);	\
+    cwScreenPtr		pCwScreen = getCwScreen (pScreen)
+
+#define cwPicturePrivate					\
+    cwPicturePtr    pPicturePrivate = getCwPicture(pPicture)
+
+#define cwSrcPictureDecl							\
+    int		    src_picture_x_off, src_picture_y_off;			\
+    PicturePtr	    pBackingSrcPicture = cwGetBackingPicture(pSrcPicture,	\
+							     &src_picture_x_off,\
+							     &src_picture_y_off)
+
+#define cwDstPictureDecl							\
+    int		    dst_picture_x_off, dst_picture_y_off;			\
+    PicturePtr	    pBackingDstPicture = cwGetBackingPicture(pDstPicture,	\
+							     &dst_picture_x_off,\
+							     &dst_picture_y_off)
+
+#define cwMskPictureDecl							\
+    int		    msk_picture_x_off = 0, msk_picture_y_off = 0;		\
+    PicturePtr	    pBackingMskPicture = (!pMskPicture ? 0 :	    		\
+					  cwGetBackingPicture(pMskPicture,	\
+							      &msk_picture_x_off,\
+							      &msk_picture_y_off))
+
+#define cwPsUnwrap(elt) {	\
+    ps->elt = pCwScreen->elt;	\
+}
+
+#define cwPsWrap(elt,func) {	\
+    pCwScreen->elt = ps->elt;	\
+    ps->elt = func;		\
+}
+
+static cwPicturePtr
+cwCreatePicturePrivate (PicturePtr pPicture)
+{
+    WindowPtr	    pWindow = (WindowPtr) pPicture->pDrawable;
+    PixmapPtr	    pPixmap = getCwPixmap (pWindow);
+    int		    error;
+    cwPicturePtr    pPicturePrivate;
+
+    pPicturePrivate = xalloc (sizeof (cwPictureRec));
+    if (!pPicturePrivate)
+	return NULL;
+    
+    pPicturePrivate->pBackingPicture = CreatePicture (0, &pPixmap->drawable, 
+						      pPicture->pFormat,
+						      0, 0, serverClient,
+						      &error);
+    if (!pPicturePrivate->pBackingPicture)
+    {
+	xfree (pPicturePrivate);
+	return NULL;
+    }
+
+    /*
+     * Ensure that this serial number does not match the window's
+     */
+    pPicturePrivate->serialNumber = pPixmap->drawable.serialNumber;
+    pPicturePrivate->stateChanges = (1 << (CPLastBit + 1)) - 1;
+    
+    setCwPicture(pPicture, pPicturePrivate);
+
+    return pPicturePrivate;
+}
+
+static void
+cwDestroyPicturePrivate (PicturePtr pPicture)
+{
+    cwPicturePrivate;
+
+    if (pPicturePrivate)
+    {
+	if (pPicturePrivate->pBackingPicture)
+	    FreePicture (pPicturePrivate->pBackingPicture, 0);
+	xfree (pPicturePrivate);
+	setCwPicture(pPicture, NULL);
+    }
+}
+
+static PicturePtr
+cwGetBackingPicture (PicturePtr pPicture, int *x_off, int *y_off)
+{
+    cwPicturePrivate;
+
+    if (pPicturePrivate)
+    {
+	DrawablePtr pDrawable = pPicture->pDrawable;
+	WindowPtr   pWindow = (WindowPtr) pDrawable;
+	PixmapPtr   pPixmap = getCwPixmap (pWindow);
+
+	*x_off = pDrawable->x - pPixmap->screen_x;
+	*y_off = pDrawable->y - pPixmap->screen_y;
+
+	return pPicturePrivate->pBackingPicture;
+    }
+    else
+    {
+	*x_off = *y_off = 0;
+	return pPicture;
+    }
+}
+    
+static void
+cwDestroyPicture (PicturePtr pPicture)
+{
+    ScreenPtr		pScreen = pPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    
+    cwPsUnwrap(DestroyPicture);
+    cwDestroyPicturePrivate (pPicture);
+    (*ps->DestroyPicture) (pPicture);
+    cwPsWrap(DestroyPicture, cwDestroyPicture);
+}
+
+static void
+cwChangePicture (PicturePtr pPicture, Mask mask)
+{
+    ScreenPtr		pScreen = pPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwPicturePtr	pPicturePrivate = getCwPicture(pPicture);
+    
+    cwPsUnwrap(ChangePicture);
+    (*ps->ChangePicture) (pPicture, mask);
+    if (pPicturePrivate)
+	pPicturePrivate->stateChanges |= mask;
+    cwPsWrap(ChangePicture, cwChangePicture);
+}
+
+
+static void
+cwValidatePicture (PicturePtr pPicture,
+		   Mask       mask)
+{
+    DrawablePtr		pDrawable = pPicture->pDrawable;
+    ScreenPtr		pScreen = pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwPicturePrivate;
+    
+    cwPsUnwrap(ValidatePicture);
+
+    /*
+     * Must call ValidatePicture to ensure pPicture->pCompositeClip is valid
+     */
+    (*ps->ValidatePicture) (pPicture, mask);
+    
+    if (!cwDrawableIsRedirWindow (pDrawable))
+    {
+	if (pPicturePrivate)
+	    cwDestroyPicturePrivate (pPicture);
+    }
+    else
+    {
+	PicturePtr  pBackingPicture;
+	DrawablePtr pBackingDrawable;
+	int	    x_off, y_off;
+	
+	pBackingDrawable = cwGetBackingDrawable(pDrawable, &x_off, &y_off);
+
+	if (pPicturePrivate && 
+	    pPicturePrivate->pBackingPicture->pDrawable != pBackingDrawable)
+	{
+	    cwDestroyPicturePrivate (pPicture);
+	    pPicturePrivate = 0;
+	}
+
+	if (!pPicturePrivate)
+	{
+	    pPicturePrivate = cwCreatePicturePrivate (pPicture);
+	    if (!pPicturePrivate)
+	    {
+		cwPsWrap(ValidatePicture, cwValidatePicture);
+		return;
+	    }
+	}
+
+	pBackingPicture = pPicturePrivate->pBackingPicture;
+
+	/*
+	 * Always copy transform and filters because there's no
+	 * indication of when they've changed
+	 */
+	SetPictureTransform(pBackingPicture, pPicture->transform);
+	
+	if (pBackingPicture->filter != pPicture->filter ||
+	    pPicture->filter_nparams > 0)
+	{
+	    char    *filter = PictureGetFilterName (pPicture->filter);
+	    
+	    SetPictureFilter(pBackingPicture,
+			     filter, strlen (filter),
+			     pPicture->filter_params,
+			     pPicture->filter_nparams);
+	}
+
+	pPicturePrivate->stateChanges |= mask;
+
+	if (pPicturePrivate->serialNumber != pDrawable->serialNumber ||
+	    (pPicturePrivate->stateChanges & (CPClipXOrigin|CPClipYOrigin|CPClipMask)))
+	{
+	    SetPictureClipRegion (pBackingPicture, 
+				  x_off - pDrawable->x,
+				  y_off - pDrawable->y,
+				  pPicture->pCompositeClip);
+    
+	    pPicturePrivate->serialNumber = pDrawable->serialNumber;
+	    pPicturePrivate->stateChanges &= ~(CPClipXOrigin | CPClipYOrigin | CPClipMask);
+	}
+
+	CopyPicture(pPicture, pPicturePrivate->stateChanges, pBackingPicture);
+
+	ValidatePicture (pBackingPicture);
+    }
+    cwPsWrap(ValidatePicture, cwValidatePicture);
+}
+
+static void
+cwComposite (CARD8	op,
+	     PicturePtr pSrcPicture,
+	     PicturePtr pMskPicture,
+	     PicturePtr pDstPicture,
+	     INT16	xSrc,
+	     INT16	ySrc,
+	     INT16	xMsk,
+	     INT16	yMsk,
+	     INT16	xDst,
+	     INT16	yDst,
+	     CARD16	width,
+	     CARD16	height)
+{
+    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwSrcPictureDecl;
+    cwMskPictureDecl;
+    cwDstPictureDecl;
+    
+    cwPsUnwrap(Composite);
+    (*ps->Composite) (op, pBackingSrcPicture, pBackingMskPicture, pBackingDstPicture,
+		      xSrc + src_picture_x_off, ySrc + src_picture_y_off,
+		      xMsk + msk_picture_x_off, yMsk + msk_picture_y_off,
+		      xDst + dst_picture_x_off, yDst + dst_picture_y_off,
+		      width, height);
+    cwPsWrap(Composite, cwComposite);
+}
+
+static void
+cwGlyphs (CARD8      op,
+	  PicturePtr pSrcPicture,
+	  PicturePtr pDstPicture,
+	  PictFormatPtr  maskFormat,
+	  INT16      xSrc,
+	  INT16      ySrc,
+	  int	nlists,
+	  GlyphListPtr   lists,
+	  GlyphPtr	*glyphs)
+{
+    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwSrcPictureDecl;
+    cwDstPictureDecl;
+    
+    cwPsUnwrap(Glyphs);
+    if (nlists)
+    {
+	lists->xOff += dst_picture_x_off;
+	lists->yOff += dst_picture_y_off;
+    }
+    (*ps->Glyphs) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
+		   xSrc + src_picture_x_off, ySrc + src_picture_y_off,
+		   nlists, lists, glyphs);
+    cwPsWrap(Glyphs, cwGlyphs);
+}
+
+static void
+cwCompositeRects (CARD8		op,
+		  PicturePtr	pDstPicture,
+		  xRenderColor  *color,
+		  int		nRect,
+		  xRectangle	*rects)
+{
+    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwDstPictureDecl;
+    int i;
+    
+    cwPsUnwrap(CompositeRects);
+    for (i = 0; i < nRect; i++)
+    {
+	rects[i].x += dst_picture_x_off;
+	rects[i].y += dst_picture_y_off;
+    }
+    (*ps->CompositeRects) (op, pBackingDstPicture, color, nRect, rects);
+    cwPsWrap(CompositeRects, cwCompositeRects);
+}
+
+static void
+cwTrapezoids (CARD8	    op,
+	      PicturePtr    pSrcPicture,
+	      PicturePtr    pDstPicture,
+	      PictFormatPtr maskFormat,
+	      INT16	    xSrc,
+	      INT16	    ySrc,
+	      int	    ntrap,
+	      xTrapezoid    *traps)
+{
+    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwSrcPictureDecl;
+    cwDstPictureDecl;
+    int i;
+    
+    cwPsUnwrap(Trapezoids);
+    if (dst_picture_x_off || dst_picture_y_off) {
+	for (i = 0; i < ntrap; i++)
+	{
+	    traps[i].top += dst_picture_y_off << 16;
+	    traps[i].bottom += dst_picture_y_off << 16;
+	    traps[i].left.p1.x += dst_picture_x_off << 16;
+	    traps[i].left.p1.y += dst_picture_y_off << 16;
+	    traps[i].left.p2.x += dst_picture_x_off << 16;
+	    traps[i].left.p2.y += dst_picture_y_off << 16;
+	    traps[i].right.p1.x += dst_picture_x_off << 16;
+	    traps[i].right.p1.y += dst_picture_y_off << 16;
+	    traps[i].right.p2.x += dst_picture_x_off << 16;
+	    traps[i].right.p2.y += dst_picture_y_off << 16;
+	}
+    }
+    (*ps->Trapezoids) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
+		       xSrc + src_picture_x_off, ySrc + src_picture_y_off,
+		       ntrap, traps);
+    cwPsWrap(Trapezoids, cwTrapezoids);
+}
+
+static void
+cwTriangles (CARD8	    op,
+	     PicturePtr	    pSrcPicture,
+	     PicturePtr	    pDstPicture,
+	     PictFormatPtr  maskFormat,
+	     INT16	    xSrc,
+	     INT16	    ySrc,
+	     int	    ntri,
+	     xTriangle	   *tris)
+{
+    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwSrcPictureDecl;
+    cwDstPictureDecl;
+    int i;
+    
+    cwPsUnwrap(Triangles);
+    if (dst_picture_x_off || dst_picture_y_off) {
+	for (i = 0; i < ntri; i++)
+	{
+	    tris[i].p1.x += dst_picture_x_off << 16;
+	    tris[i].p1.y += dst_picture_y_off << 16;
+	    tris[i].p2.x += dst_picture_x_off << 16;
+	    tris[i].p2.y += dst_picture_y_off << 16;
+	    tris[i].p3.x += dst_picture_x_off << 16;
+	    tris[i].p3.y += dst_picture_y_off << 16;
+	}
+    }
+    (*ps->Triangles) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
+		      xSrc + src_picture_x_off, ySrc + src_picture_y_off,
+		      ntri, tris);
+    cwPsWrap(Triangles, cwTriangles);
+}
+
+static void
+cwTriStrip (CARD8	    op,
+	    PicturePtr	    pSrcPicture,
+	    PicturePtr	    pDstPicture,
+	    PictFormatPtr   maskFormat,
+	    INT16	    xSrc,
+	    INT16	    ySrc,
+	    int		    npoint,
+	    xPointFixed    *points)
+{
+    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwSrcPictureDecl;
+    cwDstPictureDecl;
+    int i;
+
+    cwPsUnwrap(TriStrip);
+    if (dst_picture_x_off || dst_picture_y_off) {
+	for (i = 0; i < npoint; i++)
+	{
+	    points[i].x += dst_picture_x_off << 16;
+	    points[i].y += dst_picture_y_off << 16;
+	}
+    }
+    (*ps->TriStrip) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
+		     xSrc + src_picture_x_off, ySrc + src_picture_y_off,
+		     npoint, points);
+    cwPsWrap(TriStrip, cwTriStrip);
+}
+
+static void
+cwTriFan (CARD8		 op,
+	  PicturePtr	 pSrcPicture,
+	  PicturePtr	 pDstPicture,
+	  PictFormatPtr  maskFormat,
+	  INT16		 xSrc,
+	  INT16		 ySrc,
+	  int		 npoint,
+	  xPointFixed   *points)
+{
+    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
+    cwPsDecl(pScreen);
+    cwSrcPictureDecl;
+    cwDstPictureDecl;
+    int i;
+
+    cwPsUnwrap(TriFan);
+    if (dst_picture_x_off || dst_picture_y_off) {
+	for (i = 0; i < npoint; i++)
+	{
+	    points[i].x += dst_picture_x_off << 16;
+	    points[i].y += dst_picture_y_off << 16;
+	}
+    }
+    (*ps->TriFan) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
+		   xSrc + src_picture_x_off, ySrc + src_picture_y_off,
+		   npoint, points);
+    cwPsWrap(TriFan, cwTriFan);
+}
+
+void
+cwInitializeRender (ScreenPtr pScreen)
+{
+    cwPsDecl (pScreen);
+
+    cwPsWrap(DestroyPicture, cwDestroyPicture);
+    cwPsWrap(ChangePicture, cwChangePicture);
+    cwPsWrap(ValidatePicture, cwValidatePicture);
+    cwPsWrap(Composite, cwComposite);
+    cwPsWrap(Glyphs, cwGlyphs);
+    cwPsWrap(CompositeRects, cwCompositeRects);
+    cwPsWrap(Trapezoids, cwTrapezoids);
+    cwPsWrap(Triangles, cwTriangles);
+    cwPsWrap(TriStrip, cwTriStrip);
+    cwPsWrap(TriFan, cwTriFan);
+    /* There is no need to wrap AddTraps as far as we can tell.  AddTraps can
+     * only be done on alpha-only pictures, and we won't be getting
+     * alpha-only window pictures, so there's no need to translate.
+     */
+}
+
+void
+cwFiniRender (ScreenPtr pScreen)
+{
+    cwPsDecl (pScreen);
+
+    cwPsUnwrap(DestroyPicture);
+    cwPsUnwrap(ChangePicture);
+    cwPsUnwrap(ValidatePicture);
+    cwPsUnwrap(Composite);
+    cwPsUnwrap(Glyphs);
+    cwPsUnwrap(CompositeRects);
+    cwPsUnwrap(Trapezoids);
+    cwPsUnwrap(Triangles);
+    cwPsUnwrap(TriStrip);
+    cwPsUnwrap(TriFan);
+}
+
+#endif /* RENDER */
diff --git a/nx-X11/programs/Xserver/miext/damage/Imakefile b/nx-X11/programs/Xserver/miext/damage/Imakefile
new file mode 100755
index 000000000..1fa5cf126
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/damage/Imakefile
@@ -0,0 +1,26 @@
+#define IHaveModules
+#include <Server.tmpl>
+
+#if BuildRootless
+DEFINES = -DROOTLESS_WORKAROUND
+#endif
+
+SRCS = damage.c
+
+OBJS = damage.o
+
+   INCLUDES = -I. -I../shadow -I../../mi -I../../fb -I../../include -I$(XINCLUDESRC) \
+	      -I$(FONTINCSRC) -I$(XF86SRC)/common $(EXTRAINCLUDES) \
+	      -I../../render -I../cw -I$(EXTINCSRC)
+   LINTLIBS = ../../dix/llib-ldix.ln ../../os/llib-los.ln \
+	     ../../mi/llib-lmi.ln
+
+NormalLibraryObjectRule()
+NormalLibraryTarget(damage,$(OBJS))
+LintLibraryTarget(damage,$(SRCS))
+
+NormalLintTarget($(SRCS))
+
+DependTarget()
+
+InstallDriverSDKNonExecFile(damage.h,$(DRIVERSDKINCLUDEDIR))
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.c b/nx-X11/programs/Xserver/miext/damage/damage.c
new file mode 100755
index 000000000..286728cd1
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/damage/damage.c
@@ -0,0 +1,1966 @@
+/*
+ * $Id: damage.c,v 1.19 2005/10/06 21:55:41 anholt Exp $
+ *
+ * Copyright © 2003 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "damage.h"
+#include    "damagestr.h"
+#ifdef COMPOSITE
+#include    "cw.h"
+#endif
+
+#define wrap(priv, real, mem, func) {\
+    priv->mem = real->mem; \
+    real->mem = func; \
+}
+
+#define unwrap(priv, real, mem) {\
+    real->mem = priv->mem; \
+}
+
+#define BOX_SAME(a,b) \
+    ((a)->x1 == (b)->x1 && \
+     (a)->y1 == (b)->y1 && \
+     (a)->x2 == (b)->x2 && \
+     (a)->y2 == (b)->y2)
+
+#define DAMAGE_VALIDATE_ENABLE 0
+#define DAMAGE_DEBUG_ENABLE 0
+#if DAMAGE_DEBUG_ENABLE
+#define DAMAGE_DEBUG(x)	ErrorF x
+#else
+#define DAMAGE_DEBUG(x)
+#endif
+
+#define getPixmapDamageRef(pPixmap) \
+    ((DamagePtr *) &(pPixmap->devPrivates[damagePixPrivateIndex].ptr))
+
+#define pixmapDamage(pPixmap)		damagePixPriv(pPixmap)
+
+static DamagePtr *
+getDrawableDamageRef (DrawablePtr pDrawable)
+{
+    PixmapPtr   pPixmap;
+    
+    if (pDrawable->type == DRAWABLE_WINDOW)
+    {
+	ScreenPtr   pScreen = pDrawable->pScreen;
+
+	pPixmap = 0;
+	if (pScreen->GetWindowPixmap
+#ifdef ROOTLESS_WORKAROUND
+	    && ((WindowPtr)pDrawable)->viewable
+#endif
+	    )
+	    pPixmap = (*pScreen->GetWindowPixmap) ((WindowPtr)pDrawable);
+
+	if (!pPixmap)
+	{
+	    damageScrPriv(pScreen);
+
+	    return &pScrPriv->pScreenDamage;
+	}
+    }
+    else
+	pPixmap = (PixmapPtr) pDrawable;
+    return getPixmapDamageRef (pPixmap);
+}
+
+#define getDrawableDamage(pDrawable)	(*getDrawableDamageRef (pDrawable))
+#define getWindowDamage(pWin)		getDrawableDamage(&(pWin)->drawable)
+
+#define drawableDamage(pDrawable)	\
+    DamagePtr	pDamage = getDrawableDamage(pDrawable)
+
+#define windowDamage(pWin)		drawableDamage(&(pWin)->drawable)
+
+#define winDamageRef(pWindow) \
+    DamagePtr	*pPrev = (DamagePtr *) \
+	    &(pWindow->devPrivates[damageWinPrivateIndex].ptr)
+
+#if DAMAGE_DEBUG_ENABLE
+static void
+_damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip, int subWindowMode, const char *where)
+#define damageDamageRegion(d,r,c,m) _damageDamageRegion(d,r,c,m,__FUNCTION__)
+#else
+static void
+damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
+			int subWindowMode)
+#endif
+{
+    ScreenPtr	    pScreen = pDrawable->pScreen;
+    damageScrPriv(pScreen);
+    drawableDamage(pDrawable);
+    DamagePtr	    pNext;
+    RegionRec	    clippedRec;
+    RegionPtr	    pDamageRegion;
+    RegionRec	    pixClip;
+    Bool	    was_empty;
+    RegionRec	    tmpRegion;
+    BoxRec	    tmpBox;
+    int		    draw_x, draw_y;
+#ifdef COMPOSITE
+    int		    screen_x = 0, screen_y = 0;
+#endif
+
+    /* short circuit for empty regions */
+    if (!REGION_NOTEMPTY(pScreen, pRegion))
+	return;
+    
+#ifdef COMPOSITE
+    /*
+     * When drawing to a pixmap which is storing window contents,
+     * the region presented is in pixmap relative coordinates which
+     * need to be converted to screen relative coordinates
+     */
+    if (pDrawable->type != DRAWABLE_WINDOW)
+    {
+	screen_x = ((PixmapPtr) pDrawable)->screen_x - pDrawable->x;
+	screen_y = ((PixmapPtr) pDrawable)->screen_y - pDrawable->y;
+    }
+    if (screen_x || screen_y)
+        REGION_TRANSLATE (pScreen, pRegion, screen_x, screen_y);
+#endif
+	
+    if (pDrawable->type == DRAWABLE_WINDOW &&
+	((WindowPtr)(pDrawable))->backingStore == NotUseful)
+    {
+	if (subWindowMode == ClipByChildren)
+	{
+	    REGION_INTERSECT(pScreen, pRegion, pRegion,
+			     &((WindowPtr)(pDrawable))->clipList);
+	}
+	else if (subWindowMode == IncludeInferiors)
+	{
+	    RegionPtr pTempRegion =
+		NotClippedByChildren((WindowPtr)(pDrawable));
+	    REGION_INTERSECT(pScreen, pRegion, pRegion, pTempRegion);
+	    REGION_DESTROY(pScreen, pTempRegion);
+	}
+	/* If subWindowMode is set to an invalid value, don't perform
+	 * any drawable-based clipping. */
+    }
+        
+
+    REGION_NULL (pScreen, &clippedRec);
+    for (; pDamage; pDamage = pNext)
+    {
+	pNext = pDamage->pNext;
+	/*
+	 * Check for internal damage and don't send events
+	 */
+	if (pScrPriv->internalLevel > 0 && !pDamage->isInternal)
+	{
+	    DAMAGE_DEBUG (("non internal damage, skipping at %d\n",
+			   pScrPriv->internalLevel));
+	    continue;
+	}
+	/*
+	 * Check for unrealized windows
+	 */
+	if (pDamage->pDrawable->type == DRAWABLE_WINDOW &&
+	    !((WindowPtr) (pDamage->pDrawable))->realized)
+	{
+#if 0
+	    DAMAGE_DEBUG (("damage while window unrealized\n"));
+#endif
+	    continue;
+	}
+	
+	draw_x = pDamage->pDrawable->x;
+	draw_y = pDamage->pDrawable->y;
+#ifdef COMPOSITE
+	/*
+	 * Need to move everyone to screen coordinates
+	 * XXX what about off-screen pixmaps with non-zero x/y?
+	 */
+	if (pDamage->pDrawable->type != DRAWABLE_WINDOW)
+	{
+	    draw_x += ((PixmapPtr) pDamage->pDrawable)->screen_x;
+	    draw_y += ((PixmapPtr) pDamage->pDrawable)->screen_y;
+	}
+#endif
+	
+	/*
+	 * Clip against border or pixmap bounds
+	 */
+	
+	pDamageRegion = pRegion;
+	if (clip || pDamage->pDrawable != pDrawable)
+	{
+	    pDamageRegion = &clippedRec;
+	    if (pDamage->pDrawable->type == DRAWABLE_WINDOW) {
+		REGION_INTERSECT (pScreen, pDamageRegion, pRegion,
+		    &((WindowPtr)(pDamage->pDrawable))->borderClip);
+	    } else {
+		BoxRec	box;
+		box.x1 = draw_x;
+		box.y1 = draw_y;
+		box.x2 = draw_x + pDamage->pDrawable->width;
+		box.y2 = draw_y + pDamage->pDrawable->height;
+		REGION_INIT(pScreen, &pixClip, &box, 1);
+		REGION_INTERSECT (pScreen, pDamageRegion, pRegion, &pixClip);
+		REGION_UNINIT(pScreen, &pixClip);
+	    }
+	    /*
+	     * Short circuit empty results
+	     */
+	    if (!REGION_NOTEMPTY(pScreen, pDamageRegion))
+		continue;
+	}
+	
+	DAMAGE_DEBUG (("%s %d x %d +%d +%d (target 0x%lx monitor 0x%lx)\n",
+		       where,
+		       pDamageRegion->extents.x2 - pDamageRegion->extents.x1,
+		       pDamageRegion->extents.y2 - pDamageRegion->extents.y1,
+		       pDamageRegion->extents.x1, pDamageRegion->extents.y1,
+		       pDrawable->id, pDamage->pDrawable->id));
+	
+	/*
+	 * Move region to target coordinate space
+	 */
+	if (draw_x || draw_y)
+	    REGION_TRANSLATE (pScreen, pDamageRegion, -draw_x, -draw_y);
+	
+	switch (pDamage->damageLevel) {
+	case DamageReportRawRegion:
+	    (*pDamage->damageReport) (pDamage, pDamageRegion, pDamage->closure);
+	    break;
+	case DamageReportDeltaRegion:
+	    REGION_NULL (pScreen, &tmpRegion);
+	    REGION_SUBTRACT (pScreen, &tmpRegion, pDamageRegion, &pDamage->damage);
+	    if (REGION_NOTEMPTY (pScreen, &tmpRegion))
+	    {
+		REGION_UNION(pScreen, &pDamage->damage,
+			     &pDamage->damage, pDamageRegion);
+		(*pDamage->damageReport) (pDamage, &tmpRegion, pDamage->closure);
+	    }
+	    REGION_UNINIT(pScreen, &tmpRegion);
+	    break;
+	case DamageReportBoundingBox:
+	    tmpBox = *REGION_EXTENTS (pScreen, &pDamage->damage);
+	    REGION_UNION(pScreen, &pDamage->damage,
+			 &pDamage->damage, pDamageRegion);
+	    if (!BOX_SAME (&tmpBox, REGION_EXTENTS (pScreen, &pDamage->damage)))
+		(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
+	    break;
+	case DamageReportNonEmpty:
+	    was_empty = !REGION_NOTEMPTY(pScreen, &pDamage->damage);
+	    REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+			 pDamageRegion);
+	    if (was_empty && REGION_NOTEMPTY(pScreen, &pDamage->damage))
+		(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
+	    break;
+	case DamageReportNone:
+	    REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+			 pDamageRegion);
+	    break;
+	}
+	/*
+	 * translate original region back
+	 */
+	if (pDamageRegion == pRegion && (draw_x || draw_y))
+	    REGION_TRANSLATE (pScreen, pDamageRegion, draw_x, draw_y);
+    }
+#ifdef COMPOSITE
+    if (screen_x || screen_y)
+	REGION_TRANSLATE (pScreen, pRegion, -screen_x, -screen_y);
+#endif
+    
+    REGION_UNINIT (pScreen, &clippedRec);
+}
+
+#if DAMAGE_DEBUG_ENABLE
+#define damageDamageBox(d,b,m) _damageDamageBox(d,b,m,__FUNCTION__)
+static void
+_damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode, const char *where)
+#else
+static void
+damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode)
+#endif
+{
+    RegionRec	region;
+
+    REGION_INIT (pDrawable->pScreen, &region, pBox, 1);
+#if DAMAGE_DEBUG_ENABLE
+    _damageDamageRegion (pDrawable, &region, TRUE, subWindowMode, where);
+#else
+    damageDamageRegion (pDrawable, &region, TRUE, subWindowMode);
+#endif
+    REGION_UNINIT (pDrawable->pScreen, &region);
+}
+
+static void damageValidateGC(GCPtr, unsigned long, DrawablePtr);
+static void damageChangeGC(GCPtr, unsigned long);
+static void damageCopyGC(GCPtr, unsigned long, GCPtr);
+static void damageDestroyGC(GCPtr);
+static void damageChangeClip(GCPtr, int, pointer, int);
+static void damageDestroyClip(GCPtr);
+static void damageCopyClip(GCPtr, GCPtr);
+
+GCFuncs damageGCFuncs = {
+    damageValidateGC, damageChangeGC, damageCopyGC, damageDestroyGC,
+    damageChangeClip, damageDestroyClip, damageCopyClip
+};
+
+extern GCOps damageGCOps;
+
+static Bool
+damageCreateGC(GCPtr pGC)
+{
+    ScreenPtr pScreen = pGC->pScreen;
+    damageScrPriv(pScreen);
+    damageGCPriv(pGC);
+    Bool ret;
+
+    pGC->pCompositeClip = 0;
+    unwrap (pScrPriv, pScreen, CreateGC);
+    if((ret = (*pScreen->CreateGC) (pGC))) {
+	pGCPriv->ops = NULL;
+	pGCPriv->funcs = pGC->funcs;
+	pGC->funcs = &damageGCFuncs;
+    }
+    wrap (pScrPriv, pScreen, CreateGC, damageCreateGC);
+
+    return ret;
+}
+
+#ifdef NOTUSED
+static void
+damageWrapGC (GCPtr pGC)
+{
+    damageGCPriv(pGC);
+
+    pGCPriv->ops = NULL;
+    pGCPriv->funcs = pGC->funcs;
+    pGC->funcs = &damageGCFuncs;
+}
+
+static void
+damageUnwrapGC (GCPtr pGC)
+{
+    damageGCPriv(pGC);
+
+    pGC->funcs = pGCPriv->funcs;
+    if (pGCPriv->ops)
+	pGC->ops = pGCPriv->ops;
+}
+#endif
+
+#define DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable) \
+    damageGCPriv(pGC);  \
+    GCFuncs *oldFuncs = pGC->funcs; \
+    unwrap(pGCPriv, pGC, funcs);  \
+    unwrap(pGCPriv, pGC, ops); \
+
+#define DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable) \
+    wrap(pGCPriv, pGC, funcs, oldFuncs); \
+    wrap(pGCPriv, pGC, ops, &damageGCOps)
+
+#define DAMAGE_GC_FUNC_PROLOGUE(pGC) \
+    damageGCPriv(pGC); \
+    unwrap(pGCPriv, pGC, funcs); \
+    if (pGCPriv->ops) unwrap(pGCPriv, pGC, ops)
+
+#define DAMAGE_GC_FUNC_EPILOGUE(pGC) \
+    wrap(pGCPriv, pGC, funcs, &damageGCFuncs);  \
+    if (pGCPriv->ops) wrap(pGCPriv, pGC, ops, &damageGCOps)
+
+static void
+damageValidateGC(GCPtr         pGC,
+		 unsigned long changes,
+		 DrawablePtr   pDrawable)
+{
+    DAMAGE_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ValidateGC)(pGC, changes, pDrawable);
+    pGCPriv->ops = pGC->ops;  /* just so it's not NULL */
+    DAMAGE_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+damageDestroyGC(GCPtr pGC)
+{
+    DAMAGE_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->DestroyGC)(pGC);
+    DAMAGE_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+damageChangeGC (GCPtr		pGC,
+		unsigned long   mask)
+{
+    DAMAGE_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ChangeGC) (pGC, mask);
+    DAMAGE_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+damageCopyGC (GCPtr	    pGCSrc,
+	      unsigned long mask,
+	      GCPtr	    pGCDst)
+{
+    DAMAGE_GC_FUNC_PROLOGUE (pGCDst);
+    (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
+    DAMAGE_GC_FUNC_EPILOGUE (pGCDst);
+}
+
+static void
+damageChangeClip (GCPtr	    pGC,
+		  int	    type,
+		  pointer   pvalue,
+		  int	    nrects)
+{
+    DAMAGE_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
+    DAMAGE_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+damageCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
+{
+    DAMAGE_GC_FUNC_PROLOGUE (pgcDst);
+    (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
+    DAMAGE_GC_FUNC_EPILOGUE (pgcDst);
+}
+
+static void
+damageDestroyClip(GCPtr pGC)
+{
+    DAMAGE_GC_FUNC_PROLOGUE (pGC);
+    (* pGC->funcs->DestroyClip)(pGC);
+    DAMAGE_GC_FUNC_EPILOGUE (pGC);
+}
+
+#define TRIM_BOX(box, pGC) if (pGC->pCompositeClip) { \
+    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, pDrawable) { \
+    box.x1 += pDrawable->x; \
+    box.x2 += pDrawable->x; \
+    box.y1 += pDrawable->y; \
+    box.y2 += pDrawable->y; \
+    }
+
+#define TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC) { \
+    TRANSLATE_BOX(box, pDrawable); \
+    TRIM_BOX(box, pGC); \
+    }
+
+#define BOX_NOT_EMPTY(box) \
+    (((box.x2 - box.x1) > 0) && ((box.y2 - box.y1) > 0))
+
+#define checkGCDamage(d,g)	(getDrawableDamage(d) && \
+				 (!g->pCompositeClip ||\
+				  REGION_NOTEMPTY(d->pScreen, \
+						  g->pCompositeClip)))
+
+#ifdef RENDER
+
+#define TRIM_PICTURE_BOX(box, pDst) { \
+    BoxPtr extents = &pDst->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 checkPictureDamage(p)	(getDrawableDamage(p->pDrawable) && \
+				 REGION_NOTEMPTY(pScreen, p->pCompositeClip))
+
+static void
+damageComposite (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);
+    damageScrPriv(pScreen);
+
+    if (checkPictureDamage (pDst))
+    {
+	BoxRec	box;
+
+	box.x1 = xDst + pDst->pDrawable->x;
+	box.y1 = yDst + pDst->pDrawable->y;
+	box.x2 = box.x1 + width;
+	box.y2 = box.y1 + height;
+	TRIM_PICTURE_BOX(box, pDst);
+	if (BOX_NOT_EMPTY(box))
+	    damageDamageBox (pDst->pDrawable, &box, pDst->subWindowMode);
+    }
+    unwrap (pScrPriv, ps, Composite);
+    (*ps->Composite) (op,
+		       pSrc,
+		       pMask,
+		       pDst,
+		       xSrc,
+		       ySrc,
+		       xMask,
+		       yMask,
+		       xDst,
+		       yDst,
+		       width,
+		       height);
+    wrap (pScrPriv, ps, Composite, damageComposite);
+}
+
+static void
+damageGlyphs (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);
+    damageScrPriv(pScreen);
+
+    if (checkPictureDamage (pDst))
+    {
+	int		nlistTmp = nlist;
+	GlyphListPtr	listTmp = list;
+	GlyphPtr	*glyphsTmp = glyphs;
+	int		x, y;
+	int		n;
+	GlyphPtr	glyph;
+	BoxRec		box;
+	int		x1, y1, x2, y2;
+
+	box.x1 = 32767;
+	box.y1 = 32767;
+	box.x2 = -32767;
+	box.y2 = -32767;
+	x = pDst->pDrawable->x;
+	y = pDst->pDrawable->y;
+	while (nlistTmp--)
+	{
+	    x += listTmp->xOff;
+	    y += listTmp->yOff;
+	    n = listTmp->len;
+	    while (n--)
+	    {
+		glyph = *glyphsTmp++;
+		x1 = x - glyph->info.x;
+		y1 = y - glyph->info.y;
+		x2 = x1 + glyph->info.width;
+		y2 = y1 + glyph->info.height;
+		if (x1 < box.x1)
+		    box.x1 = x1;
+		if (y1 < box.y1)
+		    box.y1 = y1;
+		if (x2 > box.x2)
+		    box.x2 = x2;
+		if (y2 > box.y2)
+		    box.y2 = y2;
+		x += glyph->info.xOff;
+		y += glyph->info.yOff;
+	    }
+	    listTmp++;
+	}
+	TRIM_PICTURE_BOX (box, pDst);
+	if (BOX_NOT_EMPTY(box))
+	    damageDamageBox (pDst->pDrawable, &box, pDst->subWindowMode);
+    }
+    unwrap (pScrPriv, ps, Glyphs);
+    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
+    wrap (pScrPriv, ps, Glyphs, damageGlyphs);
+}
+#endif
+
+/**********************************************************/
+
+
+static void
+damageFillSpans(DrawablePtr pDrawable,
+		GC	    *pGC,
+		int	    npt,
+		DDXPointPtr ppt,
+		int	    *pwidth,
+		int	    fSorted)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (npt && checkGCDamage (pDrawable, pGC))
+    {
+	int	    nptTmp = npt;
+	DDXPointPtr pptTmp = ppt;
+	int	    *pwidthTmp = pwidth;
+	BoxRec	    box;
+
+	box.x1 = pptTmp->x;
+	box.x2 = box.x1 + *pwidthTmp;
+	box.y2 = box.y1 = pptTmp->y;
+
+	while(--nptTmp) 
+	{
+	   pptTmp++;
+	   pwidthTmp++;
+	   if(box.x1 > pptTmp->x) box.x1 = pptTmp->x;
+	   if(box.x2 < (pptTmp->x + *pwidthTmp))
+		box.x2 = pptTmp->x + *pwidthTmp;
+	   if(box.y1 > pptTmp->y) box.y1 = pptTmp->y;
+	   else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y;
+	}
+
+	box.y2++;
+
+        if(!pGC->miTranslate) {
+           TRANSLATE_BOX(box, pDrawable);
+        }
+        TRIM_BOX(box, pGC); 
+
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    
+    (*pGC->ops->FillSpans)(pDrawable, pGC, npt, ppt, pwidth, fSorted);
+
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damageSetSpans(DrawablePtr  pDrawable,
+	       GCPtr	    pGC,
+	       char	    *pcharsrc,
+	       DDXPointPtr  ppt,
+	       int	    *pwidth,
+	       int	    npt,
+	       int	    fSorted)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (npt && checkGCDamage (pDrawable, pGC))
+    {
+	DDXPointPtr pptTmp = ppt;
+	int	    *pwidthTmp = pwidth;
+	int	    nptTmp = npt;
+	BoxRec	    box;
+
+	box.x1 = pptTmp->x;
+	box.x2 = box.x1 + *pwidthTmp;
+	box.y2 = box.y1 = pptTmp->y;
+
+	while(--nptTmp) 
+	{
+	   pptTmp++;
+	   pwidthTmp++;
+	   if(box.x1 > pptTmp->x) box.x1 = pptTmp->x;
+	   if(box.x2 < (pptTmp->x + *pwidthTmp))
+		box.x2 = pptTmp->x + *pwidthTmp;
+	   if(box.y1 > pptTmp->y) box.y1 = pptTmp->y;
+	   else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y;
+	}
+
+	box.y2++;
+
+        if(!pGC->miTranslate) {
+           TRANSLATE_BOX(box, pDrawable);
+        }
+        TRIM_BOX(box, pGC); 
+
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->SetSpans)(pDrawable, pGC, pcharsrc, ppt, pwidth, npt, fSorted);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damagePutImage(DrawablePtr  pDrawable,
+	       GCPtr	    pGC,
+	       int	    depth,
+	       int	    x,
+	       int	    y,
+	       int	    w,
+	       int	    h,
+	       int	    leftPad,
+	       int	    format,
+	       char	    *pImage)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+    if (checkGCDamage (pDrawable, pGC))
+    {
+	BoxRec box;
+
+	box.x1 = x + pDrawable->x;
+	box.x2 = box.x1 + w;
+	box.y1 = y + pDrawable->y;
+	box.y2 = box.y1 + h;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->PutImage)(pDrawable, pGC, depth, x, y, w, h,
+		leftPad, format, pImage);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static RegionPtr
+damageCopyArea(DrawablePtr   pSrc,
+	       DrawablePtr  pDst,
+	       GC	    *pGC,
+	       int	    srcx,
+	       int	    srcy,
+	       int	    width,
+	       int	    height,
+	       int	    dstx,
+	       int	    dsty)
+{
+    RegionPtr ret;
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDst);
+    
+    /* The driver will only call SourceValidate() when pSrc != pDst,
+     * but the software sprite (misprite.c) always need to know when a
+     * drawable is copied so it can remove the sprite. See #1030. */
+    if ((pSrc == pDst) && pSrc->pScreen->SourceValidate &&
+	pSrc->type == DRAWABLE_WINDOW &&
+	((WindowPtr)pSrc)->viewable)
+    {
+	(*pSrc->pScreen->SourceValidate) (pSrc, srcx, srcy, width, height);
+    }
+    
+    if (checkGCDamage (pDst, pGC))
+    {
+	BoxRec box;
+
+	box.x1 = dstx + pDst->x;
+	box.x2 = box.x1 + width;
+	box.y1 = dsty + pDst->y;
+	box.y2 = box.y1 + height;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDst, &box, pGC->subWindowMode);
+    }
+
+    ret = (*pGC->ops->CopyArea)(pSrc, pDst,
+            pGC, srcx, srcy, width, height, dstx, dsty);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDst);
+    return ret;
+}
+
+static RegionPtr
+damageCopyPlane(DrawablePtr	pSrc,
+		DrawablePtr	pDst,
+		GCPtr		pGC,
+		int		srcx,
+		int		srcy,
+		int		width,
+		int		height,
+		int		dstx,
+		int		dsty,
+		unsigned long	bitPlane)
+{
+    RegionPtr ret;
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDst);
+
+    /* The driver will only call SourceValidate() when pSrc != pDst,
+     * but the software sprite (misprite.c) always need to know when a
+     * drawable is copied so it can remove the sprite. See #1030. */
+    if ((pSrc == pDst) && pSrc->pScreen->SourceValidate &&
+	pSrc->type == DRAWABLE_WINDOW &&
+	((WindowPtr)pSrc)->viewable)
+    {
+        (*pSrc->pScreen->SourceValidate) (pSrc, srcx, srcy, width, height);
+    }
+
+    if (checkGCDamage (pDst, pGC))
+    {
+	BoxRec box;
+
+	box.x1 = dstx + pDst->x;
+	box.x2 = box.x1 + width;
+	box.y1 = dsty + pDst->y;
+	box.y2 = box.y1 + height;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDst, &box, pGC->subWindowMode);
+    }
+
+    ret = (*pGC->ops->CopyPlane)(pSrc, pDst,
+	       pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDst);
+    return ret;
+}
+
+static void
+damagePolyPoint(DrawablePtr pDrawable,
+		GCPtr	    pGC,
+		int	    mode,
+		int	    npt,
+		xPoint	    *ppt)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (npt && checkGCDamage (pDrawable, pGC))
+    {
+	BoxRec	box;
+	int	nptTmp = npt;
+	xPoint	*pptTmp = ppt;
+
+	box.x2 = box.x1 = pptTmp->x;
+	box.y2 = box.y1 = pptTmp->y;
+
+	/* this could be slow if the points were spread out */
+
+	while(--nptTmp) 
+	{
+	   pptTmp++;
+	   if(box.x1 > pptTmp->x) box.x1 = pptTmp->x;
+	   else if(box.x2 < pptTmp->x) box.x2 = pptTmp->x;
+	   if(box.y1 > pptTmp->y) box.y1 = pptTmp->y;
+	   else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y;
+	}
+
+	box.x2++;
+	box.y2++;
+
+	TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->PolyPoint)(pDrawable, pGC, mode, npt, ppt);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damagePolylines(DrawablePtr pDrawable,
+		GCPtr	    pGC,
+		int	    mode,
+		int	    npt,
+		DDXPointPtr ppt)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (npt && checkGCDamage (pDrawable, pGC))
+    {
+	int	    nptTmp = npt;
+	DDXPointPtr pptTmp = ppt;
+	BoxRec	    box;
+	int	    extra = pGC->lineWidth >> 1;
+
+	box.x2 = box.x1 = pptTmp->x;
+	box.y2 = box.y1 = pptTmp->y;
+
+	if(nptTmp > 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(--nptTmp) 
+	   {
+		pptTmp++;
+		x += pptTmp->x;
+		y += pptTmp->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(--nptTmp) 
+	   {
+		pptTmp++;
+		if(box.x1 > pptTmp->x) box.x1 = pptTmp->x;
+		else if(box.x2 < pptTmp->x) box.x2 = pptTmp->x;
+		if(box.y1 > pptTmp->y) box.y1 = pptTmp->y;
+		else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y;
+	    }
+	}
+
+	box.x2++;
+	box.y2++;
+
+	if(extra) 
+	{
+	   box.x1 -= extra;
+	   box.x2 += extra;
+	   box.y1 -= extra;
+	   box.y2 += extra;
+        }
+
+	TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->Polylines)(pDrawable, pGC, mode, npt, ppt);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damagePolySegment(DrawablePtr	pDrawable,
+		  GCPtr		pGC,
+		  int		nSeg,
+		  xSegment	*pSeg)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (nSeg && checkGCDamage (pDrawable, pGC))
+    {
+	BoxRec	    box;
+	int	    extra = pGC->lineWidth;
+	int	    nsegTmp = nSeg;
+	xSegment    *pSegTmp = pSeg;
+
+        if(pGC->capStyle != CapProjecting)
+	   extra >>= 1;
+
+	if(pSegTmp->x2 > pSegTmp->x1) {
+	    box.x1 = pSegTmp->x1;
+	    box.x2 = pSegTmp->x2;
+	} else {
+	    box.x2 = pSegTmp->x1;
+	    box.x1 = pSegTmp->x2;
+	}
+
+	if(pSegTmp->y2 > pSegTmp->y1) {
+	    box.y1 = pSegTmp->y1;
+	    box.y2 = pSegTmp->y2;
+	} else {
+	    box.y2 = pSegTmp->y1;
+	    box.y1 = pSegTmp->y2;
+	}
+
+	while(--nsegTmp) 
+	{
+	    pSegTmp++;
+	    if(pSegTmp->x2 > pSegTmp->x1) 
+	    {
+		if(pSegTmp->x1 < box.x1) box.x1 = pSegTmp->x1;
+		if(pSegTmp->x2 > box.x2) box.x2 = pSegTmp->x2;
+	    }
+	    else 
+	    {
+		if(pSegTmp->x2 < box.x1) box.x1 = pSegTmp->x2;
+		if(pSegTmp->x1 > box.x2) box.x2 = pSegTmp->x1;
+	    }
+	    if(pSegTmp->y2 > pSegTmp->y1) 
+	    {
+		if(pSegTmp->y1 < box.y1) box.y1 = pSegTmp->y1;
+		if(pSegTmp->y2 > box.y2) box.y2 = pSegTmp->y2;
+	    }
+	    else
+	    {
+		if(pSegTmp->y2 < box.y1) box.y1 = pSegTmp->y2;
+		if(pSegTmp->y1 > box.y2) box.y2 = pSegTmp->y1;
+	    }
+	}
+
+	box.x2++;
+	box.y2++;
+
+	if(extra) 
+	{
+	   box.x1 -= extra;
+	   box.x2 += extra;
+	   box.y1 -= extra;
+	   box.y2 += extra;
+        }
+
+	TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->PolySegment)(pDrawable, pGC, nSeg, pSeg);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damagePolyRectangle(DrawablePtr  pDrawable,
+		    GCPtr        pGC,
+		    int	         nRects,
+		    xRectangle  *pRects)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (nRects && checkGCDamage (pDrawable, pGC))
+    {
+	BoxRec	    box;
+	int	    offset1, offset2, offset3;
+	int	    nRectsTmp = nRects;
+	xRectangle  *pRectsTmp = pRects;
+
+	offset2 = pGC->lineWidth;
+	if(!offset2) offset2 = 1;
+	offset1 = offset2 >> 1;
+	offset3 = offset2 - offset1;
+
+	while(nRectsTmp--)
+	{
+	    box.x1 = pRectsTmp->x - offset1;
+	    box.y1 = pRectsTmp->y - offset1;
+	    box.x2 = box.x1 + pRectsTmp->width + offset2;
+	    box.y2 = box.y1 + offset2;
+	    TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+
+	    box.x1 = pRectsTmp->x - offset1;
+	    box.y1 = pRectsTmp->y + offset3;
+	    box.x2 = box.x1 + offset2;
+	    box.y2 = box.y1 + pRectsTmp->height - offset2;
+	    TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+
+	    box.x1 = pRectsTmp->x + pRectsTmp->width - offset1;
+	    box.y1 = pRectsTmp->y + offset3;
+	    box.x2 = box.x1 + offset2;
+	    box.y2 = box.y1 + pRectsTmp->height - offset2;
+	    TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+
+	    box.x1 = pRectsTmp->x - offset1;
+	    box.y1 = pRectsTmp->y + pRectsTmp->height - offset1;
+	    box.x2 = box.x1 + pRectsTmp->width + offset2;
+	    box.y2 = box.y1 + offset2;
+	    TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+
+	    pRectsTmp++;
+	}
+    }
+    (*pGC->ops->PolyRectangle)(pDrawable, pGC, nRects, pRects);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damagePolyArc(DrawablePtr   pDrawable,
+	      GCPtr	    pGC,
+	      int	    nArcs,
+	      xArc	    *pArcs)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (nArcs && checkGCDamage (pDrawable, pGC))
+    {
+	int	extra = pGC->lineWidth >> 1;
+	BoxRec	box;
+	int	nArcsTmp = nArcs;
+	xArc	*pArcsTmp = pArcs;
+
+	box.x1 = pArcsTmp->x;
+	box.x2 = box.x1 + pArcsTmp->width;
+	box.y1 = pArcsTmp->y;
+	box.y2 = box.y1 + pArcsTmp->height;
+
+	while(--nArcsTmp) 
+	{
+	    pArcsTmp++;
+	    if(box.x1 > pArcsTmp->x)
+		box.x1 = pArcsTmp->x;
+	    if(box.x2 < (pArcsTmp->x + pArcsTmp->width))
+		box.x2 = pArcsTmp->x + pArcsTmp->width;
+	    if(box.y1 > pArcsTmp->y) 
+		box.y1 = pArcsTmp->y;
+	    if(box.y2 < (pArcsTmp->y + pArcsTmp->height))
+		box.y2 = pArcsTmp->y + pArcsTmp->height;
+        }
+
+	if(extra) 
+	{
+	   box.x1 -= extra;
+	   box.x2 += extra;
+	   box.y1 -= extra;
+	   box.y2 += extra;
+        }
+
+	box.x2++;
+	box.y2++;
+
+	TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->PolyArc)(pDrawable, pGC, nArcs, pArcs);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damageFillPolygon(DrawablePtr	pDrawable,
+		  GCPtr		pGC,
+		  int		shape,
+		  int		mode,
+		  int		npt,
+		  DDXPointPtr	ppt)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (npt > 2 && checkGCDamage (pDrawable, pGC))
+    {
+	DDXPointPtr pptTmp = ppt;
+	int	    nptTmp = npt;
+	BoxRec	    box;
+
+	box.x2 = box.x1 = pptTmp->x;
+	box.y2 = box.y1 = pptTmp->y;
+
+	if(mode != CoordModeOrigin) 
+	{
+	   int x = box.x1;
+	   int y = box.y1;
+	   while(--nptTmp) 
+	   {
+		pptTmp++;
+		x += pptTmp->x;
+		y += pptTmp->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(--nptTmp) 
+	   {
+		pptTmp++;
+		if(box.x1 > pptTmp->x) box.x1 = pptTmp->x;
+		else if(box.x2 < pptTmp->x) box.x2 = pptTmp->x;
+		if(box.y1 > pptTmp->y) box.y1 = pptTmp->y;
+		else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y;
+	    }
+	}
+
+	box.x2++;
+	box.y2++;
+
+	TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    
+    (*pGC->ops->FillPolygon)(pDrawable, pGC, shape, mode, npt, ppt);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+
+static void
+damagePolyFillRect(DrawablePtr	pDrawable,
+		   GCPtr	pGC,
+		   int		nRects,
+		   xRectangle	*pRects)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+    if (nRects && checkGCDamage (pDrawable, pGC))
+    {
+	BoxRec	    box;
+	xRectangle  *pRectsTmp = pRects;
+	int	    nRectsTmp = nRects;
+
+	box.x1 = pRectsTmp->x;
+	box.x2 = box.x1 + pRectsTmp->width;
+	box.y1 = pRectsTmp->y;
+	box.y2 = box.y1 + pRectsTmp->height;
+
+	while(--nRectsTmp) 
+	{
+	    pRectsTmp++;
+	    if(box.x1 > pRectsTmp->x) box.x1 = pRectsTmp->x;
+	    if(box.x2 < (pRectsTmp->x + pRectsTmp->width))
+		box.x2 = pRectsTmp->x + pRectsTmp->width;
+	    if(box.y1 > pRectsTmp->y) box.y1 = pRectsTmp->y;
+	    if(box.y2 < (pRectsTmp->y + pRectsTmp->height))
+		box.y2 = pRectsTmp->y + pRectsTmp->height;
+	}
+
+	TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	if(BOX_NOT_EMPTY(box))
+	    damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->PolyFillRect)(pDrawable, pGC, nRects, pRects);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+
+static void
+damagePolyFillArc(DrawablePtr	pDrawable,
+		  GCPtr		pGC,
+		  int		nArcs,
+		  xArc		*pArcs)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (nArcs && checkGCDamage (pDrawable, pGC))
+    {
+	BoxRec	box;
+	int	nArcsTmp = nArcs;
+	xArc	*pArcsTmp = pArcs;
+
+	box.x1 = pArcsTmp->x;
+	box.x2 = box.x1 + pArcsTmp->width;
+	box.y1 = pArcsTmp->y;
+	box.y2 = box.y1 + pArcsTmp->height;
+
+	while(--nArcsTmp) 
+	{
+	    pArcsTmp++;
+	    if(box.x1 > pArcsTmp->x)
+		box.x1 = pArcsTmp->x;
+	    if(box.x2 < (pArcsTmp->x + pArcsTmp->width))
+		box.x2 = pArcsTmp->x + pArcsTmp->width;
+	    if(box.y1 > pArcsTmp->y)
+		box.y1 = pArcsTmp->y;
+	    if(box.y2 < (pArcsTmp->y + pArcsTmp->height))
+		box.y2 = pArcsTmp->y + pArcsTmp->height;
+        }
+
+	TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->PolyFillArc)(pDrawable, pGC, nArcs, pArcs);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+/*
+ * general Poly/Image text function.  Extract glyph information,
+ * compute bounding box and remove cursor if it is overlapped.
+ */
+
+static void
+damageDamageChars (DrawablePtr	pDrawable,
+		   FontPtr	font,
+		   int		x,
+		   int		y,
+		   unsigned int	n,
+		   CharInfoPtr	*charinfo,
+		   Bool		imageblt,
+		   int		subWindowMode)
+{
+    ExtentInfoRec   extents;
+    BoxRec	    box;
+
+    QueryGlyphExtents(font, charinfo, n, &extents);
+    if (imageblt)
+    {
+	if (extents.overallWidth > extents.overallRight)
+	    extents.overallRight = extents.overallWidth;
+	if (extents.overallWidth < extents.overallLeft)
+	    extents.overallLeft = extents.overallWidth;
+	if (extents.overallLeft > 0)
+	    extents.overallLeft = 0;
+	if (extents.fontAscent > extents.overallAscent)
+	    extents.overallAscent = extents.fontAscent;
+	if (extents.fontDescent > extents.overallDescent)
+	    extents.overallDescent = extents.fontDescent;
+    }
+    box.x1 = x + extents.overallLeft;
+    box.y1 = y - extents.overallAscent;
+    box.x2 = x + extents.overallRight;
+    box.y2 = y + extents.overallDescent;
+    damageDamageBox (pDrawable, &box, subWindowMode);
+}
+
+/*
+ * values for textType:
+ */
+#define TT_POLY8   0
+#define TT_IMAGE8  1
+#define TT_POLY16  2
+#define TT_IMAGE16 3
+
+static int 
+damageText (DrawablePtr	    pDrawable,
+	    GCPtr	    pGC,
+	    int		    x,
+	    int		    y,
+	    unsigned long   count,
+	    char	    *chars,
+	    FontEncoding    fontEncoding,
+	    Bool	    textType)
+{
+    CharInfoPtr	    *charinfo;
+    CharInfoPtr	    *info;
+    unsigned long   i;
+    unsigned int    n;
+    int		    w;
+    Bool	    imageblt;
+
+    imageblt = (textType == TT_IMAGE8) || (textType == TT_IMAGE16);
+
+    charinfo = (CharInfoPtr *) ALLOCATE_LOCAL(count * sizeof(CharInfoPtr));
+    if (!charinfo)
+	return x;
+
+    GetGlyphs(pGC->font, count, (unsigned char *)chars,
+	      fontEncoding, &i, charinfo);
+    n = (unsigned int)i;
+    w = 0;
+    if (!imageblt)
+	for (info = charinfo; i--; info++)
+	    w += (*info)->metrics.characterWidth;
+
+    if (n != 0) {
+	damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y, n,
+			   charinfo, imageblt, pGC->subWindowMode);
+	if (imageblt)
+	    (*pGC->ops->ImageGlyphBlt)(pDrawable, pGC, x, y, n, charinfo,
+				       FONTGLYPHS(pGC->font));
+	else
+	    (*pGC->ops->PolyGlyphBlt)(pDrawable, pGC, x, y, n, charinfo,
+				      FONTGLYPHS(pGC->font));
+    }
+    DEALLOCATE_LOCAL(charinfo);
+    return x + w;
+}
+
+static int
+damagePolyText8(DrawablePtr pDrawable,
+		GCPtr	    pGC,
+		int	    x,
+		int	    y,
+		int	    count,
+		char	    *chars)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (checkGCDamage (pDrawable, pGC))
+	x = damageText (pDrawable, pGC, x, y, (unsigned long) count, chars,
+		    Linear8Bit, TT_POLY8);
+    else
+	x = (*pGC->ops->PolyText8)(pDrawable, pGC, x, y, count, chars);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+    return x;
+}
+
+static int
+damagePolyText16(DrawablePtr	pDrawable,
+		 GCPtr		pGC,
+		 int		x,
+		 int		y,
+		 int		count,
+		 unsigned short	*chars)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (checkGCDamage (pDrawable, pGC))
+	x = damageText (pDrawable, pGC, x, y, (unsigned long) count, (char *) chars,
+		    FONTLASTROW(pGC->font) == 0 ? Linear16Bit : TwoD16Bit,
+		    TT_POLY16);
+    else
+	x = (*pGC->ops->PolyText16)(pDrawable, pGC, x, y, count, chars);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+    return x;
+}
+
+static void
+damageImageText8(DrawablePtr	pDrawable,
+		 GCPtr		pGC,
+		 int		x,
+		 int		y,
+		 int		count,
+		 char		*chars)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (checkGCDamage (pDrawable, pGC))
+	damageText (pDrawable, pGC, x, y, (unsigned long) count, chars,
+		    Linear8Bit, TT_IMAGE8);
+    else
+	(*pGC->ops->ImageText8)(pDrawable, pGC, x, y, count, chars);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damageImageText16(DrawablePtr	pDrawable,
+		  GCPtr		pGC,
+		  int		x,
+		  int		y,
+		  int		count,
+		  unsigned short *chars)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+
+    if (checkGCDamage (pDrawable, pGC))
+	damageText (pDrawable, pGC, x, y, (unsigned long) count, (char *) chars,
+		    FONTLASTROW(pGC->font) == 0 ? Linear16Bit : TwoD16Bit,
+		    TT_IMAGE16);
+    else
+	(*pGC->ops->ImageText16)(pDrawable, pGC, x, y, count, chars);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+
+static void
+damageImageGlyphBlt(DrawablePtr	    pDrawable,
+		    GCPtr	    pGC,
+		    int		    x,
+		    int		    y,
+		    unsigned int    nglyph,
+		    CharInfoPtr	    *ppci,
+		    pointer	    pglyphBase)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+    damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y,
+		       nglyph, ppci, TRUE, pGC->subWindowMode);
+    (*pGC->ops->ImageGlyphBlt)(pDrawable, pGC, x, y, nglyph,
+					ppci, pglyphBase);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damagePolyGlyphBlt(DrawablePtr	pDrawable,
+		   GCPtr	pGC,
+		   int		x,
+		   int		y,
+		   unsigned int	nglyph,
+		   CharInfoPtr	*ppci,
+		   pointer	pglyphBase)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+    damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y,
+		       nglyph, ppci, FALSE, pGC->subWindowMode);
+    (*pGC->ops->PolyGlyphBlt)(pDrawable, pGC, x, y, nglyph,
+				ppci, pglyphBase);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damagePushPixels(GCPtr		pGC,
+		 PixmapPtr	pBitMap,
+		 DrawablePtr	pDrawable,
+		 int		dx,
+		 int		dy,
+		 int		xOrg,
+		 int		yOrg)
+{
+    DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
+    if(checkGCDamage (pDrawable, pGC))
+    {
+	BoxRec box;
+
+        box.x1 = xOrg;
+        box.y1 = yOrg;
+
+        if(!pGC->miTranslate) {
+           box.x1 += pDrawable->x;          
+           box.y1 += pDrawable->y;          
+        }
+
+	box.x2 = box.x1 + dx;
+	box.y2 = box.y1 + dy;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   damageDamageBox (pDrawable, &box, pGC->subWindowMode);
+    }
+    (*pGC->ops->PushPixels)(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg);
+    DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
+}
+
+static void
+damageRemoveDamage (DamagePtr *pPrev, DamagePtr pDamage)
+{
+    while (*pPrev)
+    {
+	if (*pPrev == pDamage)
+	{
+	    *pPrev = pDamage->pNext;
+	    return;
+	}
+	pPrev = &(*pPrev)->pNext;
+    }
+#if DAMAGE_VALIDATE_ENABLE
+    ErrorF ("Damage not on list\n");
+    abort ();
+#endif
+}
+
+static void
+damageInsertDamage (DamagePtr *pPrev, DamagePtr pDamage)
+{
+#if DAMAGE_VALIDATE_ENABLE
+    DamagePtr	pOld;
+
+    for (pOld = *pPrev; pOld; pOld = pOld->pNext)
+	if (pOld == pDamage) {
+	    ErrorF ("Damage already on list\n");
+	    abort ();
+	}
+#endif
+    pDamage->pNext = *pPrev;
+    *pPrev = pDamage;
+}
+
+static Bool
+damageDestroyPixmap (PixmapPtr pPixmap)
+{
+    ScreenPtr	pScreen = pPixmap->drawable.pScreen;
+    damageScrPriv(pScreen);
+
+    if (pPixmap->refcnt == 1)
+    {
+	DamagePtr	*pPrev = getPixmapDamageRef (pPixmap);
+	DamagePtr	pDamage;
+
+	while ((pDamage = *pPrev))
+	{
+	    damageRemoveDamage (pPrev, pDamage);
+	    if (!pDamage->isWindow)
+		DamageDestroy (pDamage);
+	}
+    }
+    unwrap (pScrPriv, pScreen, DestroyPixmap);
+    (*pScreen->DestroyPixmap) (pPixmap);
+    wrap (pScrPriv, pScreen, DestroyPixmap, damageDestroyPixmap);
+    return TRUE;
+}
+
+static void
+damagePaintWindow(WindowPtr pWindow,
+		  RegionPtr prgn,
+		  int	    what)
+{
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    damageScrPriv(pScreen);
+
+    /*
+     * Painting background none doesn't actually *do* anything, so
+     * no damage is recorded
+     */
+    if ((what != PW_BACKGROUND || pWindow->backgroundState != None) &&
+	getWindowDamage (pWindow))
+	damageDamageRegion (&pWindow->drawable, prgn, FALSE, -1);
+    if(what == PW_BACKGROUND) {
+	unwrap (pScrPriv, pScreen, PaintWindowBackground);
+	(*pScreen->PaintWindowBackground) (pWindow, prgn, what);
+	wrap (pScrPriv, pScreen, PaintWindowBackground, damagePaintWindow);
+    } else {
+	unwrap (pScrPriv, pScreen, PaintWindowBorder);
+	(*pScreen->PaintWindowBorder) (pWindow, prgn, what);
+	wrap (pScrPriv, pScreen, PaintWindowBorder, damagePaintWindow);
+    }
+}
+
+
+static void
+damageCopyWindow(WindowPtr	pWindow,
+		 DDXPointRec	ptOldOrg,
+		 RegionPtr	prgnSrc)
+{
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    damageScrPriv(pScreen);
+
+    if (getWindowDamage (pWindow))
+    {
+	int dx = pWindow->drawable.x - ptOldOrg.x;
+	int dy = pWindow->drawable.y - ptOldOrg.y;
+	
+	/*
+	 * The region comes in source relative, but the damage occurs
+	 * at the destination location.  Translate back and forth.
+	 */
+	REGION_TRANSLATE (pScreen, prgnSrc, dx, dy);
+	damageDamageRegion (&pWindow->drawable, prgnSrc, FALSE, -1);
+	REGION_TRANSLATE (pScreen, prgnSrc, -dx, -dy);
+    }
+    unwrap (pScrPriv, pScreen, CopyWindow);
+    (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
+    wrap (pScrPriv, pScreen, CopyWindow, damageCopyWindow);
+}
+
+GCOps damageGCOps = {
+    damageFillSpans, damageSetSpans,
+    damagePutImage, damageCopyArea,
+    damageCopyPlane, damagePolyPoint,
+    damagePolylines, damagePolySegment,
+    damagePolyRectangle, damagePolyArc,
+    damageFillPolygon, damagePolyFillRect,
+    damagePolyFillArc, damagePolyText8,
+    damagePolyText16, damageImageText8,
+    damageImageText16, damageImageGlyphBlt,
+    damagePolyGlyphBlt, damagePushPixels,
+#ifdef NEED_LINEHELPER
+    NULL,
+#endif
+    {NULL}		/* devPrivate */
+};
+
+static void
+damageRestoreAreas (PixmapPtr	pPixmap,
+		    RegionPtr	prgn,
+		    int		xorg,
+		    int		yorg,
+		    WindowPtr	pWindow)
+{
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    damageScrPriv(pScreen);
+
+    damageDamageRegion (&pWindow->drawable, prgn, FALSE, -1);
+    unwrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas);
+    (*pScreen->BackingStoreFuncs.RestoreAreas) (pPixmap, prgn,
+						xorg, yorg, pWindow);
+    wrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas,
+			     damageRestoreAreas);
+}
+
+static void
+damageSetWindowPixmap (WindowPtr pWindow, PixmapPtr pPixmap)
+{
+    DamagePtr	pDamage;
+    ScreenPtr	pScreen = pWindow->drawable.pScreen;
+    damageScrPriv(pScreen);
+
+    if ((pDamage = damageGetWinPriv(pWindow)))
+    {
+	PixmapPtr   pOldPixmap = (*pScreen->GetWindowPixmap) (pWindow);
+	DamagePtr   *pPrev = getPixmapDamageRef(pOldPixmap);
+	
+	while (pDamage)
+	{
+	    damageRemoveDamage (pPrev, pDamage);
+	    pDamage = pDamage->pNextWin;
+	}
+    }
+    unwrap (pScrPriv, pScreen, SetWindowPixmap);
+    (*pScreen->SetWindowPixmap) (pWindow, pPixmap);
+    wrap (pScrPriv, pScreen, SetWindowPixmap, damageSetWindowPixmap);
+    if ((pDamage = damageGetWinPriv(pWindow)))
+    {
+	DamagePtr   *pPrev = getPixmapDamageRef(pPixmap);
+	
+	while (pDamage)
+	{
+	    damageInsertDamage (pPrev, pDamage);
+	    pDamage = pDamage->pNextWin;
+	}
+    }
+}
+
+static Bool
+damageDestroyWindow (WindowPtr pWindow)
+{
+    DamagePtr	pDamage;
+    ScreenPtr	pScreen = pWindow->drawable.pScreen;
+    Bool	ret;
+    damageScrPriv(pScreen);
+
+    while ((pDamage = damageGetWinPriv(pWindow)))
+    {
+	DamageUnregister (&pWindow->drawable, pDamage);
+	DamageDestroy (pDamage);
+    }
+    unwrap (pScrPriv, pScreen, DestroyWindow);
+    ret = (*pScreen->DestroyWindow) (pWindow);
+    wrap (pScrPriv, pScreen, DestroyWindow, damageDestroyWindow);
+    return ret;
+}
+
+static Bool
+damageCloseScreen (int i, ScreenPtr pScreen)
+{
+    damageScrPriv(pScreen);
+
+    unwrap (pScrPriv, pScreen, DestroyPixmap);
+    unwrap (pScrPriv, pScreen, CreateGC);
+    unwrap (pScrPriv, pScreen, PaintWindowBackground);
+    unwrap (pScrPriv, pScreen, PaintWindowBorder);
+    unwrap (pScrPriv, pScreen, CopyWindow);
+    unwrap (pScrPriv, pScreen, CloseScreen);
+    unwrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas);
+    xfree (pScrPriv);
+    return (*pScreen->CloseScreen) (i, pScreen);
+}
+
+int damageScrPrivateIndex;
+int damagePixPrivateIndex;
+int damageGCPrivateIndex;
+int damageWinPrivateIndex;
+int damageGeneration;
+
+Bool
+DamageSetup (ScreenPtr pScreen)
+{
+    DamageScrPrivPtr	pScrPriv;
+#ifdef RENDER
+    PictureScreenPtr	ps = GetPictureScreenIfSet(pScreen);
+#endif
+
+    if (damageGeneration != serverGeneration)
+    {
+	damageScrPrivateIndex = AllocateScreenPrivateIndex ();
+	if (damageScrPrivateIndex == -1)
+	    return FALSE;
+	damageGCPrivateIndex = AllocateGCPrivateIndex ();
+	if (damageGCPrivateIndex == -1)
+	    return FALSE;
+	damagePixPrivateIndex = AllocatePixmapPrivateIndex ();
+	if (damagePixPrivateIndex == -1)
+	    return FALSE;
+	damageWinPrivateIndex = AllocateWindowPrivateIndex ();
+	if (damageWinPrivateIndex == -1)
+	    return FALSE;
+	damageGeneration = serverGeneration;
+    }
+    if (pScreen->devPrivates[damageScrPrivateIndex].ptr)
+	return TRUE;
+
+    if (!AllocateGCPrivate (pScreen, damageGCPrivateIndex, sizeof (DamageGCPrivRec)))
+	return FALSE;
+    if (!AllocatePixmapPrivate (pScreen, damagePixPrivateIndex, 0))
+	return FALSE;
+    if (!AllocateWindowPrivate (pScreen, damageWinPrivateIndex, 0))
+	return FALSE;
+
+    pScrPriv = (DamageScrPrivPtr) xalloc (sizeof (DamageScrPrivRec));
+    if (!pScrPriv)
+	return FALSE;
+
+#ifdef COMPOSITE
+    /* This is a kludge to ensure wrapping order with the composite wrapper.
+     * If it's done from compinit.c, then DamageSetup may be called before the
+     * extension init phase, so that cw will be higher in the wrapping chain and
+     * rewrite drawables before damage gets to it, causing confusion.
+     */
+    if (!noCompositeExtension)
+	miInitializeCompositeWrapper (pScreen);
+#endif
+	
+    pScrPriv->internalLevel = 0;
+    pScrPriv->pScreenDamage = 0;
+
+    wrap (pScrPriv, pScreen, DestroyPixmap, damageDestroyPixmap);
+    wrap (pScrPriv, pScreen, CreateGC, damageCreateGC);
+    wrap (pScrPriv, pScreen, PaintWindowBackground, damagePaintWindow);
+    wrap (pScrPriv, pScreen, PaintWindowBorder, damagePaintWindow);
+    wrap (pScrPriv, pScreen, DestroyWindow, damageDestroyWindow);
+    wrap (pScrPriv, pScreen, SetWindowPixmap, damageSetWindowPixmap);
+    wrap (pScrPriv, pScreen, CopyWindow, damageCopyWindow);
+    wrap (pScrPriv, pScreen, CloseScreen, damageCloseScreen);
+    wrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas,
+			     damageRestoreAreas);
+#ifdef RENDER
+    if (ps) {
+	wrap (pScrPriv, ps, Glyphs, damageGlyphs);
+	wrap (pScrPriv, ps, Composite, damageComposite);
+    }
+#endif
+
+    pScreen->devPrivates[damageScrPrivateIndex].ptr = (pointer) pScrPriv;
+    return TRUE;
+}
+
+DamagePtr
+DamageCreate (DamageReportFunc  damageReport,
+	      DamageDestroyFunc	damageDestroy,
+	      DamageReportLevel	damageLevel,
+	      Bool		isInternal,
+	      ScreenPtr		pScreen,
+	      void		*closure)
+{
+    DamagePtr	pDamage;
+
+    pDamage = xalloc (sizeof (DamageRec));
+    if (!pDamage)
+	return 0;
+    pDamage->pNext = 0;
+    pDamage->pNextWin = 0;
+    REGION_NULL(pScreen, &pDamage->damage);
+    
+    pDamage->damageLevel = damageLevel;
+    pDamage->isInternal = isInternal;
+    pDamage->closure = closure;
+    pDamage->isWindow = FALSE;
+    pDamage->pDrawable = 0;
+
+    pDamage->damageReport = damageReport;
+    pDamage->damageDestroy = damageDestroy;
+    return pDamage;
+}
+
+void
+DamageRegister (DrawablePtr pDrawable,
+		DamagePtr   pDamage)
+{
+    if (pDrawable->type == DRAWABLE_WINDOW)
+    {
+	WindowPtr   pWindow = (WindowPtr) pDrawable;
+	winDamageRef(pWindow);
+
+#if DAMAGE_VALIDATE_ENABLE
+	DamagePtr   pOld;
+	
+	for (pOld = *pPrev; pOld; pOld = pOld->pNextWin)
+	    if (pOld == pDamage) {
+		ErrorF ("Damage already on window list\n");
+		abort ();
+	    }
+#endif
+	pDamage->pNextWin = *pPrev;
+	*pPrev = pDamage;
+	pDamage->isWindow = TRUE;
+    }
+    else
+	pDamage->isWindow = FALSE;
+    pDamage->pDrawable = pDrawable;
+    damageInsertDamage (getDrawableDamageRef (pDrawable), pDamage);
+}
+
+void
+DamageDrawInternal (ScreenPtr pScreen, Bool enable)
+{
+    damageScrPriv (pScreen);
+
+    pScrPriv->internalLevel += enable ? 1 : -1;
+}
+
+void
+DamageUnregister (DrawablePtr	    pDrawable,
+		  DamagePtr	    pDamage)
+{
+    if (pDrawable->type == DRAWABLE_WINDOW)
+    {
+	WindowPtr   pWindow = (WindowPtr) pDrawable;
+	winDamageRef (pWindow);
+#if DAMAGE_VALIDATE_ENABLE
+	int	found = 0;
+#endif
+
+	while (*pPrev)
+	{
+	    if (*pPrev == pDamage)
+	    {
+		*pPrev = pDamage->pNextWin;
+#if DAMAGE_VALIDATE_ENABLE
+		found = 1;
+#endif
+		break;
+	    }
+	    pPrev = &(*pPrev)->pNextWin;
+	}
+#if DAMAGE_VALIDATE_ENABLE
+	if (!found) {
+	    ErrorF ("Damage not on window list\n");
+	    abort ();
+	}
+#endif
+    }
+    pDamage->pDrawable = 0;
+    damageRemoveDamage (getDrawableDamageRef (pDrawable), pDamage);
+}
+
+void
+DamageDestroy (DamagePtr    pDamage)
+{
+    if (pDamage->damageDestroy)
+	(*pDamage->damageDestroy) (pDamage, pDamage->closure);
+    REGION_UNINIT (pDamage->pDrawable->pScreen, &pDamage->damage);
+    xfree (pDamage);
+}
+
+Bool
+DamageSubtract (DamagePtr	    pDamage,
+		const RegionPtr	    pRegion)
+{
+    RegionPtr	pClip;
+    RegionRec	pixmapClip;
+    DrawablePtr	pDrawable = pDamage->pDrawable;
+    
+    REGION_SUBTRACT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pRegion);
+    if (pDrawable)
+    {
+	if (pDrawable->type == DRAWABLE_WINDOW)
+	    pClip = &((WindowPtr) pDrawable)->borderClip;
+	else
+	{
+	    BoxRec  box;
+
+	    box.x1 = pDrawable->x;
+	    box.y1 = pDrawable->y;
+	    box.x2 = pDrawable->x + pDrawable->width;
+	    box.y2 = pDrawable->y + pDrawable->height;
+	    REGION_INIT (pDrawable->pScreen, &pixmapClip, &box, 1);
+	    pClip = &pixmapClip;
+	}
+	REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, pDrawable->x, pDrawable->y);
+	REGION_INTERSECT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pClip);
+	REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, -pDrawable->x, -pDrawable->y);
+	if (pDrawable->type != DRAWABLE_WINDOW)
+	    REGION_UNINIT(pDrawable->pScreen, &pixmapClip);
+    }
+    return REGION_NOTEMPTY (pDrawable->pScreen, &pDamage->damage);
+}
+
+void
+DamageEmpty (DamagePtr	    pDamage)
+{
+    REGION_EMPTY (pDamage->pDrawable->pScreen, &pDamage->damage);
+}
+
+RegionPtr
+DamageRegion (DamagePtr		    pDamage)
+{
+    return &pDamage->damage;
+}
+
+void
+DamageDamageRegion (DrawablePtr	pDrawable,
+		    RegionPtr	pRegion)
+{
+    damageDamageRegion (pDrawable, pRegion, FALSE, -1);
+}
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.h b/nx-X11/programs/Xserver/miext/damage/damage.h
new file mode 100755
index 000000000..a363e09bb
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/damage/damage.h
@@ -0,0 +1,84 @@
+/*
+ * $Id: damage.h,v 1.4 2005/07/03 07:02:01 daniels Exp $
+ *
+ * Copyright © 2003 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _DAMAGE_H_
+#define _DAMAGE_H_
+
+typedef struct _damage	*DamagePtr;
+
+typedef enum _damageReportLevel {
+    DamageReportRawRegion,
+    DamageReportDeltaRegion,
+    DamageReportBoundingBox,
+    DamageReportNonEmpty,
+    DamageReportNone
+} DamageReportLevel;
+
+typedef void (*DamageReportFunc) (DamagePtr pDamage, RegionPtr pRegion, void *closure);
+typedef void (*DamageDestroyFunc) (DamagePtr pDamage, void *closure);
+
+Bool
+DamageSetup (ScreenPtr pScreen);
+    
+DamagePtr
+DamageCreate (DamageReportFunc  damageReport,
+	      DamageDestroyFunc	damageDestroy,
+	      DamageReportLevel damageLevel,
+	      Bool		isInternal,
+	      ScreenPtr		pScreen,
+	      void *		closure);
+
+void
+DamageDrawInternal (ScreenPtr pScreen, Bool enable);
+
+void
+DamageRegister (DrawablePtr	pDrawable,
+		DamagePtr	pDamage);
+
+void
+DamageUnregister (DrawablePtr	pDrawable,
+		  DamagePtr	pDamage);
+
+void
+DamageDestroy (DamagePtr pDamage);
+
+Bool
+DamageSubtract (DamagePtr	    pDamage,
+		const RegionPtr	    pRegion);
+
+void
+DamageEmpty (DamagePtr pDamage);
+
+RegionPtr
+DamageRegion (DamagePtr		    pDamage);
+
+void
+DamageDamageRegion (DrawablePtr	    pDrawable,
+		    const RegionPtr pRegion);
+
+#endif /* _DAMAGE_H_ */
diff --git a/nx-X11/programs/Xserver/miext/damage/damagestr.h b/nx-X11/programs/Xserver/miext/damage/damagestr.h
new file mode 100755
index 000000000..d7dd11d92
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/damage/damagestr.h
@@ -0,0 +1,113 @@
+/*
+ * $Id: damagestr.h,v 1.6 2005/07/03 07:02:01 daniels Exp $
+ *
+ * Copyright © 2003 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _DAMAGESTR_H_
+#define _DAMAGESTR_H_
+
+#include "damage.h"
+#ifdef RENDER
+# include "picturestr.h"
+#endif
+
+typedef struct _damage {
+    DamagePtr		pNext;
+    DamagePtr		pNextWin;
+    RegionRec		damage;
+    
+    DamageReportLevel	damageLevel;
+    Bool		isInternal;
+    void		*closure;
+    Bool		isWindow;
+    DrawablePtr		pDrawable;
+    
+    DamageReportFunc	damageReport;
+    DamageDestroyFunc	damageDestroy;
+} DamageRec;
+
+typedef struct _damageScrPriv {
+    int				internalLevel;
+
+    /*
+     * For DDXen which don't provide GetScreenPixmap, this provides
+     * a place to hook damage for windows on the screen
+     */
+    DamagePtr			pScreenDamage;
+
+    PaintWindowBackgroundProcPtr PaintWindowBackground;
+    PaintWindowBorderProcPtr	PaintWindowBorder;
+    CopyWindowProcPtr		CopyWindow;
+    CloseScreenProcPtr		CloseScreen;
+    CreateGCProcPtr		CreateGC;
+    DestroyPixmapProcPtr	DestroyPixmap;
+    SetWindowPixmapProcPtr	SetWindowPixmap;
+    DestroyWindowProcPtr	DestroyWindow;
+#ifdef RENDER
+    CompositeProcPtr		Composite;
+    GlyphsProcPtr		Glyphs;
+#endif
+    BSFuncRec			BackingStoreFuncs;
+} DamageScrPrivRec, *DamageScrPrivPtr;
+
+typedef struct _damageGCPriv {
+    GCOps   *ops;
+    GCFuncs *funcs;
+} DamageGCPrivRec, *DamageGCPrivPtr;
+
+extern int damageScrPrivateIndex;
+extern int damagePixPrivateIndex;
+extern int damageGCPrivateIndex;
+extern int damageWinPrivateIndex;
+
+#define damageGetScrPriv(pScr) \
+    ((DamageScrPrivPtr) (pScr)->devPrivates[damageScrPrivateIndex].ptr)
+
+#define damageScrPriv(pScr) \
+    DamageScrPrivPtr    pScrPriv = damageGetScrPriv(pScr)
+
+#define damageGetPixPriv(pPix) \
+    ((DamagePtr) (pPix)->devPrivates[damagePixPrivateIndex].ptr)
+
+#define damgeSetPixPriv(pPix,v) \
+    ((pPix)->devPrivates[damagePixPrivateIndex].ptr = (pointer ) (v))
+
+#define damagePixPriv(pPix) \
+    DamagePtr	    pDamage = damageGetPixPriv(pPix)
+
+#define damageGetGCPriv(pGC) \
+    ((DamageGCPrivPtr) (pGC)->devPrivates[damageGCPrivateIndex].ptr)
+
+#define damageGCPriv(pGC) \
+    DamageGCPrivPtr  pGCPriv = damageGetGCPriv(pGC)
+
+#define damageGetWinPriv(pWin) \
+    ((DamagePtr) (pWin)->devPrivates[damageWinPrivateIndex].ptr)
+
+#define damageSetWinPriv(pWin,d) \
+    ((pWin)->devPrivates[damageWinPrivateIndex].ptr = (d))
+
+#endif /* _DAMAGESTR_H_ */
diff --git a/nx-X11/programs/Xserver/miext/layer/Imakefile b/nx-X11/programs/Xserver/miext/layer/Imakefile
new file mode 100644
index 000000000..32507d20a
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/Imakefile
@@ -0,0 +1,49 @@
+XCOMM $XFree86: xc/programs/Xserver/miext/layer/Imakefile,v 1.1 2001/05/29 04:54:13 keithp Exp $
+XCOMM
+XCOMM
+
+#define IHaveModules
+#include <Server.tmpl>
+
+#if (defined(XFree86Version) || defined(XorgVersion))
+#if DoLoadableServer
+XFMODSRC = laymodule.c
+XFMODOBJ = laymodule.o
+#endif
+#endif
+
+#if BuildRender
+RENDERSRC = layerpict.c
+RENDEROBJ = layerpict.o
+#endif
+
+SRCS = layergc.c \
+       layerinit.c \
+       $(RENDERSRC) \
+       layerwin.c \
+       $(XFMODSRC)
+
+OBJS = layergc.o \
+       layerinit.o \
+       $(RENDEROBJ) \
+       layerwin.o \
+       $(XFMODOBJ)
+
+   INCLUDES = -I. -I../shadow -I../../mi -I../../fb -I../../include -I$(XINCLUDESRC) \
+	      -I$(FONTINCSRC) -I$(XF86SRC)/common $(EXTRAINCLUDES) \
+	      -I../../render -I$(EXTINCSRC)
+   LINTLIBS = ../../dix/llib-ldix.ln ../../os/llib-los.ln \
+	     ../../mi/llib-lmi.ln
+
+NormalLibraryObjectRule()
+LibraryModuleTarget(layer,$(OBJS))
+LintLibraryTarget(layer,$(SRCS))
+
+NormalLintTarget($(SRCS))
+
+InstallLibraryModule(layer,$(MODULEDIR),.)
+
+DependTarget()
+
+InstallDriverSDKLibraryModule(layer,$(DRIVERSDKMODULEDIR),.)
+InstallDriverSDKNonExecFile(layer.h,$(DRIVERSDKINCLUDEDIR))
diff --git a/nx-X11/programs/Xserver/miext/layer/layer.h b/nx-X11/programs/Xserver/miext/layer/layer.h
new file mode 100644
index 000000000..e8f3a856e
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/layer.h
@@ -0,0 +1,149 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/layer/layer.h,v 1.4 2001/08/01 00:44:58 tsi Exp $
+ *
+ * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _LAYER_H_
+#define _LAYER_H_
+
+#include <shadow.h>
+
+#define LAYER_FB	0
+#define LAYER_SHADOW	1
+
+typedef struct _LayerKind   *LayerKindPtr;
+typedef struct _LayerWin    *LayerWinPtr;
+typedef struct _LayerList   *LayerListPtr;
+typedef struct _LayerGC	    *LayerGCPtr;
+typedef struct _Layer	    *LayerPtr;
+typedef struct _LayerScreen *LayerScreenPtr;
+
+/*
+ * We'll try to work without a list of windows in each layer
+ * for now, this will make computing bounding boxes for each
+ * layer rather expensive, so that may need to change at some point.
+ */
+
+#define LAYER_SCREEN_PIXMAP ((PixmapPtr) 1)
+
+typedef struct _Layer {
+    LayerPtr		pNext;	    /* a list of all layers for this screen */
+    LayerKindPtr	pKind;	    /* characteristics of this layer */
+    int			refcnt;	    /* reference count, layer is freed when zero */
+    int			windows;    /* number of windows, free pixmap when zero */
+    int			depth;	    /* window depth in this layer */
+    PixmapPtr		pPixmap;    /* pixmap for this layer (may be frame buffer) */
+    Bool		freePixmap; /* whether to free this pixmap when done */
+    RegionRec		region;	    /* valid set of pPixmap for drawing */
+    ShadowUpdateProc	update;	    /* for shadow layers, update/window/closure values */
+    ShadowWindowProc	window;
+    int			randr;
+    void		*closure;
+} LayerRec;
+
+/*
+ * Call this before wrapping stuff for acceleration, it
+ * gives layer pointers to the raw frame buffer functions
+ */
+
+Bool
+LayerStartInit (ScreenPtr pScreen);
+
+/*
+ * Initialize wrappers for each acceleration type and
+ * call this function, it will move the needed functions
+ * into a new LayerKind and replace them with the generic
+ * functions.
+ */
+
+int
+LayerNewKind (ScreenPtr pScreen);
+
+/*
+ * Finally, call this function and layer
+ * will wrap the screen functions and prepare for execution
+ */
+
+Bool
+LayerFinishInit (ScreenPtr pScreen);
+
+/*
+ * At any point after LayerStartInit, a new layer can be created.
+ */
+LayerPtr
+LayerCreate (ScreenPtr		pScreen, 
+	     int		kind, 
+	     int		depth,
+	     PixmapPtr		pPixmap,
+	     ShadowUpdateProc	update,
+	     ShadowWindowProc	window,
+	     int		randr,
+	     void		*closure);
+
+/*
+ * Create a layer pixmap
+ */
+Bool
+LayerCreatePixmap (ScreenPtr pScreen, LayerPtr pLayer);
+
+/*
+ * Change a layer pixmap
+ */
+void
+LayerSetPixmap (ScreenPtr pScreen, LayerPtr pLayer, PixmapPtr pPixmap);
+
+/*
+ * Destroy a layer pixmap
+ */
+void
+LayerDestroyPixmap (ScreenPtr pScreen, LayerPtr pLayer);
+
+/*
+ * Change a layer kind
+ */
+void
+LayerSetKind (ScreenPtr pScreen, LayerPtr pLayer, int kind);
+
+/*
+ * Destroy a layer.  The layer must not contain any windows.
+ */
+void
+LayerDestroy (ScreenPtr pScreen, LayerPtr layer);
+
+/*
+ * Add a window to a layer
+ */
+Bool
+LayerWindowAdd (ScreenPtr pScreen, LayerPtr pLayer, WindowPtr pWin);
+
+/*
+ * Remove a window from a layer
+ */
+
+void
+LayerWindowRemove (ScreenPtr pScreen, LayerPtr pLayer, WindowPtr pWin);
+
+#endif /* _LAYER_H_ */
diff --git a/nx-X11/programs/Xserver/miext/layer/layergc.c b/nx-X11/programs/Xserver/miext/layer/layergc.c
new file mode 100644
index 000000000..343edfcf5
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/layergc.c
@@ -0,0 +1,194 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/layer/layergc.c,v 1.4 2001/08/27 03:55:46 keithp Exp $
+ *
+ * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "layerstr.h"
+
+GCFuncs	layerGCFuncs = {
+    layerValidateGC, layerChangeGC, layerCopyGC, layerDestroyGC,
+    layerChangeClip, layerDestroyClip, layerCopyClip
+};
+
+#if 0
+/*
+ * XXX dont need this until this supports 
+ * separate clipping and multiple layers
+ */
+GCOps layerGCOps = {
+    layerFillSpans, layerSetSpans, 
+    layerPutImage, layerCopyArea, 
+    layerCopyPlane, layerPolyPoint, 
+    layerPolylines, layerPolySegment, 
+    layerPolyRectangle, layerPolyArc, 
+    layerFillPolygon, layerPolyFillRect, 
+    layerPolyFillArc, layerPolyText8, 
+    layerPolyText16, layerImageText8, 
+    layerImageText16, layerImageGlyphBlt, 
+    layerPolyGlyphBlt, layerPushPixels,
+#ifdef NEED_LINEHELPER
+    NULL,
+#endif
+    {NULL}		/* devPrivate */
+};
+#endif
+
+Bool
+layerCreateGC (GCPtr pGC)
+{
+    Bool	    ret = TRUE;
+    LayerKindPtr    pLayKind;
+    ScreenPtr	    pScreen = pGC->pScreen;
+    layerScrPriv(pScreen);
+    layerGCPriv(pGC);
+    
+    /*
+     * XXX assume the first layer can handle all GCs
+     */
+    pLayKind = &pLayScr->kinds[0];
+    if (pLayScr->pLayers)
+	pLayKind = pLayScr->pLayers->pKind;
+    pLayGC->pKind = pLayKind;
+    LayerUnwrap (pScreen,pLayGC->pKind,CreateGC);
+    
+    if (!(*pScreen->CreateGC) (pGC))
+	ret = FALSE;
+    LayerWrap (pScreen,pLayKind,CreateGC,layerCreateGC);
+
+    LayerWrap (pGC,pLayGC,funcs,&layerGCFuncs);
+
+    return ret;
+}
+
+void
+layerValidateGC(GCPtr         pGC,
+		unsigned long changes,
+		DrawablePtr   pDraw)
+{
+    layerGCPriv(pGC);
+    LayerKindPtr    pKind;
+    
+    if (pDraw->type == DRAWABLE_WINDOW)
+    {
+	layerWinPriv ((WindowPtr) pDraw);
+	pKind = layerWinLayer (pLayWin)->pKind;
+    }
+    else
+    {
+	/* XXX assume the first layer can handle all pixmaps */
+	layerScrPriv (pDraw->pScreen);
+	pKind = &pLayScr->kinds[0];
+	if (pLayScr->pLayers)
+	    pKind = pLayScr->pLayers->pKind;
+    }
+    
+    LayerUnwrap (pGC,pLayGC,funcs);
+    if (pKind != pLayGC->pKind)
+    {
+	/*
+	 * Clean up the previous user
+	 */
+	CreateGCProcPtr	CreateGC;
+	(*pGC->funcs->DestroyGC) (pGC);
+	
+	pGC->serialNumber = GC_CHANGE_SERIAL_BIT;
+
+	pLayGC->pKind = pKind;
+	
+	/*
+	 * Temporarily unwrap Create GC and let
+	 * the new code setup the GC 
+	 */
+	CreateGC = pGC->pScreen->CreateGC;
+	LayerUnwrap (pGC->pScreen, pLayGC->pKind, CreateGC);
+	(*pGC->pScreen->CreateGC) (pGC);
+	LayerWrap (pGC->pScreen, pLayGC->pKind, CreateGC, CreateGC);
+    }
+    
+    (*pGC->funcs->ValidateGC) (pGC, changes, pDraw);
+    LayerWrap(pGC,pLayGC,funcs,&layerGCFuncs);
+}
+
+void
+layerDestroyGC(GCPtr pGC)
+{
+    layerGCPriv(pGC);
+    LayerUnwrap (pGC,pLayGC,funcs);
+    (*pGC->funcs->DestroyGC)(pGC);
+    LayerWrap(pGC,pLayGC,funcs,&layerGCFuncs);
+}
+
+void
+layerChangeGC (GCPtr		pGC,
+	       unsigned long	mask)
+{
+    layerGCPriv(pGC);
+    LayerUnwrap (pGC,pLayGC,funcs);
+    (*pGC->funcs->ChangeGC) (pGC, mask);
+    LayerWrap(pGC,pLayGC,funcs,&layerGCFuncs);
+}
+
+void
+layerCopyGC (GCPtr	    pGCSrc, 
+	     unsigned long  mask,
+	     GCPtr	    pGCDst)
+{
+    layerGCPriv(pGCDst);
+    LayerUnwrap (pGCDst,pLayGC,funcs);
+    (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
+    LayerWrap(pGCDst,pLayGC,funcs,&layerGCFuncs);
+}
+
+void
+layerChangeClip (GCPtr	    pGC,
+		 int	    type,
+		 pointer    pvalue,
+		 int	    nrects)
+{
+    layerGCPriv(pGC);
+    LayerUnwrap (pGC,pLayGC,funcs);
+    (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
+    LayerWrap(pGC,pLayGC,funcs,&layerGCFuncs);
+}
+
+void
+layerCopyClip(GCPtr pGCDst, GCPtr pGCSrc)
+{
+    layerGCPriv(pGCDst);
+    LayerUnwrap (pGCDst,pLayGC,funcs);
+    (*pGCDst->funcs->CopyClip) (pGCDst, pGCSrc);
+    LayerWrap(pGCDst,pLayGC,funcs,&layerGCFuncs);
+}
+
+void
+layerDestroyClip(GCPtr pGC)
+{
+    layerGCPriv(pGC);
+    LayerUnwrap (pGC,pLayGC,funcs);
+    (*pGC->funcs->DestroyClip) (pGC);
+    LayerWrap(pGC,pLayGC,funcs,&layerGCFuncs);
+}
+
diff --git a/nx-X11/programs/Xserver/miext/layer/layerinit.c b/nx-X11/programs/Xserver/miext/layer/layerinit.c
new file mode 100644
index 000000000..994c6747c
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/layerinit.c
@@ -0,0 +1,363 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/layer/layerinit.c,v 1.6tsi Exp $
+ *
+ * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    "layerstr.h"
+
+int layerScrPrivateIndex;
+int layerGCPrivateIndex;
+int layerWinPrivateIndex;
+int layerGeneration;
+
+/*
+ * Call this before wrapping stuff for acceleration, it
+ * gives layer pointers to the raw frame buffer functions
+ */
+
+extern const GCFuncs fbGCFuncs;
+extern GCFuncs shadowGCFuncs;
+
+Bool
+LayerStartInit (ScreenPtr pScreen)
+{
+    LayerScreenPtr  pScrPriv;
+    
+    if (layerGeneration != serverGeneration)
+    {
+	layerScrPrivateIndex = AllocateScreenPrivateIndex ();
+	if (layerScrPrivateIndex == -1)
+	    return FALSE;
+	layerGCPrivateIndex = AllocateGCPrivateIndex ();
+	if (layerGCPrivateIndex == -1)
+	    return FALSE;
+	layerWinPrivateIndex = AllocateWindowPrivateIndex ();
+	if (layerWinPrivateIndex == -1)
+	    return FALSE;
+	layerGeneration = serverGeneration;
+    }
+    if (!AllocateGCPrivate (pScreen, layerGCPrivateIndex, sizeof (LayerGCRec)))
+	return FALSE;
+    if (!AllocateWindowPrivate (pScreen, layerWinPrivateIndex, sizeof (LayerWinRec)))
+	return FALSE;
+    pScrPriv = (LayerScreenPtr) xalloc (sizeof (LayerScreenRec));
+    if (!pScrPriv)
+	return FALSE;
+    pScrPriv->nkinds = 0;
+    pScrPriv->kinds = 0;
+    pScrPriv->pLayers = 0;
+    pScreen->devPrivates[layerScrPrivateIndex].ptr = (pointer) pScrPriv;
+    /*
+     * Add fb kind -- always 0
+     */
+    if (LayerNewKind (pScreen) < 0)
+    {
+	pScreen->devPrivates[layerScrPrivateIndex].ptr = 0;
+	xfree (pScrPriv);
+	return FALSE;
+    }
+    /*
+     * Add shadow kind -- always 1
+     */
+    if (!shadowSetup (pScreen))
+	return FALSE;
+    if (LayerNewKind (pScreen) < 0)
+    {
+	pScreen->devPrivates[layerScrPrivateIndex].ptr = 0;
+	xfree (pScrPriv->kinds);
+	xfree (pScrPriv);
+	return FALSE;
+    }
+    return TRUE;
+}
+
+/*
+ * Initialize wrappers for each acceleration type and
+ * call this function, it will move the needed functions
+ * into a new LayerKind and replace them with the generic
+ * functions.
+ */
+
+int
+LayerNewKind (ScreenPtr pScreen)
+{
+    layerScrPriv(pScreen);
+    LayerKindPtr	pLayKind, pLayKinds;
+#ifdef RENDER
+    PictureScreenPtr	ps = GetPictureScreen (pScreen);
+#endif
+    LayerPtr		pLayer;
+    
+    /*
+     * Allocate a new kind structure
+     */
+    if (pLayScr->kinds)
+	pLayKinds = (LayerKindPtr) xrealloc ((pointer) pLayScr->kinds,
+					     (pLayScr->nkinds + 1) * sizeof (LayerKindRec));
+    else
+	pLayKinds = (LayerKindPtr) xalloc (sizeof (LayerKindRec));
+    if (!pLayKinds)
+	return -1;
+
+    /*
+     * Fix up existing layers to point at the new kind
+     */
+    for (pLayer = pLayScr->pLayers; pLayer; pLayer = pLayer->pNext)
+    {
+	int kind = pLayer->pKind - pLayScr->kinds;
+	
+	pLayer->pKind = &pLayKinds[kind];
+    }
+
+    pLayScr->kinds = pLayKinds;
+    pLayKind = &pLayScr->kinds[pLayScr->nkinds];
+    pLayKind->kind = pLayScr->nkinds;
+
+    /*
+     * Extract wrapped functions from screen and stick in kind
+     */
+    pLayKind->CloseScreen = pScreen->CloseScreen;
+    
+    pLayKind->CreateWindow = pScreen->CreateWindow;
+    pLayKind->DestroyWindow = pScreen->DestroyWindow;
+    pLayKind->ChangeWindowAttributes = pScreen->ChangeWindowAttributes;
+    pLayKind->PaintWindowBackground = pScreen->PaintWindowBackground;
+    pLayKind->PaintWindowBorder = pScreen->PaintWindowBorder;
+    pLayKind->CopyWindow = pScreen->CopyWindow;
+
+    pLayKind->CreatePixmap = pScreen->CreatePixmap;
+    pLayKind->DestroyPixmap = pScreen->DestroyPixmap;
+    
+    pLayKind->CreateGC = pScreen->CreateGC;
+
+#ifdef RENDER
+    if (ps)
+    {
+	pLayKind->Composite = ps->Composite;
+	pLayKind->Glyphs = ps->Glyphs;
+	pLayKind->CompositeRects = ps->CompositeRects;
+    }
+#endif
+    /*
+     * If not underlying frame buffer kind,
+     * replace screen functions with those
+     */
+    if (pLayKind->kind != 0)
+    {
+	pScreen->CloseScreen = pLayKinds->CloseScreen;
+
+	pScreen->CreateWindow = pLayKinds->CreateWindow;
+	pScreen->DestroyWindow = pLayKinds->DestroyWindow;
+	pScreen->ChangeWindowAttributes = pLayKinds->ChangeWindowAttributes;
+	pScreen->PaintWindowBackground = pLayKinds->PaintWindowBackground;
+	pScreen->PaintWindowBorder = pLayKinds->PaintWindowBorder;
+	pScreen->CopyWindow = pLayKinds->CopyWindow;
+
+	pScreen->CreatePixmap = pLayKinds->CreatePixmap;
+	pScreen->DestroyPixmap = pLayKinds->DestroyPixmap;
+
+	pScreen->CreateGC = pLayKinds->CreateGC;
+
+#ifdef RENDER
+	if (ps)
+	{
+	    ps->Composite = pLayKinds->Composite;
+	    ps->Glyphs = pLayKinds->Glyphs;
+	    ps->CompositeRects = pLayKinds->CompositeRects;
+	}
+#endif
+    }
+
+    pLayScr->nkinds++;
+    return pLayKind->kind;
+}
+
+/*
+ * Finally, call this function and layer
+ * will wrap the screen functions and prepare for execution
+ */
+
+Bool
+LayerFinishInit (ScreenPtr pScreen)
+{
+#ifdef RENDER
+    PictureScreenPtr	ps = GetPictureScreen (pScreen);
+#endif
+    
+    pScreen->CloseScreen = layerCloseScreen;
+
+    pScreen->CreateWindow = layerCreateWindow;
+    pScreen->DestroyWindow = layerDestroyWindow;
+    pScreen->ChangeWindowAttributes = layerChangeWindowAttributes;
+    pScreen->PaintWindowBackground = layerPaintWindowBackground;
+    pScreen->PaintWindowBorder = layerPaintWindowBorder;
+    pScreen->CopyWindow = layerCopyWindow;
+
+    pScreen->CreatePixmap = layerCreatePixmap;
+    pScreen->DestroyPixmap = layerDestroyPixmap;
+
+    pScreen->CreateGC = layerCreateGC;
+
+#ifdef RENDER
+    if (ps)
+    {
+	ps->Composite = layerComposite;
+	ps->Glyphs = layerGlyphs;
+	ps->CompositeRects = layerCompositeRects;
+    }
+#endif
+    
+    return TRUE;
+}
+
+/*
+ * At any point after LayerStartInit, a new layer can be created.
+ */
+LayerPtr
+LayerCreate (ScreenPtr		pScreen, 
+	     int		kind, 
+	     int		depth,
+	     PixmapPtr		pPixmap,
+	     ShadowUpdateProc	update,
+	     ShadowWindowProc	window,
+	     int		randr,
+	     void		*closure)
+{
+    layerScrPriv(pScreen);
+    LayerPtr	    pLay, *pPrev;
+    LayerKindPtr    pLayKind;
+
+    if (kind < 0 || pLayScr->nkinds <= kind)
+	return 0;
+    pLayKind = &pLayScr->kinds[kind];
+    pLay = (LayerPtr) xalloc (sizeof (LayerRec));
+    if (!pLay)
+	return 0;
+    /*
+     * Initialize the layer
+     */
+    pLay->pNext = 0;
+    pLay->pKind = pLayKind;
+    pLay->refcnt = 1;
+    pLay->windows = 0;
+    pLay->depth = depth;
+    pLay->pPixmap = pPixmap;
+    pLay->update = update;
+    pLay->window = window;
+    pLay->randr = randr;
+    pLay->closure = closure;
+    if (pPixmap == LAYER_SCREEN_PIXMAP)
+	pLay->freePixmap = FALSE;
+    else
+    {
+	pLay->freePixmap = TRUE;
+	if (pPixmap)
+	    pPixmap->refcnt++;
+    }
+    REGION_NULL(pScreen, &pLay->region);
+    /*
+     * Hook the layer at the end of the list
+     */
+    for (pPrev = &pLayScr->pLayers; *pPrev; pPrev = &(*pPrev)->pNext)
+	;
+    *pPrev = pLay;
+    return pLay;
+}
+
+/*
+ * Change a layer pixmap
+ */
+void
+LayerSetPixmap (ScreenPtr pScreen, LayerPtr pLayer, PixmapPtr pPixmap)
+{
+    LayerDestroyPixmap (pScreen, pLayer);
+    pLayer->pPixmap = pPixmap;
+    if (pPixmap == LAYER_SCREEN_PIXMAP)
+	pLayer->freePixmap = FALSE;
+    else
+    {
+	if (pPixmap)
+	    pPixmap->refcnt++;
+	pLayer->freePixmap = TRUE;
+    }
+}
+
+/*
+ * Destroy a layer. The layer must not contain any windows.
+ */
+void
+LayerDestroy (ScreenPtr pScreen, LayerPtr pLay)
+{
+    layerScrPriv(pScreen);
+    LayerPtr	*pPrev;
+    
+    --pLay->refcnt;
+    if (pLay->refcnt > 0)
+	return;
+    /*
+     * Unhook the layer from the list
+     */
+    for (pPrev = &pLayScr->pLayers; *pPrev; pPrev = &(*pPrev)->pNext)
+	if (*pPrev == pLay)
+	{
+	    *pPrev = pLay->pNext;
+	    break;
+	}
+    /*
+     * Free associated storage
+     */
+    LayerDestroyPixmap (pScreen, pLay);
+    REGION_UNINIT (pScreen, &pLay->region);
+    xfree (pLay);
+}
+
+/*
+ * CloseScreen wrapper
+ */
+Bool
+layerCloseScreen (int index, ScreenPtr pScreen)
+{
+    layerScrPriv(pScreen);
+    int	    kind;
+
+    /* XXX this is a mess -- fbCloseScreen can only be called once,
+     * and yet the intervening layers need to be called as well.
+     */
+    kind = pLayScr->nkinds - 1;
+    pScreen->CloseScreen = pLayScr->kinds[kind].CloseScreen;
+    (*pScreen->CloseScreen) (index, pScreen);
+    
+    /*
+     * make sure the shadow layer is cleaned up as well
+     */
+    if (kind != LAYER_SHADOW)
+	xfree (shadowGetScrPriv (pScreen));
+
+    xfree (pLayScr->kinds);
+    xfree (pLayScr);
+    pScreen->devPrivates[layerScrPrivateIndex].ptr = 0;
+    return TRUE;
+}
diff --git a/nx-X11/programs/Xserver/miext/layer/layerpict.c b/nx-X11/programs/Xserver/miext/layer/layerpict.c
new file mode 100644
index 000000000..16e46f0ab
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/layerpict.c
@@ -0,0 +1,149 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "layerstr.h"
+
+void
+layerComposite (CARD8      op,
+		PicturePtr pSrc,
+		PicturePtr pMask,
+		PicturePtr pDst,
+		INT16      xSrc,
+		INT16      ySrc,
+		INT16      xMask,
+		INT16      yMask,
+		INT16      xDst,
+		INT16      yDst,
+		CARD16     width,
+		CARD16     height)
+{
+    LayerPtr		pLayer;
+    LayerWinLoopRec	loop;
+    DrawablePtr		pDstDrawable = pDst->pDrawable;
+    ScreenPtr		pScreen = pDstDrawable->pScreen;
+    PictureScreenPtr	ps = GetPictureScreen (pScreen);
+
+    if (pDstDrawable->type == DRAWABLE_WINDOW)
+    {
+	WindowPtr   pWin = (WindowPtr) pDstDrawable;
+	for (pLayer = LayerWindowFirst (pWin, &loop);
+	     pLayer;
+	     pLayer = LayerWindowNext (pWin, &loop))
+	{
+	    LayerUnwrap (ps, pLayer->pKind, Composite);
+	    (*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc,
+			      xMask, yMask, xDst, yDst, width, height);
+	    LayerWrap (ps, pLayer->pKind, Composite, layerComposite);
+	}
+	LayerWindowDone (pWin, &loop);
+    }
+    else
+    {
+	layerScrPriv (pScreen);
+	LayerUnwrap (ps, &pLayScr->kinds[LAYER_FB], Composite);
+	(*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc,
+			  xMask, yMask, xDst, yDst, width, height);
+	LayerWrap (ps, &pLayScr->kinds[LAYER_FB], Composite, layerComposite);
+    }
+}
+
+void
+layerGlyphs (CARD8	    op,
+	     PicturePtr	    pSrc,
+	     PicturePtr	    pDst,
+	     PictFormatPtr  maskFormat,
+	     INT16	    xSrc,
+	     INT16	    ySrc,
+	     int	    nlist,
+	     GlyphListPtr   list,
+	     GlyphPtr	    *glyphs)
+{
+    LayerPtr		pLayer;
+    LayerWinLoopRec	loop;
+    DrawablePtr		pDstDrawable = pDst->pDrawable;
+    ScreenPtr		pScreen = pDstDrawable->pScreen;
+    PictureScreenPtr	ps = GetPictureScreen (pScreen);
+
+    if (pDstDrawable->type == DRAWABLE_WINDOW)
+    {
+	WindowPtr   pWin = (WindowPtr) pDstDrawable;
+	for (pLayer = LayerWindowFirst (pWin, &loop);
+	     pLayer;
+	     pLayer = LayerWindowNext (pWin, &loop))
+	{
+	    LayerUnwrap (ps, pLayer->pKind, Glyphs);
+	    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc,
+			   nlist, list, glyphs);
+	    LayerWrap (ps, pLayer->pKind, Glyphs, layerGlyphs);
+	}
+	LayerWindowDone (pWin, &loop);
+    }
+    else
+    {
+	layerScrPriv (pScreen);
+	LayerUnwrap (ps, &pLayScr->kinds[LAYER_FB], Glyphs);
+	(*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc,
+		       nlist, list, glyphs);
+	LayerWrap (ps, &pLayScr->kinds[LAYER_FB], Glyphs, layerGlyphs);
+    }
+}
+
+void
+layerCompositeRects (CARD8	    op,
+		     PicturePtr	    pDst,
+		     xRenderColor   *color,
+		     int	    nRect,
+		     xRectangle	    *rects)
+{
+    LayerPtr		pLayer;
+    LayerWinLoopRec	loop;
+    DrawablePtr		pDstDrawable = pDst->pDrawable;
+    ScreenPtr		pScreen = pDstDrawable->pScreen;
+    PictureScreenPtr	ps = GetPictureScreen (pScreen);
+
+    if (pDstDrawable->type == DRAWABLE_WINDOW)
+    {
+	WindowPtr   pWin = (WindowPtr) pDstDrawable;
+	for (pLayer = LayerWindowFirst (pWin, &loop);
+	     pLayer;
+	     pLayer = LayerWindowNext (pWin, &loop))
+	{
+	    LayerUnwrap (ps, pLayer->pKind, CompositeRects);
+	    (*ps->CompositeRects) (op, pDst, color, nRect, rects);
+	    LayerWrap (ps, pLayer->pKind, CompositeRects, layerCompositeRects);
+	}
+	LayerWindowDone (pWin, &loop);
+    }
+    else
+    {
+	layerScrPriv (pScreen);
+	LayerUnwrap (ps, &pLayScr->kinds[LAYER_FB], CompositeRects);
+	(*ps->CompositeRects) (op, pDst, color, nRect, rects);
+	LayerWrap (ps, &pLayScr->kinds[LAYER_FB], CompositeRects, layerCompositeRects);
+    }
+}
diff --git a/nx-X11/programs/Xserver/miext/layer/layerstr.h b/nx-X11/programs/Xserver/miext/layer/layerstr.h
new file mode 100644
index 000000000..fb5a0d411
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/layerstr.h
@@ -0,0 +1,425 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/layer/layerstr.h,v 1.2 2001/06/04 09:45:41 keithp Exp $
+ *
+ * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _LAYERSTR_H_
+#define _LAYERSTR_H_
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "layer.h"
+#ifdef RENDER
+#include    "picturestr.h"
+#endif
+
+extern int layerScrPrivateIndex;
+extern int layerGCPrivateIndex;
+extern int layerWinPrivateIndex;
+
+/*
+ * One of these for each possible set of underlying
+ * rendering code.  The first kind always points at the
+ * underlying frame buffer code and is created in LayerStartInit
+ * so that LayerNewKind can unwrap the screen and prepare it
+ * for another wrapping sequence.
+ *
+ * The set of functions wrapped here must be at least the union
+ * of all functions wrapped by any rendering layer in use; they're
+ * easy to add, so don't be shy
+ */
+
+typedef struct _LayerKind {
+    int				kind;			/* kind index */
+
+    CloseScreenProcPtr		CloseScreen;
+    
+    CreateWindowProcPtr		CreateWindow;
+    DestroyWindowProcPtr	DestroyWindow;
+    ChangeWindowAttributesProcPtr ChangeWindowAttributes;
+    PaintWindowBackgroundProcPtr PaintWindowBackground;
+    PaintWindowBorderProcPtr	PaintWindowBorder;
+    CopyWindowProcPtr		CopyWindow;
+    
+    CreatePixmapProcPtr		CreatePixmap;
+    DestroyPixmapProcPtr	DestroyPixmap;
+
+    CreateGCProcPtr		CreateGC;
+#ifdef RENDER
+    CompositeProcPtr		Composite;
+    GlyphsProcPtr		Glyphs;
+    CompositeRectsProcPtr	CompositeRects;
+#endif
+} LayerKindRec;
+
+#define LayerWrap(orig,lay,member,func) \
+    (((lay)->member = (orig)->member),\
+     ((orig)->member = (func)))
+#define LayerUnwrap(orig,lay,member) \
+    ((orig)->member = (lay)->member)
+
+/*
+ * This is the window private structure allocated for
+ * all windows.  There are two possible alternatives here,
+ * either the window belongs to a single layer and uses its
+ * internal clip/borderClip lists or the window belongs to one
+ * or more layers and uses a separate clip/borderclip for each
+ * layer.  When this is integrated into the core window struct,
+ * the LayerWinKind can become a single bit saving 8 bytes per
+ * window.
+ */
+
+typedef struct _LayerWin {
+    Bool		isList;
+    union {
+	LayerPtr	pLayer;
+	LayerListPtr	pLayList;
+    } u;
+} LayerWinRec;
+
+typedef struct _LayerList {
+    LayerListPtr    pNext;	    /* list of layers for this window */
+    LayerPtr	    pLayer;	    /* the layer */
+    Bool	    inheritClip;    /* use the window clipList/borderClip */
+    RegionRec	    clipList;	    /* per-layer clip/border clip lists */
+    RegionRec	    borderClip;
+} LayerListRec;
+
+#define layerGetWinPriv(pWin)	    ((LayerWinPtr) (pWin)->devPrivates[layerWinPrivateIndex].ptr)
+#define layerWinPriv(pWin)	    LayerWinPtr	pLayWin = layerGetWinPriv(pWin)
+
+#define layerWinLayer(pLayWin)	    ((pLayWin)->isList ? (pLayWin)->u.pLayList->pLayer : (pLayWin)->u.pLayer)
+
+typedef struct _LayerWinLoop {
+    LayerWinPtr	    pLayWin;
+    LayerListPtr    pLayList;
+    PixmapPtr	    pPixmap;	    /* original window pixmap */
+    RegionRec	    clipList;	    /* saved original clipList contents */
+    RegionRec	    borderClip;	    /* saved original borderClip contents */
+} LayerWinLoopRec, *LayerWinLoopPtr;
+
+#define layerWinFirstLayer(pLayWin,pLayList) ((pLayWin)->isList ? ((pLayList) = (pLayWin)->u.pLayList)->pLayer : pLayWin->u.pLayer)
+#define layerWinNextLayer(pLayWin,pLayList) ((pLayWin)->isList ? ((pLayList) = (pLayList)->pNext)->pLayer : 0)
+					      
+LayerPtr
+LayerWindowFirst (WindowPtr pWin, LayerWinLoopPtr pLoop);
+
+LayerPtr
+LayerWindowNext (WindowPtr pWin, LayerWinLoopPtr pLoop);
+
+void
+LayerWindowDone (WindowPtr pWin, LayerWinLoopPtr pLoop);
+
+
+/*
+ * This is the GC private structure allocated for all GCs.
+ * XXX this is really messed up; I'm not sure how to fix it yet
+ */
+
+typedef struct _LayerGC {
+    GCFuncs	    *funcs;
+    LayerKindPtr    pKind;
+} LayerGCRec;
+
+#define layerGetGCPriv(pGC)	    ((LayerGCPtr) (pGC)->devPrivates[layerGCPrivateIndex].ptr)
+#define layerGCPriv(pGC)	    LayerGCPtr pLayGC = layerGetGCPriv(pGC)
+
+/*
+ * This is the screen private, it contains
+ * the layer kinds and the layers themselves
+ */
+typedef struct _LayerScreen {
+    int		    nkinds;	    /* number of elements in kinds array */
+    LayerKindPtr    kinds;	    /* created kinds; reallocated when new ones added */
+    LayerPtr	    pLayers;	    /* list of layers for this screen */
+} LayerScreenRec;
+
+#define layerGetScrPriv(pScreen)    ((LayerScreenPtr) (pScreen)->devPrivates[layerScrPrivateIndex].ptr)
+#define layerScrPriv(pScreen)	    LayerScreenPtr  pLayScr = layerGetScrPriv(pScreen)
+
+Bool
+layerCloseScreen (int index, ScreenPtr pScreen);
+
+Bool
+layerCreateWindow (WindowPtr pWin);
+
+Bool
+layerDestroyWindow (WindowPtr pWin);
+
+Bool
+layerChangeWindowAttributes (WindowPtr pWin, unsigned long mask);
+
+void
+layerPaintWindowBackground (WindowPtr pWin, RegionPtr pRegion, int what);
+
+void
+layerPaintWindowBorder (WindowPtr pWin, RegionPtr pRegion, int what);
+
+void
+layerCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
+
+PixmapPtr
+layerCreatePixmap (ScreenPtr pScreen, int width, int height, int depth);
+
+Bool
+layerDestroyPixmap (PixmapPtr pPixmap);
+
+Bool
+layerCreateGC (GCPtr pGC);
+
+#ifdef RENDER
+void
+layerComposite (CARD8      op,
+		PicturePtr pSrc,
+		PicturePtr pMask,
+		PicturePtr pDst,
+		INT16      xSrc,
+		INT16      ySrc,
+		INT16      xMask,
+		INT16      yMask,
+		INT16      xDst,
+		INT16      yDst,
+		CARD16     width,
+		CARD16     height);
+void
+layerGlyphs (CARD8	    op,
+	     PicturePtr	    pSrc,
+	     PicturePtr	    pDst,
+	     PictFormatPtr  maskFormat,
+	     INT16	    xSrc,
+	     INT16	    ySrc,
+	     int	    nlist,
+	     GlyphListPtr   list,
+	     GlyphPtr	    *glyphs);
+
+void
+layerCompositeRects (CARD8	    op,
+		     PicturePtr	    pDst,
+		     xRenderColor   *color,
+		     int	    nRect,
+		     xRectangle	    *rects);
+#endif
+void layerValidateGC(GCPtr, unsigned long, DrawablePtr);
+void layerChangeGC(GCPtr, unsigned long);
+void layerCopyGC(GCPtr, unsigned long, GCPtr);
+void layerDestroyGC(GCPtr);
+void layerChangeClip(GCPtr, int, pointer, int);
+void layerDestroyClip(GCPtr);
+void layerCopyClip(GCPtr, GCPtr);
+
+void
+layerFillSpans(DrawablePtr  pDraw,
+	       GC	    *pGC,
+	       int	    nInit,	
+	       DDXPointPtr  pptInit,	
+	       int	    *pwidthInit,		
+	       int	    fSorted);
+
+void
+layerSetSpans(DrawablePtr	pDraw,
+	      GCPtr		pGC,
+	      char		*pcharsrc,
+	      DDXPointPtr 	pptInit,
+	      int		*pwidthInit,
+	      int		nspans,
+	      int		fSorted);
+
+void
+layerPutImage(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		depth, 
+    int x, int y, int w, int h,
+    int		leftPad,
+    int		format,
+    char 	*pImage 
+);
+
+RegionPtr
+layerCopyArea(
+    DrawablePtr pSrc,
+    DrawablePtr pDst,
+    GC *pGC,
+    int srcx, int srcy,
+    int width, int height,
+    int dstx, int dsty 
+);
+
+RegionPtr
+layerCopyPlane(
+    DrawablePtr	pSrc,
+    DrawablePtr	pDst,
+    GCPtr pGC,
+    int	srcx, int srcy,
+    int	width, int height,
+    int	dstx, int dsty,
+    unsigned long bitPlane 
+);
+
+void
+layerPolyPoint(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int mode,
+    int npt,
+    xPoint *pptInit 
+);
+void
+layerPolylines(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		mode,		
+    int		npt,		
+    DDXPointPtr pptInit 
+);
+
+void 
+layerPolySegment(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		nseg,
+    xSegment	*pSeg 
+);
+
+void
+layerPolyRectangle(
+    DrawablePtr  pDraw,
+    GCPtr        pGC,
+    int	         nRects,
+    xRectangle  *pRects 
+);
+
+void
+layerPolyArc(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		narcs,
+    xArc	*parcs 
+);
+
+void
+layerFillPolygon(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		shape,
+    int		mode,
+    int		count,
+    DDXPointPtr	pptInit 
+);
+
+void 
+layerPolyFillRect(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		nRectsInit, 
+    xRectangle	*pRectsInit 
+);
+
+void
+layerPolyFillArc(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		narcs,
+    xArc	*parcs 
+);
+
+int
+layerPolyText8(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x, 
+    int 	y,
+    int 	count,
+    char	*chars 
+);
+
+int
+layerPolyText16(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int		y,
+    int 	count,
+    unsigned short *chars 
+);
+
+void
+layerImageText8(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x, 
+    int		y,
+    int 	count,
+    char	*chars 
+);
+
+void
+layerImageText16(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int		y,
+    int 	count,
+    unsigned short *chars 
+);
+
+void
+layerImageGlyphBlt(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int x, int y,
+    unsigned int nglyph,
+    CharInfoPtr *ppci,
+    pointer pglyphBase 
+);
+
+void
+layerPolyGlyphBlt(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int x, int y,
+    unsigned int nglyph,
+    CharInfoPtr *ppci,
+    pointer pglyphBase 
+);
+
+void
+layerPushPixels(
+    GCPtr	pGC,
+    PixmapPtr	pBitMap,
+    DrawablePtr pDraw,
+    int	dx, int dy, int xOrg, int yOrg 
+);
+
+#endif /* _LAYERSTR_H_ */
diff --git a/nx-X11/programs/Xserver/miext/layer/layerwin.c b/nx-X11/programs/Xserver/miext/layer/layerwin.c
new file mode 100644
index 000000000..7afe90ade
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/layerwin.c
@@ -0,0 +1,487 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/layer/layerwin.c,v 1.7tsi Exp $
+ *
+ * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "layerstr.h"
+
+static LayerListPtr
+NewLayerList (ScreenPtr pScreen, LayerPtr pLayer)
+{
+    LayerListPtr    pLayList;
+
+    pLayList = (LayerListPtr) xalloc (sizeof (LayerListRec));
+    if (!pLayList)
+	return 0;
+    pLayList->pNext = 0;
+    pLayList->pLayer = pLayer;
+    pLayList->inheritClip = TRUE;
+    REGION_NULL (pScreen, &pLayList->clipList);
+    REGION_NULL (pScreen, &pLayList->borderClip);
+    return pLayList;
+}
+
+static void
+FreeLayerList (ScreenPtr pScreen, LayerListPtr pLayList)
+{
+    REGION_UNINIT (pScreen, &pLayList->clipList);
+    REGION_UNINIT (pScreen, &pLayList->borderClip);
+    xfree (pLayList);
+}
+
+/*
+ * Create pixmap for a layer
+ */
+
+Bool
+LayerCreatePixmap (ScreenPtr pScreen, LayerPtr pLayer)
+{
+    LayerKindPtr    pKind = pLayer->pKind;
+    
+    LayerUnwrap (pScreen, pKind, CreatePixmap);
+    /* XXX create full-screen sized layers all around */
+    pLayer->pPixmap = (*pScreen->CreatePixmap) (pScreen, pScreen->width, 
+						pScreen->height, pLayer->depth);
+    LayerWrap (pScreen, pKind, CreatePixmap, layerCreatePixmap);
+    if (!pLayer->pPixmap)
+	return FALSE;
+    if (pLayer->pKind->kind == LAYER_SHADOW)
+    {
+	if (!shadowAdd (pScreen, pLayer->pPixmap, pLayer->update, 
+			pLayer->window, pLayer->randr, 
+			pLayer->closure))
+	    return FALSE;
+    }
+    return TRUE;
+}
+
+/*
+ * Destroy pixmap for a layer
+ */
+
+void
+LayerDestroyPixmap (ScreenPtr pScreen, LayerPtr pLayer)
+{
+    if (pLayer->pPixmap)
+    {
+	if (pLayer->pKind->kind == LAYER_SHADOW)
+	    shadowRemove (pScreen, pLayer->pPixmap);
+	if (pLayer->freePixmap)
+	{
+	    LayerKindPtr    pKind = pLayer->pKind;
+
+	    LayerUnwrap (pScreen, pKind, DestroyPixmap);
+	    (*pScreen->DestroyPixmap) (pLayer->pPixmap);
+	    LayerWrap (pScreen, pKind, DestroyPixmap, layerDestroyPixmap);
+	}
+	pLayer->pPixmap = 0;
+    }
+}
+    
+/*
+ * Add a window to a layer
+ */
+Bool
+LayerWindowAdd (ScreenPtr pScreen, LayerPtr pLayer, WindowPtr pWin)
+{
+    layerWinPriv(pWin);
+
+    if (pLayer->pPixmap == LAYER_SCREEN_PIXMAP)
+	pLayer->pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
+    else if (!pLayer->pPixmap && !LayerCreatePixmap (pScreen, pLayer))
+	return FALSE;
+    /*
+     * Add a new layer list if needed
+     */
+    if (pLayWin->isList || pLayWin->u.pLayer)
+    {
+	LayerListPtr	pPrev;
+	LayerListPtr    pLayList;
+	
+	if (!pLayWin->isList)
+	{
+	    pPrev = NewLayerList (pScreen, pLayWin->u.pLayer);
+	    if (!pPrev)
+		return FALSE;
+	}
+	else
+	{
+	    for (pPrev = pLayWin->u.pLayList; pPrev->pNext; pPrev = pPrev->pNext)
+		;
+	}
+	pLayList = NewLayerList (pScreen, pLayer);
+	if (!pLayList)
+	{
+	    if (!pLayWin->isList)
+		FreeLayerList (pScreen, pPrev);
+	    return FALSE;
+	}
+	pPrev->pNext = pLayList;
+	if (!pLayWin->isList)
+	{
+	    pLayWin->isList = TRUE;
+	    pLayWin->u.pLayList = pPrev;
+	}
+    }
+    else
+	pLayWin->u.pLayer = pLayer;
+    /*
+     * XXX only one layer supported for drawing, last one wins
+     */
+    (*pScreen->SetWindowPixmap) (pWin, pLayer->pPixmap);
+    pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+    pLayer->refcnt++;
+    pLayer->windows++;
+    return TRUE;
+}
+
+/*
+ * Remove a window from a layer
+ */
+
+void
+LayerWindowRemove (ScreenPtr pScreen, LayerPtr pLayer, WindowPtr pWin)
+{
+    layerWinPriv(pWin);
+
+    if (pLayWin->isList)
+    {
+	LayerListPtr	*pPrev;
+	LayerListPtr	pLayList;
+
+	for (pPrev = &pLayWin->u.pLayList; (pLayList = *pPrev); pPrev = &pLayList->pNext)
+	{
+	    if (pLayList->pLayer == pLayer)
+	    {
+		*pPrev = pLayList->pNext;
+		FreeLayerList (pScreen, pLayList);
+		--pLayer->windows;
+		if (pLayer->windows <= 0)
+		    LayerDestroyPixmap (pScreen, pLayer);
+		LayerDestroy (pScreen, pLayer);
+		break;
+	    }
+	}
+	pLayList = pLayWin->u.pLayList;
+	if (!pLayList)
+	{
+	    /*
+	     * List is empty, set isList back to false
+	     */
+	    pLayWin->isList = FALSE;
+	    pLayWin->u.pLayer = 0;
+	}
+	else if (!pLayList->pNext && pLayList->inheritClip)
+	{
+	    /*
+	     * List contains a single element using the
+	     * window clip, free the list structure and
+	     * host the layer back to the window private
+	     */
+	    pLayer = pLayList->pLayer;
+	    FreeLayerList (pScreen, pLayList);
+	    pLayWin->isList = FALSE;
+	    pLayWin->u.pLayer = pLayer;
+	}
+    }
+    else
+    {
+	if (pLayWin->u.pLayer == pLayer)
+	{
+	    --pLayer->windows;
+	    if (pLayer->windows <= 0)
+		LayerDestroyPixmap (pScreen, pLayer);
+	    LayerDestroy (pScreen, pLayer);
+	    pLayWin->u.pLayer = 0;
+	}
+    }
+    pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+}
+
+/*
+ * Looping primitives for window layering.  Usage:
+ *
+ *  for (pLayer = LayerWindowFirst (pWin, &loop); 
+ *	 pLayer; 
+ *	 pLayer = LayerWindowNext (&loop))
+ *  {
+ *	...
+ *  }
+ *  LayerWindowDone (pWin, &loop);
+ */
+
+LayerPtr
+LayerWindowFirst (WindowPtr pWin, LayerWinLoopPtr pLoop)
+{
+    layerWinPriv (pWin);
+
+    pLoop->pLayWin = pLayWin;
+    if (!pLayWin->isList)
+	return pLayWin->u.pLayer;
+
+    /*
+     * Preserve original state
+     */
+    pLoop->clipList = pWin->clipList;
+    pLoop->borderClip = pWin->borderClip;
+    pLoop->pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin);
+
+    /*
+     * Set initial list element 
+     */
+    pLoop->pLayList = pLayWin->u.pLayList;
+
+    /*
+     * Return first layer
+     */
+    return LayerWindowNext (pWin, pLoop);
+}
+
+LayerPtr
+LayerWindowNext (WindowPtr pWin, LayerWinLoopPtr pLoop)
+{
+    LayerPtr	    pLayer;
+    LayerWinPtr	    pLayWin = pLoop->pLayWin;
+    LayerListPtr    pLayList;
+
+    if (!pLayWin->isList)
+	return 0;
+    
+    pLayList = pLoop->pLayList;
+    pLayer = pLayList->pLayer;
+    /*
+     * Configure window for this layer
+     */
+    (*pWin->drawable.pScreen->SetWindowPixmap) (pWin, pLayer->pPixmap);
+    if (!pLayList->inheritClip)
+    {
+	pWin->clipList = pLayList->clipList;
+	pWin->borderClip = pLayList->borderClip;
+    }
+    /*
+     * Step to next layer list
+     */
+    pLoop->pLayList = pLayList->pNext;
+    /*
+     * Return layer
+     */
+    return pLayer;
+}
+
+void
+LayerWindowDone (WindowPtr pWin, LayerWinLoopPtr pLoop)
+{
+    LayerWinPtr	pLayWin = pLoop->pLayWin;
+
+    if (!pLayWin->isList)
+	return;
+    /*
+     * clean up after the loop
+     */
+    pWin->clipList = pLoop->clipList;
+    pWin->borderClip = pLoop->clipList;
+    (*pWin->drawable.pScreen->SetWindowPixmap) (pWin, pLoop->pPixmap);
+}
+
+Bool
+layerCreateWindow (WindowPtr pWin)
+{
+    ScreenPtr	pScreen = pWin->drawable.pScreen;
+    layerWinPriv(pWin);
+    layerScrPriv(pScreen);
+    LayerPtr	pLayer;
+    Bool	ret;
+
+    pLayWin->isList = FALSE;
+    pLayWin->u.pLayer = 0;
+    
+    /*
+     * input only windows don't live in any layer
+     */
+    if (pWin->drawable.type == UNDRAWABLE_WINDOW)
+	return TRUE;
+    /*
+     * Use a reasonable default layer -- the first
+     * layer matching the windows depth.  Subsystems needing
+     * alternative layering semantics can override this by
+     * replacing this function.  Perhaps a new screen function
+     * could be used to select the correct initial window
+     * layer instead.
+     */
+    for (pLayer = pLayScr->pLayers; pLayer; pLayer = pLayer->pNext)
+	if (pLayer->depth == pWin->drawable.depth)
+	    break;
+    ret = TRUE;
+    if (pLayer)
+    {
+	pScreen->CreateWindow = pLayer->pKind->CreateWindow;
+	ret = (*pScreen->CreateWindow) (pWin);
+	pLayer->pKind->CreateWindow = pScreen->CreateWindow;
+	pScreen->CreateWindow = layerCreateWindow;
+	LayerWindowAdd (pScreen, pLayer, pWin);
+    }
+    return ret;
+}
+
+Bool
+layerDestroyWindow (WindowPtr pWin)
+{
+    ScreenPtr	pScreen = pWin->drawable.pScreen;
+    layerWinPriv(pWin);
+    LayerPtr	pLayer;
+    Bool	ret = TRUE;
+
+    while ((pLayer = layerWinLayer (pLayWin)))
+    {
+	LayerUnwrap (pScreen, pLayer->pKind, DestroyWindow);
+	ret = (*pScreen->DestroyWindow) (pWin);
+	LayerWrap (pScreen, pLayer->pKind, DestroyWindow, layerDestroyWindow);
+	LayerWindowRemove (pWin->drawable.pScreen, pLayer, pWin);
+    }
+    return ret;
+}
+
+Bool
+layerChangeWindowAttributes (WindowPtr pWin, unsigned long mask)
+{
+    ScreenPtr	    pScreen = pWin->drawable.pScreen;
+    LayerPtr	    pLay;
+    LayerWinLoopRec loop;
+    Bool	    ret = TRUE;
+
+    for (pLay = LayerWindowFirst (pWin, &loop);
+	 pLay;
+	 pLay = LayerWindowNext (pWin, &loop))
+    {
+	LayerUnwrap(pScreen,pLay->pKind,ChangeWindowAttributes);
+	if (!(*pScreen->ChangeWindowAttributes) (pWin, mask))
+	    ret = FALSE;
+	LayerWrap(pScreen,pLay->pKind,ChangeWindowAttributes,layerChangeWindowAttributes);
+    }
+    LayerWindowDone (pWin, &loop);
+    return ret;
+}
+
+void
+layerPaintWindowBackground (WindowPtr pWin, RegionPtr pRegion, int what)
+{
+    ScreenPtr	    pScreen = pWin->drawable.pScreen;
+    LayerPtr	    pLay;
+    LayerWinLoopRec loop;
+
+    for (pLay = LayerWindowFirst (pWin, &loop);
+	 pLay;
+	 pLay = LayerWindowNext (pWin, &loop))
+    {
+	LayerUnwrap(pScreen,pLay->pKind,PaintWindowBackground);
+	(*pScreen->PaintWindowBackground) (pWin, pRegion, what);
+	LayerWrap(pScreen,pLay->pKind,PaintWindowBackground,layerPaintWindowBackground);
+    }
+    LayerWindowDone (pWin, &loop);
+}
+
+void
+layerPaintWindowBorder (WindowPtr pWin, RegionPtr pRegion, int what)
+{
+    ScreenPtr	    pScreen = pWin->drawable.pScreen;
+    LayerPtr	    pLay;
+    LayerWinLoopRec loop;
+
+    for (pLay = LayerWindowFirst (pWin, &loop);
+	 pLay;
+	 pLay = LayerWindowNext (pWin, &loop))
+    {
+	LayerUnwrap(pScreen,pLay->pKind,PaintWindowBorder);
+	(*pScreen->PaintWindowBorder) (pWin, pRegion, what);
+	LayerWrap(pScreen,pLay->pKind,PaintWindowBorder,layerPaintWindowBorder);
+    }
+    LayerWindowDone (pWin, &loop);
+}
+
+void
+layerCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
+{
+    ScreenPtr	    pScreen = pWin->drawable.pScreen;
+    LayerPtr	    pLay;
+    LayerWinLoopRec loop;
+    int		    dx = 0, dy = 0;
+
+    for (pLay = LayerWindowFirst (pWin, &loop);
+	 pLay;
+	 pLay = LayerWindowNext (pWin, &loop))
+    {
+	LayerUnwrap(pScreen,pLay->pKind,CopyWindow);
+	/*
+	 * Undo the translation done within the last CopyWindow proc (sigh)
+	 */
+	if (dx || dy)
+	    REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, dx, dy);
+	(*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
+	LayerWrap(pScreen,pLay->pKind,CopyWindow,layerCopyWindow);
+	/*
+	 * Save offset to undo translation next time around
+	 */
+	dx = ptOldOrg.x - pWin->drawable.x;
+	dy = ptOldOrg.y - pWin->drawable.y;
+    }
+    LayerWindowDone (pWin, &loop);
+}
+
+PixmapPtr
+layerCreatePixmap (ScreenPtr pScreen, int width, int height, int depth)
+{
+    /* XXX assume the first layer can handle all pixmaps */
+    layerScrPriv (pScreen);
+    LayerKindPtr    pKind;
+    PixmapPtr	    pPixmap;
+    
+    pKind = &pLayScr->kinds[0];
+    if (pLayScr->pLayers)
+	pKind = pLayScr->pLayers->pKind;
+    LayerUnwrap (pScreen, pKind, CreatePixmap);
+    pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, depth);
+    LayerWrap (pScreen,pKind,CreatePixmap,layerCreatePixmap);
+    return pPixmap;
+}
+
+Bool
+layerDestroyPixmap (PixmapPtr pPixmap)
+{
+    /* XXX assume the first layer can handle all pixmaps */
+    ScreenPtr	    pScreen = pPixmap->drawable.pScreen;
+    layerScrPriv (pScreen);
+    LayerKindPtr    pKind;
+    Bool	    ret;
+    
+    pKind = &pLayScr->kinds[0];
+    if (pLayScr->pLayers)
+	pKind = pLayScr->pLayers->pKind;
+    LayerUnwrap (pScreen, pKind, DestroyPixmap);
+    ret = (*pScreen->DestroyPixmap) (pPixmap);
+    LayerWrap (pScreen,pKind,DestroyPixmap,layerDestroyPixmap);
+    return ret;
+}
+
diff --git a/nx-X11/programs/Xserver/miext/layer/laymodule.c b/nx-X11/programs/Xserver/miext/layer/laymodule.c
new file mode 100644
index 000000000..5af41617a
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/layer/laymodule.c
@@ -0,0 +1,60 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#ifdef XFree86LOADER
+
+#include "xf86Module.h"
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include "layer.h"
+
+static XF86ModuleVersionInfo VersRec =
+{
+	"layer",
+	MODULEVENDORSTRING,
+	MODINFOSTRING1,
+	MODINFOSTRING2,
+	XORG_VERSION_CURRENT,
+	1, 0, 0,
+	ABI_CLASS_ANSIC,		/* Only need the ansic layer */
+	ABI_ANSIC_VERSION,
+	MOD_CLASS_NONE,
+	{0,0,0,0}       /* signature, to be patched into the file by a tool */
+};
+
+XF86ModuleData layerModuleData = { &VersRec, NULL, NULL };
+
+#endif
diff --git a/nx-X11/programs/Xserver/miext/rootless/Imakefile b/nx-X11/programs/Xserver/miext/rootless/Imakefile
new file mode 100644
index 000000000..2a2bbb2c8
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/Imakefile
@@ -0,0 +1,54 @@
+XCOMM $XFree86: xc/programs/Xserver/miext/rootless/Imakefile,v 1.2 2003/09/16 00:36:20 torrey Exp $
+
+#include <Server.tmpl>
+
+#ifdef DarwinArchitecture
+#define RootlessSafeAlpha YES
+#define RootlessAcceleration YES
+#elif (defined(XWinServer) && XWinServer) || (defined(NXWinServer) && NXWinServer) || defined(Win32Architecture)
+#define RootlessSafeAlpha YES
+#define RootlessAcceleration YES
+#else
+#define RootlessSafeAlpha NO
+#define RootlessAcceleration NO
+#endif
+
+#if RootlessSafeAlpha || RootlessAcceleration
+#define IHaveSubdirs
+#endif
+
+#if RootlessSafeAlpha
+ALPHADIRS = safeAlpha
+#endif
+
+#if RootlessAcceleration
+ACCELDIRS = accel
+#endif
+
+SRCS =  rootlessCommon.c \
+        rootlessScreen.c \
+        rootlessWindow.c \
+        rootlessGC.c \
+        rootlessValTree.c
+
+OBJS =  rootlessCommon.o \
+        rootlessScreen.o \
+        rootlessWindow.o \
+        rootlessGC.o \
+        rootlessValTree.o
+
+INCLUDES = -I. -I$(SERVERSRC)/fb -I$(SERVERSRC)/mi -I$(SERVERSRC)/include \
+           -I$(XINCLUDESRC) -I$(FONTINCSRC) -I$(SERVERSRC)/render \
+           -I$(EXTINCSRC) -I$(ACCELDIRS)
+
+NormalLibraryObjectRule()
+LibraryModuleTarget(rootless,$(OBJS))
+
+DependTarget()
+
+SUBDIRS = $(ALPHADIRS) $(ACCELDIRS)
+
+#if RootlessSafeAlpha || RootlessAcceleration
+MakeSubdirs($(SUBDIRS))
+DependSubdirs($(SUBDIRS))
+#endif
diff --git a/nx-X11/programs/Xserver/miext/rootless/Imakefile.NX.original b/nx-X11/programs/Xserver/miext/rootless/Imakefile.NX.original
new file mode 100644
index 000000000..2a2bbb2c8
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/Imakefile.NX.original
@@ -0,0 +1,54 @@
+XCOMM $XFree86: xc/programs/Xserver/miext/rootless/Imakefile,v 1.2 2003/09/16 00:36:20 torrey Exp $
+
+#include <Server.tmpl>
+
+#ifdef DarwinArchitecture
+#define RootlessSafeAlpha YES
+#define RootlessAcceleration YES
+#elif (defined(XWinServer) && XWinServer) || (defined(NXWinServer) && NXWinServer) || defined(Win32Architecture)
+#define RootlessSafeAlpha YES
+#define RootlessAcceleration YES
+#else
+#define RootlessSafeAlpha NO
+#define RootlessAcceleration NO
+#endif
+
+#if RootlessSafeAlpha || RootlessAcceleration
+#define IHaveSubdirs
+#endif
+
+#if RootlessSafeAlpha
+ALPHADIRS = safeAlpha
+#endif
+
+#if RootlessAcceleration
+ACCELDIRS = accel
+#endif
+
+SRCS =  rootlessCommon.c \
+        rootlessScreen.c \
+        rootlessWindow.c \
+        rootlessGC.c \
+        rootlessValTree.c
+
+OBJS =  rootlessCommon.o \
+        rootlessScreen.o \
+        rootlessWindow.o \
+        rootlessGC.o \
+        rootlessValTree.o
+
+INCLUDES = -I. -I$(SERVERSRC)/fb -I$(SERVERSRC)/mi -I$(SERVERSRC)/include \
+           -I$(XINCLUDESRC) -I$(FONTINCSRC) -I$(SERVERSRC)/render \
+           -I$(EXTINCSRC) -I$(ACCELDIRS)
+
+NormalLibraryObjectRule()
+LibraryModuleTarget(rootless,$(OBJS))
+
+DependTarget()
+
+SUBDIRS = $(ALPHADIRS) $(ACCELDIRS)
+
+#if RootlessSafeAlpha || RootlessAcceleration
+MakeSubdirs($(SUBDIRS))
+DependSubdirs($(SUBDIRS))
+#endif
diff --git a/nx-X11/programs/Xserver/miext/rootless/Imakefile.X.original b/nx-X11/programs/Xserver/miext/rootless/Imakefile.X.original
new file mode 100644
index 000000000..2d6066f41
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/Imakefile.X.original
@@ -0,0 +1,54 @@
+XCOMM $XFree86: xc/programs/Xserver/miext/rootless/Imakefile,v 1.2 2003/09/16 00:36:20 torrey Exp $
+
+#include <Server.tmpl>
+
+#ifdef DarwinArchitecture
+#define RootlessSafeAlpha YES
+#define RootlessAcceleration YES
+#elif (defined(XWinServer) && XWinServer) || defined(Win32Architecture)
+#define RootlessSafeAlpha YES
+#define RootlessAcceleration YES
+#else
+#define RootlessSafeAlpha NO
+#define RootlessAcceleration NO
+#endif
+
+#if RootlessSafeAlpha || RootlessAcceleration
+#define IHaveSubdirs
+#endif
+
+#if RootlessSafeAlpha
+ALPHADIRS = safeAlpha
+#endif
+
+#if RootlessAcceleration
+ACCELDIRS = accel
+#endif
+
+SRCS =  rootlessCommon.c \
+        rootlessScreen.c \
+        rootlessWindow.c \
+        rootlessGC.c \
+        rootlessValTree.c
+
+OBJS =  rootlessCommon.o \
+        rootlessScreen.o \
+        rootlessWindow.o \
+        rootlessGC.o \
+        rootlessValTree.o
+
+INCLUDES = -I. -I$(SERVERSRC)/fb -I$(SERVERSRC)/mi -I$(SERVERSRC)/include \
+           -I$(XINCLUDESRC) -I$(FONTINCSRC) -I$(SERVERSRC)/render \
+           -I$(EXTINCSRC) -I$(ACCELDIRS)
+
+NormalLibraryObjectRule()
+LibraryModuleTarget(rootless,$(OBJS))
+
+DependTarget()
+
+SUBDIRS = $(ALPHADIRS) $(ACCELDIRS)
+
+#if RootlessSafeAlpha || RootlessAcceleration
+MakeSubdirs($(SUBDIRS))
+DependSubdirs($(SUBDIRS))
+#endif
diff --git a/nx-X11/programs/Xserver/miext/rootless/README.txt b/nx-X11/programs/Xserver/miext/rootless/README.txt
new file mode 100644
index 000000000..ffd17902f
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/README.txt
@@ -0,0 +1,403 @@
+                            Generic Rootless Layer
+                                 Version 1.0
+                                July 13, 2004
+
+                               Torrey T. Lyons
+                              torrey@xfree86.org
+
+
+Introduction
+
+        The generic rootless layer allows an X server to be implemented 
+on top of another window server in a cooperative manner. This allows the 
+X11 windows and native windows of the underlying window server to 
+coexist on the same screen. The layer is called "rootless" because the root 
+window of the X server is generally not drawn. Instead, each top-level 
+child of the root window is represented as a separate on-screen window by 
+the underlying window server. The layer is referred to as "generic" 
+because it abstracts away the details of the underlying window system and 
+contains code that is useful for any rootless X server. The code for the 
+generic rootless layer is located in xc/programs/Xserver/miext/rootless. To 
+build a complete rootless X server requires a specific rootless 
+implementation, which provides functions that allow the generic rootless 
+layer to interact with the underlying window system.
+
+
+Concepts
+
+        In the context of a rootless X server the term window is used to 
+mean many fundamentally different things. For X11 a window is a DDX 
+resource that describes a visible, or potentially visible, rectangle on the 
+screen. A top-level window is a direct child of the root window. To avoid 
+confusion, an on-screen native window of the underlying window system 
+is referred to as a "frame". The generic rootless layer associates each 
+mapped top-level X11 window with a frame. An X11 window may be said 
+to be "framed" if it or its top-level parent is represented by a frame.
+
+        The generic rootless layer models each frame as being backed at 
+all times by a backing buffer, which is periodically flushed to the screen. 
+If the underlying window system does not provide a backing buffer for 
+frames, this must be done by the rootless implementation. The generic 
+rootless layer model does not assume it always has access to the frames' 
+backing buffers. Any drawing to the buffer will be proceeded by a call to 
+the rootless implementation's StartDrawing() function and StopDrawing() 
+will be called when the drawing is concluded. The address of the frame's 
+backing buffer is returned by the StartDrawing() function and it can 
+change between successive calls.
+
+        Because each frame is assumed to have a backing buffer, the 
+generic rootless layer will stop Expose events being generated when the 
+regions of visibility of a frame change on screen. This is similar to backing 
+store, but backing buffers are different in that they always store a copy of 
+the entire window contents, not just the obscured portions. The price paid 
+in increased memory consumption is made up by the greatly decreased 
+complexity in not having to track and record regions as they are obscured.
+
+
+Rootless Implementation
+
+        The specifics of the underlying window system are provided to the 
+generic rootless layer through rootless implementation functions, compile-
+time options, and runtime parameters. The rootless implementation 
+functions are a list of functions that allow the generic rootless layer to 
+perform operations such as creating, destroying, moving, and resizing 
+frames. Some of the implementation functions are optional. A detailed 
+description of the rootless implementation functions is provided in 
+Appendix A.
+
+        By design, a rootless implementation should only have to include 
+the rootless.h header file. The rootlessCommon.h file contains definitions 
+internal to the generic rootless layer. (If you find you need to use 
+rootlessCommon.h in your implementation, let the generic rootless layer 
+maintainers know. This could be an area where the generic rootless layer 
+should be generalized.) A rootless implementation should also modify 
+rootlessConfig.h to specify compile time options for its platform.
+
+        The following compile-time options are defined in 
+rootlessConfig.h:
+
+      o ROOTLESS_ACCEL: If true, use the optional rootless acceleration
+        functions where possible to a accelerate X11 drawing primitives.
+        If false, all drawing will be done with fb.
+
+      o ROOTLESS_GLOBAL_COORDS: This option controls the way that frame
+        coordinates are passed to the rootless implementation. If false,
+        the coordinates are passed per screen relative to the origin of 
+        the screen the frame is currently on. Some implementations may 
+        prefer to work in a single global coordinate space that spans all 
+        screens. If this option is true, the coordinates are passed after 
+        adding the coordinates of the screen origin and an overall offset of 
+        (rootlessGlobalOffsetX, rootlessGlobalOffsetY).
+
+      o ROOTLESS_PROTECT_ALPHA: By default for a color bit depth of 24 and
+        32 bits per pixel, fb will overwrite the "unused" 8 bits to optimize
+        drawing speed. If this is true, the alpha channel of frames is
+        protected and is not modified when drawing to them. The bits 
+        containing the alpha channel are defined by the macro 
+        RootlessAlphaMask(bpp), which should return a bit mask for 
+        various bits per pixel.
+
+      o ROOTLESS_REDISPLAY_DELAY: Time in milliseconds between updates to
+        the underlying window server. Most operations will be buffered until
+        this time has expired.
+
+      o ROOTLESS_RESIZE_GRAVITY: If the underlying window system supports it,
+        some frame resizes can be optimized by relying on the frame contents
+        maintaining a particular gravity during the resize. In this way less
+        of the frame contents need to be preserved by the generic rootless
+        layer. If true, the generic rootless layer will pass gravity hints
+        during resizing and rely on the frame contents being preserved
+        accordingly.
+
+      o ROOTLESS_TRACK_DAMAGE: The generic rootless layer draws to the
+        frames' backing buffers and periodically flushes the modified
+        regions to the underlying window server. If this option is true,
+        the generic rootless layer will track these damaged regions. 
+        Currently it uses the miRegion code and will not simplify damaged 
+        regions even when updating a bounding region would be more 
+        efficient. Some window systems provide a more efficient way to 
+        track damaged regions. If this option is false, the rootless 
+        implementation function DamageRects() is called whenever a 
+        backing buffer is modified and the rootless implementation is 
+        expected to track the damaged regions itself.
+
+        The following runtime options are defined in rootless.h:
+
+      o rootlessGlobalOffsetX, rootlessGlobalOffsetY: These are only 
+        used if ROOTLESS_GLOBAL_COORDS is true. They specify the global
+        offset that is applied to all screens when converting from
+        screen-local to global coordinates.
+
+      o rootless_CopyBytes_threshold, rootless_FillBytes_threshold, 
+        rootless_CompositePixels_threshold, rootless_CopyWindow_threshold:
+        The minimum number of bytes or pixels for which to use the rootless
+        implementation's respective acceleration function. The rootless
+        acceleration functions are all optional so these will only be used
+        if the respective acceleration function pointer is not NULL.
+
+
+Accelerated Drawing
+
+	The rootless implementation typically does not have direct access 
+to the hardware. Its access to the graphics hardware is generally through 
+the API of the underlying window system. This underlying API may not 
+overlap well with the X11 drawing primitives. The generic rootless layer 
+falls back to using fb for all its 2-D drawing. Providing optional rootless 
+implementation acceleration functions can accelerate some graphics 
+primitives and some window functions. Typically calling through to the 
+underlying window systems API will not speed up these operations for 
+small enough areas. The rootless_*_threshold runtime options allow the 
+rootless implementation to provide hints for when the acceleration 
+functions should be used instead of fb.
+
+
+Alpha Channel Protection
+
+	If the bits per pixel is greater then the color bit depth, the contents 
+of the extra bits are undefined by the X11 protocol. Some window systems 
+will use these extra bits as an alpha channel. The generic rootless layer can 
+be configured to protect these bits and make sure they are not modified by 
+other parts of the X server. To protect the alpha channel 
+ROOTLESS_PROTECT_ALPHA and RootlessAlphaMask(bpp) must be 
+set appropriately as described under the compile time options. This 
+ensures that the X11 graphics primitives do not overwrite the alpha 
+channel in an attempt to optimize drawing. In addition, the window 
+functions PaintWindow() and Composite() must be replaced by alpha 
+channel safe variants. These are provided in rootless/safeAlpha.
+
+
+Credits
+
+	The generic rootless layer was originally conceived and developed 
+by Greg Parker as part of the XDarwin X server on Mac OS X. John 
+Harper made later optimizations to this code but removed its generic 
+independence of the underlying window system. Torrey T. Lyons 
+reintroduced the generic abstractions and made the rootless code suitable 
+for use by other X servers.
+
+
+Appendix A: Rootless Implementation Functions
+
+	The rootless implementation functions are defined in rootless.h. It 
+is intended that rootless.h contains the complete interface that is needed by 
+rootless implementations. The definitions contained in rootlessCommon.h 
+are intended for internal use by the generic rootless layer and are more 
+likely to change.
+
+	Most of these functions take a RootlessFrameID as a parameter. 
+The RootlessFrameID is an opaque object that is returned by the 
+implementation's CreateFrame() function. The generic rootless layer does 
+not use this frame id other than to pass it back to the rootless 
+implementation to indicate the frame to operate on.
+
+/*
+ * 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-local
+ *              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);
+
diff --git a/nx-X11/programs/Xserver/miext/rootless/accel/Imakefile b/nx-X11/programs/Xserver/miext/rootless/accel/Imakefile
new file mode 100644
index 000000000..a3dabe64b
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/Imakefile
@@ -0,0 +1,30 @@
+XCOMM $XFree86: xc/programs/Xserver/miext/rootless/safeAlpha/Imakefile,v 1.1 2003/09/16 00:36:20 torrey Exp $
+
+#include <Server.tmpl>
+
+SRCS =  rlAccel.c \
+        rlBlt.c \
+        rlCopy.c \
+        rlFill.c \
+        rlFillRect.c \
+        rlFillSpans.c \
+        rlGlyph.c \
+        rlSolid.c
+
+OBJS =  rlAccel.o \
+        rlBlt.o \
+        rlCopy.o \
+        rlFill.o \
+        rlFillRect.o \
+        rlFillSpans.o \
+        rlGlyph.o \
+        rlSolid.o
+
+INCLUDES = -I. -I$(SERVERSRC)/fb -I$(SERVERSRC)/mi -I$(SERVERSRC)/include \
+           -I$(XINCLUDESRC) -I$(FONTINCSRC) -I$(SERVERSRC)/render \
+           -I$(EXTINCSRC) -I$(SERVERSRC)/Xext -I..
+
+NormalLibraryObjectRule()
+LibraryModuleTarget(rlAccel,$(OBJS))
+
+DependTarget()
diff --git a/nx-X11/programs/Xserver/miext/rootless/accel/rlAccel.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlAccel.c
new file mode 100644
index 000000000..9977c9e4a
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlAccel.c
@@ -0,0 +1,155 @@
+/*
+ * Support for accelerated rootless code
+ */
+/*
+ * Copyright (c) 2004 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.
+ */
+/* $XdotOrg: xc/programs/Xserver/miext/rootless/accel/rlAccel.c,v 1.5 2005/07/03 07:02:03 daniels Exp $ */
+
+/*
+ * The accelerated rootless code replaces some GC operations from fb with
+ * versions that call the rootless acceleration functions where appropriate.
+ * To work properly, this must be wrapped directly on top of fb. Nothing
+ * underneath this layer besides fb will get called.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "rootless.h"
+#include "rlAccel.h"
+
+typedef struct _rlAccelScreenRec {
+    CreateGCProcPtr CreateGC;
+    CloseScreenProcPtr CloseScreen;
+} rlAccelScreenRec, *rlAccelScreenPtr;
+
+static int rlAccelScreenPrivateIndex = -1;
+
+#define RLACCELREC(pScreen) \
+   ((rlAccelScreenRec *)(pScreen)->devPrivates[rlAccelScreenPrivateIndex].ptr)
+
+/* This is mostly identical to fbGCOps. */
+static GCOps rlAccelOps = {
+    rlFillSpans,
+    fbSetSpans,
+    fbPutImage,
+    rlCopyArea,
+    fbCopyPlane,
+    fbPolyPoint,
+    fbPolyLine,
+    fbPolySegment,
+    fbPolyRectangle,
+    fbPolyArc,
+    miFillPolygon,
+    rlPolyFillRect,
+    fbPolyFillArc,
+    miPolyText8,
+    miPolyText16,
+    miImageText8,
+    miImageText16,
+    rlImageGlyphBlt,
+    fbPolyGlyphBlt,
+    fbPushPixels
+#ifdef NEED_LINEHELPER
+    ,NULL
+#endif
+};
+
+
+/*
+ * Screen function to create a graphics context
+ */
+static Bool
+rlCreateGC(GCPtr pGC)
+{
+    ScreenPtr pScreen = pGC->pScreen;
+    rlAccelScreenRec *s = RLACCELREC(pScreen);
+    Bool result;
+
+    // Unwrap and call
+    pScreen->CreateGC = s->CreateGC;
+    result = s->CreateGC(pGC);
+
+    // Accelerated GC ops replace some fb GC ops
+    pGC->ops = &rlAccelOps;
+
+    // Rewrap
+    s->CreateGC = pScreen->CreateGC;
+    pScreen->CreateGC = rlCreateGC;
+
+    return result;
+}
+
+
+/*
+ * Clean up when closing a screen on server reset
+ */
+static Bool
+rlCloseScreen (int iScreen, ScreenPtr pScreen)
+{
+    rlAccelScreenRec *s = RLACCELREC(pScreen);
+    Bool result;
+
+    // Unwrap
+    pScreen->CloseScreen = s->CloseScreen;
+    result = pScreen->CloseScreen(iScreen, pScreen);
+
+    xfree(s);
+
+    return result;
+}
+
+
+/*
+ * RootlessAccelInit
+ *  Called by the rootless implementation to initialize accelerated
+ *  rootless drawing.
+ */
+Bool
+RootlessAccelInit(ScreenPtr pScreen)
+{
+    static unsigned long rlAccelGeneration = 0;
+    rlAccelScreenRec *s;
+
+    if (rlAccelGeneration != serverGeneration) {
+        rlAccelScreenPrivateIndex = AllocateScreenPrivateIndex();
+        if (rlAccelScreenPrivateIndex == -1) return FALSE;
+        rlAccelGeneration = serverGeneration;
+    }
+
+    s = xalloc(sizeof(rlAccelScreenRec));
+    if (!s) return FALSE;
+    RLACCELREC(pScreen) = s;
+
+    // Wrap the screen functions we need
+    s->CreateGC = pScreen->CreateGC;
+    pScreen->CreateGC = rlCreateGC;
+    s->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = rlCloseScreen;
+
+    return TRUE;
+}
diff --git a/nx-X11/programs/Xserver/miext/rootless/accel/rlAccel.h b/nx-X11/programs/Xserver/miext/rootless/accel/rlAccel.h
new file mode 100644
index 000000000..a4402bdf2
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlAccel.h
@@ -0,0 +1,141 @@
+/*
+ * 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/rootlessCommon.c,v 1.4 2003/10/18 00:00:34 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "fb.h"
+
+/*
+ * 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/nx-X11/programs/Xserver/miext/rootless/accel/rlBlt.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlBlt.c
new file mode 100644
index 000000000..e5fa5f7bd
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlBlt.c
@@ -0,0 +1,370 @@
+/*
+ * 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/fb/fbblt.c,v 1.8 2000/09/28 00:47:22 keithp Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/accel/rlCopy.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlCopy.c
new file mode 100644
index 000000000..ccea7fbd3
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlCopy.c
@@ -0,0 +1,107 @@
+/*
+ * 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/fb/fbcopy.c,v 1.12 2001/07/16 05:04:05 keithp Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/accel/rlFill.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlFill.c
new file mode 100644
index 000000000..a6ed2fbbb
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlFill.c
@@ -0,0 +1,221 @@
+/*
+ * 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/fb/fbfill.c,v 1.6 2003/01/31 00:01:45 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/accel/rlFillRect.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlFillRect.c
new file mode 100644
index 000000000..e4bab4f53
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlFillRect.c
@@ -0,0 +1,118 @@
+/*
+ * 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/fb/fbfillrect.c,v 1.2 2000/02/23 20:29:43 dawes Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/accel/rlFillSpans.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlFillSpans.c
new file mode 100644
index 000000000..9942d70e4
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlFillSpans.c
@@ -0,0 +1,106 @@
+/*
+ * 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/fb/fbfillsp.c,v 1.2 2000/02/23 20:29:43 dawes Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/accel/rlGlyph.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlGlyph.c
new file mode 100644
index 000000000..3f1571963
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlGlyph.c
@@ -0,0 +1,170 @@
+/*
+ * 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/fb/fbglyph.c,v 1.12 2001/09/07 15:16:00 keithp Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "fb.h"
+#include <X11/fonts/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/nx-X11/programs/Xserver/miext/rootless/accel/rlSolid.c b/nx-X11/programs/Xserver/miext/rootless/accel/rlSolid.c
new file mode 100644
index 000000000..edce3d2c4
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/accel/rlSolid.c
@@ -0,0 +1,112 @@
+/*
+ * 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/fb/fbsolid.c,v 1.8 2001/10/28 03:33:08 tsi Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/rootless.h b/nx-X11/programs/Xserver/miext/rootless/rootless.h
new file mode 100644
index 000000000..dec0e2c64
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootless.h
@@ -0,0 +1,436 @@
+/*
+ * 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.7 2004/07/02 01:30:33 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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);
+
+/*
+ * Check if window should be reordered. (Optional)
+ *  The underlying window system may animate windows being ordered in.
+ *  We want them to be mapped but remain ordered out until the animation
+ *  completes. If defined this function will be called to check if a
+ *  framed window should be reordered now. If this function returns
+ *  FALSE, the window will still be mapped from the X11 perspective, but
+ *  the RestackFrame function will not be called for its frame.
+ *
+ *  pFrame      Frame to reorder
+ */
+typedef Bool (*RootlessDoReorderWindowProc)
+    (RootlessWindowPtr pFrame);
+
+/*
+ * 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;
+    RootlessDoReorderWindowProc DoReorderWindow;
+
+    /* 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);
+
+/*
+ * Initialize acceleration for rootless mode on a given screen.
+ *  Note: RootlessAccelInit() must be called before DamageSetup()
+ *  and RootlessInit() must be called afterwards.
+ */
+Bool RootlessAccelInit(ScreenPtr pScreen);
+
+/*
+ * 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);
+
+/*
+ * Alocate a new screen pixmap.
+ *  miCreateScreenResources does not do this properly with a null
+ *  framebuffer pointer.
+ */
+void RootlessUpdateScreenPixmap(ScreenPtr pScreen);
+
+/*
+ * Reposition all windows on a screen to their correct positions.
+ */
+void RootlessRepositionWindows(ScreenPtr pScreen);
+
+#endif /* _ROOTLESS_H */
diff --git a/nx-X11/programs/Xserver/miext/rootless/rootlessCommon.c b/nx-X11/programs/Xserver/miext/rootless/rootlessCommon.c
new file mode 100644
index 000000000..33321105e
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessCommon.c
@@ -0,0 +1,405 @@
+/*
+ * 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.6 2004/07/02 01:30:33 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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
+}
+
+
+/*
+ * RootlessRepositionWindows
+ *  Reposition all windows on a screen to their correct positions.
+ */
+void
+RootlessRepositionWindows(ScreenPtr pScreen)
+{
+    WindowPtr root = WindowTable[pScreen->myNum];
+    WindowPtr win;
+
+    if (root != NULL) {
+        RootlessRepositionWindow(root);
+
+        for (win = root->firstChild; win; win = win->nextSib) {
+            if (WINREC(win) != NULL)
+                RootlessRepositionWindow(win);
+        }
+    }
+}
+
+
+/*
+ * 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/nx-X11/programs/Xserver/miext/rootless/rootlessCommon.h b/nx-X11/programs/Xserver/miext/rootless/rootlessCommon.h
new file mode 100644
index 000000000..beb1fd666
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessCommon.h
@@ -0,0 +1,261 @@
+/*
+ * Common internal rootless definitions and code
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2004 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.5 2004/07/02 01:30:33 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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 a window to its proper location on the screen.
+void RootlessRepositionWindow(WindowPtr pWin);
+
+// Move the window to it's correct place in the physical stacking order.
+void RootlessReorderWindow(WindowPtr pWin);
+
+#endif /* _ROOTLESSCOMMON_H */
diff --git a/nx-X11/programs/Xserver/miext/rootless/rootlessConfig.h b/nx-X11/programs/Xserver/miext/rootless/rootlessConfig.h
new file mode 100644
index 000000000..eabbaef43
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessConfig.h
@@ -0,0 +1,68 @@
+/*
+ * 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.1 2003/04/15 01:05:44 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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__ */
+
+#if defined(__CYGWIN__) || defined(WIN32)
+
+# define ROOTLESS_ACCEL YES
+# define ROOTLESS_GLOBAL_COORDS TRUE
+# define ROOTLESS_PROTECT_ALPHA NO
+# define ROOTLESS_REDISPLAY_DELAY 10
+# undef  ROOTLESS_RESIZE_GRAVITY
+# undef  ROOTLESS_TRACK_DAMAGE
+/*# define ROOTLESSDEBUG*/
+
+# define RootlessAlphaMask(bpp) ((bpp) == 32 ? 0xFF000000 : 0)
+
+#endif /* __CYGWIN__ */
+
+#endif /* _ROOTLESSCONFIG_H */
diff --git a/nx-X11/programs/Xserver/miext/rootless/rootlessGC.c b/nx-X11/programs/Xserver/miext/rootless/rootlessGC.c
new file mode 100644
index 000000000..61987addb
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessGC.c
@@ -0,0 +1,1508 @@
+/*
+ * 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.1 2003/04/15 01:05:44 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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"
+
+
+// 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 (canAccelxxx(..) && 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);
+
+    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/nx-X11/programs/Xserver/miext/rootless/rootlessScreen.c b/nx-X11/programs/Xserver/miext/rootless/rootlessScreen.c
new file mode 100644
index 000000000..6b7697383
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessScreen.c
@@ -0,0 +1,670 @@
+/*
+ * 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.2 2003/04/30 23:15:35 torrey Exp $ */
+
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/rootlessValTree.c b/nx-X11/programs/Xserver/miext/rootless/rootlessValTree.c
new file mode 100644
index 000000000..2717ddf6f
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessValTree.c
@@ -0,0 +1,648 @@
+/*
+ * 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.1tsi 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) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.
+
+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.
+
+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
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL 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 Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+
+******************************************************************/
+ /* 
+  * 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
+  */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/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/nx-X11/programs/Xserver/miext/rootless/rootlessWindow.c b/nx-X11/programs/Xserver/miext/rootless/rootlessWindow.c
new file mode 100644
index 000000000..6eb66501d
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessWindow.c
@@ -0,0 +1,1468 @@
+/* $XdotOrg: xc/programs/Xserver/miext/rootless/rootlessWindow.c,v 1.6 2005/07/03 07:02:02 daniels Exp $ */
+/*
+ * Rootless window management
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2004 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.12 2004/07/02 01:30:33 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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 frame associated with the given window 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;
+
+        /* Check if the implementation wants the frame to not be reordered
+           even though the X11 window is restacked. This can be useful if
+           frames are ordered-in with animation so that the reordering is not
+           done until the animation is complete. */
+        if (SCREENREC(pScreen)->imp->DoReorderWindow) {
+            if (!SCREENREC(pScreen)->imp->DoReorderWindow(winRec))
+                return;
+        }
+
+        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);
+    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? */
+
+    RootlessDamageRect(pWin, -newBW, -newBW, newW, newH);
+
+    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");
+}
+
+
+/*
+ * RootlessRepositionWindow
+ *  Called by the implementation when a window needs to be repositioned to
+ *  its correct location on the screen. This routine is typically needed
+ *  due to changes in the underlying window system, such as a screen layout
+ *  change.
+ */
+void
+RootlessRepositionWindow(WindowPtr pWin)
+{
+    RootlessWindowRec *winRec = WINREC(pWin);
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    if (winRec == NULL)
+        return;
+
+    RootlessStopDrawing(pWin, FALSE);
+    SCREENREC(pScreen)->imp->MoveFrame(winRec->wid, pScreen,
+                                       winRec->x + SCREEN_TO_GLOBAL_X,
+                                       winRec->y + SCREEN_TO_GLOBAL_Y);
+
+    RootlessReorderWindow(pWin);
+}
+
+
+/*
+ * 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/nx-X11/programs/Xserver/miext/rootless/rootlessWindow.h b/nx-X11/programs/Xserver/miext/rootless/rootlessWindow.h
new file mode 100644
index 000000000..9cceed347
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/rootlessWindow.h
@@ -0,0 +1,64 @@
+/*
+ * 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.1 2003/04/15 01:05:44 torrey Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/miext/rootless/safeAlpha/Imakefile b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/Imakefile
new file mode 100644
index 000000000..bb14bb146
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/Imakefile
@@ -0,0 +1,18 @@
+XCOMM $XFree86: xc/programs/Xserver/miext/rootless/Imakefile,v 1.1 2003/04/15 01:05:44 torrey Exp $
+
+#include <Server.tmpl>
+
+SRCS =  safeAlphaPicture.c \
+        safeAlphaWindow.c
+
+OBJS =  safeAlphaPicture.o \
+        safeAlphaWindow.o
+
+   INCLUDES = -I. -I$(SERVERSRC)/fb -I$(SERVERSRC)/mi -I$(SERVERSRC)/include \
+              -I$(XINCLUDESRC) -I$(FONTINCSRC) -I$(SERVERSRC)/render \
+              -I$(EXTINCSRC) -I$(SERVERSRC)/Xext -I..
+
+NormalLibraryObjectRule()
+LibraryModuleTarget(safeAlpha,$(OBJS))
+
+DependTarget()
diff --git a/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlpha.h b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlpha.h
new file mode 100644
index 000000000..63922aeec
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlpha.h
@@ -0,0 +1,45 @@
+/*
+ * 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"
+
+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/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlphaPicture.c b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlphaPicture.c
new file mode 100644
index 000000000..f73a3b5c1
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlphaPicture.c
@@ -0,0 +1,643 @@
+/*
+ * 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"
+#include "rootlessCommon.h"
+
+# define mod(a,b)	((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b))
+
+
+typedef void	(*CompositeFunc) (CARD8      op,
+				  PicturePtr pSrc,
+				  PicturePtr pMask,
+				  PicturePtr pDst,
+				  INT16      xSrc,
+				  INT16      ySrc,
+				  INT16      xMask,
+                                  INT16      yMask,
+				  INT16      xDst,
+				  INT16      yDst,
+				  CARD16     width,
+				  CARD16     height);
+
+
+/* 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, pDst->format);
+
+    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
+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 = 0;
+    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;
+    int		    oldFormat = pDst->format;
+
+    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;
+    }
+
+
+    /*
+     * 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;
+    }
+    /* For rootless preserve the alpha in x8r8g8b8 which really is
+     * a8r8g8b8
+     */
+    if (oldFormat == PICT_x8r8g8b8)
+    {
+        pDst->format = PICT_a8r8g8b8;
+    }
+
+
+
+    if (!pSrc->transform && !(pMask && pMask->transform))
+    if (!maskAlphaMap && !srcAlphaMap && !dstAlphaMap)
+    switch (op) {
+    case PictOpSrc:
+#ifdef USE_MMX
+	if (!pMask && pSrc->format == pDst->format &&
+	    pSrc->pDrawable != pDst->pDrawable)
+	{
+	    func = fbCompositeCopyAreammx;
+	}
+#endif
+	break;
+    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:
+#ifdef USE_MMX
+			    if (fbHaveMMX())
+				func = fbCompositeSolidMask_nx8x0565mmx;
+			    else
+#endif
+			    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:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSolidMask_nx8888x8888Cmmx;
+				else
+#endif
+				func = fbCompositeSolidMask_nx8888x8888C;
+				break;
+			    case PICT_r5g6b5:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSolidMask_nx8888x0565Cmmx;
+				else
+#endif
+				func = fbCompositeSolidMask_nx8888x0565C;
+				break;
+			    }
+			}
+			break;
+		    case PICT_a8b8g8r8:
+			if (pMask->componentAlpha) {
+			    switch (pDst->format) {
+			    case PICT_a8b8g8r8:
+			    case PICT_x8b8g8r8:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSolidMask_nx8888x8888Cmmx;
+				else
+#endif
+				func = fbCompositeSolidMask_nx8888x8888C;
+				break;
+			    case PICT_b5g6r5:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSolidMask_nx8888x0565Cmmx;
+				else
+#endif
+				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;
+			}
+			break;
+		    }
+		}
+	    }
+	    else /* has mask and non-repeating source */
+	    {
+		if (pSrc->pDrawable == pMask->pDrawable &&
+		    xSrc == xMask && ySrc == yMask &&
+		    !pMask->componentAlpha)
+		{
+		    /* source == mask: non-premultiplied data */
+		    switch (pSrc->format) {
+		    case PICT_x8b8g8r8:
+			switch (pMask->format) {
+			case PICT_a8r8g8b8:
+			case PICT_a8b8g8r8:
+			    switch (pDst->format) {
+			    case PICT_a8r8g8b8:
+			    case PICT_x8r8g8b8:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSrc_8888RevNPx8888mmx;
+#endif
+				break;
+			    case PICT_r5g6b5:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSrc_8888RevNPx0565mmx;
+#endif
+				break;
+			    }
+			    break;
+			}
+			break;
+		    case PICT_x8r8g8b8:
+			switch (pMask->format) {
+			case PICT_a8r8g8b8:
+			case PICT_a8b8g8r8:
+			    switch (pDst->format) {
+			    case PICT_a8b8g8r8:
+			    case PICT_x8b8g8r8:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSrc_8888RevNPx8888mmx;
+#endif
+				break;
+			    case PICT_r5g6b5:
+#ifdef USE_MMX
+				if (fbHaveMMX())
+				    func = fbCompositeSrc_8888RevNPx0565mmx;
+#endif
+				break;
+			    }
+			    break;
+			}
+			break;
+		    }
+		    break;
+	}
+	else
+	{
+		    /* non-repeating source, repeating mask => translucent window */
+		    if (maskRepeat &&
+			pMask->pDrawable->width == 1 &&
+			pMask->pDrawable->height == 1)
+		    {
+			if (pSrc->format == PICT_x8r8g8b8 &&
+			    pDst->format == PICT_x8r8g8b8 &&
+			    pMask->format == PICT_a8)
+			{
+#ifdef USE_MMX
+			    if (fbHaveMMX())
+				func = fbCompositeSrc_8888x8x8888mmx;
+#endif
+			}
+		    }
+		}
+	    }
+	}
+	else /* no mask */
+	{
+	    if (srcRepeat &&
+		pSrc->pDrawable->width == 1 &&
+		pSrc->pDrawable->height == 1)
+	    {
+		/* no mask and repeating source */
+	    switch (pSrc->format) {
+	    case PICT_a8r8g8b8:
+		    switch (pDst->format) {
+		    case PICT_a8r8g8b8:
+	    case PICT_x8r8g8b8:
+#ifdef USE_MMX
+			if (fbHaveMMX())
+			{
+			    srcRepeat = FALSE;
+			    func = fbCompositeSolid_nx8888mmx;
+			}
+#endif
+			break;
+		    case PICT_r5g6b5:
+#ifdef USE_MMX
+			if (fbHaveMMX())
+			{
+			    srcRepeat = FALSE;
+			    func = fbCompositeSolid_nx0565mmx;
+			}
+#endif
+			break;
+		    }
+		    break;
+		}
+	    }
+	    else
+	    {
+		switch (pSrc->format) {
+		case PICT_a8r8g8b8:
+		switch (pDst->format) {
+		case PICT_a8r8g8b8:
+		case PICT_x8r8g8b8:
+#ifdef USE_MMX
+			if (fbHaveMMX())
+			    func = fbCompositeSrc_8888x8888mmx;
+			else
+#endif
+		    func = fbCompositeSrc_8888x8888;
+		    break;
+		case PICT_r8g8b8:
+		    func = fbCompositeSrc_8888x0888;
+		    break;
+		case PICT_r5g6b5:
+		    func = fbCompositeSrc_8888x0565;
+		    break;
+		}
+		break;
+		case PICT_x8r8g8b8:
+		    switch (pDst->format) {
+		    case PICT_a8r8g8b8:
+		    case PICT_x8r8g8b8:
+#ifdef USE_MMX
+			if (fbHaveMMX())
+			    func = fbCompositeCopyAreammx;
+#endif
+			break;
+		    }
+		case PICT_x8b8g8r8:
+		    switch (pDst->format) {
+	    case PICT_a8b8g8r8:
+	    case PICT_x8b8g8r8:
+#ifdef USE_MMX
+			if (fbHaveMMX())
+			    func = fbCompositeCopyAreammx;
+#endif
+			break;
+		    }
+		    break;
+		case PICT_a8b8g8r8:
+		switch (pDst->format) {
+		case PICT_a8b8g8r8:
+		case PICT_x8b8g8r8:
+#ifdef USE_MMX
+			if (fbHaveMMX())
+			    func = fbCompositeSrc_8888x8888mmx;
+			else
+#endif
+		    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:
+#ifdef USE_MMX
+		    if (fbHaveMMX())
+			func = fbCompositeSrcAdd_8888x8888mmx;
+		    else
+#endif
+		    func = fbCompositeSrcAdd_8888x8888;
+		    break;
+		}
+		break;
+	    case PICT_a8b8g8r8:
+		switch (pDst->format) {
+		case PICT_a8b8g8r8:
+#ifdef USE_MMX
+		    if (fbHaveMMX())
+			func = fbCompositeSrcAdd_8888x8888mmx;
+		    else
+#endif
+		    func = fbCompositeSrcAdd_8888x8888;
+		    break;
+		}
+		break;
+	    case PICT_a8:
+		switch (pDst->format) {
+		case PICT_a8:
+#ifdef USE_MMX
+		    if (fbHaveMMX())
+			func = fbCompositeSrcAdd_8000x8000mmx;
+		    else
+#endif
+		    func = fbCompositeSrcAdd_8000x8000;
+		    break;
+		}
+		break;
+	    case PICT_a1:
+		switch (pDst->format) {
+		case PICT_a1:
+		    func = fbCompositeSrcAdd_1000x1000;
+		    break;
+		}
+		break;
+	    }
+	}
+	break;
+    }
+
+    if (!func) {
+        /* no fast path, use the general code */
+        fbCompositeGeneral(op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height);
+        // Reset destination depth and format to their true value
+        pDst->pDrawable->depth = dstDepth;
+        pDst->format = oldFormat;
+        return;
+    }
+
+    if (!miComputeCompositeRegion (&region,
+ 				   pSrc,
+ 				   pMask,
+ 				   pDst,
+ 				   xSrc,
+ 				   ySrc,
+ 				   xMask,
+ 				   yMask,
+ 				   xDst,
+ 				   yDst,
+ 				   width,
+                                   height))
+        return;
+
+    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/format to its true value
+    pDst->pDrawable->depth = dstDepth;
+    pDst->format = oldFormat;
+}
+
+#endif /* RENDER */
diff --git a/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlphaWindow.c b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlphaWindow.c
new file mode 100644
index 000000000..ff812385b
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/safeAlpha/safeAlphaWindow.c
@@ -0,0 +1,175 @@
+/* $XdotOrg: xc/programs/Xserver/miext/rootless/safeAlpha/safeAlphaWindow.c,v 1.4 2005/07/01 22:43:42 daniels Exp $ */
+/*
+ * 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"
+#include "rootlessCommon.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);
+}
diff --git a/nx-X11/programs/Xserver/miext/shadow/Imakefile b/nx-X11/programs/Xserver/miext/shadow/Imakefile
new file mode 100644
index 000000000..fd97ab1cc
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/Imakefile
@@ -0,0 +1,66 @@
+XCOMM $XFree86: xc/programs/Xserver/miext/shadow/Imakefile,v 1.6 2001/07/20 19:25:02 keithp Exp $
+XCOMM 
+XCOMM 
+
+#define IHaveModules
+#include <Server.tmpl>
+
+#if (defined (XFree86Version) || defined(XorgVersion))
+#if DoLoadableServer
+XFMODSRC = shmodule.c
+XFMODOBJ = shmodule.o
+#endif
+#endif
+
+SRCS =  $(XFMODSRC) \
+	shadow.c \
+	shalloc.c \
+	shplanar.c \
+	shplanar8.c \
+	shpacked.c \
+	shrotate.c \
+	shrot8pack_90.c \
+	shrot8pack_180.c \
+	shrot8pack_270.c \
+	shrot16pack_90.c \
+	shrot16pack_180.c \
+	shrot16pack_270.c \
+	shrot32pack_90.c \
+	shrot32pack_180.c \
+	shrot32pack_270.c
+
+OBJS =  $(XFMODOBJ) \
+	shadow.o \
+	shalloc.o \
+	shplanar.o \
+	shplanar8.o \
+	shpacked.o \
+	shrotate.o \
+	shrot8pack_90.o \
+	shrot8pack_180.o \
+	shrot8pack_270.o \
+	shrot16pack_90.o \
+	shrot16pack_180.o \
+	shrot16pack_270.o \
+	shrot32pack_90.o \
+	shrot32pack_180.o \
+	shrot32pack_270.o
+
+   INCLUDES = -I. -I../../mi -I../../fb -I../../include -I$(XINCLUDESRC) \
+	      -I$(FONTINCSRC) -I$(XF86SRC)/common $(EXTRAINCLUDES) \
+	      -I../../render -I$(EXTINCSRC)
+   LINTLIBS = ../../dix/llib-ldix.ln ../../os/llib-los.ln \
+	     ../../mi/llib-lmi.ln
+
+NormalLibraryObjectRule()
+LibraryModuleTarget(shadow,$(OBJS))
+LintLibraryTarget(shadow,$(SRCS))
+
+NormalLintTarget($(SRCS))
+
+InstallLibraryModule(shadow,$(MODULEDIR),.)
+
+DependTarget()
+
+InstallDriverSDKLibraryModule(shadow,$(DRIVERSDKMODULEDIR),.)
+InstallDriverSDKNonExecFile(shadow.h,$(DRIVERSDKINCLUDEDIR))
diff --git a/nx-X11/programs/Xserver/miext/shadow/shadow.c b/nx-X11/programs/Xserver/miext/shadow/shadow.c
new file mode 100644
index 000000000..92cb5e980
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shadow.c
@@ -0,0 +1,1544 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/shadow/shadow.c,v 1.14tsi Exp $
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "shadow.h"
+
+typedef struct _shadowGCPriv {
+    GCOps   *ops;
+    GCFuncs *funcs;
+} shadowGCPrivRec, *shadowGCPrivPtr;
+
+int shadowScrPrivateIndex;
+int shadowGCPrivateIndex;
+int shadowGeneration;
+
+#define shadowGetGCPriv(pGC) \
+    ((shadowGCPrivPtr) (pGC)->devPrivates[shadowGCPrivateIndex].ptr)
+#define shadowGCPriv(pGC) \
+    shadowGCPrivPtr  pGCPriv = shadowGetGCPriv(pGC)
+
+#define wrap(priv, real, mem, func) {\
+    priv->mem = real->mem; \
+    real->mem = func; \
+}
+
+#define unwrap(priv, real, mem) {\
+    real->mem = priv->mem; \
+}
+
+static void
+shadowRedisplay (ScreenPtr pScreen)
+{
+    shadowScrPriv(pScreen);
+    shadowBufPtr    pBuf;
+
+    for (pBuf = pScrPriv->pBuf; pBuf; pBuf = pBuf->pNext)
+    {
+	if (REGION_NOTEMPTY (pScreen, &pBuf->damage))
+	{
+	    REGION_INTERSECT (pScreen, &pBuf->damage, &pBuf->damage,
+			      &WindowTable[pScreen->myNum]->borderClip);
+	    (*pBuf->update) (pScreen, pBuf);
+	    REGION_EMPTY (pScreen, &pBuf->damage);
+	}
+    }
+}
+
+static void
+shadowBlockHandler (pointer	data,
+		      OSTimePtr pTimeout,
+		      pointer pRead)
+{
+    ScreenPtr	pScreen = (ScreenPtr) data;
+
+    shadowRedisplay (pScreen);
+}
+
+static void
+shadowWakeupHandler (pointer data, int i, pointer LastSelectMask)
+{
+}
+
+static void
+shadowDamageRegion (WindowPtr pWindow, RegionPtr pRegion)
+{
+    shadowBufPtr    pBuf = shadowFindBuf (pWindow);
+
+    if (!pBuf)
+	abort ();
+
+    REGION_INTERSECT(pWindow->drawable.pScreen, pRegion, pRegion,
+		     &pWindow->borderClip);
+    REGION_UNION(pWindow->drawable.pScreen, &pBuf->damage, &pBuf->damage,
+		 pRegion);
+#ifdef ALWAYS_DISPLAY
+    shadowRedisplay (pWindow->drawable.pScreen);
+#endif
+}
+
+static void
+shadowDamageBox (WindowPtr pWindow, BoxPtr pBox)
+{
+    RegionRec	region;
+
+    REGION_INIT (pWindow->drawable.pScreen, &region, pBox, 1);
+    shadowDamageRegion (pWindow, &region);
+    REGION_UNINIT (pWindow->drawable.pScreen, &region);
+}
+
+static void
+shadowDamageRect (WindowPtr pWindow, int x, int y, int w, int h)
+{
+    BoxRec	box;
+
+    x += pWindow->drawable.x;
+    y += pWindow->drawable.y;
+    box.x1 = x;
+    box.x2 = x + w;
+    box.y1 = y;
+    box.y2 = y + h;
+    shadowDamageBox (pWindow, &box);
+}
+
+static void shadowValidateGC(GCPtr, unsigned long, DrawablePtr);
+static void shadowChangeGC(GCPtr, unsigned long);
+static void shadowCopyGC(GCPtr, unsigned long, GCPtr);
+static void shadowDestroyGC(GCPtr);
+static void shadowChangeClip(GCPtr, int, pointer, int);
+static void shadowDestroyClip(GCPtr);
+static void shadowCopyClip(GCPtr, GCPtr);
+
+GCFuncs shadowGCFuncs = {
+    shadowValidateGC, shadowChangeGC, shadowCopyGC, shadowDestroyGC,
+    shadowChangeClip, shadowDestroyClip, shadowCopyClip
+};
+
+extern GCOps shadowGCOps;
+
+static Bool
+shadowCreateGC(GCPtr pGC)
+{
+    ScreenPtr pScreen = pGC->pScreen;
+    shadowScrPriv(pScreen);
+    shadowGCPriv(pGC);
+    Bool ret;
+
+    unwrap (pScrPriv, pScreen, CreateGC);
+    if((ret = (*pScreen->CreateGC) (pGC))) {
+	pGCPriv->ops = NULL;
+	pGCPriv->funcs = pGC->funcs;
+	pGC->funcs = &shadowGCFuncs;
+    }
+    wrap (pScrPriv, pScreen, CreateGC, shadowCreateGC);
+
+    return ret;
+}
+
+void
+shadowWrapGC (GCPtr pGC)
+{
+    shadowGCPriv(pGC);
+
+    pGCPriv->ops = NULL;
+    pGCPriv->funcs = pGC->funcs;
+    pGC->funcs = &shadowGCFuncs;
+}
+
+void
+shadowUnwrapGC (GCPtr pGC)
+{
+    shadowGCPriv(pGC);
+
+    pGC->funcs = pGCPriv->funcs;
+    if (pGCPriv->ops)
+	pGC->ops = pGCPriv->ops;
+}
+
+#define SHADOW_GC_OP_PROLOGUE(pGC, pDraw) \
+    shadowGCPriv(pGC);  \
+    GCFuncs *oldFuncs = pGC->funcs; \
+    unwrap(pGCPriv, pGC, funcs);  \
+    unwrap(pGCPriv, pGC, ops); \
+
+#define SHADOW_GC_OP_EPILOGUE(pGC, pDraw) \
+    wrap(pGCPriv, pGC, funcs, oldFuncs); \
+    wrap(pGCPriv, pGC, ops, &shadowGCOps)
+
+#define SHADOW_GC_FUNC_PROLOGUE(pGC) \
+    shadowGCPriv(pGC); \
+    unwrap(pGCPriv, pGC, funcs); \
+    if (pGCPriv->ops) unwrap(pGCPriv, pGC, ops)
+
+#define SHADOW_GC_FUNC_EPILOGUE(pGC) \
+    wrap(pGCPriv, pGC, funcs, &shadowGCFuncs);  \
+    if (pGCPriv->ops) wrap(pGCPriv, pGC, ops, &shadowGCOps)
+
+static void
+shadowValidateGC(
+   GCPtr         pGC,
+   unsigned long changes,
+   DrawablePtr   pDraw
+){
+    SHADOW_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ValidateGC)(pGC, changes, pDraw);
+    if(pDraw->type == DRAWABLE_WINDOW)
+	pGCPriv->ops = pGC->ops;  /* just so it's not NULL */
+    else
+	pGCPriv->ops = NULL;
+    SHADOW_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+shadowDestroyGC(GCPtr pGC)
+{
+    SHADOW_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->DestroyGC)(pGC);
+    SHADOW_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+shadowChangeGC (
+    GCPtr	    pGC,
+    unsigned long   mask
+){
+    SHADOW_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ChangeGC) (pGC, mask);
+    SHADOW_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+shadowCopyGC (
+    GCPtr	    pGCSrc,
+    unsigned long   mask,
+    GCPtr	    pGCDst
+){
+    SHADOW_GC_FUNC_PROLOGUE (pGCDst);
+    (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
+    SHADOW_GC_FUNC_EPILOGUE (pGCDst);
+}
+
+static void
+shadowChangeClip (
+    GCPtr   pGC,
+    int		type,
+    pointer	pvalue,
+    int		nrects
+){
+    SHADOW_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
+    SHADOW_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+shadowCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
+{
+    SHADOW_GC_FUNC_PROLOGUE (pgcDst);
+    (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
+    SHADOW_GC_FUNC_EPILOGUE (pgcDst);
+}
+
+static void
+shadowDestroyClip(GCPtr pGC)
+{
+    SHADOW_GC_FUNC_PROLOGUE (pGC);
+    (* pGC->funcs->DestroyClip)(pGC);
+    SHADOW_GC_FUNC_EPILOGUE (pGC);
+}
+
+#define IS_VISIBLE(pWin) 1
+
+
+#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))
+
+#ifdef RENDER
+static void
+shadowComposite (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);
+    shadowScrPriv(pScreen);
+
+    unwrap (pScrPriv, ps, Composite);
+    (*ps->Composite) (op,
+		       pSrc,
+		       pMask,
+		       pDst,
+		       xSrc,
+		       ySrc,
+		       xMask,
+		       yMask,
+		       xDst,
+		       yDst,
+		       width,
+		       height);
+    wrap (pScrPriv, ps, Composite, shadowComposite);
+    if (pDst->pDrawable->type == DRAWABLE_WINDOW)
+	shadowDamageRect ((WindowPtr) pDst->pDrawable, xDst, yDst,
+			    width, height);
+}
+
+static void
+shadowGlyphs (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);
+    shadowScrPriv(pScreen);
+    int			x, y;
+    int			n;
+    GlyphPtr		glyph;
+
+    unwrap (pScrPriv, ps, Glyphs);
+    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
+    wrap (pScrPriv, ps, Glyphs, shadowGlyphs);
+    if (pDst->pDrawable->type == DRAWABLE_WINDOW)
+    {
+	x = xSrc;
+	y = ySrc;
+	while (nlist--)
+	{
+	    x += list->xOff;
+	    y += list->yOff;
+	    n = list->len;
+	    while (n--)
+	    {
+		glyph = *glyphs++;
+		shadowDamageRect ((WindowPtr) pDst->pDrawable,
+				    x - glyph->info.x,
+				    y - glyph->info.y,
+				    glyph->info.width,
+				    glyph->info.height);
+		x += glyph->info.xOff;
+		y += glyph->info.yOff;
+	    }
+	    list++;
+	}
+    }
+}
+#endif
+
+/**********************************************************/
+
+
+static void
+shadowFillSpans(
+    DrawablePtr pDraw,
+    GC		*pGC,
+    int		nInit,
+    DDXPointPtr pptInit,
+    int 	*pwidthInit,
+    int 	fSorted
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nInit) {
+	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++;
+
+	(*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
+
+        if(!pGC->miTranslate) {
+           TRANSLATE_BOX(box, pDraw);
+        }
+        TRIM_BOX(box, pGC); 
+
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    } else
+	(*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
+
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+static void
+shadowSetSpans(
+    DrawablePtr		pDraw,
+    GCPtr		pGC,
+    char		*pcharsrc,
+    DDXPointPtr 	pptInit,
+    int			*pwidthInit,
+    int			nspans,
+    int			fSorted
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nspans) {
+	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++;
+
+	(*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, pptInit,
+				pwidthInit, nspans, fSorted);
+
+        if(!pGC->miTranslate) {
+           TRANSLATE_BOX(box, pDraw);
+        }
+        TRIM_BOX(box, pGC); 
+
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    } else
+	(*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, pptInit,
+				pwidthInit, nspans, fSorted);
+
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+static void
+shadowPutImage(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		depth,
+    int x, int y, int w, int h,
+    int		leftPad,
+    int		format,
+    char 	*pImage
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h,
+		leftPad, format, pImage);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw)) {
+	BoxRec box;
+
+	box.x1 = x + pDraw->x;
+	box.x2 = box.x1 + w;
+	box.y1 = y + pDraw->y;
+	box.y2 = box.y1 + h;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+static RegionPtr
+shadowCopyArea(
+    DrawablePtr pSrc,
+    DrawablePtr pDst,
+    GC *pGC,
+    int srcx, int srcy,
+    int width, int height,
+    int dstx, int dsty
+){
+    RegionPtr ret;
+    SHADOW_GC_OP_PROLOGUE(pGC, pDst);
+    ret = (*pGC->ops->CopyArea)(pSrc, pDst,
+            pGC, srcx, srcy, width, height, dstx, dsty);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDst);
+
+    if(IS_VISIBLE(pDst)) {
+	BoxRec box;
+
+	box.x1 = dstx + pDst->x;
+	box.x2 = box.x1 + width;
+	box.y1 = dsty + pDst->y;
+	box.y2 = box.y1 + height;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDst, &box);
+    }
+
+    return ret;
+}
+
+static RegionPtr
+shadowCopyPlane(
+    DrawablePtr	pSrc,
+    DrawablePtr	pDst,
+    GCPtr pGC,
+    int	srcx, int srcy,
+    int	width, int height,
+    int	dstx, int dsty,
+    unsigned long bitPlane
+){
+    RegionPtr ret;
+    SHADOW_GC_OP_PROLOGUE(pGC, pDst);
+    ret = (*pGC->ops->CopyPlane)(pSrc, pDst,
+	       pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDst);
+
+    if(IS_VISIBLE(pDst)) {
+	BoxRec box;
+
+	box.x1 = dstx + pDst->x;
+	box.x2 = box.x1 + width;
+	box.y1 = dsty + pDst->y;
+	box.y2 = box.y1 + height;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDst, &box);
+    }
+
+    return ret;
+}
+
+static void
+shadowPolyPoint(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int mode,
+    int npt,
+    xPoint *pptInit
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && npt) {
+	BoxRec box;
+
+	box.x2 = box.x1 = pptInit->x;
+	box.y2 = box.y1 = pptInit->y;
+
+	/* this could be slow if the points were spread out */
+
+	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, pDraw, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+static void
+shadowPolylines(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		mode,
+    int		npt,
+    DDXPointPtr pptInit
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+
+    if(IS_VISIBLE(pDraw) && npt) {
+	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, pDraw, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+static void
+shadowPolySegment(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		nseg,
+    xSegment	*pSeg
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nseg) {
+	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, pDraw, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+static void
+shadowPolyRectangle(
+    DrawablePtr  pDraw,
+    GCPtr        pGC,
+    int	         nRects,
+    xRectangle  *pRects
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyRectangle)(pDraw, pGC, nRects, pRects);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nRects)
+    {
+	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, pDraw, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		shadowDamageBox ((WindowPtr) pDraw, &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, pDraw, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		shadowDamageBox ((WindowPtr) pDraw, &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, pDraw, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		shadowDamageBox ((WindowPtr) pDraw, &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, pDraw, pGC);
+	    if(BOX_NOT_EMPTY(box))
+		shadowDamageBox ((WindowPtr) pDraw, &box);
+
+	    pRects++;
+	}
+    }
+ }
+
+static void
+shadowPolyArc(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		narcs,
+    xArc	*parcs
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && narcs) {
+	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, pDraw, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+static void
+shadowFillPolygon(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		shape,
+    int		mode,
+    int		count,
+    DDXPointPtr	pptInit
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && (count > 2)) {
+	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++;
+
+	(*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, pptInit);
+
+	TRIM_AND_TRANSLATE_BOX(box, pDraw, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    } else
+	(*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, pptInit);
+
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+
+static void
+shadowPolyFillRect(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		nRectsInit,
+    xRectangle	*pRectsInit
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nRectsInit) {
+	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;
+	}
+
+	/* cfb messes with the pRectsInit so we have to do our
+	   calculations first */
+
+	(*pGC->ops->PolyFillRect)(pDraw, pGC, nRectsInit, pRectsInit);
+
+	TRIM_AND_TRANSLATE_BOX(box, pDraw, pGC);
+	if(BOX_NOT_EMPTY(box))
+	    shadowDamageBox ((WindowPtr) pDraw, &box);
+    } else
+	(*pGC->ops->PolyFillRect)(pDraw, pGC, nRectsInit, pRectsInit);
+
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+
+static void
+shadowPolyFillArc(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		narcs,
+    xArc	*parcs
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && narcs) {
+	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;
+        }
+
+	TRIM_AND_TRANSLATE_BOX(box, pDraw, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+
+}
+
+static int
+shadowPolyText8(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int 	y,
+    int 	count,
+    char	*chars
+){
+    int width;
+
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    width = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    width -= x;
+
+    if(IS_VISIBLE(pDraw) && (width > 0)) {
+	BoxRec box;
+
+	/* ugh */
+	box.x1 = pDraw->x + x + FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	if(count > 1) {
+	   if(width > 0) box.x2 += width;
+	   else box.x1 += width;
+	}
+
+	box.y1 = pDraw->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+	box.y2 = pDraw->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+
+    return (width + x);
+}
+
+static int
+shadowPolyText16(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int		y,
+    int 	count,
+    unsigned short *chars
+){
+    int width;
+
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    width = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    width -= x;
+
+    if(IS_VISIBLE(pDraw) && (width > 0)) {
+	BoxRec box;
+
+	/* ugh */
+	box.x1 = pDraw->x + x + FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	if(count > 1) {
+	   if(width > 0) box.x2 += width;
+	   else box.x1 += width;
+	}
+
+	box.y1 = pDraw->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+	box.y2 = pDraw->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+
+    return (width + x);
+}
+
+static void
+shadowImageText8(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int		y,
+    int 	count,
+    char	*chars
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && count) {
+	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 = pDraw->x + x + Min +
+		FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + Max +
+		FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	box.y1 = pDraw->y + y - top;
+	box.y2 = pDraw->y + y + bot;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+static void
+shadowImageText16(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int		y,
+    int 	count,
+    unsigned short *chars
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && count) {
+	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 = pDraw->x + x + Min +
+		FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + Max +
+		FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	box.y1 = pDraw->y + y - top;
+	box.y2 = pDraw->y + y + bot;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+
+static void
+shadowImageGlyphBlt(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int x, int y,
+    unsigned int nglyph,
+    CharInfoPtr *ppci,
+    pointer pglyphBase
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, x, y, nglyph,
+					ppci, pglyphBase);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nglyph) {
+	int top, bot, width = 0;
+	BoxRec box;
+
+	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 += pDraw->x + x;
+	box.x1 += pDraw->x + x;
+
+	while(nglyph--) {
+	    width += (*ppci)->metrics.characterWidth;
+	    ppci++;
+	}
+
+	if(width > 0)
+	   box.x2 += width;
+	else
+	   box.x1 += width;
+
+	box.y1 = pDraw->y + y - top;
+	box.y2 = pDraw->y + y + bot;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+static void
+shadowPolyGlyphBlt(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int x, int y,
+    unsigned int nglyph,
+    CharInfoPtr *ppci,
+    pointer pglyphBase
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, x, y, nglyph,
+				ppci, pglyphBase);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nglyph) {
+	BoxRec box;
+
+	/* ugh */
+	box.x1 = pDraw->x + x + ppci[0]->metrics.leftSideBearing;
+	box.x2 = pDraw->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 = pDraw->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+	box.y2 = pDraw->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+static void
+shadowPushPixels(
+    GCPtr	pGC,
+    PixmapPtr	pBitMap,
+    DrawablePtr pDraw,
+    int	dx, int dy, int xOrg, int yOrg
+){
+    SHADOW_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
+    SHADOW_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw)) {
+	BoxRec box;
+
+        box.x1 = xOrg;
+        box.y1 = yOrg;
+
+        if(!pGC->miTranslate) {
+           box.x1 += pDraw->x;          
+           box.y1 += pDraw->y;          
+        }
+
+	box.x2 = box.x1 + dx;
+	box.y2 = box.y1 + dy;
+
+	TRIM_BOX(box, pGC);
+	if(BOX_NOT_EMPTY(box))
+	   shadowDamageBox ((WindowPtr) pDraw, &box);
+    }
+}
+
+
+static void
+shadowPaintWindow(
+  WindowPtr pWindow,
+  RegionPtr prgn,
+  int what
+){
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    shadowScrPriv(pScreen);
+
+    if(what == PW_BACKGROUND) {
+	unwrap (pScrPriv, pScreen, PaintWindowBackground);
+	(*pScreen->PaintWindowBackground) (pWindow, prgn, what);
+	wrap (pScrPriv, pScreen, PaintWindowBackground, shadowPaintWindow);
+    } else {
+	unwrap (pScrPriv, pScreen, PaintWindowBorder);
+	(*pScreen->PaintWindowBorder) (pWindow, prgn, what);
+	wrap (pScrPriv, pScreen, PaintWindowBorder, shadowPaintWindow);
+    }
+    shadowDamageRegion (pWindow, prgn);
+}
+
+
+static void
+shadowCopyWindow(
+   WindowPtr pWindow,
+   DDXPointRec ptOldOrg,
+   RegionPtr prgn
+){
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    shadowScrPriv(pScreen);
+
+    unwrap (pScrPriv, pScreen, CopyWindow);
+    (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgn);
+    wrap (pScrPriv, pScreen, CopyWindow, shadowCopyWindow);
+    shadowDamageRegion (pWindow, prgn);
+}
+
+GCOps shadowGCOps = {
+    shadowFillSpans, shadowSetSpans,
+    shadowPutImage, shadowCopyArea,
+    shadowCopyPlane, shadowPolyPoint,
+    shadowPolylines, shadowPolySegment,
+    shadowPolyRectangle, shadowPolyArc,
+    shadowFillPolygon, shadowPolyFillRect,
+    shadowPolyFillArc, shadowPolyText8,
+    shadowPolyText16, shadowImageText8,
+    shadowImageText16, shadowImageGlyphBlt,
+    shadowPolyGlyphBlt, shadowPushPixels,
+#ifdef NEED_LINEHELPER
+    NULL,
+#endif
+    {NULL}		/* devPrivate */
+};
+
+static void
+shadowGetImage (DrawablePtr pDrawable,
+		int sx,
+		int sy,
+		int w,
+		int h,
+		unsigned int format,
+		unsigned long planeMask,
+		char * pdstLine)
+{
+    ScreenPtr pScreen = pDrawable->pScreen;
+    shadowScrPriv(pScreen);
+
+    /* Many apps use GetImage to sync with the visable frame buffer */
+    if (pDrawable->type == DRAWABLE_WINDOW)
+	shadowRedisplay (pScreen);
+    unwrap (pScrPriv, pScreen, GetImage);
+    (*pScreen->GetImage) (pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
+    wrap (pScrPriv, pScreen, GetImage, shadowGetImage);
+}
+
+static void
+shadowRestoreAreas (PixmapPtr pPixmap,
+		    RegionPtr prgn,
+		    int xorg,
+		    int yorg,
+		    WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    shadowScrPriv(pScreen);
+
+    unwrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas);
+    (*pScreen->BackingStoreFuncs.RestoreAreas) (pPixmap, prgn,
+						xorg, yorg, pWin);
+    wrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas,
+			     shadowRestoreAreas);
+    shadowDamageRegion (pWin, prgn);
+}
+
+static Bool
+shadowCloseScreen (int i, ScreenPtr pScreen)
+{
+    shadowScrPriv(pScreen);
+
+    unwrap (pScrPriv, pScreen, CreateGC);
+    unwrap (pScrPriv, pScreen, PaintWindowBackground);
+    unwrap (pScrPriv, pScreen, PaintWindowBorder);
+    unwrap (pScrPriv, pScreen, CopyWindow);
+    unwrap (pScrPriv, pScreen, CloseScreen);
+    unwrap (pScrPriv, pScreen, GetImage);
+    unwrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas);
+    xfree (pScrPriv);
+    return (*pScreen->CloseScreen) (i, pScreen);
+}
+
+Bool
+shadowSetup (ScreenPtr pScreen)
+{
+    shadowScrPrivPtr	pScrPriv;
+#ifdef RENDER
+    PictureScreenPtr	ps = GetPictureScreenIfSet(pScreen);
+#endif
+
+    if (shadowGeneration != serverGeneration)
+    {
+	shadowScrPrivateIndex = AllocateScreenPrivateIndex ();
+	if (shadowScrPrivateIndex == -1)
+	    return FALSE;
+	shadowGCPrivateIndex = AllocateGCPrivateIndex ();
+	if (shadowGCPrivateIndex == -1)
+	    return FALSE;
+	shadowGeneration = serverGeneration;
+    }
+    if (!AllocateGCPrivate (pScreen, shadowGCPrivateIndex, sizeof (shadowGCPrivRec)))
+	return FALSE;
+    pScrPriv = (shadowScrPrivPtr) xalloc (sizeof (shadowScrPrivRec));
+    if (!pScrPriv)
+	return FALSE;
+
+    if (!RegisterBlockAndWakeupHandlers (shadowBlockHandler,
+					 shadowWakeupHandler,
+					 (pointer) pScreen))
+	return FALSE;
+
+    wrap (pScrPriv, pScreen, CreateGC, shadowCreateGC);
+    wrap (pScrPriv, pScreen, PaintWindowBackground, shadowPaintWindow);
+    wrap (pScrPriv, pScreen, PaintWindowBorder, shadowPaintWindow);
+    wrap (pScrPriv, pScreen, CopyWindow, shadowCopyWindow);
+    wrap (pScrPriv, pScreen, CloseScreen, shadowCloseScreen);
+    wrap (pScrPriv, pScreen, GetImage, shadowGetImage);
+    wrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas,
+			     shadowRestoreAreas);
+#ifdef RENDER
+    if (ps) {
+	wrap (pScrPriv, ps, Glyphs, shadowGlyphs);
+	wrap (pScrPriv, ps, Composite, shadowComposite);
+    }
+#endif
+    pScrPriv->pBuf = 0;
+
+    pScreen->devPrivates[shadowScrPrivateIndex].ptr = (pointer) pScrPriv;
+    return TRUE;
+}
+
+Bool
+shadowAdd (ScreenPtr	    pScreen,
+	   PixmapPtr	    pPixmap,
+	   ShadowUpdateProc update,
+	   ShadowWindowProc window,
+	   int		    randr,
+	   void		    *closure)
+{
+    shadowScrPriv(pScreen);
+    shadowBufPtr    pBuf;
+
+    pBuf = (shadowBufPtr) xalloc (sizeof (shadowBufRec));
+    if (!pBuf)
+	return FALSE;
+    /*
+     * Map simple rotation values to bitmasks; fortunately,
+     * these are all unique
+     */
+    switch (randr) {
+    case 0:
+	randr = SHADOW_ROTATE_0;
+	break;
+    case 90:
+	randr = SHADOW_ROTATE_90;
+	break;
+    case 180:
+	randr = SHADOW_ROTATE_180;
+	break;
+    case 270:
+	randr = SHADOW_ROTATE_270;
+	break;
+    }
+    pBuf->pPixmap = pPixmap;
+    pBuf->update = update;
+    pBuf->window = window;
+    REGION_NULL(pScreen, &pBuf->damage);
+    pBuf->pNext = pScrPriv->pBuf;
+    pBuf->randr = randr;
+    pBuf->closure = 0;
+    pScrPriv->pBuf = pBuf;
+    return TRUE;
+}
+
+void
+shadowRemove (ScreenPtr pScreen, PixmapPtr pPixmap)
+{
+    shadowScrPriv(pScreen);
+    shadowBufPtr    pBuf, *pPrev;
+
+    for (pPrev = &pScrPriv->pBuf; (pBuf = *pPrev); pPrev = &pBuf->pNext)
+	if (pBuf->pPixmap == pPixmap)
+	{
+	    REGION_UNINIT (pScreen, &pBuf->damage);
+	    *pPrev = pBuf->pNext;
+	    xfree (pBuf);
+	    break;
+	}
+}
+
+shadowBufPtr
+shadowFindBuf (WindowPtr pWindow)
+{
+    ScreenPtr	    pScreen = pWindow->drawable.pScreen;
+    shadowScrPriv(pScreen);
+    shadowBufPtr    pBuf, *pPrev;
+    PixmapPtr	    pPixmap = (*pScreen->GetWindowPixmap) (pWindow);
+
+    for (pPrev = &pScrPriv->pBuf; (pBuf = *pPrev); pPrev = &pBuf->pNext)
+    {
+	if (!pBuf->pPixmap)
+	    pBuf->pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
+	if (pBuf->pPixmap == pPixmap)
+	{
+	    /*
+	     * Reorder so this one is first next time
+	     */
+	    if (pPrev != &pScrPriv->pBuf)
+	    {
+		*pPrev = pBuf->pNext;
+		pBuf->pNext = pScrPriv->pBuf;
+		pScrPriv->pBuf = pBuf;
+	    }
+	    return pBuf;
+	}
+    }
+    return 0;
+}
+
+Bool
+shadowInit (ScreenPtr pScreen, ShadowUpdateProc update, ShadowWindowProc window)
+{
+    if (!shadowSetup (pScreen))
+	return FALSE;
+
+    if (!shadowAdd (pScreen, 0, update, window, SHADOW_ROTATE_0, 0))
+	return FALSE;
+
+    return TRUE;
+}
diff --git a/nx-X11/programs/Xserver/miext/shadow/shadow.h b/nx-X11/programs/Xserver/miext/shadow/shadow.h
new file mode 100644
index 000000000..85b2604f5
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shadow.h
@@ -0,0 +1,179 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/shadow/shadow.h,v 1.6tsi Exp $
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#ifndef _SHADOW_H_
+#define _SHADOW_H_
+
+#include "scrnintstr.h"
+
+#ifdef RENDER
+#include "picturestr.h"
+#endif
+
+typedef struct _shadowBuf   *shadowBufPtr;
+
+typedef void (*ShadowUpdateProc) (ScreenPtr pScreen,
+				  shadowBufPtr pBuf);
+
+#define SHADOW_WINDOW_RELOCATE 1
+#define SHADOW_WINDOW_READ 2
+#define SHADOW_WINDOW_WRITE 4
+
+typedef void *(*ShadowWindowProc) (ScreenPtr	pScreen,
+				   CARD32	row,
+				   CARD32	offset,
+				   int		mode,
+				   CARD32	*size,
+				   void		*closure);
+
+typedef struct _shadowBuf {
+    shadowBufPtr	pNext;
+    ShadowUpdateProc	update;
+    ShadowWindowProc	window;
+    RegionRec		damage;
+    PixmapPtr		pPixmap;
+    void		*closure;
+    int			randr;
+} shadowBufRec;
+
+/* Match defines from randr extension */
+#define SHADOW_ROTATE_0	    1
+#define SHADOW_ROTATE_90    2
+#define SHADOW_ROTATE_180   4
+#define SHADOW_ROTATE_270   8
+#define SHADOW_ROTATE_ALL   (SHADOW_ROTATE_0|SHADOW_ROTATE_90|\
+			     SHADOW_ROTATE_180|SHADOW_ROTATE_270)
+#define SHADOW_REFLECT_X    16
+#define SHADOW_REFLECT_Y    32
+#define SHADOW_REFLECT_ALL  (SHADOW_REFLECT_X|SHADOW_REFLECT_Y)
+
+typedef struct _shadowScrPriv {
+    PaintWindowBackgroundProcPtr PaintWindowBackground;
+    PaintWindowBorderProcPtr	PaintWindowBorder;
+    CopyWindowProcPtr		CopyWindow;
+    CloseScreenProcPtr		CloseScreen;
+    CreateGCProcPtr		CreateGC;
+    GetImageProcPtr		GetImage;
+#ifdef RENDER
+    CompositeProcPtr		Composite;
+    GlyphsProcPtr		Glyphs;
+#endif
+    shadowBufPtr		pBuf;
+    BSFuncRec			BackingStoreFuncs;
+} shadowScrPrivRec, *shadowScrPrivPtr;
+
+extern int shadowScrPrivateIndex;
+
+#define shadowGetScrPriv(pScr)  ((shadowScrPrivPtr) (pScr)->devPrivates[shadowScrPrivateIndex].ptr)
+#define shadowScrPriv(pScr)	shadowScrPrivPtr    pScrPriv = shadowGetScrPriv(pScr)
+
+Bool
+shadowSetup (ScreenPtr pScreen);
+
+Bool
+shadowAdd (ScreenPtr	    pScreen,
+	   PixmapPtr	    pPixmap,
+	   ShadowUpdateProc update,
+	   ShadowWindowProc window,
+	   int		    randr,
+	   void		    *closure);
+
+void
+shadowRemove (ScreenPtr pScreen, PixmapPtr pPixmap);
+
+shadowBufPtr
+shadowFindBuf (WindowPtr pWindow);
+
+Bool
+shadowInit (ScreenPtr pScreen, ShadowUpdateProc update, ShadowWindowProc window);
+
+void *
+shadowAlloc (int width, int height, int bpp);
+
+void
+shadowUpdatePacked (ScreenPtr	    pScreen,
+		    shadowBufPtr    pBuf);
+
+void
+shadowUpdatePlanar4 (ScreenPtr	    pScreen,
+		     shadowBufPtr   pBuf);
+
+void
+shadowUpdatePlanar4x8 (ScreenPtr    pScreen,
+		       shadowBufPtr pBuf);
+
+void
+shadowUpdateRotatePacked (ScreenPtr    pScreen,
+			  shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate8_90 (ScreenPtr    pScreen,
+			shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate16_90 (ScreenPtr    pScreen,
+			 shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate32_90 (ScreenPtr    pScreen,
+			 shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate8_180 (ScreenPtr    pScreen,
+			 shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate16_180 (ScreenPtr    pScreen,
+			  shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate32_180 (ScreenPtr    pScreen,
+			  shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate8_270 (ScreenPtr    pScreen,
+			 shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate16_270 (ScreenPtr    pScreen,
+			  shadowBufPtr pBuf);
+
+void
+shadowUpdateRotate32_270 (ScreenPtr    pScreen,
+			  shadowBufPtr pBuf);
+
+typedef void (* shadowUpdateProc)(ScreenPtr, shadowBufPtr);
+
+shadowUpdateProc shadowUpdatePackedWeak(void);
+shadowUpdateProc shadowUpdatePlanar4Weak(void);
+shadowUpdateProc shadowUpdatePlanar4x8Weak(void);
+shadowUpdateProc shadowUpdateRotatePackedWeak(void);
+
+void
+shadowWrapGC (GCPtr pGC);
+
+void
+shadowUnwrapGC (GCPtr pGC);
+
+#endif /* _SHADOW_H_ */
diff --git a/nx-X11/programs/Xserver/miext/shadow/shalloc.c b/nx-X11/programs/Xserver/miext/shadow/shalloc.c
new file mode 100644
index 000000000..5c01f2aac
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shalloc.c
@@ -0,0 +1,52 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "shadow.h"
+
+void *
+shadowAlloc (int width, int height, int bpp)
+{
+    int	    stride;
+    void    *fb;
+
+    /* Cant use PixmapBytePad -- the structure is probably not initialized yet */
+    stride = BitmapBytePad (width * bpp);
+    fb = xalloc (stride * height);
+    return fb;
+}
diff --git a/nx-X11/programs/Xserver/miext/shadow/shmodule.c b/nx-X11/programs/Xserver/miext/shadow/shmodule.c
new file mode 100644
index 000000000..5f347a3b5
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shmodule.c
@@ -0,0 +1,60 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#ifdef XFree86LOADER
+
+#include "xf86Module.h"
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include "shadow.h"
+
+static XF86ModuleVersionInfo VersRec =
+{
+	"shadow",
+	MODULEVENDORSTRING,
+	MODINFOSTRING1,
+	MODINFOSTRING2,
+	XORG_VERSION_CURRENT,
+	1, 0, 0,
+	ABI_CLASS_ANSIC,		/* Only need the ansic layer */
+	ABI_ANSIC_VERSION,
+	MOD_CLASS_NONE,
+	{0,0,0,0}       /* signature, to be patched into the file by a tool */
+};
+
+XF86ModuleData shadowModuleData = { &VersRec, NULL, NULL };
+
+#endif
diff --git a/nx-X11/programs/Xserver/miext/shadow/shpacked.c b/nx-X11/programs/Xserver/miext/shadow/shpacked.c
new file mode 100644
index 000000000..3fdee1473
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shpacked.c
@@ -0,0 +1,114 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/shadow/shpacked.c,v 1.4 2001/05/29 04:54:13 keithp Exp $
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "shadow.h"
+#include    "fb.h"
+
+void
+shadowUpdatePacked (ScreenPtr	    pScreen,
+		    shadowBufPtr    pBuf)
+{
+    RegionPtr	damage = &pBuf->damage;
+    PixmapPtr	pShadow = pBuf->pPixmap;
+    int		nbox = REGION_NUM_RECTS (damage);
+    BoxPtr	pbox = REGION_RECTS (damage);
+    FbBits	*shaBase, *shaLine, *sha;
+    FbStride	shaStride;
+    int		scrBase, scrLine, scr;
+    int		shaBpp;
+    int		shaXoff, shaYoff; /* XXX assumed to be zero */
+    int		x, y, w, h, width;
+    int         i;
+    FbBits	*winBase = NULL, *win;
+    CARD32      winSize;
+
+    fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff);
+    while (nbox--)
+    {
+	x = pbox->x1 * shaBpp;
+	y = pbox->y1;
+	w = (pbox->x2 - pbox->x1) * shaBpp;
+	h = pbox->y2 - pbox->y1;
+
+	scrLine = (x >> FB_SHIFT);
+	shaLine = shaBase + y * shaStride + (x >> FB_SHIFT);
+				   
+	x &= FB_MASK;
+	w = (w + x + FB_MASK) >> FB_SHIFT;
+	
+	while (h--)
+	{
+	    winSize = 0;
+	    scrBase = 0;
+	    width = w;
+	    scr = scrLine;
+	    sha = shaLine;
+	    while (width) {
+		/* how much remains in this window */
+		i = scrBase + winSize - scr;
+		if (i <= 0 || scr < scrBase)
+		{
+		    winBase = (FbBits *) (*pBuf->window) (pScreen,
+							  y,
+							  scr * sizeof (FbBits),
+							  SHADOW_WINDOW_WRITE,
+							  &winSize,
+							  pBuf->closure);
+		    if(!winBase)
+			return;
+		    scrBase = scr;
+		    winSize /= sizeof (FbBits);
+		    i = winSize;
+		}
+		win = winBase + (scr - scrBase);
+		if (i > width)
+		    i = width;
+		width -= i;
+		scr += i;
+#define PickBit(a,i)	(((a) >> (i)) & 1)
+		while (i--)
+		    *win++ = *sha++;
+	    }
+	    shaLine += shaStride;
+	    y++;
+	}
+	pbox++;
+    }
+}
+
+shadowUpdateProc shadowUpdatePackedWeak(void) { return shadowUpdatePacked; }
diff --git a/nx-X11/programs/Xserver/miext/shadow/shplanar.c b/nx-X11/programs/Xserver/miext/shadow/shplanar.c
new file mode 100644
index 000000000..979905b86
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shplanar.c
@@ -0,0 +1,179 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/shadow/shplanar.c,v 1.3 2001/05/29 04:54:13 keithp Exp $
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "shadow.h"
+#include    "fb.h"
+
+/*
+ * 32 4-bit pixels per write
+ */
+
+#define PL_SHIFT    7	    
+#define PL_UNIT	    (1 << PL_SHIFT)
+#define PL_MASK	    (PL_UNIT - 1)
+
+/*
+ *  32->8 conversion:
+ *
+ *      7 6 5 4 3 2 1 0
+ *      A B C D E F G H
+ *
+ *      3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
+ *      1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+ * m    . . . H . . . G . . . F . . . E . . . D . . . C . . . B . . . A
+ * m1   G . . . F . . . E . . . D . . . C . . . B . . . A . . . . . . .	    m << (7 - (p))
+ * m2   . H . . . G . . . F . . . E . . . D . . . C . . . B . . . A . .	    (m >> (p)) << 2
+ * m3   G               E               C               A                   m1 & 0x80808080
+ * m4     H               F               D               B                 m2 & 0x40404040
+ * m5   G H             E F             C D             A B                 m3 | m4
+ * m6   G H             E F             C D     G H     A B     E F         m5 | (m5 >> 20)
+ * m7   G H             E F             C D     G H     A B C D E F G H     m6 | (m6 >> 10)
+ */
+
+#if 0
+#define GetBits(p,o,d) {\
+    m = sha[o]; \
+    m1 = m << (7 - (p)); \
+    m2 = (m >> (p)) << 2; \
+    m3 = m1 & 0x80808080; \
+    m4 = m2 & 0x40404040; \
+    m5 = m3 | m4; \
+    m6 = m5 | (m5 >> 20); \
+    d = m6 | (m6 >> 10); \
+}
+#else
+#define GetBits(p,o,d) {\
+    m = sha[o]; \
+    m5 = ((m << (7 - (p))) & 0x80808080) | (((m >> (p)) << 2) & 0x40404040); \
+    m6 = m5 | (m5 >> 20); \
+    d = m6 | (m6 >> 10); \
+}
+#endif
+
+void
+shadowUpdatePlanar4 (ScreenPtr	    pScreen,
+		     shadowBufPtr   pBuf)
+{
+    RegionPtr	damage = &pBuf->damage;
+    PixmapPtr	pShadow = pBuf->pPixmap;
+    int		nbox = REGION_NUM_RECTS (damage);
+    BoxPtr	pbox = REGION_RECTS (damage);
+    CARD32	*shaBase, *shaLine, *sha;
+    FbStride	shaStride;
+    int		scrBase, scrLine, scr;
+    int		shaBpp;
+    int		shaXoff, shaYoff;   /* XXX assumed to be zero */
+    int		x, y, w, h, width;
+    int         i;
+    CARD32	*winBase = NULL, *win;
+    CARD32	winSize;
+    int		plane;
+    CARD32	m,m5,m6;
+    CARD8	s1, s2, s3, s4;
+
+    fbGetStipDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff);
+    while (nbox--)
+    {
+	x = (pbox->x1) * shaBpp;
+	y = (pbox->y1);
+	w = (pbox->x2 - pbox->x1) * shaBpp;
+	h = pbox->y2 - pbox->y1;
+
+	w = (w + (x & PL_MASK) + PL_MASK) >> PL_SHIFT;
+	x &= ~PL_MASK;
+	
+	scrLine = (x >> PL_SHIFT);
+	shaLine = shaBase + y * shaStride + (x >> FB_SHIFT);
+	
+	while (h--)
+	{
+	    for (plane = 0; plane < 4; plane++)
+	    {
+		width = w;
+		scr = scrLine;
+		sha = shaLine;
+		winSize = 0;
+		scrBase = 0;
+		while (width) {
+		    /* how much remains in this window */
+		    i = scrBase + winSize - scr;
+		    if (i <= 0 || scr < scrBase)
+		    {
+			winBase = (CARD32 *) (*pBuf->window) (pScreen,
+							      y,
+							      (scr << 4) | (plane),
+							      SHADOW_WINDOW_WRITE,
+							      &winSize,
+							      pBuf->closure);
+			if(!winBase)
+			return;
+			winSize >>= 2;
+			scrBase = scr;
+			i = winSize;
+		    }
+		    win = winBase + (scr - scrBase);
+		    if (i > width)
+		    i = width;
+		    width -= i;
+		    scr += i;
+		   
+		    while (i--)
+		    {
+			GetBits(plane,0,s1);
+			GetBits(plane,1,s2);
+			GetBits(plane,2,s3);
+			GetBits(plane,3,s4);
+			*win++ = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24);
+			sha += 4;
+		    }
+		}
+	    }
+	    shaLine += shaStride;
+	    y++;
+	}
+	pbox++;
+    }
+}
+
+shadowUpdateProc shadowUpdatePlanar4Weak(void) {
+    return shadowUpdatePlanar4;
+}
+
+shadowUpdateProc shadowUpdatePlanar4x8Weak(void) {
+    return shadowUpdatePlanar4x8;
+}
diff --git a/nx-X11/programs/Xserver/miext/shadow/shplanar8.c b/nx-X11/programs/Xserver/miext/shadow/shplanar8.c
new file mode 100644
index 000000000..f1d87dc50
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shplanar8.c
@@ -0,0 +1,174 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/shadow/shplanar8.c,v 1.3 2001/05/29 04:54:13 keithp Exp $
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "shadow.h"
+#include    "fb.h"
+
+/*
+ * Expose 8bpp depth 4
+ */
+
+/*
+ *  32->8 conversion:
+ *
+ *      7 6 5 4 3 2 1 0
+ *      A B C D E F G H
+ *
+ *      3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
+ *      1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+ * m1   D x x x x x x x C x x x x x x x B x x x x x x x A x x x x x x x     sha[0] << (7-(p))
+ * m2   x x x x H x x x x x x x G x x x x x x x F x x x x x x x E x x x     sha[1] << (3-(p))
+ * m3   D               C               B               A                   m1 & 0x80808080
+ * m4           H               G               F               E           m2 & 0x08080808
+ * m5   D       H       C       G       B       F       A       E	    m3 | m4
+ * m6                     D       H       C       G       B       F         m5 >> 9
+ * m7   D       H       C D     G H     B C     F G     A B     E F         m5 | m6
+ * m8                                       D       H       C D     G H     m7 >> 18
+ * m9   D       H       C D     G H     B C D   F G H   A B C D E F G H     m7 | m8
+ */
+
+#define PL_SHIFT    8
+#define PL_UNIT	    (1 << PL_SHIFT)
+#define PL_MASK	    (PL_UNIT - 1)
+
+#if 0
+#define GetBits(p,o,d) { \
+    CARD32	m1,m2,m3,m4,m5,m6,m7,m8; \
+    m1 = sha[o] << (7 - (p)); \
+    m2 = sha[(o)+1] << (3 - (p)); \
+    m3 = m1 & 0x80808080; \
+    m4 = m2 & 0x08080808; \
+    m5 = m3 | m4; \
+    m6 = m5 >> 9; \
+    m7 = m5 | m6; \
+    m8 = m7 >> 18; \
+    d = m7 | m8; \
+}
+#else
+#define GetBits(p,o,d) { \
+    CARD32	m5,m7; \
+    m5 = ((sha[o] << (7 - (p))) & 0x80808080) | ((sha[(o)+1] << (3 - (p))) & 0x08080808); \
+    m7 = m5 | (m5 >> 9); \
+    d = m7 | (m7 >> 18); \
+}
+#endif
+
+void
+shadowUpdatePlanar4x8 (ScreenPtr	pScreen,
+		       shadowBufPtr	pBuf)
+{
+    RegionPtr	damage = &pBuf->damage;
+    PixmapPtr	pShadow = pBuf->pPixmap;
+    int		nbox = REGION_NUM_RECTS (damage);
+    BoxPtr	pbox = REGION_RECTS (damage);
+    CARD32	*shaBase, *shaLine, *sha;
+    CARD8	s1, s2, s3, s4;
+    FbStride	shaStride;
+    int		scrBase, scrLine, scr;
+    int		shaBpp;
+    int		shaXoff, shaYoff;   /* XXX assumed to be zero */
+    int		x, y, w, h, width;
+    int         i;
+    CARD32	*winBase = NULL, *win;
+    CARD32	winSize;
+    int		plane;
+
+    fbGetStipDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff);
+    while (nbox--)
+    {
+	x = pbox->x1 * shaBpp;
+	y = pbox->y1;
+	w = (pbox->x2 - pbox->x1) * shaBpp;
+	h = pbox->y2 - pbox->y1;
+
+	w = (w + (x & PL_MASK) + PL_MASK) >> PL_SHIFT;
+	x &= ~PL_MASK;
+	
+	scrLine = (x >> PL_SHIFT);
+	shaLine = shaBase + y * shaStride + (x >> FB_SHIFT);
+	
+	while (h--)
+	{
+	    for (plane = 0; plane < 4; plane++)
+	    {
+		width = w;
+		scr = scrLine;
+		sha = shaLine;
+		winSize = 0;
+		scrBase = 0;
+		while (width) {
+		    /* how much remains in this window */
+		    i = scrBase + winSize - scr;
+		    if (i <= 0 || scr < scrBase)
+		    {
+			winBase = (CARD32 *) (*pBuf->window) (pScreen,
+							      y,
+							      (scr << 4) | (plane),
+							      SHADOW_WINDOW_WRITE,
+							      &winSize,
+							      pBuf->closure);
+			if(!winBase)
+			    return;
+			winSize >>= 2;
+			scrBase = scr;
+			i = winSize;
+		    }
+		    win = winBase + (scr - scrBase);
+		    if (i > width)
+		    i = width;
+		    width -= i;
+		    scr += i;
+		   
+		    while (i--)
+		    {
+			GetBits(plane,0,s1);
+			GetBits(plane,2,s2);
+			GetBits(plane,4,s3);
+			GetBits(plane,6,s4);
+			*win++ = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24);
+			sha += 8;
+		    }
+		}
+	    }
+	    shaLine += shaStride;
+	    y++;
+	}
+	pbox++;
+    }
+}
+		    
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot16pack.c b/nx-X11/programs/Xserver/miext/shadow/shrot16pack.c
new file mode 100644
index 000000000..2ec41bb07
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot16pack.c
@@ -0,0 +1,32 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate16
+#define Data	CARD16
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot16pack_180.c b/nx-X11/programs/Xserver/miext/shadow/shrot16pack_180.c
new file mode 100644
index 000000000..06b1603ba
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot16pack_180.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate16_180
+#define Data	CARD16
+#define ROTATE	180
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot16pack_270.c b/nx-X11/programs/Xserver/miext/shadow/shrot16pack_270.c
new file mode 100644
index 000000000..1ad952ec6
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot16pack_270.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate16_270
+#define Data	CARD16
+#define ROTATE	270
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot16pack_90.c b/nx-X11/programs/Xserver/miext/shadow/shrot16pack_90.c
new file mode 100644
index 000000000..cfef7785c
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot16pack_90.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate16_90
+#define Data	CARD16
+#define ROTATE	90
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot32pack.c b/nx-X11/programs/Xserver/miext/shadow/shrot32pack.c
new file mode 100644
index 000000000..95c7c292c
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot32pack.c
@@ -0,0 +1,32 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate32
+#define Data	CARD32
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot32pack_180.c b/nx-X11/programs/Xserver/miext/shadow/shrot32pack_180.c
new file mode 100644
index 000000000..cbadba59d
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot32pack_180.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate32_180
+#define Data	CARD32
+#define ROTATE	180
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot32pack_270.c b/nx-X11/programs/Xserver/miext/shadow/shrot32pack_270.c
new file mode 100644
index 000000000..8f434b08e
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot32pack_270.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate32_270
+#define Data	CARD32
+#define ROTATE	270
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot32pack_90.c b/nx-X11/programs/Xserver/miext/shadow/shrot32pack_90.c
new file mode 100644
index 000000000..98c22c37d
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot32pack_90.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate32_90
+#define Data	CARD32
+#define ROTATE	90
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot8pack.c b/nx-X11/programs/Xserver/miext/shadow/shrot8pack.c
new file mode 100644
index 000000000..9e77f43e8
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot8pack.c
@@ -0,0 +1,32 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate8
+#define Data	CARD8
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot8pack_180.c b/nx-X11/programs/Xserver/miext/shadow/shrot8pack_180.c
new file mode 100644
index 000000000..6f4eca93e
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot8pack_180.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate8_180
+#define Data	CARD8
+#define ROTATE	180
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot8pack_270.c b/nx-X11/programs/Xserver/miext/shadow/shrot8pack_270.c
new file mode 100644
index 000000000..d56a3366c
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot8pack_270.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate8_270
+#define Data	CARD8
+#define ROTATE	270
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrot8pack_90.c b/nx-X11/programs/Xserver/miext/shadow/shrot8pack_90.c
new file mode 100644
index 000000000..2fed8126d
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrot8pack_90.c
@@ -0,0 +1,33 @@
+/*
+ * $XFree86$
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+#define FUNC	shadowUpdateRotate8_90
+#define Data	CARD8
+#define ROTATE	90
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "shrotpack.h"
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrotate.c b/nx-X11/programs/Xserver/miext/shadow/shrotate.c
new file mode 100644
index 000000000..927bc61be
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrotate.c
@@ -0,0 +1,314 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/shadow/shrotate.c,v 1.4tsi Exp $
+ *
+ * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "shadow.h"
+#include    "fb.h"
+
+/*
+ * These indicate which way the source (shadow) is scanned when
+ * walking the screen in a particular direction
+ */
+
+#define LEFT_TO_RIGHT	1
+#define RIGHT_TO_LEFT	-1
+#define TOP_TO_BOTTOM	2
+#define BOTTOM_TO_TOP	-2
+
+void
+shadowUpdateRotatePacked (ScreenPtr	pScreen,
+			  shadowBufPtr	pBuf)
+{
+    RegionPtr	damage = &pBuf->damage;
+    PixmapPtr	pShadow = pBuf->pPixmap;
+    int		nbox = REGION_NUM_RECTS (damage);
+    BoxPtr	pbox = REGION_RECTS (damage);
+    FbBits	*shaBits;
+    FbStride	shaStride;
+    int		shaBpp;
+    int		shaXoff, shaYoff;
+    int		box_x1, box_x2, box_y1, box_y2;
+    int		sha_x1 = 0, sha_y1 = 0;
+    int		scr_x1 = 0, scr_x2 = 0, scr_y1 = 0, scr_y2 = 0, scr_w, scr_h;
+    int		scr_x, scr_y;
+    int		w;
+    int		pixelsPerBits;
+    int		pixelsMask;
+    FbStride	shaStepOverY = 0, shaStepDownY = 0;
+    FbStride	shaStepOverX = 0, shaStepDownX = 0;
+    FbBits	*shaLine, *sha;
+    int		shaHeight = pShadow->drawable.height;
+    int		shaWidth = pShadow->drawable.width;
+    FbBits	shaMask;
+    int		shaFirstShift, shaShift;
+    int		o_x_dir;
+    int		o_y_dir;
+    int		x_dir;
+    int		y_dir;
+
+    fbGetDrawable (&pShadow->drawable, shaBits, shaStride, shaBpp, shaXoff, shaYoff);
+    pixelsPerBits = (sizeof (FbBits) * 8) / shaBpp;
+    pixelsMask = ~(pixelsPerBits - 1);
+    shaMask = FbBitsMask (FB_UNIT-shaBpp, shaBpp);
+    /*
+     * Compute rotation related constants to walk the shadow
+     */
+    o_x_dir = LEFT_TO_RIGHT;
+    o_y_dir = TOP_TO_BOTTOM;
+    if (pBuf->randr & SHADOW_REFLECT_X)
+	o_x_dir = -o_x_dir;
+    if (pBuf->randr & SHADOW_REFLECT_Y)
+	o_y_dir = -o_y_dir;
+    switch (pBuf->randr & (SHADOW_ROTATE_ALL)) {
+    case SHADOW_ROTATE_0:	/* upper left shadow -> upper left screen */
+    default:
+	x_dir = o_x_dir;
+	y_dir = o_y_dir;
+	break;
+    case SHADOW_ROTATE_90:    	/* upper right shadow -> upper left screen */
+	x_dir = o_y_dir;
+	y_dir = -o_x_dir;
+	break;
+    case SHADOW_ROTATE_180:	/* lower right shadow -> upper left screen */
+	x_dir = -o_x_dir;
+	y_dir = -o_y_dir;
+	break;
+    case SHADOW_ROTATE_270:	/* lower left shadow -> upper left screen */
+	x_dir = -o_y_dir;
+	y_dir = o_x_dir;
+	break;
+    }
+    switch (x_dir) {
+    case LEFT_TO_RIGHT:
+	shaStepOverX = shaBpp;
+	shaStepOverY = 0;
+	break;
+    case TOP_TO_BOTTOM:
+	shaStepOverX = 0;
+	shaStepOverY = shaStride;
+	break;
+    case RIGHT_TO_LEFT:
+	shaStepOverX = -shaBpp;
+	shaStepOverY = 0;
+	break;
+    case BOTTOM_TO_TOP:
+	shaStepOverX = 0;
+	shaStepOverY = -shaStride;
+	break;
+    }
+    switch (y_dir) {
+    case TOP_TO_BOTTOM:
+	shaStepDownX = 0;
+	shaStepDownY = shaStride;
+	break;
+    case RIGHT_TO_LEFT:
+	shaStepDownX = -shaBpp;
+	shaStepDownY = 0;
+	break;
+    case BOTTOM_TO_TOP:
+	shaStepDownX = 0;
+	shaStepDownY = -shaStride;
+	break;
+    case LEFT_TO_RIGHT:
+	shaStepDownX = shaBpp;
+	shaStepDownY = 0;
+	break;
+    }
+    
+    while (nbox--)
+    {
+        box_x1 = pbox->x1;
+        box_y1 = pbox->y1;
+        box_x2 = pbox->x2;
+        box_y2 = pbox->y2;
+        pbox++;
+
+	/*
+	 * Compute screen and shadow locations for this box
+	 */
+	switch (x_dir) {
+	case LEFT_TO_RIGHT:
+	    scr_x1 = box_x1 & pixelsMask;
+	    scr_x2 = (box_x2 + pixelsPerBits - 1) & pixelsMask;
+	    
+	    sha_x1 = scr_x1;
+	    break;
+	case TOP_TO_BOTTOM:
+	    scr_x1 = box_y1 & pixelsMask;
+	    scr_x2 = (box_y2 + pixelsPerBits - 1) & pixelsMask;
+
+	    sha_y1 = scr_x1;
+	    break;
+	case RIGHT_TO_LEFT:
+	    scr_x1 = (shaWidth - box_x2) & pixelsMask;
+	    scr_x2 = (shaWidth - box_x1 + pixelsPerBits - 1) & pixelsMask;
+
+	    sha_x1 = (shaWidth - scr_x1 - 1);
+	    break;
+	case BOTTOM_TO_TOP:
+	    scr_x1 = (shaHeight - box_y2) & pixelsMask;
+	    scr_x2 = (shaHeight - box_y1 + pixelsPerBits - 1) & pixelsMask;
+	    
+	    sha_y1 = (shaHeight - scr_x1 - 1);
+	    break;
+	}
+	switch (y_dir) {
+	case TOP_TO_BOTTOM:
+	    scr_y1 = box_y1;
+	    scr_y2 = box_y2;
+
+	    sha_y1 = scr_y1;
+	    break;
+	case RIGHT_TO_LEFT:
+	    scr_y1 = (shaWidth - box_x2);
+	    scr_y2 = (shaWidth - box_x1);
+
+	    sha_x1 = box_x2 - 1;
+	    break;
+	case BOTTOM_TO_TOP:
+	    scr_y1 = shaHeight - box_y2;
+	    scr_y2 = shaHeight - box_y1;
+	    
+	    sha_y1 = box_y2 - 1;
+	    break;
+	case LEFT_TO_RIGHT:
+	    scr_y1 = box_x1;
+	    scr_y2 = box_x2;
+
+	    sha_x1 = box_x1;
+	    break;
+	}
+	scr_w = ((scr_x2 - scr_x1) * shaBpp) >> FB_SHIFT;
+	scr_h = scr_y2 - scr_y1;
+	scr_y = scr_y1;
+
+	/* shift amount for first pixel on screen */ 
+	shaFirstShift = FB_UNIT - ((sha_x1 * shaBpp) & FB_MASK) - shaBpp;
+	
+	/* pointer to shadow data first placed on screen */
+	shaLine = (shaBits + 
+		   sha_y1 * shaStride + 
+		   ((sha_x1 * shaBpp) >> FB_SHIFT));
+
+	/*
+	 * Copy the bits, always write across the physical frame buffer
+	 * to take advantage of write combining.
+	 */
+	while (scr_h--)
+	{
+	    int	    p;
+	    FbBits  bits;
+	    FbBits  *win;
+	    int	    i;
+	    CARD32  winSize;
+	    
+	    sha = shaLine;
+	    shaShift = shaFirstShift;
+	    w = scr_w;
+	    scr_x = scr_x1 * shaBpp >> FB_SHIFT;
+
+	    while (w)
+	    {
+		/*
+		 * Map some of this line
+		 */
+		win = (FbBits *) (*pBuf->window) (pScreen,
+						  scr_y,
+						  scr_x << 2,
+						  SHADOW_WINDOW_WRITE,
+						  &winSize,
+						  pBuf->closure);
+		i = (winSize >> 2);
+		if (i > w)
+		    i = w;
+		w -= i;
+		scr_x += i;
+		/*
+		 * Copy the portion of the line mapped
+		 */
+		while (i--)
+		{
+		    bits = 0;
+		    p = pixelsPerBits;
+		    /*
+		     * Build one word of output from multiple inputs
+		     * 
+		     * Note that for 90/270 rotations, this will walk
+		     * down the shadow hitting each scanline once.
+		     * This is probably not very efficient.
+		     */
+		    while (p--)
+		    {
+			bits = FbScrLeft(bits, shaBpp);
+			bits |= FbScrRight (*sha, shaShift) & shaMask;
+
+			shaShift -= shaStepOverX;
+			if (shaShift >= FB_UNIT)
+			{
+			    shaShift -= FB_UNIT;
+			    sha--;
+			}
+			else if (shaShift < 0)
+			{
+			    shaShift += FB_UNIT;
+			    sha++;
+			}
+			sha += shaStepOverY;
+		    }
+		    *win++ = bits;
+		}
+	    }
+	    scr_y++;
+	    shaFirstShift -= shaStepDownX;
+	    if (shaFirstShift >= FB_UNIT)
+	    {
+		shaFirstShift -= FB_UNIT;
+		shaLine--;
+	    }
+	    else if (shaFirstShift < 0)
+	    {
+		shaFirstShift += FB_UNIT;
+		shaLine++;
+	    }
+	    shaLine += shaStepDownY;
+	}
+    }
+}
+
+shadowUpdateProc shadowUpdateRotatePackedWeak(void) {
+    return shadowUpdateRotatePacked;
+}
diff --git a/nx-X11/programs/Xserver/miext/shadow/shrotpack.h b/nx-X11/programs/Xserver/miext/shadow/shrotpack.h
new file mode 100644
index 000000000..062d8c394
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/shadow/shrotpack.h
@@ -0,0 +1,186 @@
+/*
+ * $XFree86: xc/programs/Xserver/miext/shadow/shrotpack.h,v 1.3 2001/05/29 04:54:13 keithp Exp $
+ *
+ * Copyright © 2000 Keith Packard
+ *
+ * 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.
+ */
+
+/*
+ * Thanks to Daniel Chemko <dchemko@intrinsyc.com> for making the 90 and 180
+ * orientations work.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include    <X11/X.h>
+#include    "scrnintstr.h"
+#include    "windowstr.h"
+#include    <X11/fonts/font.h>
+#include    "dixfontstr.h"
+#include    <X11/fonts/fontstruct.h>
+#include    "mi.h"
+#include    "regionstr.h"
+#include    "globals.h"
+#include    "gcstruct.h"
+#include    "shadow.h"
+#include    "fb.h"
+
+#define DANDEBUG         0
+
+#if ROTATE == 270
+
+#define SCRLEFT(x,y,w,h)    (pScreen->height - ((y) + (h)))
+#define SCRY(x,y,w,h)	    (x)
+#define SCRWIDTH(x,y,w,h)   (h)
+#define FIRSTSHA(x,y,w,h)   (((y) + (h) - 1) * shaStride + (x))
+#define STEPDOWN(x,y,w,h)   ((w)--)
+#define NEXTY(x,y,w,h)	    ((x)++)
+#define SHASTEPX(stride)    -(stride)
+#define SHASTEPY(stride)    (1)
+
+#elif ROTATE == 90
+
+#define SCRLEFT(x,y,w,h)    (y)
+#define SCRY(x,y,w,h)	    (pScreen->width - ((x) + (w)) - 1)
+#define SCRWIDTH(x,y,w,h)   (h)
+#define FIRSTSHA(x,y,w,h)   ((y) * shaStride + (x + w - 1))
+#define STEPDOWN(x,y,w,h)   ((w)--)
+#define NEXTY(x,y,w,h)	    ((void)(x))
+#define SHASTEPX(stride)    (stride)
+#define SHASTEPY(stride)    (-1)
+
+#elif ROTATE == 180
+
+#define SCRLEFT(x,y,w,h)    (pScreen->width - ((x) + (w)))
+#define SCRY(x,y,w,h)	    (pScreen->height - ((y) + (h)) - 1)
+#define SCRWIDTH(x,y,w,h)   (w)
+#define FIRSTSHA(x,y,w,h)   ((y + h - 1) * shaStride + (x + w - 1))
+#define STEPDOWN(x,y,w,h)   ((h)--)
+#define NEXTY(x,y,w,h)	    ((void)(y))
+#define SHASTEPX(stride)    (-1)
+#define SHASTEPY(stride)    -(stride)
+
+#else
+
+#define SCRLEFT(x,y,w,h)    (x)
+#define SCRY(x,y,w,h)	    (y)
+#define SCRWIDTH(x,y,w,h)   (w)
+#define FIRSTSHA(x,y,w,h)   ((y) * shaStride + (x))
+#define STEPDOWN(x,y,w,h)   ((h)--)
+#define NEXTY(x,y,w,h)	    ((y)++)
+#define SHASTEPX(stride)    (1)
+#define SHASTEPY(stride)    (stride)
+
+#endif
+
+void
+FUNC (ScreenPtr	    pScreen,
+      shadowBufPtr  pBuf)
+{
+    RegionPtr	damage = &pBuf->damage;
+    PixmapPtr	pShadow = pBuf->pPixmap;
+    int		nbox = REGION_NUM_RECTS (damage);
+    BoxPtr	pbox = REGION_RECTS (damage);
+    FbBits	*shaBits;
+    Data	*shaBase, *shaLine, *sha;
+    FbStride	shaStride;
+    int		scrBase, scrLine, scr;
+    int		shaBpp;
+    int		shaXoff, shaYoff;   /* XXX assumed to be zero */
+    int		x, y, w, h, width;
+    int         i;
+    Data	*winBase = NULL, *win;
+    CARD32	winSize;
+
+    fbGetDrawable (&pShadow->drawable, shaBits, shaStride, shaBpp, shaXoff, shaYoff);
+    shaBase = (Data *) shaBits;
+    shaStride = shaStride * sizeof (FbBits) / sizeof (Data);
+#if (DANDEBUG > 1)
+    ErrorF ("-> Entering Shadow Update:\r\n   |- Origins: pShadow=%x, pScreen=%x, damage=%x\r\n   |- Metrics: shaStride=%d, shaBase=%x, shaBpp=%d\r\n   |                                                     \n", pShadow, pScreen, damage, shaStride, shaBase, shaBpp);
+#endif
+    while (nbox--)
+    {
+        x = pbox->x1;
+        y = pbox->y1;
+        w = (pbox->x2 - pbox->x1);
+        h = pbox->y2 - pbox->y1;
+        
+#if (DANDEBUG > 2)
+        ErrorF ("   |-> Redrawing box - Metrics: X=%d, Y=%d, Width=%d, Height=%d\n", x, y, w, h);
+#endif
+        scrLine = SCRLEFT(x,y,w,h);
+        shaLine = shaBase + FIRSTSHA(x,y,w,h);
+        
+        while (STEPDOWN(x,y,w,h))
+        {
+            winSize = 0;
+            scrBase = 0;
+            width = SCRWIDTH(x,y,w,h);
+            scr = scrLine;
+            sha = shaLine;
+#if (DANDEBUG > 3)
+            ErrorF ("   |   |-> StepDown - Metrics: width=%d, scr=%x, sha=%x\n", width, scr, sha);
+#endif
+            while (width)
+            {
+                /*  how much remains in this window */
+                i = scrBase + winSize - scr;
+                if (i <= 0 || scr < scrBase)
+                {
+                    winBase = (Data *) (*pBuf->window) (pScreen,
+							SCRY(x,y,w,h),
+							scr * sizeof (Data),
+							SHADOW_WINDOW_WRITE,
+							&winSize,
+							pBuf->closure);
+                    if(!winBase)
+                        return;
+                    scrBase = scr;
+                    winSize /= sizeof (Data);
+                    i = winSize;
+#if(DANDEBUG > 4)
+                    ErrorF ("   |   |   |-> Starting New Line - Metrics: winBase=%x, scrBase=%x, winSize=%d\r\n   |   |   |   Xstride=%d, Ystride=%d, w=%d h=%d\n", winBase, scrBase, winSize, SHASTEPX(shaStride), SHASTEPY(shaStride), w, h);
+#endif
+                }
+                win = winBase + (scr - scrBase);
+                if (i > width)
+                    i = width;
+                width -= i;
+                scr += i;
+#if(DANDEBUG > 5)
+		ErrorF ("   |   |   |-> Writing Line - Metrics: win=%x, sha=%x\n", win, sha);
+#endif
+                while (i--)
+                {
+#if(DANDEBUG > 6)
+		    ErrorF ("   |   |   |-> Writing Pixel - Metrics: win=%x, sha=%d, remaining=%d\n", win, sha, i);
+#endif
+                    *win++ = *sha;
+                    sha += SHASTEPX(shaStride);
+                } /*  i */
+            } /*  width */
+            shaLine += SHASTEPY(shaStride);
+            NEXTY(x,y,w,h);
+        } /*  STEPDOWN */
+        pbox++;
+    } /*  nbox */
+}