Initial revision

8 files changed, 6241 insertions, 0 deletions

diff --git a/mi/mibank.c b/mi/mibank.c
new file mode 100644
index 000000000..a6e1942c2
--- /dev/null
+++ b/mi/mibank.c
@@ -0,0 +1,2573 @@
+/*
+ * Copyright 1997 through 2003 by Marc Aurele La France (TSI @ UQV), tsi@xfree86.org
+ *
+ * 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 Marc Aurele La France not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  Marc Aurele La France makes no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as-is" without express or implied warranty.
+ *
+ * MARC AURELE LA FRANCE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO
+ * EVENT SHALL MARC AURELE LA FRANCE 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.
+ */
+
+/*
+ * Copyright 1990,91,92,93 by Thomas Roell, Germany.
+ * Copyright 1991,92,93    by SGCS (Snitily Graphics Consulting Services), USA.
+ *
+ * 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 Thomas Roell nor
+ * SGCS be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ * Thomas Roell nor SGCS makes no representations about the suitability
+ * of this software for any purpose. It is provided "as is" without
+ * express or implied warranty.
+ *
+ * THOMAS ROELL AND SGCS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR SGCS 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/mi/mibank.c,v 1.13 2003/01/01 19:16:42 tsi Exp $ */
+
+/*
+ * This thing originated from an idea of Edwin Goei and his bank switching
+ * code for the DEC TX board.
+ */
+
+/*
+ * Heavily modified for the XFree86 Project to turn this into an mi wrapper.
+ * ---  Marc Aurele La France (tsi@xfree86.org)
+ */
+
+/*
+ * "Heavily modified", indeed!  By the time this is finalized, there probably
+ * won't be much left of Roell's code...
+ *
+ * Miscellaneous notes:
+ * - Pixels with imbedded bank boundaries are required to be off-screen.  There
+ *   >might< be a way to fool the underlying framebuffer into dealing with
+ *   partial pixels.
+ * - Plans to generalise this to do (hardware) colour plane switching have been
+ *   dropped due to colour flashing concerns.
+ *
+ * TODO:
+ * - Allow miModifyBanking() to change BankSize and nBankDepth.
+ * - Re-instate shared and double banking for framebuffers whose pixmap formats
+ *   don't describe how the server "sees" the screen.
+ * - Remove remaining assumptions that a pixmap's devPrivate field points
+ *   directly to its pixel data.
+ */
+
+/* #define NO_ALLOCA 1 */
+
+#include "servermd.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+#include "mi.h"
+#include "mibank.h"
+
+#define BANK_SINGLE 0
+#define BANK_SHARED 1
+#define BANK_DOUBLE 2
+#define BANK_NOBANK 3
+
+typedef struct _miBankScreen
+{
+    miBankInfoRec BankInfo;
+    unsigned int  nBankBPP;
+    unsigned int  type;
+
+    unsigned long nBitsPerBank;
+    unsigned long nBitsPerScanline;
+    unsigned long nPixelsPerScanlinePadUnit;
+
+    PixmapPtr     pScreenPixmap;
+    PixmapPtr     pBankPixmap;
+    GCPtr         pBankGC;
+
+    int           nBanks, maxRects;
+    RegionPtr     *pBanks;
+
+    pointer       pbits;
+
+    /*
+     * Screen Wrappers
+     */
+    CreateScreenResourcesProcPtr  CreateScreenResources;
+    ModifyPixmapHeaderProcPtr     ModifyPixmapHeader;
+    CloseScreenProcPtr            CloseScreen;
+    GetImageProcPtr               GetImage;
+    GetSpansProcPtr               GetSpans;
+    CreateGCProcPtr               CreateGC;
+    PaintWindowBackgroundProcPtr  PaintWindowBackground;
+    PaintWindowBorderProcPtr      PaintWindowBorder;
+    CopyWindowProcPtr             CopyWindow;
+    BSFuncRec                     BackingStoreFuncs;
+} miBankScreenRec, *miBankScreenPtr;
+
+typedef struct _miBankGC
+{
+    GCOps     *wrappedOps,   *unwrappedOps;
+    GCFuncs   *wrappedFuncs, *unwrappedFuncs;
+
+    Bool      fastCopy, fastPlane;
+
+    RegionPtr pBankedClips[1];
+} miBankGCRec, *miBankGCPtr;
+
+typedef struct _miBankQueue
+{
+    Bool           fastBlit;
+    unsigned short srcBankNo;
+    unsigned short dstBankNo;
+    short          x;
+    short          y;
+    short          w;
+    short          h;
+} miBankQueue;
+
+/*
+ * CAVEAT:  This banking scheme requires that the DDX store Pixmap data in the
+ *          server's address space.
+ */
+
+#define ModifyPixmap(_pPix, _width, _devKind, _pbits) \
+    (*pScreen->ModifyPixmapHeader)((_pPix), \
+        (_width), -1, -1, -1, (_devKind), (_pbits))
+
+#define SET_SINGLE_BANK(_pPix, _width, _devKind, _no) \
+    ModifyPixmap(_pPix, _width, _devKind, \
+        (char *)pScreenPriv->BankInfo.pBankA + \
+        (*pScreenPriv->BankInfo.SetSourceAndDestinationBanks)(pScreen, (_no)) - \
+        (pScreenPriv->BankInfo.BankSize * (_no)))
+
+#define SET_SOURCE_BANK(_pPix, _width, _devKind, _no) \
+    ModifyPixmap(_pPix, _width, _devKind, \
+        (char *)pScreenPriv->BankInfo.pBankA + \
+        (*pScreenPriv->BankInfo.SetSourceBank)(pScreen, (_no)) - \
+        (pScreenPriv->BankInfo.BankSize * (_no)))
+
+#define SET_DESTINATION_BANK(_pPix, _width, _devKind, _no) \
+    ModifyPixmap(_pPix, _width, _devKind, \
+        (char *)pScreenPriv->BankInfo.pBankB + \
+        (*pScreenPriv->BankInfo.SetDestinationBank)(pScreen, (_no)) - \
+        (pScreenPriv->BankInfo.BankSize * (_no)))
+
+#define ALLOCATE_LOCAL_ARRAY(atype, ntype) \
+    (atype *)ALLOCATE_LOCAL((ntype) * sizeof(atype))
+
+static int           miBankScreenIndex;
+static int           miBankGCIndex;
+static unsigned long miBankGeneration = 0;
+
+#define BANK_SCRPRIVLVAL pScreen->devPrivates[miBankScreenIndex].ptr
+
+#define BANK_SCRPRIVATE ((miBankScreenPtr)(BANK_SCRPRIVLVAL))
+
+#define BANK_GCPRIVLVAL(pGC) (pGC)->devPrivates[miBankGCIndex].ptr
+
+#define BANK_GCPRIVATE(pGC) ((miBankGCPtr)(BANK_GCPRIVLVAL(pGC)))
+
+#define PIXMAP_STATUS(_pPix) \
+    pointer pbits = (_pPix)->devPrivate.ptr
+
+#define PIXMAP_SAVE(_pPix) \
+    PIXMAP_STATUS(_pPix); \
+    if (pbits == (pointer)pScreenPriv) \
+        (_pPix)->devPrivate.ptr = pScreenPriv->pbits
+
+#define PIXMAP_RESTORE(_pPix) \
+    (_pPix)->devPrivate.ptr = pbits
+
+#define BANK_SAVE \
+    int width   = pScreenPriv->pBankPixmap->drawable.width; \
+    int devKind = pScreenPriv->pBankPixmap->devKind; \
+    PIXMAP_SAVE(pScreenPriv->pBankPixmap)
+
+#define BANK_RESTORE \
+    pScreenPriv->pBankPixmap->drawable.width = width; \
+    pScreenPriv->pBankPixmap->devKind = devKind; \
+    PIXMAP_RESTORE(pScreenPriv->pBankPixmap)
+
+#define SCREEN_STATUS \
+    PIXMAP_STATUS(pScreenPriv->pScreenPixmap)
+
+#define SCREEN_SAVE \
+    PIXMAP_SAVE(pScreenPriv->pScreenPixmap)
+
+#define SCREEN_RESTORE \
+    PIXMAP_RESTORE(pScreenPriv->pScreenPixmap)
+
+#define SCREEN_INIT \
+    miBankScreenPtr pScreenPriv = BANK_SCRPRIVATE
+
+#define SCREEN_UNWRAP(field) \
+    pScreen->field = pScreenPriv->field
+
+#define SCREEN_WRAP(field, wrapper) \
+    pScreenPriv->field = pScreen->field; \
+    pScreen->field     = wrapper
+
+#define GC_INIT(pGC) \
+    miBankGCPtr pGCPriv = BANK_GCPRIVATE(pGC)
+
+#define GC_UNWRAP(pGC) \
+    pGCPriv->unwrappedOps   = (pGC)->ops; \
+    pGCPriv->unwrappedFuncs = (pGC)->funcs; \
+    (pGC)->ops              = pGCPriv->wrappedOps; \
+    (pGC)->funcs            = pGCPriv->wrappedFuncs
+
+#define GC_WRAP(pGC) \
+    pGCPriv->wrappedOps   = (pGC)->ops; \
+    pGCPriv->wrappedFuncs = (pGC)->funcs; \
+    (pGC)->ops            = pGCPriv->unwrappedOps; \
+    (pGC)->funcs          = pGCPriv->unwrappedFuncs
+
+#define IS_BANKED(pDrawable) \
+    ((pbits == (pointer)pScreenPriv) && \
+     (((DrawablePtr)(pDrawable))->type == DRAWABLE_WINDOW))
+
+#define CLIP_SAVE \
+    RegionPtr pOrigCompositeClip = pGC->pCompositeClip
+
+#define CLIP_RESTORE \
+    pGC->pCompositeClip = pOrigCompositeClip
+
+#define GCOP_INIT \
+    ScreenPtr pScreen = pGC->pScreen; \
+    SCREEN_INIT; \
+    GC_INIT(pGC)
+
+#define GCOP_UNWRAP \
+    GC_UNWRAP(pGC)
+
+#define GCOP_WRAP \
+    GC_WRAP(pGC)
+
+#define GCOP_TOP_PART \
+    for (i = 0;  i < pScreenPriv->nBanks;  i++) \
+    { \
+        if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[i])) \
+            continue; \
+        GCOP_UNWRAP; \
+        SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i)
+
+#define GCOP_BOTTOM_PART \
+        GCOP_WRAP; \
+    }
+
+#define GCOP_SIMPLE(statement) \
+    if (nArray > 0) \
+    { \
+        GCOP_INIT; \
+        SCREEN_SAVE; \
+        if (!IS_BANKED(pDrawable)) \
+        { \
+            GCOP_UNWRAP; \
+            statement; \
+            GCOP_WRAP; \
+        } \
+        else \
+        { \
+            int i; \
+            CLIP_SAVE; \
+            GCOP_TOP_PART; \
+            statement; \
+            GCOP_BOTTOM_PART; \
+            CLIP_RESTORE; \
+        } \
+        SCREEN_RESTORE; \
+    }
+
+#define GCOP_0D_ARGS mode,
+#define GCOP_1D_ARGS
+#define GCOP_2D_ARGS shape, mode, 
+
+#define GCOP_COMPLEX(aop, atype) \
+    if (nArray > 0) \
+    { \
+        GCOP_INIT; \
+        SCREEN_SAVE; \
+        if (!IS_BANKED(pDrawable)) \
+        { \
+            GCOP_UNWRAP; \
+            (*pGC->ops->aop)(pDrawable, pGC, GCOP_ARGS nArray, pArray); \
+            GCOP_WRAP; \
+        } \
+        else \
+        { \
+            atype *aarg = pArray, *acopy; \
+            int   i; \
+            CLIP_SAVE; \
+            if ((acopy = ALLOCATE_LOCAL_ARRAY(atype, nArray))) \
+                aarg = acopy; \
+            GCOP_TOP_PART; \
+            if (acopy) \
+                memcpy(acopy, pArray, nArray * sizeof(atype)); \
+            (*pGC->ops->aop)(pDrawable, pGC, GCOP_ARGS nArray, aarg); \
+            GCOP_BOTTOM_PART; \
+            DEALLOCATE_LOCAL(acopy); \
+            CLIP_RESTORE; \
+        } \
+        SCREEN_RESTORE; \
+    }
+
+/*********************
+ * Utility functions *
+ *********************/
+
+static int
+miBankOf(
+    miBankScreenPtr pScreenPriv,
+    int             x,
+    int             y
+)
+{
+    int iBank = ((x * (int)pScreenPriv->nBankBPP) +
+                 (y * (long)pScreenPriv->nBitsPerScanline)) /
+                (long)pScreenPriv->nBitsPerBank;
+
+    if (iBank < 0)
+        iBank = 0;
+    else if (iBank >= pScreenPriv->nBanks)
+        iBank = pScreenPriv->nBanks - 1;
+
+    return iBank;
+}
+
+#define FirstBankOf(_x, _y) miBankOf(pScreenPriv, (_x), (_y))
+#define  LastBankOf(_x, _y) miBankOf(pScreenPriv, (_x) - 1, (_y))
+
+/* Determine banking type from the BankInfoRec */
+static unsigned int
+miBankDeriveType(
+    ScreenPtr     pScreen,
+    miBankInfoPtr pBankInfo
+)
+{
+    unsigned int type;
+
+    if (pBankInfo->pBankA == pBankInfo->pBankB)
+    {
+        if (pBankInfo->SetSourceBank == pBankInfo->SetDestinationBank)
+        {
+            if (pBankInfo->SetSourceAndDestinationBanks !=
+                pBankInfo->SetSourceBank)
+                return BANK_NOBANK;
+
+            type = BANK_SINGLE;
+        }
+        else
+        {
+            if (pBankInfo->SetSourceAndDestinationBanks ==
+                pBankInfo->SetDestinationBank)
+                return BANK_NOBANK;
+            if (pBankInfo->SetSourceAndDestinationBanks ==
+                pBankInfo->SetSourceBank)
+                return BANK_NOBANK;
+
+            type = BANK_SHARED;
+        }
+    }
+    else
+    {
+        if ((unsigned long)abs((char *)pBankInfo->pBankA -
+                               (char *)pBankInfo->pBankB) < pBankInfo->BankSize)
+            return BANK_NOBANK;
+
+        if (pBankInfo->SetSourceBank == pBankInfo->SetDestinationBank)
+        {
+            if (pBankInfo->SetSourceAndDestinationBanks !=
+                pBankInfo->SetSourceBank)
+                return BANK_NOBANK;
+        }
+        else
+        {
+            if (pBankInfo->SetSourceAndDestinationBanks ==
+                pBankInfo->SetDestinationBank)
+                return BANK_NOBANK;
+        }
+
+        type = BANK_DOUBLE;
+    }
+
+    /*
+     * Internal limitation:  Currently, only single banking is supported when
+     * the pixmap format and the screen's pixel format are different.  The
+     * following test is only partially successful at detecting this condition.
+     */
+    if (pBankInfo->nBankDepth != pScreen->rootDepth)
+        type = BANK_SINGLE;
+
+    return type;
+}
+
+/* Least common multiple */
+static unsigned int
+miLCM(
+    unsigned int x,
+    unsigned int y
+)
+{
+    unsigned int m = x, n = y, o;
+
+    while ((o = m % n))
+    {
+        m = n;
+        n = o;
+    }
+
+    return (x / n) * y;
+}
+
+/******************
+ * GCOps wrappers *
+ ******************/
+
+static void
+miBankFillSpans(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         nArray,
+    DDXPointPtr pptInit,
+    int         *pwidthInit,
+    int         fSorted
+)
+{
+    GCOP_SIMPLE((*pGC->ops->FillSpans)(pDrawable, pGC,
+        nArray, pptInit, pwidthInit, fSorted));
+}
+
+static void
+miBankSetSpans(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    char        *psrc,
+    DDXPointPtr ppt,
+    int         *pwidth,
+    int         nArray,
+    int         fSorted
+)
+{
+    GCOP_SIMPLE((*pGC->ops->SetSpans)(pDrawable, pGC, psrc,
+        ppt, pwidth, nArray, fSorted));
+}
+
+static void
+miBankPutImage(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         depth,
+    int         x,
+    int         y,
+    int         w,
+    int         h,
+    int         leftPad,
+    int         format,
+    char        *pImage
+)
+{
+    if ((w > 0) && (h > 0))
+    {
+        GCOP_INIT;
+        SCREEN_SAVE;
+
+        if (!IS_BANKED(pDrawable))
+        {
+            GCOP_UNWRAP;
+
+            (*pGC->ops->PutImage)(pDrawable, pGC, depth, x, y, w, h,
+                leftPad, format, pImage);
+
+            GCOP_WRAP;
+        }
+        else
+        {
+            int i, j;
+
+            CLIP_SAVE;
+
+            i = FirstBankOf(x + pDrawable->x,     y + pDrawable->y);
+            j =  LastBankOf(x + pDrawable->x + w, y + pDrawable->y + h);
+            for (;  i <= j;  i++)
+            {
+                if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[i]))
+                    continue;
+
+                GCOP_UNWRAP;
+
+                SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
+
+                (*pGC->ops->PutImage)(pDrawable, pGC, depth, x, y, w, h,
+                    leftPad, format, pImage);
+
+                GCOP_WRAP;
+            }
+
+            CLIP_RESTORE;
+        }
+
+        SCREEN_RESTORE;
+    }
+}
+
+/*
+ * Here the CopyArea/CopyPlane wrappers.  First off, we have to clip against
+ * the source in order to make the minimal number of copies in case of slow
+ * systems.  Also the exposure handling is quite tricky.  Special attention
+ * is to be given to the way the copies are sequenced.  The list of boxes after
+ * the source clip is used to build a workqueue, that contains the atomic
+ * copies (i.e. only from one bank to one bank).  Doing so produces a minimal
+ * list of things to do.
+ */
+static RegionPtr
+miBankCopy(
+    DrawablePtr   pSrc,
+    DrawablePtr   pDst,
+    GCPtr         pGC,
+    int           srcx,
+    int           srcy,
+    int           w,
+    int           h,
+    int           dstx,
+    int           dsty,
+    unsigned long plane,
+    Bool          SinglePlane
+)
+{
+    int         cx1, cy1, cx2, cy2;
+    int         ns, nd, nse, nde, dx, dy, xorg = 0, yorg = 0;
+    int         maxWidth = 0, maxHeight = 0, paddedWidth = 0;
+    int         nBox, nBoxClipSrc, nBoxClipDst, nQueue;
+    BoxPtr      pBox, pBoxClipSrc, pBoxClipDst;
+    BoxRec      fastBox, ccBox;
+    RegionPtr   ret = NULL, prgnSrcClip = NULL;
+    RegionRec   rgnDst;
+    char        *pImage = NULL;
+    miBankQueue *pQueue, *pQueueNew, *Queue;
+    miBankQueue *pQueueTmp, *pQueueNext, *pQueueBase;
+    Bool        fastBlit, freeSrcClip, fastClip;
+    Bool        fExpose = FALSE, fastExpose = FALSE;
+
+    GCOP_INIT;
+    SCREEN_SAVE;
+
+    if (!IS_BANKED(pSrc) && !IS_BANKED(pDst))
+    {
+        GCOP_UNWRAP;
+
+        if (SinglePlane)
+            ret = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
+                srcx, srcy, w, h, dstx, dsty, plane);
+        else
+            ret = (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
+                srcx, srcy, w, h, dstx, dsty);
+
+        GCOP_WRAP;
+    }
+    else if (!IS_BANKED(pDst))
+    {
+        fExpose = pGC->fExpose;
+        pGC->fExpose = FALSE;
+
+        xorg = pSrc->x;
+        yorg = pSrc->y;
+        dx   = dstx - srcx;
+        dy   = dsty - srcy;
+        srcx += xorg;
+        srcy += yorg;
+
+        ns = FirstBankOf(srcx,     srcy);
+        nse = LastBankOf(srcx + w, srcy + h);
+        for (;  ns <= nse;  ns++)
+        {
+            if (!pScreenPriv->pBanks[ns])
+                continue;
+
+            nBox = REGION_NUM_RECTS(pScreenPriv->pBanks[ns]);
+            pBox = REGION_RECTS(pScreenPriv->pBanks[ns]);
+
+            for (;  nBox--;  pBox++)
+            {
+                cx1 = max(pBox->x1, srcx);
+                cy1 = max(pBox->y1, srcy);
+                cx2 = min(pBox->x2, srcx + w);
+                cy2 = min(pBox->y2, srcy + h);
+
+                if ((cx1 >= cx2) || (cy1 >= cy2))
+                    continue;
+
+                GCOP_UNWRAP;
+
+                SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, ns);
+
+                if (SinglePlane)
+                    (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
+                        cx1 - xorg, cy1 - yorg,
+                        cx2 - cx1, cy2 - cy1,
+                        cx1 + dx - xorg, cy1 + dy - yorg, plane);
+                else
+                    (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
+                        cx1 - xorg, cy1 - yorg,
+                        cx2 - cx1, cy2 - cy1,
+                        cx1 + dx - xorg, cy1 + dy - yorg);
+
+                GCOP_WRAP;
+            }
+        }
+
+        pGC->fExpose = fExpose;
+        srcx -= xorg;
+        srcy -= yorg;
+    }
+    else if (!IS_BANKED(pSrc))
+    {
+        CLIP_SAVE;
+
+        if (pGC->miTranslate)
+        {
+            xorg = pDst->x;
+            yorg = pDst->y;
+        }
+        dx = srcx - dstx;
+        dy = srcy - dsty;
+        dstx += xorg;
+        dsty += yorg;
+
+        nd = FirstBankOf(dstx,     dsty);
+        nde = LastBankOf(dstx + w, dsty + h);
+        for (;  nd <= nde;  nd++)
+        {
+            if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[nd]))
+                continue;
+
+            /*
+             * It's faster to let the lower-level CopyArea do the clipping
+             * within each bank.
+             */
+            nBox = REGION_NUM_RECTS(pScreenPriv->pBanks[nd]);
+            pBox = REGION_RECTS(pScreenPriv->pBanks[nd]);
+
+            for (;  nBox--;  pBox++)
+            {
+                cx1 = max(pBox->x1, dstx);
+                cy1 = max(pBox->y1, dsty);
+                cx2 = min(pBox->x2, dstx + w);
+                cy2 = min(pBox->y2, dsty + h);
+
+                if ((cx1 >= cx2) || (cy1 >= cy2))
+                    continue;
+
+                GCOP_UNWRAP;
+
+                SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, nd);
+
+                if (SinglePlane)
+                    (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
+                        cx1 + dx - xorg, cy1 + dy - yorg,
+                        cx2 - cx1, cy2 - cy1,
+                        cx1 - xorg, cy1 - yorg, plane);
+                else
+                    (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
+                        cx1 + dx - xorg, cy1 + dy - yorg,
+                        cx2 - cx1, cy2 - cy1,
+                        cx1 - xorg, cy1 - yorg);
+
+                GCOP_WRAP;
+            }
+        }
+
+        CLIP_RESTORE;
+    }
+    else /* IS_BANKED(pSrc) && IS_BANKED(pDst) */
+    {
+        CLIP_SAVE;
+
+        fExpose = pGC->fExpose;
+
+        fastBox.x1 = srcx + pSrc->x;
+        fastBox.y1 = srcy + pSrc->y;
+        fastBox.x2 = fastBox.x1 + w;
+        fastBox.y2 = fastBox.y1 + h;
+
+        dx = dstx - fastBox.x1;
+        dy = dsty - fastBox.y1;
+        if (pGC->miTranslate)
+        {
+            xorg = pDst->x;
+            yorg = pDst->y;
+        }
+
+        /*
+         * Clip against the source.  Otherwise we will blit too much for SINGLE
+         * and SHARED banked systems.
+         */
+        freeSrcClip = FALSE;
+        fastClip    = FALSE;
+        fastExpose  = FALSE;
+
+        if (pGC->subWindowMode != IncludeInferiors)
+            prgnSrcClip = &((WindowPtr)pSrc)->clipList;
+        else if (!((WindowPtr)pSrc)->parent)
+            fastClip = TRUE;
+        else if ((pSrc == pDst) && (pGC->clientClipType == CT_NONE))
+            prgnSrcClip = pGC->pCompositeClip;
+        else
+        {
+            prgnSrcClip = NotClippedByChildren((WindowPtr)pSrc);
+            freeSrcClip = TRUE;
+        }
+
+        if (fastClip)
+        {
+            fastExpose = TRUE;
+
+            /*
+             * Clip the source.  If regions extend beyond the source size, make
+             * sure exposure events get sent.
+             */
+            if (fastBox.x1 < pSrc->x)
+            {
+                fastBox.x1 = pSrc->x;
+                fastExpose = FALSE;
+            }
+            if (fastBox.y1 < pSrc->y)
+            {
+                fastBox.y1 = pSrc->y;
+                fastExpose = FALSE;
+            }
+            if (fastBox.x2 > pSrc->x + (int) pSrc->width)
+            {
+                fastBox.x2 = pSrc->x + (int) pSrc->width;
+                fastExpose = FALSE;
+            }
+            if (fastBox.y2 > pSrc->y + (int) pSrc->height)
+            {
+                fastBox.y2 = pSrc->y + (int) pSrc->height;
+                fastExpose = FALSE;
+            }
+
+            nBox = 1;
+            pBox = &fastBox;
+        }
+        else
+        {
+            REGION_INIT(pScreen, &rgnDst, &fastBox, 1);
+            REGION_INTERSECT(pScreen, &rgnDst, &rgnDst, prgnSrcClip);
+            pBox = REGION_RECTS(&rgnDst);
+            nBox = REGION_NUM_RECTS(&rgnDst);
+        }
+
+        /*
+         * fastBlit can only be TRUE if we don't need to worry about attempts
+         * to read partial pixels through the destination bank.
+         */
+        if (SinglePlane)
+            fastBlit = pGCPriv->fastPlane;
+        else
+            fastBlit = pGCPriv->fastCopy;
+
+        nQueue = nBox * pScreenPriv->maxRects * 2;
+        pQueue = Queue = ALLOCATE_LOCAL_ARRAY(miBankQueue, nQueue);
+
+        if (Queue)
+        {
+            for (;  nBox--;  pBox++)
+            {
+                ns = FirstBankOf(pBox->x1, pBox->y1);
+                nse = LastBankOf(pBox->x2, pBox->y2);
+                for (;  ns <= nse;  ns++)
+                {
+                    if (!pScreenPriv->pBanks[ns])
+                        continue;
+
+                    nBoxClipSrc = REGION_NUM_RECTS(pScreenPriv->pBanks[ns]);
+                    pBoxClipSrc = REGION_RECTS(pScreenPriv->pBanks[ns]);
+
+                    for (;  nBoxClipSrc--;  pBoxClipSrc++)
+                    {
+                        cx1 = max(pBox->x1, pBoxClipSrc->x1);
+                        cy1 = max(pBox->y1, pBoxClipSrc->y1);
+                        cx2 = min(pBox->x2, pBoxClipSrc->x2);
+                        cy2 = min(pBox->y2, pBoxClipSrc->y2);
+
+                        /* Check to see if the region is empty */
+                        if ((cx1 >= cx2) || (cy1 >= cy2))
+                            continue;
+
+                        /* Translate c[xy]* to destination coordinates */
+                        cx1 += dx + xorg;
+                        cy1 += dy + yorg;
+                        cx2 += dx + xorg;
+                        cy2 += dy + yorg;
+
+                        nd = FirstBankOf(cx1, cy1);
+                        nde = LastBankOf(cx2, cy2);
+                        for (;  nd <= nde;  nd++)
+                        {
+                            if (!pGCPriv->pBankedClips[nd])
+                                continue;
+
+                            /*
+                             * Clients can send quite large clip descriptions,
+                             * so use the bank clips here instead.
+                             */
+                            nBoxClipDst =
+                                REGION_NUM_RECTS(pScreenPriv->pBanks[nd]);
+                            pBoxClipDst =
+                                REGION_RECTS(pScreenPriv->pBanks[nd]);
+
+                            for (;  nBoxClipDst--;  pBoxClipDst++)
+                            {
+                                ccBox.x1 = max(cx1, pBoxClipDst->x1);
+                                ccBox.y1 = max(cy1, pBoxClipDst->y1);
+                                ccBox.x2 = min(cx2, pBoxClipDst->x2);
+                                ccBox.y2 = min(cy2, pBoxClipDst->y2);
+
+                                /* Check to see if the region is empty */
+                                if ((ccBox.x1 >= ccBox.x2) ||
+                                    (ccBox.y1 >= ccBox.y2))
+                                    continue;
+
+                                pQueue->srcBankNo = ns;
+                                pQueue->dstBankNo = nd;
+                                pQueue->x         = ccBox.x1 - xorg;
+                                pQueue->y         = ccBox.y1 - yorg;
+                                pQueue->w         = ccBox.x2 - ccBox.x1;
+                                pQueue->h         = ccBox.y2 - ccBox.y1;
+
+                                if (maxWidth < pQueue->w)
+                                    maxWidth = pQueue->w;
+                                if (maxHeight < pQueue->h)
+                                    maxHeight = pQueue->h;
+
+                                /*
+                                 * When shared banking is used and the source
+                                 * and destination banks differ, prevent
+                                 * attempts to fetch partial scanline pad units
+                                 * through the destination bank.
+                                 */
+                                pQueue->fastBlit = fastBlit;
+                                if (fastBlit &&
+                                    (pScreenPriv->type == BANK_SHARED) &&
+                                    (ns != nd) &&
+                                    ((ccBox.x1 %
+                                      pScreenPriv->nPixelsPerScanlinePadUnit) ||
+                                     (ccBox.x2 %
+                                      pScreenPriv->nPixelsPerScanlinePadUnit) ||
+                                     (RECT_IN_REGION(pScreen,
+                                       pGCPriv->pBankedClips[nd], &ccBox) !=
+                                      rgnIN)))
+                                    pQueue->fastBlit = FALSE;
+                                pQueue++;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!fastClip)
+        {
+            REGION_UNINIT(pScreen, &rgnDst);
+            if (freeSrcClip)
+                REGION_DESTROY(pScreen, prgnSrcClip);
+        }
+
+        pQueueNew = pQueue;
+        nQueue = pQueue - Queue;
+
+        if (nQueue > 0)
+        {
+            BANK_SAVE;
+
+            pQueue = Queue;
+
+            if ((nQueue > 1) &&
+                ((pSrc == pDst) || (pGC->subWindowMode == IncludeInferiors)))
+            {
+                if ((srcy + pSrc->y) < (dsty + yorg))
+                {
+                    /* Sort from bottom to top */
+                    pQueueBase = pQueueNext = pQueue + nQueue - 1;
+
+                    while (pQueueBase >= pQueue)
+                    {
+                        while ((pQueueNext >= pQueue) &&
+                               (pQueueBase->y == pQueueNext->y))
+                            pQueueNext--;
+
+                        pQueueTmp = pQueueNext + 1;
+                        while (pQueueTmp <= pQueueBase)
+                            *pQueueNew++ = *pQueueTmp++;
+
+                        pQueueBase = pQueueNext;
+                    }
+
+                    pQueueNew -= nQueue;
+                    pQueue = pQueueNew;
+                    pQueueNew = Queue;
+                }
+
+                if ((srcx + pSrc->x) < (dstx + xorg))
+                {
+                    /* Sort from right to left */
+                    pQueueBase = pQueueNext = pQueue;
+
+                    while (pQueueBase < pQueue + nQueue)
+                    {
+                        while ((pQueueNext < pQueue + nQueue) &&
+                               (pQueueNext->y == pQueueBase->y))
+                            pQueueNext++;
+
+                        pQueueTmp = pQueueNext;
+                        while (pQueueTmp != pQueueBase)
+                            *pQueueNew++ = *--pQueueTmp;
+
+                        pQueueBase = pQueueNext;
+                    }
+
+                    pQueueNew -= nQueue;
+                    pQueue = pQueueNew;
+                }
+            }
+
+            paddedWidth = PixmapBytePad(maxWidth,
+                pScreenPriv->pScreenPixmap->drawable.depth);
+            pImage = (char *)ALLOCATE_LOCAL(paddedWidth * maxHeight);
+
+            pGC->fExpose = FALSE;
+
+            while (nQueue--)
+            {
+                pGC->pCompositeClip = pGCPriv->pBankedClips[pQueue->dstBankNo];
+
+                GCOP_UNWRAP;
+
+                if (pQueue->srcBankNo == pQueue->dstBankNo)
+                {
+                    SET_SINGLE_BANK(pScreenPriv->pScreenPixmap,
+                        -1, -1, pQueue->srcBankNo);
+
+                    if (SinglePlane)
+                        (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
+                            pQueue->x - dx - pSrc->x, pQueue->y - dy - pSrc->y,
+                            pQueue->w, pQueue->h, pQueue->x, pQueue->y, plane);
+                    else
+                        (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
+                            pQueue->x - dx - pSrc->x, pQueue->y - dy - pSrc->y,
+                            pQueue->w, pQueue->h, pQueue->x, pQueue->y);
+                }
+                else if (pQueue->fastBlit)
+                {
+                    SET_SOURCE_BANK     (pScreenPriv->pBankPixmap,
+                        pScreenPriv->pScreenPixmap->drawable.width,
+                        pScreenPriv->pScreenPixmap->devKind,
+                        pQueue->srcBankNo);
+                    SET_DESTINATION_BANK(pScreenPriv->pScreenPixmap,
+                        -1, -1, pQueue->dstBankNo);
+
+                    if (SinglePlane)
+                        (*pGC->ops->CopyPlane)(
+                            (DrawablePtr)pScreenPriv->pBankPixmap, pDst, pGC,
+                            pQueue->x - dx, pQueue->y - dy,
+                            pQueue->w, pQueue->h, pQueue->x, pQueue->y, plane);
+                    else
+                        (*pGC->ops->CopyArea)(
+                            (DrawablePtr)pScreenPriv->pBankPixmap, pDst, pGC,
+                            pQueue->x - dx, pQueue->y - dy,
+                            pQueue->w, pQueue->h, pQueue->x, pQueue->y);
+                }
+                else if (pImage)
+                {
+                    ModifyPixmap(pScreenPriv->pBankPixmap,
+                        maxWidth, paddedWidth, pImage);
+
+                    SET_SINGLE_BANK(pScreenPriv->pScreenPixmap,
+                        -1, -1, pQueue->srcBankNo);
+
+                    (*pScreenPriv->pBankGC->ops->CopyArea)(
+                        pSrc, (DrawablePtr)pScreenPriv->pBankPixmap,
+                        pScreenPriv->pBankGC,
+                        pQueue->x - dx - pSrc->x, pQueue->y - dy - pSrc->y,
+                        pQueue->w, pQueue->h, 0, 0);
+
+                    SET_SINGLE_BANK(pScreenPriv->pScreenPixmap,
+                        -1, -1, pQueue->dstBankNo);
+
+                    if (SinglePlane)
+                        (*pGC->ops->CopyPlane)(
+                            (DrawablePtr)pScreenPriv->pBankPixmap,
+                            pDst, pGC, 0, 0, pQueue->w, pQueue->h,
+                            pQueue->x, pQueue->y, plane);
+                    else
+                        (*pGC->ops->CopyArea)(
+                            (DrawablePtr)pScreenPriv->pBankPixmap,
+                            pDst, pGC, 0, 0, pQueue->w, pQueue->h,
+                            pQueue->x, pQueue->y);
+                }
+
+                GCOP_WRAP;
+
+                pQueue++;
+            }
+
+            DEALLOCATE_LOCAL(pImage);
+
+            BANK_RESTORE;
+        }
+
+        CLIP_RESTORE;
+
+        pGC->fExpose = fExpose;
+
+        DEALLOCATE_LOCAL(Queue);
+    }
+
+    SCREEN_RESTORE;
+
+    if (!fExpose || fastExpose)
+        return ret;
+
+    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, 0);
+}
+
+static RegionPtr
+miBankCopyArea(
+    DrawablePtr pSrc,
+    DrawablePtr pDst,
+    GCPtr       pGC,
+    int         srcx,
+    int         srcy,
+    int         w,
+    int         h,
+    int         dstx,
+    int         dsty
+)
+{
+    return miBankCopy(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, 0, FALSE);
+}
+
+static RegionPtr
+miBankCopyPlane(
+    DrawablePtr   pSrc,
+    DrawablePtr   pDst,
+    GCPtr         pGC,
+    int           srcx,
+    int           srcy,
+    int           w,
+    int           h,
+    int           dstx,
+    int           dsty,
+    unsigned long plane
+)
+{
+    return
+        miBankCopy(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane, TRUE);
+}
+
+static void
+miBankPolyPoint(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         mode,
+    int         nArray,
+    xPoint      *pArray
+)
+{
+#   define GCOP_ARGS GCOP_0D_ARGS
+    GCOP_COMPLEX(PolyPoint, xPoint);
+#   undef GCOP_ARGS
+}
+
+static void
+miBankPolylines(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         mode,
+    int         nArray,
+    DDXPointPtr pArray
+)
+{
+#   define GCOP_ARGS GCOP_0D_ARGS
+    GCOP_COMPLEX(Polylines, DDXPointRec);
+#   undef GCOP_ARGS
+}
+
+static void
+miBankPolySegment(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         nArray,
+    xSegment    *pArray
+)
+{
+#   define GCOP_ARGS GCOP_1D_ARGS
+    GCOP_COMPLEX(PolySegment, xSegment);
+#   undef GCOP_ARGS
+}
+
+static void
+miBankPolyRectangle(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         nArray,
+    xRectangle  *pArray
+)
+{
+#   define GCOP_ARGS GCOP_1D_ARGS
+    GCOP_COMPLEX(PolyRectangle, xRectangle);
+#   undef GCOP_ARGS
+}
+
+static void
+miBankPolyArc(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         nArray,
+    xArc        *pArray
+)
+{
+#   define GCOP_ARGS GCOP_1D_ARGS
+    GCOP_COMPLEX(PolyArc, xArc);
+#   undef GCOP_ARGS
+}
+
+static void
+miBankFillPolygon(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         shape,
+    int         mode,
+    int         nArray,
+    DDXPointRec *pArray
+)
+{
+#   define GCOP_ARGS GCOP_2D_ARGS
+    GCOP_COMPLEX(FillPolygon, DDXPointRec);
+#   undef GCOP_ARGS
+}
+
+static void
+miBankPolyFillRect(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         nArray,
+    xRectangle  *pArray
+)
+{
+#   define GCOP_ARGS GCOP_1D_ARGS
+    GCOP_COMPLEX(PolyFillRect, xRectangle);
+#   undef GCOP_ARGS
+}
+
+static void
+miBankPolyFillArc(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         nArray,
+    xArc        *pArray
+)
+{
+#   define GCOP_ARGS GCOP_1D_ARGS
+    GCOP_COMPLEX(PolyFillArc, xArc);
+#   undef GCOP_ARGS
+}
+
+static int
+miBankPolyText8(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         x,
+    int         y,
+    int         nArray,
+    char        *pchar
+)
+{
+    int retval = x;
+
+    GCOP_SIMPLE(retval =
+        (*pGC->ops->PolyText8)(pDrawable, pGC, x, y, nArray, pchar));
+
+    return retval;
+}
+
+static int
+miBankPolyText16(
+    DrawablePtr    pDrawable,
+    GCPtr          pGC,
+    int            x,
+    int            y,
+    int            nArray,
+    unsigned short *pchar
+)
+{
+    int retval = x;
+
+    GCOP_SIMPLE(retval =
+        (*pGC->ops->PolyText16)(pDrawable, pGC, x, y, nArray, pchar));
+
+    return retval;
+}
+
+static void
+miBankImageText8(
+    DrawablePtr pDrawable,
+    GCPtr       pGC,
+    int         x,
+    int         y,
+    int         nArray,
+    char        *pchar
+)
+{
+    GCOP_SIMPLE((*pGC->ops->ImageText8)(pDrawable, pGC, x, y, nArray, pchar));
+}
+
+static void
+miBankImageText16(
+    DrawablePtr    pDrawable,
+    GCPtr          pGC,
+    int            x,
+    int            y,
+    int            nArray,
+    unsigned short *pchar
+)
+{
+    GCOP_SIMPLE((*pGC->ops->ImageText16)(pDrawable, pGC, x, y, nArray, pchar));
+}
+
+static void
+miBankImageGlyphBlt(
+    DrawablePtr  pDrawable,
+    GCPtr        pGC,
+    int          x,
+    int          y,
+    unsigned int nArray,
+    CharInfoPtr  *ppci,
+    pointer      pglyphBase
+)
+{
+    GCOP_SIMPLE((*pGC->ops->ImageGlyphBlt)(pDrawable, pGC,
+        x, y, nArray, ppci, pglyphBase));
+}
+
+static void
+miBankPolyGlyphBlt(
+    DrawablePtr  pDrawable,
+    GCPtr        pGC,
+    int          x,
+    int          y,
+    unsigned int nArray,
+    CharInfoPtr  *ppci,
+    pointer      pglyphBase
+)
+{
+    GCOP_SIMPLE((*pGC->ops->PolyGlyphBlt)(pDrawable, pGC,
+        x, y, nArray, ppci, pglyphBase));
+}
+
+static void
+miBankPushPixels(
+    GCPtr       pGC,
+    PixmapPtr   pBitmap,
+    DrawablePtr pDrawable,
+    int         w,
+    int         h,
+    int         x,
+    int         y
+)
+{
+    if ((w > 0) && (h > 0))
+    {
+        GCOP_INIT;
+        SCREEN_SAVE;
+
+        if (!IS_BANKED(pDrawable))
+        {
+            GCOP_UNWRAP;
+
+            (*pGC->ops->PushPixels)(pGC, pBitmap, pDrawable, w, h, x, y);
+
+            GCOP_WRAP;
+        }
+        else
+        {
+            int i, j;
+
+            CLIP_SAVE;
+
+            i = FirstBankOf(x,     y);
+            j =  LastBankOf(x + w, y + h);
+            for (;  i <= j;  i++)
+            {
+                if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[i]))
+                    continue;
+
+                GCOP_UNWRAP;
+
+                SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
+
+                (*pGC->ops->PushPixels)(pGC, pBitmap, pDrawable, w, h, x, y);
+
+                GCOP_WRAP;
+            }
+
+            CLIP_RESTORE;
+        }
+
+        SCREEN_RESTORE;
+    }
+}
+
+static GCOps miBankGCOps =
+{
+    miBankFillSpans,
+    miBankSetSpans,
+    miBankPutImage,
+    miBankCopyArea,
+    miBankCopyPlane,
+    miBankPolyPoint,
+    miBankPolylines,
+    miBankPolySegment,
+    miBankPolyRectangle,
+    miBankPolyArc,
+    miBankFillPolygon,
+    miBankPolyFillRect,
+    miBankPolyFillArc,
+    miBankPolyText8,
+    miBankPolyText16,
+    miBankImageText8,
+    miBankImageText16,
+    miBankImageGlyphBlt,
+    miBankPolyGlyphBlt,
+    miBankPushPixels,
+#ifdef NEED_LINEHELPER
+    NULL,               /* LineHelper */
+#endif
+    {NULL}              /* devPrivate */
+};
+
+/********************
+ * GCFuncs wrappers *
+ ********************/
+
+static void
+miBankValidateGC(
+    GCPtr         pGC,
+    unsigned long changes,
+    DrawablePtr   pDrawable
+)
+{
+    GC_INIT(pGC);
+    GC_UNWRAP(pGC);
+
+    (*pGC->funcs->ValidateGC)(pGC, changes, pDrawable);
+
+    if ((changes & (GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode)) ||
+        (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)))
+    {
+        ScreenPtr     pScreen = pGC->pScreen;
+        RegionPtr     prgnClip;
+        unsigned long planemask;
+        int           i;
+
+        SCREEN_INIT;
+        SCREEN_SAVE;
+
+        if (IS_BANKED(pDrawable))
+        {
+            for (i = 0;  i < pScreenPriv->nBanks;  i++)
+            {
+                if (!pScreenPriv->pBanks[i])
+                    continue;
+
+                if (!(prgnClip = pGCPriv->pBankedClips[i]))
+                    prgnClip = REGION_CREATE(pScreen, NULL, 1);
+
+                REGION_INTERSECT(pScreen, prgnClip,
+                    pScreenPriv->pBanks[i], pGC->pCompositeClip);
+
+                if ((REGION_NUM_RECTS(prgnClip) <= 1) &&
+                    ((prgnClip->extents.x1 == prgnClip->extents.x2) ||
+                     (prgnClip->extents.y1 == prgnClip->extents.y2)))
+                {
+                    REGION_DESTROY(pScreen, prgnClip);
+                    pGCPriv->pBankedClips[i] = NULL;
+                }
+                else
+                    pGCPriv->pBankedClips[i] = prgnClip;
+            }
+
+            /*
+             * fastCopy and fastPlane can only be TRUE if we don't need to
+             * worry about attempts to read partial pixels through the
+             * destination bank.
+             */
+            switch (pScreenPriv->type)
+            {
+                case BANK_SHARED:
+                    pGCPriv->fastCopy = pGCPriv->fastPlane = FALSE;
+
+                    if ((pGC->alu != GXclear) && (pGC->alu != GXcopy) &&
+                        (pGC->alu != GXcopyInverted) && (pGC->alu != GXset))
+                        break;
+
+                    if (pScreen->rootDepth == 1)
+                        pGCPriv->fastPlane = TRUE;
+
+                    /* This is probably paranoia */
+                    if ((pDrawable->depth != pScreen->rootDepth) ||
+                        (pDrawable->depth != pGC->depth))
+                        break;
+
+                    planemask = (1 << pGC->depth) - 1;
+                    if ((pGC->planemask & planemask) == planemask)
+                        pGCPriv->fastCopy = TRUE;
+
+                    break;
+
+                case BANK_DOUBLE:
+                    pGCPriv->fastCopy = pGCPriv->fastPlane = TRUE;
+                    break;
+
+                default:
+                    pGCPriv->fastCopy = pGCPriv->fastPlane = FALSE;
+                    break;
+            }
+        }
+        else
+        {
+            /*
+             * Here we are on a pixmap and don't need all that special clipping
+             * stuff, hence free it.
+             */
+            for (i = 0;  i < pScreenPriv->nBanks;  i++)
+            {
+                if (!pGCPriv->pBankedClips[i])
+                    continue;
+
+                REGION_DESTROY(pScreen, pGCPriv->pBankedClips[i]);
+                pGCPriv->pBankedClips[i] = NULL;
+            }
+        }
+
+        SCREEN_RESTORE;
+    }
+
+    GC_WRAP(pGC);
+}
+
+static void
+miBankChangeGC(
+    GCPtr         pGC,
+    unsigned long mask
+)
+{
+    GC_INIT(pGC);
+    GC_UNWRAP(pGC);
+
+    (*pGC->funcs->ChangeGC)(pGC, mask);
+
+    GC_WRAP(pGC);
+}
+
+static void
+miBankCopyGC(
+    GCPtr         pGCSrc,
+    unsigned long mask,
+    GCPtr         pGCDst
+)
+{
+    GC_INIT(pGCDst);
+    GC_UNWRAP(pGCDst);
+
+    (*pGCDst->funcs->CopyGC)(pGCSrc, mask, pGCDst);
+
+    GC_WRAP(pGCDst);
+}
+
+static void
+miBankDestroyGC(
+    GCPtr pGC
+)
+{
+    ScreenPtr pScreen = pGC->pScreen;
+    int       i;
+
+    SCREEN_INIT;
+    GC_INIT(pGC);
+    GC_UNWRAP(pGC);
+
+    (*pGC->funcs->DestroyGC)(pGC);
+
+    for (i = 0;  i < pScreenPriv->nBanks;  i++)
+    {
+        if (!pGCPriv->pBankedClips[i])
+            continue;
+
+        REGION_DESTROY(pScreen, pGCPriv->pBankedClips[i]);
+        pGCPriv->pBankedClips[i] = NULL;
+    }
+
+    GC_WRAP(pGC);
+}
+
+static void
+miBankChangeClip(
+    GCPtr   pGC,
+    int     type,
+    pointer pvalue,
+    int     nrects
+)
+{
+    GC_INIT(pGC);
+    GC_UNWRAP(pGC);
+
+    (*pGC->funcs->ChangeClip)(pGC, type, pvalue, nrects);
+
+    GC_WRAP(pGC);
+}
+
+static void
+miBankDestroyClip(
+    GCPtr pGC
+)
+{
+    GC_INIT(pGC);
+    GC_UNWRAP(pGC);
+
+    (*pGC->funcs->DestroyClip)(pGC);
+
+    GC_WRAP(pGC);
+}
+
+static void
+miBankCopyClip(
+    GCPtr pGCDst,
+    GCPtr pGCSrc
+)
+{
+    GC_INIT(pGCDst);
+    GC_UNWRAP(pGCDst);
+
+    (*pGCDst->funcs->CopyClip)(pGCDst, pGCSrc);
+
+    GC_WRAP(pGCDst);
+}
+
+static GCFuncs miBankGCFuncs =
+{
+    miBankValidateGC,
+    miBankChangeGC,
+    miBankCopyGC,
+    miBankDestroyGC,
+    miBankChangeClip,
+    miBankDestroyClip,
+    miBankCopyClip
+};
+
+/*******************
+ * Screen Wrappers *
+ *******************/
+
+static Bool
+miBankCreateScreenResources(
+    ScreenPtr pScreen
+)
+{
+    Bool retval;
+
+    SCREEN_INIT;
+    SCREEN_UNWRAP(CreateScreenResources);
+
+    if ((retval = (*pScreen->CreateScreenResources)(pScreen)))
+    {
+        /* Set screen buffer address to something recognizable */
+        pScreenPriv->pScreenPixmap = (*pScreen->GetScreenPixmap)(pScreen);
+        pScreenPriv->pbits = pScreenPriv->pScreenPixmap->devPrivate.ptr;
+        pScreenPriv->pScreenPixmap->devPrivate.ptr = (pointer)pScreenPriv;
+
+        /* Get shadow pixmap;  width & height of 0 means no pixmap data */
+        pScreenPriv->pBankPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0,
+            pScreenPriv->pScreenPixmap->drawable.depth);
+        if (!pScreenPriv->pBankPixmap)
+            retval = FALSE;
+    }
+
+    /* Shadow the screen */
+    if (retval)
+        retval = (*pScreen->ModifyPixmapHeader)(pScreenPriv->pBankPixmap,
+            pScreenPriv->pScreenPixmap->drawable.width,
+            pScreenPriv->pScreenPixmap->drawable.height,
+            pScreenPriv->pScreenPixmap->drawable.depth,
+            pScreenPriv->pScreenPixmap->drawable.bitsPerPixel,
+            pScreenPriv->pScreenPixmap->devKind, NULL);
+
+    /* Create shadow GC */
+    if (retval)
+    {
+        pScreenPriv->pBankGC = CreateScratchGC(pScreen,
+            pScreenPriv->pBankPixmap->drawable.depth);
+        if (!pScreenPriv->pBankGC)
+            retval = FALSE;
+    }
+
+    /* Validate shadow GC */
+    if (retval)
+    {
+        pScreenPriv->pBankGC->graphicsExposures = FALSE;
+        pScreenPriv->pBankGC->subWindowMode = IncludeInferiors;
+        ValidateGC((DrawablePtr)pScreenPriv->pBankPixmap,
+            pScreenPriv->pBankGC);
+    }
+
+    SCREEN_WRAP(CreateScreenResources, miBankCreateScreenResources);
+
+    return retval;
+}
+
+static Bool
+miBankModifyPixmapHeader(
+    PixmapPtr pPixmap,
+    int       width,
+    int       height,
+    int       depth,
+    int       bitsPerPixel,
+    int       devKind,
+    pointer   pPixData
+)
+{
+    Bool retval = FALSE;
+
+    if (pPixmap)
+    {
+        ScreenPtr pScreen = pPixmap->drawable.pScreen;
+
+        SCREEN_INIT;
+        PIXMAP_SAVE(pPixmap);
+        SCREEN_UNWRAP(ModifyPixmapHeader);
+
+        retval = (*pScreen->ModifyPixmapHeader)(pPixmap, width, height,
+            depth, bitsPerPixel, devKind, pPixData);
+
+        SCREEN_WRAP(ModifyPixmapHeader, miBankModifyPixmapHeader);
+
+        if (pbits == (pointer)pScreenPriv)
+        {
+            pScreenPriv->pbits = pPixmap->devPrivate.ptr;
+            pPixmap->devPrivate.ptr = pbits;
+        }
+    }
+
+    return retval;
+}
+
+static Bool
+miBankCloseScreen(
+    int       nIndex,
+    ScreenPtr pScreen
+)
+{
+    int i;
+
+    SCREEN_INIT;
+
+    /* Free shadow GC */
+    FreeScratchGC(pScreenPriv->pBankGC);
+
+    /* Free shadow pixmap */
+    (*pScreen->DestroyPixmap)(pScreenPriv->pBankPixmap);
+
+    /* Restore screen pixmap devPrivate pointer */
+    pScreenPriv->pScreenPixmap->devPrivate.ptr = pScreenPriv->pbits;
+
+    /* Delete bank clips */
+    for (i = 0;  i < pScreenPriv->nBanks;  i++)
+        if (pScreenPriv->pBanks[i])
+            REGION_DESTROY(pScreen, pScreenPriv->pBanks[i]);
+
+    Xfree(pScreenPriv->pBanks);
+
+    SCREEN_UNWRAP(CreateScreenResources);
+    SCREEN_UNWRAP(ModifyPixmapHeader);
+    SCREEN_UNWRAP(CloseScreen);
+    SCREEN_UNWRAP(GetImage);
+    SCREEN_UNWRAP(GetSpans);
+    SCREEN_UNWRAP(CreateGC);
+    SCREEN_UNWRAP(PaintWindowBackground);
+    SCREEN_UNWRAP(PaintWindowBorder);
+    SCREEN_UNWRAP(CopyWindow);
+    SCREEN_UNWRAP(BackingStoreFuncs);
+
+    Xfree(pScreenPriv);
+    return (*pScreen->CloseScreen)(nIndex, pScreen);
+}
+
+static void
+miBankGetImage(
+    DrawablePtr   pDrawable,
+    int           sx,
+    int           sy,
+    int           w,
+    int           h,
+    unsigned int  format,
+    unsigned long planemask,
+    char          *pImage
+)
+{
+    if ((w > 0) && (h > 0))
+    {
+        ScreenPtr pScreen = pDrawable->pScreen;
+
+        SCREEN_INIT;
+        SCREEN_STATUS;
+        SCREEN_UNWRAP(GetImage);
+
+        if (!IS_BANKED(pDrawable))
+        {
+            (*pScreen->GetImage)(pDrawable, sx, sy, w, h,
+                format, planemask, pImage);
+        }
+        else
+        {
+            int  paddedWidth;
+            char *pBankImage;
+
+            paddedWidth = PixmapBytePad(w,
+                pScreenPriv->pScreenPixmap->drawable.depth);
+            pBankImage = (char *)ALLOCATE_LOCAL(paddedWidth * h);
+
+            if (pBankImage)
+            {
+                BANK_SAVE;
+
+                ModifyPixmap(pScreenPriv->pBankPixmap, w, paddedWidth,
+                    pBankImage);
+
+                (*pScreenPriv->pBankGC->ops->CopyArea)(
+                    (DrawablePtr)WindowTable[pScreen->myNum],
+                    (DrawablePtr)pScreenPriv->pBankPixmap,
+                    pScreenPriv->pBankGC,
+                    sx + pDrawable->x, sy + pDrawable->y, w, h, 0, 0);
+
+                (*pScreen->GetImage)((DrawablePtr)pScreenPriv->pBankPixmap,
+                    0, 0, w, h, format, planemask, pImage);
+
+                BANK_RESTORE;
+
+                DEALLOCATE_LOCAL(pBankImage);
+            }
+        }
+
+        SCREEN_WRAP(GetImage, miBankGetImage);
+    }
+}
+
+static void
+miBankGetSpans(
+    DrawablePtr pDrawable,
+    int         wMax,
+    DDXPointPtr ppt,
+    int         *pwidth,
+    int         nspans,
+    char        *pImage
+)
+{
+    if (nspans > 0)
+    {
+        ScreenPtr pScreen = pDrawable->pScreen;
+
+        SCREEN_INIT;
+        SCREEN_STATUS;
+        SCREEN_UNWRAP(GetSpans);
+
+        if (!IS_BANKED(pDrawable))
+        {
+            (*pScreen->GetSpans)(pDrawable, wMax, ppt, pwidth, nspans, pImage);
+        }
+        else
+        {
+            char        *pBankImage;
+            int         paddedWidth;
+            DDXPointRec pt;
+
+            pt.x = pt.y = 0;
+
+            paddedWidth =
+                PixmapBytePad(pScreenPriv->pScreenPixmap->drawable.width,
+                    pScreenPriv->pScreenPixmap->drawable.depth);
+            pBankImage = (char *)ALLOCATE_LOCAL(paddedWidth);
+
+            if (pBankImage)
+            {
+                BANK_SAVE;
+
+                ModifyPixmap(pScreenPriv->pBankPixmap,
+                    pScreenPriv->pScreenPixmap->drawable.width,
+                    paddedWidth, pBankImage);
+
+                for (;  nspans--;  ppt++, pwidth++)
+                {
+                    if (*pwidth <= 0)
+                        continue;
+
+                    (*pScreenPriv->pBankGC->ops->CopyArea)(
+                        (DrawablePtr)WindowTable[pScreen->myNum],
+                        (DrawablePtr)pScreenPriv->pBankPixmap,
+                        pScreenPriv->pBankGC,
+                        ppt->x, ppt->y, *pwidth, 1, 0, 0);
+
+                    (*pScreen->GetSpans)((DrawablePtr)pScreenPriv->pBankPixmap,
+                        wMax, &pt, pwidth, 1, pImage);
+
+                    pImage = pImage + PixmapBytePad(*pwidth, pDrawable->depth);
+                }
+
+                BANK_RESTORE;
+
+                DEALLOCATE_LOCAL(pBankImage);
+            }
+        }
+
+        SCREEN_WRAP(GetSpans, miBankGetSpans);
+    }
+}
+
+static Bool
+miBankCreateGC(
+    GCPtr pGC
+)
+{
+    ScreenPtr   pScreen = pGC->pScreen;
+    miBankGCPtr pGCPriv = BANK_GCPRIVATE(pGC);
+    Bool        ret;
+
+    SCREEN_INIT;
+    SCREEN_UNWRAP(CreateGC);
+
+    if ((ret = (*pScreen->CreateGC)(pGC)))
+    {
+        pGCPriv->unwrappedOps = &miBankGCOps;
+        pGCPriv->unwrappedFuncs = &miBankGCFuncs;
+        GC_WRAP(pGC);
+
+        memset(&pGCPriv->pBankedClips, 0,
+            pScreenPriv->nBanks * sizeof(pGCPriv->pBankedClips));
+    }
+
+    SCREEN_WRAP(CreateGC, miBankCreateGC);
+
+    return ret;
+}
+
+static void
+miBankPaintWindow(
+    WindowPtr pWin,
+    RegionPtr pRegion,
+    int       what
+)
+{
+    ScreenPtr          pScreen = pWin->drawable.pScreen;
+    RegionRec          tmpReg;
+    int                i;
+    PaintWindowProcPtr PaintWindow;
+
+    SCREEN_INIT;
+    SCREEN_SAVE;
+
+    if (what == PW_BORDER)
+    {
+        SCREEN_UNWRAP(PaintWindowBorder);
+        PaintWindow = pScreen->PaintWindowBorder;
+    }
+    else
+    {
+        SCREEN_UNWRAP(PaintWindowBackground);
+        PaintWindow = pScreen->PaintWindowBackground;
+    }
+
+    if (!IS_BANKED(pWin))
+    {
+        (*PaintWindow)(pWin, pRegion, what);
+    }
+    else
+    {
+        REGION_INIT(pScreen, &tmpReg, NullBox, 0);
+
+        for (i = 0;  i < pScreenPriv->nBanks;  i++)
+        {
+            if (!pScreenPriv->pBanks[i])
+                continue;
+
+            REGION_INTERSECT(pScreen, &tmpReg, pRegion,
+                pScreenPriv->pBanks[i]);
+
+            if (REGION_NIL(&tmpReg))
+                continue;
+
+            SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
+
+            (*PaintWindow)(pWin, &tmpReg, what);
+        }
+
+        REGION_UNINIT(pScreen, &tmpReg);
+    }
+
+    if (what == PW_BORDER)
+    {
+        SCREEN_WRAP(PaintWindowBorder, miBankPaintWindow);
+    }
+    else
+    {
+        SCREEN_WRAP(PaintWindowBackground, miBankPaintWindow);
+    }
+
+    SCREEN_RESTORE;
+}
+
+static void
+miBankCopyWindow(
+    WindowPtr   pWindow,
+    DDXPointRec ptOldOrg,
+    RegionPtr   pRgnSrc
+)
+{
+    ScreenPtr   pScreen = pWindow->drawable.pScreen;
+    GCPtr       pGC;
+    int         dx, dy, nBox;
+    DrawablePtr pDrawable = (DrawablePtr)WindowTable[pScreen->myNum];
+    RegionPtr   pRgnDst;
+    BoxPtr      pBox, pBoxTmp, pBoxNext, pBoxBase, pBoxNew1, pBoxNew2;
+    XID         subWindowMode = IncludeInferiors;
+
+    pGC = GetScratchGC(pDrawable->depth, pScreen);
+
+    ChangeGC(pGC, GCSubwindowMode, &subWindowMode);
+    ValidateGC(pDrawable, pGC);
+
+    pRgnDst = REGION_CREATE(pScreen, NULL, 1);
+
+    dx = ptOldOrg.x - pWindow->drawable.x;
+    dy = ptOldOrg.y - pWindow->drawable.y;
+    REGION_TRANSLATE(pScreen, pRgnSrc, -dx, -dy);
+    REGION_INTERSECT(pScreen, pRgnDst, &pWindow->borderClip, pRgnSrc);
+
+    pBox = REGION_RECTS(pRgnDst);
+    nBox = REGION_NUM_RECTS(pRgnDst);
+
+    pBoxNew1 = NULL;
+    pBoxNew2 = NULL;
+
+    if (nBox > 1)
+    {
+        if (dy < 0)
+        {
+            /* Sort boxes from bottom to top */
+            pBoxNew1 = ALLOCATE_LOCAL_ARRAY(BoxRec, nBox);
+
+            if (pBoxNew1)
+            {
+                pBoxBase = pBoxNext = pBox + nBox - 1;
+
+                while (pBoxBase >= pBox)
+                {
+                    while ((pBoxNext >= pBox) &&
+                           (pBoxBase->y1 == pBoxNext->y1))
+                        pBoxNext--;
+
+                    pBoxTmp = pBoxNext + 1;
+
+                    while (pBoxTmp <= pBoxBase)
+                        *pBoxNew1++ = *pBoxTmp++;
+
+                    pBoxBase = pBoxNext;
+                }
+
+                pBoxNew1 -= nBox;
+                pBox = pBoxNew1;
+            }
+        }
+
+        if (dx < 0)
+        {
+            /* Sort boxes from right to left */
+            pBoxNew2 = ALLOCATE_LOCAL_ARRAY(BoxRec, nBox);
+
+            if (pBoxNew2)
+            {
+                pBoxBase = pBoxNext = pBox;
+
+                while (pBoxBase < pBox + nBox)
+                {
+                    while ((pBoxNext < pBox + nBox) &&
+                           (pBoxNext->y1 == pBoxBase->y1))
+                        pBoxNext++;
+
+                    pBoxTmp = pBoxNext;
+
+                    while (pBoxTmp != pBoxBase)
+                        *pBoxNew2++ = *--pBoxTmp;
+
+                    pBoxBase = pBoxNext;
+                }
+
+                pBoxNew2 -= nBox;
+                pBox = pBoxNew2;
+            }
+        }
+    }
+
+    while (nBox--)
+    {
+        (*pGC->ops->CopyArea)(pDrawable, pDrawable, pGC,
+            pBox->x1 + dx, pBox->y1 + dy,
+            pBox->x2 - pBox->x1, pBox->y2 - pBox->y1,
+            pBox->x1, pBox->y1);
+
+        pBox++;
+    }
+
+    FreeScratchGC(pGC);
+
+    REGION_DESTROY(pScreen, pRgnDst);
+
+    DEALLOCATE_LOCAL(pBoxNew2);
+    DEALLOCATE_LOCAL(pBoxNew1);
+}
+
+/**************************
+ * Backing store wrappers *
+ **************************/
+
+static void
+miBankSaveAreas(
+    PixmapPtr pPixmap,
+    RegionPtr prgnSave,
+    int       xorg,
+    int       yorg,
+    WindowPtr pWin
+)
+{
+    ScreenPtr   pScreen   = pPixmap->drawable.pScreen;
+    RegionRec   rgnClipped;
+    int         i;
+
+    SCREEN_INIT;
+    SCREEN_SAVE;
+    SCREEN_UNWRAP(BackingStoreFuncs.SaveAreas);
+
+    if (!IS_BANKED(pWin))
+    {
+        (*pScreen->BackingStoreFuncs.SaveAreas)(pPixmap, prgnSave, xorg, yorg,
+            pWin);
+    }
+    else
+    {
+        REGION_INIT(pScreen, &rgnClipped, NullBox, 0);
+        REGION_TRANSLATE(pScreen, prgnSave, xorg, yorg);
+
+        for (i = 0;  i < pScreenPriv->nBanks;  i++)
+        {
+            if (!pScreenPriv->pBanks[i])
+                continue;
+
+            REGION_INTERSECT(pScreen, &rgnClipped,
+                prgnSave, pScreenPriv->pBanks[i]);
+
+            if (REGION_NIL(&rgnClipped))
+                continue;
+
+            SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
+
+            REGION_TRANSLATE(pScreen, &rgnClipped, -xorg, -yorg);
+
+            (*pScreen->BackingStoreFuncs.SaveAreas)(pPixmap, &rgnClipped,
+                xorg, yorg, pWin);
+        }
+
+        REGION_TRANSLATE(pScreen, prgnSave, -xorg, -yorg);
+        REGION_UNINIT(pScreen, &rgnClipped);
+    }
+
+    SCREEN_WRAP(BackingStoreFuncs.SaveAreas, miBankSaveAreas);
+    SCREEN_RESTORE;
+}
+
+static void
+miBankRestoreAreas(
+    PixmapPtr pPixmap,
+    RegionPtr prgnRestore,
+    int       xorg,
+    int       yorg,
+    WindowPtr pWin
+)
+{
+    ScreenPtr   pScreen   = pPixmap->drawable.pScreen;
+    RegionRec   rgnClipped;
+    int         i;
+
+    SCREEN_INIT;
+    SCREEN_SAVE;
+    SCREEN_UNWRAP(BackingStoreFuncs.RestoreAreas);
+
+    if (!IS_BANKED(pWin))
+    {
+        (*pScreen->BackingStoreFuncs.RestoreAreas)(pPixmap, prgnRestore,
+            xorg, yorg, pWin);
+    }
+    else
+    {
+        REGION_INIT(pScreen, &rgnClipped, NullBox, 0);
+
+        for (i = 0;  i < pScreenPriv->nBanks;  i++)
+        {
+            if (!pScreenPriv->pBanks[i])
+                continue;
+
+            REGION_INTERSECT(pScreen, &rgnClipped,
+                prgnRestore, pScreenPriv->pBanks[i]);
+
+            if (REGION_NIL(&rgnClipped))
+                continue;
+
+            SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
+
+            (*pScreen->BackingStoreFuncs.RestoreAreas)(pPixmap, &rgnClipped,
+                xorg, yorg, pWin);
+        }
+
+        REGION_UNINIT(pScreen, &rgnClipped);
+    }
+
+    SCREEN_WRAP(BackingStoreFuncs.RestoreAreas, miBankRestoreAreas);
+    SCREEN_RESTORE;
+}
+
+Bool
+miInitializeBanking(
+    ScreenPtr     pScreen,
+    unsigned int  xsize,
+    unsigned int  ysize,
+    unsigned int  width,
+    miBankInfoPtr pBankInfo
+)
+{
+    miBankScreenPtr pScreenPriv;
+    unsigned long   nBitsPerBank, nBitsPerScanline, nPixelsPerScanlinePadUnit;
+    unsigned long   BankBase, ServerPad;
+    unsigned int    type, iBank, nBanks, maxRects, we, nBankBPP;
+    int             i;
+
+    if (!pBankInfo || !pBankInfo->BankSize)
+        return TRUE;            /* No banking required */
+
+    /* Sanity checks */
+
+    if (!pScreen || !xsize || !ysize || (xsize > width) ||
+        !pBankInfo->SetSourceBank || !pBankInfo->SetDestinationBank ||
+        !pBankInfo->SetSourceAndDestinationBanks ||
+        !pBankInfo->pBankA || !pBankInfo->pBankB ||
+        !pBankInfo->nBankDepth)
+        return FALSE;
+
+    /*
+     * DDX *must* have registered a pixmap format whose depth is
+     * pBankInfo->nBankDepth.  This is not necessarily the rootDepth
+     * pixmap format.
+     */
+    i = 0;
+    while (screenInfo.formats[i].depth != pBankInfo->nBankDepth)
+        if (++i >= screenInfo.numPixmapFormats)
+            return FALSE;
+    nBankBPP = screenInfo.formats[i].bitsPerPixel;
+
+    i = 0;
+    while (screenInfo.formats[i].depth != pScreen->rootDepth)
+        if (++i >= screenInfo.numPixmapFormats)
+            return FALSE;
+
+    if (nBankBPP > screenInfo.formats[i].bitsPerPixel)
+        return FALSE;
+
+    /* Determine banking type */
+    if ((type = miBankDeriveType(pScreen, pBankInfo)) == BANK_NOBANK)
+        return FALSE;
+
+    /* Internal data */
+
+    nBitsPerBank = pBankInfo->BankSize * 8;
+    ServerPad = PixmapBytePad(1, pBankInfo->nBankDepth) * 8;
+    if (nBitsPerBank % ServerPad)
+        return FALSE;
+    nBitsPerScanline = PixmapBytePad(width, pBankInfo->nBankDepth) * 8;
+    nBanks = ((nBitsPerScanline * (ysize - 1)) +
+              (nBankBPP * xsize) + nBitsPerBank - 1) / nBitsPerBank;
+    nPixelsPerScanlinePadUnit = miLCM(ServerPad, nBankBPP) / nBankBPP;
+
+    /* Private areas */
+
+    if (miBankGeneration != serverGeneration)
+    {
+        if (((miBankScreenIndex = AllocateScreenPrivateIndex()) < 0) ||
+            ((miBankGCIndex = AllocateGCPrivateIndex()) < 0))
+            return FALSE;
+
+        miBankGeneration = serverGeneration;
+    }
+
+    if (!AllocateGCPrivate(pScreen, miBankGCIndex,
+        (nBanks * sizeof(RegionPtr)) +
+            (sizeof(miBankGCRec) - sizeof(RegionPtr))))
+        return FALSE;
+
+    if (!(pScreenPriv = (miBankScreenPtr)Xcalloc(sizeof(miBankScreenRec))))
+        return FALSE;
+
+    if (!(pScreenPriv->pBanks =                 /* Allocate and clear */
+        (RegionPtr *)Xcalloc(nBanks * sizeof(RegionPtr))))
+    {
+        Xfree(pScreenPriv);
+        return FALSE;
+    }
+
+    /*
+     * Translate banks into clipping regions which are themselves clipped
+     * against the screen.  This also ensures that pixels with imbedded bank
+     * boundaries are off-screen.
+     */
+
+    BankBase = 0;
+    maxRects = 0;
+    we = 0;
+    for (iBank = 0;  iBank < nBanks;  iBank++)
+    {
+        xRectangle   pRects[3], *pRect = pRects;
+        unsigned int xb, yb, xe, ye;
+
+        xb = ((BankBase + nBankBPP - 1) % nBitsPerScanline) / nBankBPP;
+        yb =  (BankBase + nBankBPP - 1) / nBitsPerScanline;
+        if (xb >= xsize)
+        {
+            xb = we = 0;
+            yb++;
+        }
+        if (yb >= ysize)
+        {
+            we = 0;
+            break;
+        }
+
+        if (we)
+            break;
+
+        BankBase += nBitsPerBank;
+
+        we = (BankBase % nBitsPerScanline) % nBankBPP;
+        xe = (BankBase % nBitsPerScanline) / nBankBPP;
+        ye =  BankBase / nBitsPerScanline;
+        if (xe >= xsize)
+        {
+            we = xe = 0;
+            ye++;
+        }
+        if (ye >= ysize)
+        {
+            we = xe = 0;
+            ye = ysize;
+        }
+
+        if (yb == ye)
+        {
+            if (xb >= xe)
+                continue;
+
+            pRect->x      = xb;
+            pRect->y      = yb;
+            pRect->width  = xe - xb;
+            pRect->height = 1;
+            maxRects += 2;
+            pRect++;
+        }
+        else
+        {
+            if (xb)
+            {
+                pRect->x      = xb;
+                pRect->y      = yb++;
+                pRect->width  = xsize - xb;
+                pRect->height = 1;
+                maxRects += 2;
+                pRect++;
+            }
+
+            if (yb < ye)
+            {
+                pRect->x      = 0;
+                pRect->y      = yb;
+                pRect->width  = xsize;
+                pRect->height = ye - yb;
+                maxRects += min(pRect->height, 3) + 1;
+                pRect++;
+            }
+
+            if (xe)
+            {
+                pRect->x      = 0;
+                pRect->y      = ye;
+                pRect->width  = xe;
+                pRect->height = 1;
+                maxRects += 2;
+                pRect++;
+            }
+        }
+
+        pScreenPriv->pBanks[iBank] =
+            RECTS_TO_REGION(pScreen, pRect - pRects, pRects, 0);
+        if (!pScreenPriv->pBanks[iBank] ||
+            REGION_NAR(pScreenPriv->pBanks[iBank]))
+        {
+            we = 1;
+            break;
+        }
+    }
+
+    if (we && (iBank < nBanks))
+    {
+        for (i = iBank;  i >= 0;  i--)
+            if (pScreenPriv->pBanks[i])
+                REGION_DESTROY(pScreen, pScreenPriv->pBanks[i]);
+
+        Xfree(pScreenPriv->pBanks);
+        Xfree(pScreenPriv);
+
+        return FALSE;
+    }
+
+    /* Open for business */
+
+    pScreenPriv->type = type;
+    pScreenPriv->nBanks = nBanks;
+    pScreenPriv->maxRects = maxRects;
+    pScreenPriv->nBankBPP = nBankBPP;
+    pScreenPriv->BankInfo = *pBankInfo;
+    pScreenPriv->nBitsPerBank = nBitsPerBank;
+    pScreenPriv->nBitsPerScanline = nBitsPerScanline;
+    pScreenPriv->nPixelsPerScanlinePadUnit = nPixelsPerScanlinePadUnit;
+
+    SCREEN_WRAP(CreateScreenResources, miBankCreateScreenResources);
+    SCREEN_WRAP(ModifyPixmapHeader,    miBankModifyPixmapHeader);
+    SCREEN_WRAP(CloseScreen,           miBankCloseScreen);
+    SCREEN_WRAP(GetImage,              miBankGetImage);
+    SCREEN_WRAP(GetSpans,              miBankGetSpans);
+    SCREEN_WRAP(CreateGC,              miBankCreateGC);
+    SCREEN_WRAP(PaintWindowBackground, miBankPaintWindow);
+    SCREEN_WRAP(PaintWindowBorder,     miBankPaintWindow);
+    SCREEN_WRAP(CopyWindow,            miBankCopyWindow);
+
+    pScreenPriv->BackingStoreFuncs     = pScreen->BackingStoreFuncs;
+
+    pScreen->BackingStoreFuncs.SaveAreas      = miBankSaveAreas;
+    pScreen->BackingStoreFuncs.RestoreAreas   = miBankRestoreAreas;
+    /* ??????????????????????????????????????????????????????????????
+    pScreen->BackingStoreFuncs.SetClipmaskRgn = miBankSetClipmaskRgn;
+    ?????????????????????????????????????????????????????????????? */
+
+    BANK_SCRPRIVLVAL = (pointer)pScreenPriv;
+
+    return TRUE;
+}
+
+/* This is used to force GC revalidation when the banking type is changed */
+/*ARGSUSED*/
+static int
+miBankNewSerialNumber(
+    WindowPtr pWin,
+    pointer   unused
+)
+{
+    pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+    return WT_WALKCHILDREN;
+}
+
+/* This entry modifies the banking interface */
+Bool
+miModifyBanking(
+    ScreenPtr     pScreen,
+    miBankInfoPtr pBankInfo
+)
+{
+    unsigned int type;
+
+    if (!pScreen)
+        return FALSE;
+
+    if (miBankGeneration == serverGeneration)
+    {
+        SCREEN_INIT;
+
+        if (pScreenPriv)
+        {
+            if (!pBankInfo || !pBankInfo->BankSize ||
+                !pBankInfo->pBankA || !pBankInfo->pBankB ||
+                !pBankInfo->SetSourceBank || !pBankInfo->SetDestinationBank ||
+                !pBankInfo->SetSourceAndDestinationBanks)
+                return FALSE;
+
+            /* BankSize and nBankDepth cannot, as yet, be changed */
+            if ((pScreenPriv->BankInfo.BankSize != pBankInfo->BankSize) ||
+                (pScreenPriv->BankInfo.nBankDepth != pBankInfo->nBankDepth))
+                return FALSE;
+
+            if ((type = miBankDeriveType(pScreen, pBankInfo)) == BANK_NOBANK)
+                return FALSE;
+
+            /* Reset banking info */
+            pScreenPriv->BankInfo = *pBankInfo;
+            if (type != pScreenPriv->type)
+            {
+                /*
+                 * Banking type is changing.  Revalidate all window GC's.
+                 */
+                pScreenPriv->type = type;
+                WalkTree(pScreen, miBankNewSerialNumber, 0);
+            }
+
+            return TRUE;
+        }
+    }
+
+    if (!pBankInfo || !pBankInfo->BankSize)
+        return TRUE;                            /* No change requested */
+
+    return FALSE;
+}
+
+/*
+ * Given various screen attributes, determine the minimum scanline width such
+ * that each scanline is server and DDX padded and any pixels with imbedded
+ * bank boundaries are off-screen.  This function returns -1 if such a width
+ * cannot exist.  This function exists because the DDX needs to be able to
+ * determine this width before initializing a frame buffer.
+ */
+int
+miScanLineWidth(
+    unsigned int     xsize,         /* pixels */
+    unsigned int     ysize,         /* pixels */
+    unsigned int     width,         /* pixels */
+    unsigned long    BankSize,      /* char's */
+    PixmapFormatRec *pBankFormat,
+    unsigned int     nWidthUnit     /* bits */
+)
+{
+    unsigned long nBitsPerBank, nBitsPerScanline, nBitsPerScanlinePadUnit;
+    unsigned long minBitsPerScanline, maxBitsPerScanline;
+
+    /* Sanity checks */
+
+    if (!nWidthUnit || !pBankFormat)
+        return -1;
+
+    nBitsPerBank = BankSize * 8;
+    if (nBitsPerBank % pBankFormat->scanlinePad)
+        return -1;
+
+    if (xsize > width)
+        width = xsize;
+    nBitsPerScanlinePadUnit = miLCM(pBankFormat->scanlinePad, nWidthUnit);
+    nBitsPerScanline =
+        (((width * pBankFormat->bitsPerPixel) + nBitsPerScanlinePadUnit - 1) /
+         nBitsPerScanlinePadUnit) * nBitsPerScanlinePadUnit;
+    width = nBitsPerScanline / pBankFormat->bitsPerPixel;
+
+    if (!xsize || !(nBitsPerBank % pBankFormat->bitsPerPixel))
+        return (int)width;
+
+    /*
+     * Scanlines will be server-pad aligned at this point.  They will also be
+     * a multiple of nWidthUnit bits long.  Ensure that pixels with imbedded
+     * bank boundaries are off-screen.
+     *
+     * It seems reasonable to limit total frame buffer size to 1/16 of the
+     * theoretical maximum address space size.  On a machine with 32-bit
+     * addresses (to 8-bit quantities) this turns out to be 256MB.  Not only
+     * does this provide a simple limiting condition for the loops below, but
+     * it also prevents unsigned long wraparounds.
+     */
+    if (!ysize)
+        return -1;
+
+    minBitsPerScanline = xsize * pBankFormat->bitsPerPixel;
+    if (minBitsPerScanline > nBitsPerBank)
+        return -1;
+
+    if (ysize == 1)
+        return (int)width;
+
+    maxBitsPerScanline =
+        (((unsigned long)(-1) >> 1) - minBitsPerScanline) / (ysize - 1);
+    while (nBitsPerScanline <= maxBitsPerScanline)
+    {
+        unsigned long BankBase, BankUnit;
+
+        BankUnit = ((nBitsPerBank + nBitsPerScanline - 1) / nBitsPerBank) *
+            nBitsPerBank;
+        if (!(BankUnit % nBitsPerScanline))
+            return (int)width;
+
+        for (BankBase = BankUnit;  ;  BankBase += nBitsPerBank)
+        {
+            unsigned long x, y;
+
+            y = BankBase / nBitsPerScanline;
+            if (y >= ysize)
+                return (int)width;
+
+            x = BankBase % nBitsPerScanline;
+            if (!(x % pBankFormat->bitsPerPixel))
+                continue;
+
+            if (x < minBitsPerScanline)
+            {
+                /*
+                 * Skip ahead certain widths by dividing the excess scanline
+                 * amongst the y's.
+                 */
+                y *= nBitsPerScanlinePadUnit;
+                nBitsPerScanline +=
+                    ((x + y - 1) / y) * nBitsPerScanlinePadUnit;
+                width = nBitsPerScanline / pBankFormat->bitsPerPixel;
+                break;
+            }
+
+            if (BankBase != BankUnit)
+                continue;
+
+            if (!(nBitsPerScanline % x))
+                return (int)width;
+
+            BankBase = ((nBitsPerScanline - minBitsPerScanline) /
+                (nBitsPerScanline - x)) * BankUnit;
+        }
+    }
+
+    return -1;
+}
diff --git a/mi/mibank.h b/mi/mibank.h
new file mode 100644
index 000000000..c3aa69379
--- /dev/null
+++ b/mi/mibank.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright 1997 through 2003 by Marc Aurele La France (TSI @ UQV), tsi@xfree86.org
+ *
+ * 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 Marc Aurele La France not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  Marc Aurele La France makes no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as-is" without express or implied warranty.
+ *
+ * MARC AURELE LA FRANCE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO
+ * EVENT SHALL MARC AURELE LA FRANCE 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/mi/mibank.h,v 1.10 2003/01/01 19:16:42 tsi Exp $ */
+
+#ifndef __MIBANK_H__
+#define __MIBANK_H__ 1
+
+#include "scrnintstr.h"
+
+/*
+ * Banking external interface.
+ */
+
+/*
+ * This is the banking function type.  The return value is normally zero.
+ * Non-zero returns can be used to implement the likes of scanline interleave,
+ * etc.
+ */
+typedef int miBankProc(
+    ScreenPtr /*pScreen*/,
+    unsigned int /*iBank*/
+);
+
+typedef miBankProc *miBankProcPtr;
+
+typedef struct _miBankInfo
+{
+    /*
+     * Banking refers to the use of one or more apertures (in the server's
+     * address space) to access various parts of a potentially larger hardware
+     * frame buffer.
+     *
+     * Three different banking schemes are supported:
+     *
+     * Single banking is indicated when pBankA and pBankB are equal and all
+     * three miBankProcPtr's point to the same function.  Here, both reads and
+     * writes through the aperture access the same hardware location.
+     *
+     * Shared banking is indicated when pBankA and pBankB are equal but the
+     * source and destination functions differ.  Here reads through the
+     * aperture do not necessarily access the same hardware location as writes.
+     *
+     * Double banking is indicated when pBankA and pBankB differ.  Here two
+     * independent apertures are used to provide read/write access to
+     * potentially different hardware locations.
+     *
+     * Any other combination will result in no banking.
+     */
+    miBankProcPtr SetSourceBank;                /* Set pBankA bank number */
+    miBankProcPtr SetDestinationBank;           /* Set pBankB bank number */
+    miBankProcPtr SetSourceAndDestinationBanks; /* Set both bank numbers */
+
+    pointer pBankA;     /* First aperture location */
+    pointer pBankB;     /* First or second aperture location */
+
+    /*
+     * BankSize is in units of sizeof(char) and is the size of each bank.
+     */
+    unsigned long BankSize;
+
+    /*
+     * nBankDepth is the colour depth associated with the maximum number of a
+     * pixel's bits that are simultaneously accessible through the frame buffer
+     * aperture.
+     */
+    unsigned int nBankDepth;
+} miBankInfoRec, *miBankInfoPtr;
+
+Bool
+miInitializeBanking(
+    ScreenPtr /*pScreen*/,
+    unsigned int /*xsize*/,
+    unsigned int /*ysize*/,
+    unsigned int /*width*/,
+    miBankInfoPtr /*pBankInfo*/
+);
+
+Bool
+miModifyBanking(
+    ScreenPtr /*pScreen*/,
+    miBankInfoPtr /*pBankInfo*/
+);
+
+/*
+ * This function determines the minimum screen width, given a initial estimate
+ * and various screen attributes.  DDX needs to determine this width before
+ * initializing the screen.
+ */
+int
+miScanLineWidth(
+    unsigned int /*xsize*/,
+    unsigned int /*ysize*/,
+    unsigned int /*width*/,
+    unsigned long /*BankSize*/,
+    PixmapFormatRec * /*pBankFormat*/,
+    unsigned int /*nWidthUnit*/
+);
+
+#endif /* __MIBANK_H__ */
diff --git a/mi/micmap.c b/mi/micmap.c
new file mode 100644
index 000000000..b3e925a09
--- /dev/null
+++ b/mi/micmap.c
@@ -0,0 +1,674 @@
+/* $XConsortium: cfbcmap.c,v 4.19 94/04/17 20:28:46 dpw Exp $ */
+/************************************************************
+Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
+
+                    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 no-
+tice  appear  in all copies and that both that copyright no-
+tice and this permission notice appear in  supporting  docu-
+mentation,  and  that the names of Sun or X Consortium
+not be used in advertising or publicity pertaining to 
+distribution  of  the software  without specific prior 
+written permission. Sun and X Consortium make no 
+representations about the suitability of this software for 
+any purpose. It is provided "as is" without any express or 
+implied warranty.
+
+SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
+NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
+ABLE  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/mi/micmap.c,v 1.11 2001/05/29 22:24:06 dawes Exp $ */
+
+/*
+ * This is based on cfbcmap.c.  The functions here are useful independently
+ * of cfb, which is the reason for including them here.  How "mi" these
+ * are may be debatable.
+ */
+
+
+#include "X.h"
+#include "Xproto.h"
+#include "scrnintstr.h"
+#include "colormapst.h"
+#include "resource.h"
+#include "globals.h"
+#include "micmap.h"
+
+ColormapPtr miInstalledMaps[MAXSCREENS];
+
+static Bool miDoInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
+		int *ndepthp, int *rootDepthp, VisualID *defaultVisp,
+		unsigned long sizes, int bitsPerRGB, int preferredVis);
+
+miInitVisualsProcPtr miInitVisualsProc = miDoInitVisuals;
+
+int
+miListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps)
+{
+    /* By the time we are processing requests, we can guarantee that there
+     * is always a colormap installed */
+    *pmaps = miInstalledMaps[pScreen->myNum]->mid;
+    return (1);
+}
+
+void
+miInstallColormap(ColormapPtr pmap)
+{
+    int index = pmap->pScreen->myNum;
+    ColormapPtr oldpmap = miInstalledMaps[index];
+
+    if(pmap != oldpmap)
+    {
+	/* Uninstall pInstalledMap. No hardware changes required, just
+	 * notify all interested parties. */
+	if(oldpmap != (ColormapPtr)None)
+	    WalkTree(pmap->pScreen, TellLostMap, (char *)&oldpmap->mid);
+	/* Install pmap */
+	miInstalledMaps[index] = pmap;
+	WalkTree(pmap->pScreen, TellGainedMap, (char *)&pmap->mid);
+
+    }
+}
+
+void
+miUninstallColormap(ColormapPtr pmap)
+{
+    int index = pmap->pScreen->myNum;
+    ColormapPtr curpmap = miInstalledMaps[index];
+
+    if(pmap == curpmap)
+    {
+	if (pmap->mid != pmap->pScreen->defColormap)
+	{
+	    curpmap = (ColormapPtr) LookupIDByType(pmap->pScreen->defColormap,
+						   RT_COLORMAP);
+	    (*pmap->pScreen->InstallColormap)(curpmap);
+	}
+    }
+}
+
+void
+miResolveColor(unsigned short *pred, unsigned short *pgreen,
+		unsigned short *pblue, VisualPtr pVisual)
+{
+    int shift = 16 - pVisual->bitsPerRGBValue;
+    unsigned lim = (1 << pVisual->bitsPerRGBValue) - 1;
+
+    if ((pVisual->class | DynamicClass) == GrayScale)
+    {
+	/* rescale to gray then rgb bits */
+	*pred = (30L * *pred + 59L * *pgreen + 11L * *pblue) / 100;
+	*pblue = *pgreen = *pred = ((*pred >> shift) * 65535) / lim;
+    }
+    else
+    {
+	/* rescale to rgb bits */
+	*pred = ((*pred >> shift) * 65535) / lim;
+	*pgreen = ((*pgreen >> shift) * 65535) / lim;
+	*pblue = ((*pblue >> shift) * 65535) / lim;
+    }
+}
+
+Bool
+miInitializeColormap(ColormapPtr pmap)
+{
+    register unsigned i;
+    register VisualPtr pVisual;
+    unsigned lim, maxent, shift;
+
+    pVisual = pmap->pVisual;
+    lim = (1 << pVisual->bitsPerRGBValue) - 1;
+    shift = 16 - pVisual->bitsPerRGBValue;
+    maxent = pVisual->ColormapEntries - 1;
+    if (pVisual->class == TrueColor)
+    {
+	unsigned limr, limg, limb;
+
+	limr = pVisual->redMask >> pVisual->offsetRed;
+	limg = pVisual->greenMask >> pVisual->offsetGreen;
+	limb = pVisual->blueMask >> pVisual->offsetBlue;
+	for(i = 0; i <= maxent; i++)
+	{
+	    /* rescale to [0..65535] then rgb bits */
+	    pmap->red[i].co.local.red =
+		((((i * 65535) / limr) >> shift) * 65535) / lim;
+	    pmap->green[i].co.local.green =
+		((((i * 65535) / limg) >> shift) * 65535) / lim;
+	    pmap->blue[i].co.local.blue =
+		((((i * 65535) / limb) >> shift) * 65535) / lim;
+	}
+    }
+    else if (pVisual->class == StaticColor)
+    {
+	unsigned limr, limg, limb;
+
+	limr = pVisual->redMask >> pVisual->offsetRed;
+	limg = pVisual->greenMask >> pVisual->offsetGreen;
+	limb = pVisual->blueMask >> pVisual->offsetBlue;
+	for(i = 0; i <= maxent; i++)
+	{
+	    /* rescale to [0..65535] then rgb bits */
+	    pmap->red[i].co.local.red =
+		((((((i & pVisual->redMask) >> pVisual->offsetRed)
+		    * 65535) / limr) >> shift) * 65535) / lim;
+	    pmap->red[i].co.local.green =
+		((((((i & pVisual->greenMask) >> pVisual->offsetGreen)
+		    * 65535) / limg) >> shift) * 65535) / lim;
+	    pmap->red[i].co.local.blue =
+		((((((i & pVisual->blueMask) >> pVisual->offsetBlue)
+		    * 65535) / limb) >> shift) * 65535) / lim;
+	}
+    }
+    else if (pVisual->class == StaticGray)
+    {
+	for(i = 0; i <= maxent; i++)
+	{
+	    /* rescale to [0..65535] then rgb bits */
+	    pmap->red[i].co.local.red = ((((i * 65535) / maxent) >> shift)
+					 * 65535) / lim;
+	    pmap->red[i].co.local.green = pmap->red[i].co.local.red;
+	    pmap->red[i].co.local.blue = pmap->red[i].co.local.red;
+	}
+    }
+    return TRUE;
+}
+
+/* When simulating DirectColor on PseudoColor hardware, multiple
+   entries of the colormap must be updated
+ */
+
+#define AddElement(mask) { \
+    pixel = red | green | blue; \
+    for (i = 0; i < nresult; i++) \
+  	if (outdefs[i].pixel == pixel) \
+    	    break; \
+    if (i == nresult) \
+    { \
+   	nresult++; \
+	outdefs[i].pixel = pixel; \
+	outdefs[i].flags = 0; \
+    } \
+    outdefs[i].flags |= (mask); \
+    outdefs[i].red = pmap->red[red >> pVisual->offsetRed].co.local.red; \
+    outdefs[i].green = pmap->green[green >> pVisual->offsetGreen].co.local.green; \
+    outdefs[i].blue = pmap->blue[blue >> pVisual->offsetBlue].co.local.blue; \
+}
+
+int
+miExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem *indefs,
+			xColorItem *outdefs)
+{
+    register int    red, green, blue;
+    int		    maxred, maxgreen, maxblue;
+    int		    stepred, stepgreen, stepblue;
+    VisualPtr	    pVisual;
+    register int    pixel;
+    register int    nresult;
+    register int    i;
+
+    pVisual = pmap->pVisual;
+
+    stepred = 1 << pVisual->offsetRed;
+    stepgreen = 1 << pVisual->offsetGreen;
+    stepblue = 1 << pVisual->offsetBlue;
+    maxred = pVisual->redMask;
+    maxgreen = pVisual->greenMask;
+    maxblue = pVisual->blueMask;
+    nresult = 0;
+    for (;ndef--; indefs++)
+    {
+	if (indefs->flags & DoRed)
+	{
+	    red = indefs->pixel & pVisual->redMask;
+    	    for (green = 0; green <= maxgreen; green += stepgreen)
+    	    {
+	    	for (blue = 0; blue <= maxblue; blue += stepblue)
+	    	{
+		    AddElement (DoRed)
+	    	}
+    	    }
+	}
+	if (indefs->flags & DoGreen)
+	{
+	    green = indefs->pixel & pVisual->greenMask;
+    	    for (red = 0; red <= maxred; red += stepred)
+    	    {
+	    	for (blue = 0; blue <= maxblue; blue += stepblue)
+	    	{
+		    AddElement (DoGreen)
+	    	}
+    	    }
+	}
+	if (indefs->flags & DoBlue)
+	{
+	    blue = indefs->pixel & pVisual->blueMask;
+    	    for (red = 0; red <= maxred; red += stepred)
+    	    {
+	    	for (green = 0; green <= maxgreen; green += stepgreen)
+	    	{
+		    AddElement (DoBlue)
+	    	}
+    	    }
+	}
+    }
+    return nresult;
+}
+
+Bool
+miCreateDefColormap(ScreenPtr pScreen)
+{
+/* 
+ * In the following sources PC X server vendors may want to delete 
+ * "_not_tog" from "#ifdef WIN32_not_tog"
+ */
+#ifdef WIN32_not_tog
+    /*  
+     * these are the MS-Windows desktop colors, adjusted for X's 16-bit 
+     * color specifications.
+     */
+    static xColorItem citems[] = {
+	{   0,      0,      0,      0, 0, 0 },
+	{   1, 0x8000,      0,      0, 0, 0 },
+	{   2,      0, 0x8000,      0, 0, 0 },
+	{   3, 0x8000, 0x8000,      0, 0, 0 },
+	{   4,      0,      0, 0x8000, 0, 0 },
+	{   5, 0x8000,      0, 0x8000, 0, 0 },
+	{   6,      0, 0x8000, 0x8000, 0, 0 },
+	{   7, 0xc000, 0xc000, 0xc000, 0, 0 },
+	{   8, 0xc000, 0xdc00, 0xc000, 0, 0 },
+	{   9, 0xa600, 0xca00, 0xf000, 0, 0 },
+	{ 246, 0xff00, 0xfb00, 0xf000, 0, 0 },
+	{ 247, 0xa000, 0xa000, 0xa400, 0, 0 },
+	{ 248, 0x8000, 0x8000, 0x8000, 0, 0 },
+	{ 249, 0xff00,      0,      0, 0, 0 },
+	{ 250,      0, 0xff00,      0, 0, 0 },
+	{ 251, 0xff00, 0xff00,      0, 0, 0 },
+	{ 252,      0,      0, 0xff00, 0, 0 },
+	{ 253, 0xff00,      0, 0xff00, 0, 0 },
+	{ 254,      0, 0xff00, 0xff00, 0, 0 },
+	{ 255, 0xff00, 0xff00, 0xff00, 0, 0 }
+    };
+#define NUM_DESKTOP_COLORS sizeof citems / sizeof citems[0]
+    int i;
+#else
+    unsigned short	zero = 0, ones = 0xFFFF;
+#endif
+    Pixel wp, bp;
+    VisualPtr	pVisual;
+    ColormapPtr	cmap;
+    int alloctype;
+    
+    for (pVisual = pScreen->visuals;
+	 pVisual->vid != pScreen->rootVisual;
+	 pVisual++)
+	;
+
+    if (pScreen->rootDepth == 1 || (pVisual->class & DynamicClass))
+	alloctype = AllocNone;
+    else
+	alloctype = AllocAll;
+
+    if (CreateColormap(pScreen->defColormap, pScreen, pVisual, &cmap,
+		       alloctype, 0) != Success)
+	return FALSE;
+
+    if (pScreen->rootDepth > 1) {
+	wp = pScreen->whitePixel;
+	bp = pScreen->blackPixel;
+#ifdef WIN32_not_tog
+	for (i = 0; i < NUM_DESKTOP_COLORS; i++) {
+	    if (AllocColor (cmap,
+			    &citems[i].red, &citems[i].green, &citems[i].blue,
+			    &citems[i].pixel, 0) != Success)
+		return FALSE;
+	}
+#else
+	if ((AllocColor(cmap, &ones, &ones, &ones, &wp, 0) !=
+       	       Success) ||
+	    (AllocColor(cmap, &zero, &zero, &zero, &bp, 0) !=
+       	       Success))
+    	    return FALSE;
+	pScreen->whitePixel = wp;
+	pScreen->blackPixel = bp;
+#endif
+    }
+
+    (*pScreen->InstallColormap)(cmap);
+    return TRUE;
+}
+
+/*
+ * Default true color bitmasks, should be overridden by
+ * driver
+ */
+
+#define _RZ(d) ((d + 2) / 3)
+#define _RS(d) 0
+#define _RM(d) ((1 << _RZ(d)) - 1)
+#define _GZ(d) ((d - _RZ(d) + 1) / 2)
+#define _GS(d) _RZ(d)
+#define _GM(d) (((1 << _GZ(d)) - 1) << _GS(d))
+#define _BZ(d) (d - _RZ(d) - _GZ(d))
+#define _BS(d) (_RZ(d) + _GZ(d))
+#define _BM(d) (((1 << _BZ(d)) - 1) << _BS(d))
+#define _CE(d) (1 << _RZ(d))
+
+typedef struct _miVisuals {
+    struct _miVisuals	*next;
+    int			depth;
+    int			bitsPerRGB;
+    int			visuals;
+    int			count;
+    int			preferredCVC;
+    Pixel		redMask, greenMask, blueMask;
+} miVisualsRec, *miVisualsPtr;
+
+static int  miVisualPriority[] = {
+    PseudoColor, GrayScale, StaticColor, TrueColor, DirectColor, StaticGray
+};
+
+#define NUM_PRIORITY	6
+
+static miVisualsPtr	miVisuals;
+
+void
+miClearVisualTypes()
+{
+    miVisualsPtr v;
+
+    while ((v = miVisuals)) {
+	miVisuals = v->next;
+	xfree(v);
+    }
+}
+
+
+Bool
+miSetVisualTypesAndMasks(int depth, int visuals, int bitsPerRGB, 
+			 int preferredCVC,
+			 Pixel redMask, Pixel greenMask, Pixel blueMask)
+{
+    miVisualsPtr   new, *prev, v;
+    int		    count;
+
+    new = (miVisualsPtr) xalloc (sizeof *new);
+    if (!new)
+	return FALSE;
+    if (!redMask || !greenMask || !blueMask)
+    {
+	redMask = _RM(depth);
+	greenMask = _GM(depth);
+	blueMask = _BM(depth);
+    }
+    new->next = 0;
+    new->depth = depth;
+    new->visuals = visuals;
+    new->bitsPerRGB = bitsPerRGB;
+    new->preferredCVC = preferredCVC;
+    new->redMask = redMask;
+    new->greenMask = greenMask;
+    new->blueMask = blueMask;
+    count = (visuals >> 1) & 033333333333;
+    count = visuals - count - ((count >> 1) & 033333333333);
+    count = (((count + (count >> 3)) & 030707070707) % 077);	/* HAKMEM 169 */
+    new->count = count;
+    for (prev = &miVisuals; (v = *prev); prev = &v->next);
+    *prev = new;
+    return TRUE;
+}
+
+Bool
+miSetVisualTypes(int depth, int visuals, int bitsPerRGB, int preferredCVC)
+{
+    return miSetVisualTypesAndMasks (depth, visuals, bitsPerRGB,
+				     preferredCVC, 0, 0, 0);
+}
+
+int
+miGetDefaultVisualMask(int depth)
+{
+    if (depth > MAX_PSEUDO_DEPTH)
+	return LARGE_VISUALS;
+    else if (depth >= MIN_TRUE_DEPTH)
+	return ALL_VISUALS;
+    else if (depth == 1)
+	return StaticGrayMask;
+    else
+	return SMALL_VISUALS;
+}
+
+static Bool
+miVisualTypesSet (int depth)
+{
+    miVisualsPtr    visuals;
+
+    for (visuals = miVisuals; visuals; visuals = visuals->next)
+	if (visuals->depth == depth)
+	    return TRUE;
+    return FALSE;
+}
+
+Bool
+miSetPixmapDepths (void)
+{
+    int	d, f;
+    
+    /* Add any unlisted depths from the pixmap formats */
+    for (f = 0; f < screenInfo.numPixmapFormats; f++) 
+    {
+	d = screenInfo.formats[f].depth;
+	if (!miVisualTypesSet (d))
+	{
+	    if (!miSetVisualTypes (d, 0, 0, -1))
+		return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+Bool
+miInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
+		int *ndepthp, int *rootDepthp, VisualID *defaultVisp,
+		unsigned long sizes, int bitsPerRGB, int preferredVis)
+
+{
+    if (miInitVisualsProc)
+	return miInitVisualsProc(visualp, depthp, nvisualp, ndepthp,
+				 rootDepthp, defaultVisp, sizes, bitsPerRGB,
+				 preferredVis);
+    else
+	return FALSE;
+}
+
+/*
+ * Distance to least significant one bit
+ */
+static int
+maskShift (Pixel p)
+{
+    int	s;
+
+    if (!p) return 0;
+    s = 0;
+    while (!(p & 1))
+    {
+	s++;
+	p >>= 1;
+    }
+    return s;
+}
+
+/*
+ * Given a list of formats for a screen, create a list
+ * of visuals and depths for the screen which corespond to
+ * the set which can be used with this version of cfb.
+ */
+
+static Bool
+miDoInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
+		int *ndepthp, int *rootDepthp, VisualID *defaultVisp,
+		unsigned long sizes, int bitsPerRGB, int preferredVis)
+{
+    int		i, j = 0, k;
+    VisualPtr	visual;
+    DepthPtr	depth;
+    VisualID	*vid;
+    int		d, b;
+    int		f;
+    int		ndepth, nvisual;
+    int		nvtype;
+    int		vtype;
+    miVisualsPtr   visuals, nextVisuals;
+    int		*preferredCVCs, *prefp;
+
+    /* none specified, we'll guess from pixmap formats */
+    if (!miVisuals) 
+    {
+    	for (f = 0; f < screenInfo.numPixmapFormats; f++) 
+    	{
+	    d = screenInfo.formats[f].depth;
+	    b = screenInfo.formats[f].bitsPerPixel;
+	    if (sizes & (1 << (b - 1)))
+		vtype = miGetDefaultVisualMask(d);
+	    else
+		vtype = 0;
+	    if (!miSetVisualTypes (d, vtype, bitsPerRGB, -1))
+		return FALSE;
+    	}
+    }
+    nvisual = 0;
+    ndepth = 0;
+    for (visuals = miVisuals; visuals; visuals = nextVisuals) 
+    {
+	nextVisuals = visuals->next;
+	ndepth++;
+	nvisual += visuals->count;
+    }
+    depth = (DepthPtr) xalloc (ndepth * sizeof (DepthRec));
+    visual = (VisualPtr) xalloc (nvisual * sizeof (VisualRec));
+    preferredCVCs = (int *)xalloc(ndepth * sizeof(int));
+    if (!depth || !visual || !preferredCVCs)
+    {
+	xfree (depth);
+	xfree (visual);
+	xfree (preferredCVCs);
+	return FALSE;
+    }
+    *depthp = depth;
+    *visualp = visual;
+    *ndepthp = ndepth;
+    *nvisualp = nvisual;
+    prefp = preferredCVCs;
+    for (visuals = miVisuals; visuals; visuals = nextVisuals) 
+    {
+	nextVisuals = visuals->next;
+	d = visuals->depth;
+	vtype = visuals->visuals;
+	nvtype = visuals->count;
+	*prefp = visuals->preferredCVC;
+	prefp++;
+	vid = NULL;
+	if (nvtype)
+	{
+	    vid = (VisualID *) xalloc (nvtype * sizeof (VisualID));
+	    if (!vid)
+		return FALSE;
+	}
+	depth->depth = d;
+	depth->numVids = nvtype;
+	depth->vids = vid;
+	depth++;
+	for (i = 0; i < NUM_PRIORITY; i++) {
+	    if (! (vtype & (1 << miVisualPriority[i])))
+		continue;
+	    visual->class = miVisualPriority[i];
+	    visual->bitsPerRGBValue = visuals->bitsPerRGB;
+	    visual->ColormapEntries = 1 << d;
+	    visual->nplanes = d;
+	    visual->vid = *vid = FakeClientID (0);
+	    switch (visual->class) {
+	    case PseudoColor:
+	    case GrayScale:
+	    case StaticGray:
+		visual->redMask = 0;
+		visual->greenMask =  0;
+		visual->blueMask =  0;
+		visual->offsetRed  =  0;
+		visual->offsetGreen = 0;
+		visual->offsetBlue =  0;
+		break;
+	    case DirectColor:
+	    case TrueColor:
+		visual->ColormapEntries = _CE(d);
+		/* fall through */
+	    case StaticColor:
+		visual->redMask =  visuals->redMask;
+		visual->greenMask =  visuals->greenMask;
+		visual->blueMask =  visuals->blueMask;
+		visual->offsetRed  =  maskShift (visuals->redMask);
+		visual->offsetGreen = maskShift (visuals->greenMask);
+		visual->offsetBlue =  maskShift (visuals->blueMask);
+	    }
+	    vid++;
+	    visual++;
+	}
+	xfree (visuals);
+    }
+    miVisuals = NULL;
+    visual = *visualp;
+    depth = *depthp;
+    for (i = 0; i < ndepth; i++)
+    {
+	int prefColorVisualClass = -1;
+
+	if (defaultColorVisualClass >= 0)
+	    prefColorVisualClass = defaultColorVisualClass;
+	else if (preferredVis >= 0)
+	    prefColorVisualClass = preferredVis;
+	else if (preferredCVCs[i] >= 0)
+	    prefColorVisualClass = preferredCVCs[i];
+
+	if (*rootDepthp && *rootDepthp != depth[i].depth)
+	    continue;
+	
+	for (j = 0; j < depth[i].numVids; j++)
+	{
+	    for (k = 0; k < nvisual; k++)
+		if (visual[k].vid == depth[i].vids[j])
+		    break;
+	    if (k == nvisual)
+		continue;
+	    if (prefColorVisualClass < 0 ||
+		visual[k].class == prefColorVisualClass)
+		break;
+	}
+	if (j != depth[i].numVids)
+	    break;
+    }
+    if (i == ndepth) {
+	i = 0;
+	j = 0;
+    }
+    *rootDepthp = depth[i].depth;
+    *defaultVisp = depth[i].vids[j];
+    xfree(preferredCVCs);
+
+    return TRUE;
+}
+
+void
+miResetInitVisuals()
+{
+    miInitVisualsProc = miDoInitVisuals;
+}
+
diff --git a/mi/micmap.h b/mi/micmap.h
new file mode 100644
index 000000000..557ae63d5
--- /dev/null
+++ b/mi/micmap.h
@@ -0,0 +1,65 @@
+/* $XFree86: xc/programs/Xserver/mi/micmap.h,v 1.7 2000/09/20 00:09:15 keithp Exp $ */
+
+#include "colormapst.h"
+
+#ifndef _MICMAP_H_
+#define _MICMAP_H_
+
+extern ColormapPtr miInstalledMaps[MAXSCREENS];
+
+typedef Bool (* miInitVisualsProcPtr)(VisualPtr *, DepthPtr *, int *, int *,
+					int *, VisualID *, unsigned long, int,
+					int);
+
+extern miInitVisualsProcPtr miInitVisualsProc;
+					
+int miListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps);
+void miInstallColormap(ColormapPtr pmap);
+void miUninstallColormap(ColormapPtr pmap);
+
+void miResolveColor(unsigned short *, unsigned short *, unsigned short *,
+			VisualPtr);
+Bool miInitializeColormap(ColormapPtr);
+int miExpandDirectColors(ColormapPtr, int, xColorItem *, xColorItem *);
+Bool miCreateDefColormap(ScreenPtr);
+void miClearVisualTypes(void);
+Bool miSetVisualTypes(int, int, int, int);
+Bool miSetPixmapDepths(void);
+Bool miSetVisualTypesAndMasks(int depth, int visuals, int bitsPerRGB, 
+			      int preferredCVC,
+			      Pixel redMask, Pixel greenMask, Pixel blueMask);
+int miGetDefaultVisualMask(int);
+Bool miInitVisuals(VisualPtr *, DepthPtr *, int *, int *, int *, VisualID *,
+			unsigned long, int, int);
+void miResetInitVisuals(void);
+
+void miHookInitVisuals(void (**old)(miInitVisualsProcPtr *),
+		       void (*new)(miInitVisualsProcPtr *));
+
+
+#define MAX_PSEUDO_DEPTH	10
+#define MIN_TRUE_DEPTH		6
+
+#define StaticGrayMask	(1 << StaticGray)
+#define GrayScaleMask	(1 << GrayScale)
+#define StaticColorMask	(1 << StaticColor)
+#define PseudoColorMask	(1 << PseudoColor)
+#define TrueColorMask	(1 << TrueColor)
+#define DirectColorMask	(1 << DirectColor)
+                
+#define ALL_VISUALS	(StaticGrayMask|\
+			 GrayScaleMask|\
+			 StaticColorMask|\
+			 PseudoColorMask|\
+			 TrueColorMask|\
+			 DirectColorMask)
+
+#define LARGE_VISUALS	(TrueColorMask|\
+			 DirectColorMask)
+
+#define SMALL_VISUALS	(StaticGrayMask|\
+			 GrayScaleMask|\
+			 StaticColorMask|\
+			 PseudoColorMask)
+
+#endif /* _MICMAP_H_ */
diff --git a/mi/micoord.h b/mi/micoord.h
new file mode 100644
index 000000000..f31c88c83
--- /dev/null
+++ b/mi/micoord.h
@@ -0,0 +1,71 @@
+/* $XFree86: xc/programs/Xserver/mi/micoord.h,v 1.5 2002/05/22 21:38:31 herrb Exp $ */
+/*
+ * Copyright (C) 2000 The XFree86 Project, 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
+ * XFREE86 PROJECT 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 XFree86 Project 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
+ * XFree86 Project.
+ *
+ */
+
+#ifndef _MICOORD_H_
+#define _MICOORD_H_ 1
+
+#include "servermd.h"
+
+/* Macros which handle a coordinate in a single register */
+
+/*
+ * Most compilers will convert divisions by 65536 into shifts, if signed
+ * shifts exist.  If your machine does arithmetic shifts and your compiler
+ * can't get it right, add to this line.
+ */
+
+/*
+ * mips compiler - what a joke - it CSEs the 65536 constant into a reg
+ * forcing as to use div instead of shift.  Let's be explicit.
+ */
+
+#if defined(mips) || \
+    defined(sparc) || defined(__sparc64__) || \
+    defined(__alpha) || defined(__alpha__) || \
+    defined(__i386__) || defined(i386) || \
+    defined(__ia64__) || defined(ia64) || \
+    defined(__s390x__) || defined(__s390__) || \
+    defined(__x86_64__) || defined(x86_64)
+#define GetHighWord(x) (((int) (x)) >> 16)
+#else
+#define GetHighWord(x) (((int) (x)) / 65536)
+#endif
+
+#if IMAGE_BYTE_ORDER == MSBFirst
+#define intToCoord(i,x,y)   (((x) = GetHighWord(i)), ((y) = (int) ((short) (i))))
+#define coordToInt(x,y)	(((x) << 16) | ((y) & 0xffff))
+#define intToX(i)	(GetHighWord(i))
+#define intToY(i)	((int) ((short) i))
+#else
+#define intToCoord(i,x,y)   (((x) = (int) ((short) (i))), ((y) = GetHighWord(i)))
+#define coordToInt(x,y)	(((y) << 16) | ((x) & 0xffff))
+#define intToX(i)	((int) ((short) (i)))
+#define intToY(i)	(GetHighWord(i))
+#endif
+
+#endif /* _MICOORD_H_ */
diff --git a/mi/mioverlay.c b/mi/mioverlay.c
new file mode 100644
index 000000000..9e765b206
--- /dev/null
+++ b/mi/mioverlay.c
@@ -0,0 +1,2078 @@
+/* $XFree86: xc/programs/Xserver/mi/mioverlay.c,v 3.14 2002/10/18 00:07:13 mvojkovi Exp $ */
+
+#include "X.h"
+#include "scrnintstr.h"
+#include "validate.h"
+#include "windowstr.h"
+#include "mi.h"
+#include "gcstruct.h"
+#include "regionstr.h"
+#include "mivalidate.h"
+#include "mioverlay.h"
+#include "migc.h"
+
+#include "globals.h"
+
+
+typedef struct {
+   RegionRec 	exposed;
+   RegionRec	borderExposed;
+   RegionPtr	borderVisible;
+   DDXPointRec	oldAbsCorner;
+} miOverlayValDataRec, *miOverlayValDataPtr;
+
+typedef struct _TreeRec {
+   WindowPtr		pWin;
+   struct _TreeRec 	*parent;
+   struct _TreeRec 	*firstChild; 
+   struct _TreeRec 	*lastChild; 
+   struct _TreeRec 	*prevSib; 
+   struct _TreeRec 	*nextSib;
+   RegionRec 		borderClip;
+   RegionRec 		clipList;
+   unsigned		visibility;
+   miOverlayValDataPtr  valdata;
+} miOverlayTreeRec, *miOverlayTreePtr;
+
+typedef struct {
+   miOverlayTreePtr	tree;
+} miOverlayWindowRec, *miOverlayWindowPtr;
+
+typedef struct {
+   CloseScreenProcPtr   	CloseScreen;
+   CreateWindowProcPtr  	CreateWindow;
+   DestroyWindowProcPtr 	DestroyWindow;
+   UnrealizeWindowProcPtr	UnrealizeWindow;
+   RealizeWindowProcPtr		RealizeWindow;
+   miOverlayTransFunc		MakeTransparent;
+   miOverlayInOverlayFunc	InOverlay;
+   Bool				underlayMarked;
+   Bool				copyUnderlay;
+} miOverlayScreenRec, *miOverlayScreenPtr;
+
+static unsigned long miOverlayGeneration = 0;
+int miOverlayWindowIndex = -1;
+int miOverlayScreenIndex = -1;
+
+static void RebuildTree(WindowPtr);
+static Bool HasUnderlayChildren(WindowPtr);
+static void MarkUnderlayWindow(WindowPtr);
+static Bool CollectUnderlayChildrenRegions(WindowPtr, RegionPtr);
+
+static Bool miOverlayCloseScreen(int, ScreenPtr);
+static Bool miOverlayCreateWindow(WindowPtr);
+static Bool miOverlayDestroyWindow(WindowPtr);
+static Bool miOverlayUnrealizeWindow(WindowPtr);
+static Bool miOverlayRealizeWindow(WindowPtr);
+static void miOverlayMarkWindow(WindowPtr);
+static void miOverlayReparentWindow(WindowPtr, WindowPtr);
+static void miOverlayRestackWindow(WindowPtr, WindowPtr);
+static Bool miOverlayMarkOverlappedWindows(WindowPtr, WindowPtr, WindowPtr*);
+static void miOverlayMarkUnrealizedWindow(WindowPtr, WindowPtr, Bool);
+static int miOverlayValidateTree(WindowPtr, WindowPtr, VTKind);
+static void miOverlayHandleExposures(WindowPtr);
+static void miOverlayMoveWindow(WindowPtr, int, int, WindowPtr, VTKind);
+static void miOverlayWindowExposures(WindowPtr, RegionPtr, RegionPtr);
+static void miOverlayResizeWindow(WindowPtr, int, int, unsigned int,
+					unsigned int, WindowPtr);
+static void miOverlayClearToBackground(WindowPtr, int, int, int, int, Bool);
+
+#ifdef SHAPE
+static void miOverlaySetShape(WindowPtr);
+#endif
+static void miOverlayChangeBorderWidth(WindowPtr, unsigned int);
+
+#define MIOVERLAY_GET_SCREEN_PRIVATE(pScreen) \
+	((miOverlayScreenPtr)((pScreen)->devPrivates[miOverlayScreenIndex].ptr))
+#define MIOVERLAY_GET_WINDOW_PRIVATE(pWin) \
+	((miOverlayWindowPtr)((pWin)->devPrivates[miOverlayWindowIndex].ptr))
+#define MIOVERLAY_GET_WINDOW_TREE(pWin) \
+	(MIOVERLAY_GET_WINDOW_PRIVATE(pWin)->tree)
+
+#define IN_UNDERLAY(w) MIOVERLAY_GET_WINDOW_TREE(w)
+#define IN_OVERLAY(w) !MIOVERLAY_GET_WINDOW_TREE(w)
+
+#define MARK_OVERLAY(w) miMarkWindow(w)
+#define MARK_UNDERLAY(w) MarkUnderlayWindow(w)
+
+#define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
+                                    HasBorder(w) && \
+                                    (w)->backgroundState == ParentRelative)
+
+Bool
+miInitOverlay(
+    ScreenPtr pScreen, 
+    miOverlayInOverlayFunc inOverlayFunc,
+    miOverlayTransFunc transFunc
+){
+    miOverlayScreenPtr	pScreenPriv;
+
+    if(!inOverlayFunc || !transFunc) return FALSE;
+
+    if(miOverlayGeneration != serverGeneration) {
+	if(((miOverlayScreenIndex = AllocateScreenPrivateIndex()) < 0) ||
+	   ((miOverlayWindowIndex = AllocateWindowPrivateIndex()) < 0))
+	    return FALSE;
+	
+	miOverlayGeneration = serverGeneration;
+    }
+
+    if(!AllocateWindowPrivate(pScreen, miOverlayWindowIndex,
+				sizeof(miOverlayWindowRec)))
+	return FALSE;
+
+    if(!(pScreenPriv = xalloc(sizeof(miOverlayScreenRec))))
+	return FALSE;
+
+    pScreen->devPrivates[miOverlayScreenIndex].ptr = (pointer)pScreenPriv;
+
+    pScreenPriv->InOverlay = inOverlayFunc;
+    pScreenPriv->MakeTransparent = transFunc;
+    pScreenPriv->underlayMarked = FALSE;
+
+
+    pScreenPriv->CloseScreen = pScreen->CloseScreen;
+    pScreenPriv->CreateWindow = pScreen->CreateWindow;
+    pScreenPriv->DestroyWindow = pScreen->DestroyWindow;
+    pScreenPriv->UnrealizeWindow = pScreen->UnrealizeWindow;
+    pScreenPriv->RealizeWindow = pScreen->RealizeWindow;
+
+    pScreen->CloseScreen = miOverlayCloseScreen;
+    pScreen->CreateWindow = miOverlayCreateWindow;
+    pScreen->DestroyWindow = miOverlayDestroyWindow;
+    pScreen->UnrealizeWindow = miOverlayUnrealizeWindow;
+    pScreen->RealizeWindow = miOverlayRealizeWindow;
+
+    pScreen->ReparentWindow = miOverlayReparentWindow;
+    pScreen->RestackWindow = miOverlayRestackWindow;
+    pScreen->MarkOverlappedWindows = miOverlayMarkOverlappedWindows;
+    pScreen->MarkUnrealizedWindow = miOverlayMarkUnrealizedWindow;
+    pScreen->ValidateTree = miOverlayValidateTree;
+    pScreen->HandleExposures = miOverlayHandleExposures;
+    pScreen->MoveWindow = miOverlayMoveWindow;
+    pScreen->WindowExposures = miOverlayWindowExposures;
+    pScreen->ResizeWindow = miOverlayResizeWindow;
+    pScreen->MarkWindow = miOverlayMarkWindow;
+    pScreen->ClearToBackground = miOverlayClearToBackground;
+#ifdef SHAPE
+    pScreen->SetShape = miOverlaySetShape;
+#endif
+    pScreen->ChangeBorderWidth = miOverlayChangeBorderWidth;
+
+    return TRUE;
+}
+
+
+static Bool 
+miOverlayCloseScreen(int i, ScreenPtr pScreen)
+{
+   miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+
+   pScreen->CloseScreen = pScreenPriv->CloseScreen; 
+   pScreen->CreateWindow = pScreenPriv->CreateWindow;
+   pScreen->DestroyWindow = pScreenPriv->DestroyWindow;
+   pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow;
+   pScreen->RealizeWindow = pScreenPriv->RealizeWindow;
+
+   xfree(pScreenPriv);
+
+   return (*pScreen->CloseScreen)(i, pScreen);
+}
+
+
+static Bool 
+miOverlayCreateWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    miOverlayWindowPtr pWinPriv = MIOVERLAY_GET_WINDOW_PRIVATE(pWin);
+    miOverlayTreePtr pTree = NULL;
+    Bool result = TRUE;
+
+    pWinPriv->tree = NULL;
+
+    if(!pWin->parent || !((*pScreenPriv->InOverlay)(pWin))) {
+	if(!(pTree = (miOverlayTreePtr)xcalloc(1, sizeof(miOverlayTreeRec))))
+	   return FALSE;
+    }
+
+    if(pScreenPriv->CreateWindow) {
+	pScreen->CreateWindow = pScreenPriv->CreateWindow;
+	result = (*pScreen->CreateWindow)(pWin);
+	pScreen->CreateWindow = miOverlayCreateWindow;
+    }
+	
+    if (pTree) {
+	if(result) {
+	    pTree->pWin = pWin;
+	    pTree->visibility = VisibilityNotViewable;
+	    pWinPriv->tree = pTree;
+	    if(pWin->parent) {
+		REGION_INIT(pScreen, &(pTree->borderClip), NullBox, 1);
+		REGION_INIT(pScreen, &(pTree->clipList), NullBox, 1);
+		RebuildTree(pWin);
+	    } else {
+		BoxRec fullBox;
+		fullBox.x1 = 0;
+		fullBox.y1 = 0;
+		fullBox.x2 = pScreen->width;
+		fullBox.y2 = pScreen->height;
+		REGION_INIT(pScreen, &(pTree->borderClip), &fullBox, 1);
+		REGION_INIT(pScreen, &(pTree->clipList), &fullBox, 1);
+	    }
+	} else xfree(pTree);
+    }
+
+    return TRUE;
+}
+
+
+static Bool 
+miOverlayDestroyWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    Bool result = TRUE;
+
+    if (pTree) {
+	if(pTree->prevSib)
+	   pTree->prevSib->nextSib = pTree->nextSib;
+	else if(pTree->parent)
+	   pTree->parent->firstChild = pTree->nextSib;
+
+	if(pTree->nextSib)
+	   pTree->nextSib->prevSib = pTree->prevSib;
+	else if(pTree->parent)
+	   pTree->parent->lastChild = pTree->prevSib;
+
+	REGION_UNINIT(pScreen, &(pTree->borderClip));
+	REGION_UNINIT(pScreen, &(pTree->clipList));
+	xfree(pTree);
+    }
+
+    if(pScreenPriv->DestroyWindow) {
+	pScreen->DestroyWindow = pScreenPriv->DestroyWindow;
+	result = (*pScreen->DestroyWindow)(pWin);
+	pScreen->DestroyWindow = miOverlayDestroyWindow;
+    }
+
+    return result;
+}
+
+static Bool 
+miOverlayUnrealizeWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    Bool result = TRUE;
+
+    if(pTree) pTree->visibility = VisibilityNotViewable;
+
+    if(pScreenPriv->UnrealizeWindow) {
+	pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow;
+	result = (*pScreen->UnrealizeWindow)(pWin);
+	pScreen->UnrealizeWindow = miOverlayUnrealizeWindow;
+    }
+
+    return result;
+}
+
+
+static Bool 
+miOverlayRealizeWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    Bool result = TRUE;
+
+    if(pScreenPriv->RealizeWindow) {
+	pScreen->RealizeWindow = pScreenPriv->RealizeWindow;
+	result = (*pScreen->RealizeWindow)(pWin);
+	pScreen->RealizeWindow = miOverlayRealizeWindow;
+    }
+
+    /* we only need to catch the root window realization */
+
+    if(result && !pWin->parent && !((*pScreenPriv->InOverlay)(pWin)))
+    {
+	BoxRec box;
+	box.x1 = box.y1 = 0;
+	box.x2 = pWin->drawable.width;
+	box.y2 = pWin->drawable.height;
+	(*pScreenPriv->MakeTransparent)(pScreen, 1, &box);
+    }
+
+    return result;
+}
+
+
+static void 
+miOverlayReparentWindow(WindowPtr pWin, WindowPtr pPriorParent)
+{
+    if(IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) {
+	/* This could probably be more optimal */
+	RebuildTree(WindowTable[pWin->drawable.pScreen->myNum]->firstChild);
+    }	
+}
+
+static void 
+miOverlayRestackWindow(WindowPtr pWin, WindowPtr oldNextSib)
+{
+    if(IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) {
+	/* This could probably be more optimal */
+	RebuildTree(pWin);
+    }	
+}
+
+
+static Bool
+miOverlayMarkOverlappedWindows(
+    WindowPtr pWin,
+    WindowPtr pFirst,
+    WindowPtr *pLayerWin
+){
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    WindowPtr pChild, pLast;
+    Bool overMarked, underMarked, doUnderlay, markAll;
+    miOverlayTreePtr pTree = NULL, tLast, tChild;
+    BoxPtr box;
+    
+    overMarked = underMarked = markAll = FALSE;
+
+    if(pLayerWin) *pLayerWin = pWin; /* hah! */
+
+    doUnderlay = (IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin));
+
+    box = REGION_EXTENTS(pScreen, &pWin->borderSize);
+
+    if((pChild = pFirst)) {
+	pLast = pChild->parent->lastChild;
+	while (1) {
+	    if (pChild == pWin) markAll = TRUE;
+
+	    if(doUnderlay && IN_UNDERLAY(pChild))
+		pTree = MIOVERLAY_GET_WINDOW_TREE(pChild);
+
+	    if(pChild->viewable) {
+                if (REGION_BROKEN (pScreen, &pChild->winSize))
+                    SetWinSize (pChild);
+                if (REGION_BROKEN (pScreen, &pChild->borderSize))
+		    SetBorderSize (pChild);
+
+	    	if (markAll || 
+		    RECT_IN_REGION(pScreen, &pChild->borderSize, box))
+		{
+		    MARK_OVERLAY(pChild);
+		    overMarked = TRUE;
+		    if(doUnderlay && IN_UNDERLAY(pChild)) {
+			MARK_UNDERLAY(pChild);
+			underMarked = TRUE;
+		    }
+		    if (pChild->firstChild) {
+			pChild = pChild->firstChild;
+			continue;
+		    }
+		}
+	    }
+	    while (!pChild->nextSib && (pChild != pLast)) {
+		pChild = pChild->parent;
+		if(doUnderlay && IN_UNDERLAY(pChild))
+		    pTree = MIOVERLAY_GET_WINDOW_TREE(pChild);
+	    }
+
+	    if(pChild == pWin) markAll = FALSE;
+
+	    if (pChild == pLast) break;
+
+	    pChild = pChild->nextSib;
+	}
+	if(overMarked)
+	    MARK_OVERLAY(pWin->parent);
+    } 
+
+    if(doUnderlay && !pTree) {
+	if(!(pTree = MIOVERLAY_GET_WINDOW_TREE(pWin))) {
+ 	    pChild = pWin->lastChild;
+	    while(1) {
+		if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild)))
+		    break;
+
+		if(pChild->lastChild) {
+		    pChild = pChild->lastChild;
+		    continue;
+		}
+
+		while(!pChild->prevSib) pChild = pChild->parent;
+
+		pChild = pChild->prevSib;
+	    }
+	}
+    }
+   
+    if(pTree && pTree->nextSib) {
+	tChild = pTree->parent->lastChild;
+	tLast = pTree->nextSib;	
+
+	while(1) {
+	    if(tChild->pWin->viewable) { 
+                if (REGION_BROKEN (pScreen, &tChild->pWin->winSize))
+                    SetWinSize (tChild->pWin);
+                if (REGION_BROKEN (pScreen, &tChild->pWin->borderSize))
+		    SetBorderSize (tChild->pWin);
+
+		if(RECT_IN_REGION(pScreen, &(tChild->pWin->borderSize), box)) 
+	        {
+		    MARK_UNDERLAY(tChild->pWin);
+		    underMarked = TRUE;
+	        }
+	    }
+
+	    if(tChild->lastChild) {
+		tChild = tChild->lastChild;
+		continue;
+	    }
+
+	    while(!tChild->prevSib && (tChild != tLast))
+		tChild = tChild->parent;
+
+	    if(tChild == tLast) break;
+
+	    tChild = tChild->prevSib;
+	}
+    }
+
+    if(underMarked) {
+	MARK_UNDERLAY(pTree->parent->pWin);
+	MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->underlayMarked = TRUE;	
+    }
+
+    return (underMarked || overMarked);
+}
+
+
+static void
+miOverlayComputeClips(
+    WindowPtr pParent, 
+    RegionPtr universe,
+    VTKind kind,
+    RegionPtr exposed
+){
+    ScreenPtr pScreen = pParent->drawable.pScreen;
+    int oldVis, newVis, dx, dy;
+    BoxRec borderSize;
+    RegionPtr borderVisible;
+    RegionRec childUniverse, childUnion;
+    miOverlayTreePtr tParent = MIOVERLAY_GET_WINDOW_TREE(pParent);
+    miOverlayTreePtr tChild;
+    Bool overlap;
+
+    borderSize.x1 = pParent->drawable.x - wBorderWidth(pParent);
+    borderSize.y1 = pParent->drawable.y - wBorderWidth(pParent);
+    dx = (int) pParent->drawable.x + (int) pParent->drawable.width + 
+						wBorderWidth(pParent);
+    if (dx > 32767) dx = 32767;
+    borderSize.x2 = dx;
+    dy = (int) pParent->drawable.y + (int) pParent->drawable.height + 
+						wBorderWidth(pParent);
+    if (dy > 32767) dy = 32767;
+    borderSize.y2 = dy;
+  
+    oldVis = tParent->visibility;
+    switch (RECT_IN_REGION( pScreen, universe, &borderSize)) {
+	case rgnIN:
+	    newVis = VisibilityUnobscured;
+	    break;
+	case rgnPART:
+	    newVis = VisibilityPartiallyObscured;
+#ifdef SHAPE
+	    {
+		RegionPtr   pBounding;
+
+		if ((pBounding = wBoundingShape (pParent))) {
+		    switch (miShapedWindowIn (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;
+    }
+    tParent->visibility = newVis;
+
+    dx = pParent->drawable.x - tParent->valdata->oldAbsCorner.x;
+    dy = pParent->drawable.y - tParent->valdata->oldAbsCorner.y;
+
+    switch (kind) {
+    case VTMap:
+    case VTStack:
+    case VTUnmap:
+	break;
+    case VTMove:
+	if ((oldVis == newVis) &&
+	    ((oldVis == VisibilityFullyObscured) ||
+	     (oldVis == VisibilityUnobscured)))
+	{
+	    tChild = tParent;
+	    while (1) {
+		if (tChild->pWin->viewable) {
+		    if (tChild->visibility != VisibilityFullyObscured) {
+			REGION_TRANSLATE( pScreen, &tChild->borderClip, dx, dy);
+			REGION_TRANSLATE( pScreen, &tChild->clipList, dx, dy);
+		
+			tChild->pWin->drawable.serialNumber = 
+							 NEXT_SERIAL_NUMBER;
+                        if (pScreen->ClipNotify)
+                            (* pScreen->ClipNotify) (tChild->pWin, dx, dy);
+		    }
+		    if (tChild->valdata) {
+			REGION_INIT(pScreen, &tChild->valdata->borderExposed,
+				    NullBox, 0);
+			if (HasParentRelativeBorder(tChild->pWin)){
+			    REGION_SUBTRACT(pScreen,
+					 &tChild->valdata->borderExposed,
+					 &tChild->borderClip,
+					 &tChild->pWin->winSize);
+			}
+			REGION_INIT( pScreen, &tChild->valdata->exposed,
+						 NullBox, 0);
+		    }
+		    if (tChild->firstChild) {
+			tChild = tChild->firstChild;
+			continue;
+		    }
+		}
+		while (!tChild->nextSib && (tChild != tParent))
+		    tChild = tChild->parent;
+		if (tChild == tParent)
+		    break;
+		tChild = tChild->nextSib;
+	    }
+	    return;
+	}
+	/* fall through */
+    default:
+    	if (dx || dy)  {
+	    REGION_TRANSLATE( pScreen, &tParent->borderClip, dx, dy);
+	    REGION_TRANSLATE( pScreen, &tParent->clipList, dx, dy);
+    	} 
+	break;
+    case VTBroken:
+	REGION_EMPTY (pScreen, &tParent->borderClip);
+	REGION_EMPTY (pScreen, &tParent->clipList);
+	break;
+    }
+
+    borderVisible = tParent->valdata->borderVisible;
+    REGION_INIT( pScreen, &tParent->valdata->borderExposed, NullBox, 0);
+    REGION_INIT( pScreen, &tParent->valdata->exposed, NullBox, 0);
+
+    if (HasBorder (pParent)) {
+    	if (borderVisible) {
+	    REGION_SUBTRACT( pScreen, exposed, universe, borderVisible);
+	    REGION_DESTROY( pScreen, borderVisible);
+    	} else
+	    REGION_SUBTRACT( pScreen, exposed, universe, &tParent->borderClip);
+
+	if (HasParentRelativeBorder(pParent) && (dx || dy))
+	    REGION_SUBTRACT( pScreen, &tParent->valdata->borderExposed,
+				  universe, &pParent->winSize);
+	else
+	    REGION_SUBTRACT( pScreen, &tParent->valdata->borderExposed,
+			       exposed, &pParent->winSize);
+
+    	REGION_COPY( pScreen, &tParent->borderClip, universe);    
+    	REGION_INTERSECT( pScreen, universe, universe, &pParent->winSize);
+    }
+    else
+    	REGION_COPY( pScreen, &tParent->borderClip, universe);
+
+    if ((tChild = tParent->firstChild) && pParent->mapped) {
+	REGION_INIT(pScreen, &childUniverse, NullBox, 0);
+	REGION_INIT(pScreen, &childUnion, NullBox, 0);
+
+	for (; tChild; tChild = tChild->nextSib) {
+	    if (tChild->pWin->viewable)
+		REGION_APPEND( pScreen, &childUnion, &tChild->pWin->borderSize);
+	}
+
+	REGION_VALIDATE( pScreen, &childUnion, &overlap);
+
+	for (tChild = tParent->firstChild;
+	     tChild;
+	     tChild = tChild->nextSib)
+ 	{
+	    if (tChild->pWin->viewable) {
+		if (tChild->valdata) {
+		    REGION_INTERSECT( pScreen, &childUniverse, universe,
+					    &tChild->pWin->borderSize);
+		    miOverlayComputeClips (tChild->pWin, &childUniverse, 
+						kind, exposed);
+		}
+		if (overlap)
+		    REGION_SUBTRACT( pScreen, universe, universe,
+					  &tChild->pWin->borderSize);
+	    }
+	}
+	if (!overlap)
+	    REGION_SUBTRACT( pScreen, universe, universe, &childUnion);
+	REGION_UNINIT( pScreen, &childUnion);
+	REGION_UNINIT( pScreen, &childUniverse);
+    } 
+
+    if (oldVis == VisibilityFullyObscured ||
+	oldVis == VisibilityNotViewable)
+    {
+	REGION_COPY( pScreen, &tParent->valdata->exposed, universe);
+    }
+    else if (newVis != VisibilityFullyObscured &&
+	     newVis != VisibilityNotViewable)
+    {
+    	REGION_SUBTRACT( pScreen, &tParent->valdata->exposed,
+			       universe, &tParent->clipList);
+    }
+    
+    /* HACK ALERT - copying contents of regions, instead of regions */
+    {
+	RegionRec   tmp;
+
+	tmp = tParent->clipList;
+	tParent->clipList = *universe;
+	*universe = tmp;
+    }
+
+    pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+
+    if (pScreen->ClipNotify)
+        (* pScreen->ClipNotify) (pParent, dx, dy);
+}
+
+
+static void 
+miOverlayMarkWindow(WindowPtr pWin)
+{
+    miOverlayTreePtr pTree = NULL;
+    WindowPtr pChild, pGrandChild;
+   
+    miMarkWindow(pWin);
+
+    /* look for UnmapValdata among immediate children */
+
+    if(!(pChild = pWin->firstChild)) return;
+
+    for( ; pChild; pChild = pChild->nextSib) {
+	if(pChild->valdata == UnmapValData) {
+	    if(IN_UNDERLAY(pChild)) {
+		pTree = MIOVERLAY_GET_WINDOW_TREE(pChild);
+		pTree->valdata = (miOverlayValDataPtr)UnmapValData; 
+		continue;
+	    } else {	
+	        if(!(pGrandChild = pChild->firstChild))
+		   continue;
+
+		while(1) {
+		    if(IN_UNDERLAY(pGrandChild)) {
+			pTree = MIOVERLAY_GET_WINDOW_TREE(pGrandChild);
+			pTree->valdata = (miOverlayValDataPtr)UnmapValData; 
+		    } else if(pGrandChild->firstChild) {	
+			pGrandChild = pGrandChild->firstChild;
+			continue;
+		    }
+
+		    while(!pGrandChild->nextSib && (pGrandChild != pChild))
+			pGrandChild = pGrandChild->parent;
+
+		    if(pChild == pGrandChild) break;
+		
+		    pGrandChild = pGrandChild->nextSib;
+		}
+	    }
+        }
+    }
+
+    if(pTree) {
+	MARK_UNDERLAY(pTree->parent->pWin);
+	MIOVERLAY_GET_SCREEN_PRIVATE(
+		pWin->drawable.pScreen)->underlayMarked = TRUE;
+    }
+}
+
+static void
+miOverlayMarkUnrealizedWindow(
+    WindowPtr pChild,
+    WindowPtr pWin,
+    Bool fromConfigure
+){
+    if ((pChild != pWin) || fromConfigure) {
+	miOverlayTreePtr pTree;
+
+        REGION_EMPTY(pChild->drawable.pScreen, &pChild->clipList);
+        if (pChild->drawable.pScreen->ClipNotify)
+            (* pChild->drawable.pScreen->ClipNotify)(pChild, 0, 0);
+        REGION_EMPTY(pChild->drawable.pScreen, &pChild->borderClip);
+	if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) {
+	    if(pTree->valdata != (miOverlayValDataPtr)UnmapValData) {
+		REGION_EMPTY(pChild->drawable.pScreen, &pTree->clipList);
+		REGION_EMPTY(pChild->drawable.pScreen, &pTree->borderClip);
+	    }
+	}
+    }
+}
+
+
+static int 
+miOverlayValidateTree(
+    WindowPtr pParent,
+    WindowPtr pChild,   /* first child effected */
+    VTKind    kind
+){
+    ScreenPtr pScreen = pParent->drawable.pScreen;
+    miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    RegionRec totalClip, childClip, exposed;
+    miOverlayTreePtr tParent, tChild, tWin;
+    Bool overlap;
+    WindowPtr newParent;
+
+    if(!pPriv->underlayMarked)
+	goto SKIP_UNDERLAY;
+
+    if (!pChild) pChild = pParent->firstChild;
+
+    REGION_INIT(pScreen, &totalClip, NullBox, 0);
+    REGION_INIT(pScreen, &childClip, NullBox, 0);
+    REGION_INIT(pScreen, &exposed, NullBox, 0);
+
+    newParent = pParent;
+
+    while(IN_OVERLAY(newParent))
+    	newParent = newParent->parent;
+
+    tParent = MIOVERLAY_GET_WINDOW_TREE(newParent);
+
+    if(IN_UNDERLAY(pChild))
+	tChild = MIOVERLAY_GET_WINDOW_TREE(pChild);
+    else
+	tChild = tParent->firstChild;
+
+    if (REGION_BROKEN (pScreen, &tParent->clipList) &&
+        !REGION_BROKEN (pScreen, &tParent->borderClip))
+    {
+	kind = VTBroken;
+	REGION_COPY (pScreen, &totalClip, &tParent->borderClip);
+	REGION_INTERSECT (pScreen, &totalClip, &totalClip,
+						 &tParent->pWin->winSize);
+        
+        for (tWin = tParent->firstChild; tWin != tChild; tWin = tWin->nextSib) {
+            if (tWin->pWin->viewable)
+                REGION_SUBTRACT (pScreen, &totalClip, &totalClip, 
+					&tWin->pWin->borderSize);
+        }        
+        REGION_EMPTY (pScreen, &tParent->clipList);
+    } else {
+	for(tWin = tChild; tWin; tWin = tWin->nextSib) {
+	    if(tWin->valdata)
+		REGION_APPEND(pScreen, &totalClip, &tWin->borderClip);
+	}
+	REGION_VALIDATE(pScreen, &totalClip, &overlap);
+    }
+
+    if(kind != VTStack)
+	REGION_UNION(pScreen, &totalClip, &totalClip, &tParent->clipList);
+	
+    for(tWin = tChild; tWin; tWin = tWin->nextSib) {
+	if(tWin->valdata) {
+	    if(tWin->pWin->viewable) {
+		REGION_INTERSECT(pScreen, &childClip, &totalClip,
+					&tWin->pWin->borderSize);
+		miOverlayComputeClips(tWin->pWin, &childClip, kind, &exposed);
+		REGION_SUBTRACT(pScreen, &totalClip, &totalClip,
+					&tWin->pWin->borderSize);
+	    } else {  /* Means we are unmapping */
+                REGION_EMPTY(pScreen, &tWin->clipList);
+                REGION_EMPTY( pScreen, &tWin->borderClip);
+		tWin->valdata = NULL;
+	    }
+	}
+    }
+
+    REGION_UNINIT(pScreen, &childClip);
+
+    if(!((*pPriv->InOverlay)(newParent))) {
+	REGION_INIT(pScreen, &tParent->valdata->exposed, NullBox, 0);
+	REGION_INIT(pScreen, &tParent->valdata->borderExposed, NullBox, 0);
+    }
+
+    switch (kind) {
+    case VTStack:
+	break;
+    default:
+    	if(!((*pPriv->InOverlay)(newParent))) 
+	    REGION_SUBTRACT(pScreen, &tParent->valdata->exposed, &totalClip, 
+						&tParent->clipList);
+	/* fall through */
+    case VTMap:
+	REGION_COPY( pScreen, &tParent->clipList, &totalClip);
+    	if(!((*pPriv->InOverlay)(newParent))) 
+	    newParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+	break;
+    }
+
+    REGION_UNINIT( pScreen, &totalClip);
+    REGION_UNINIT( pScreen, &exposed);
+
+SKIP_UNDERLAY:
+
+    miValidateTree(pParent, pChild, kind);
+
+    return 1;
+}
+
+
+static void
+miOverlayHandleExposures(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    WindowPtr pChild;
+    ValidatePtr val;
+    void (* WindowExposures)(WindowPtr, RegionPtr, RegionPtr);
+
+    WindowExposures = pWin->drawable.pScreen->WindowExposures;
+    if(pPriv->underlayMarked) {
+	miOverlayTreePtr pTree;
+	miOverlayValDataPtr mival;
+
+	pChild = pWin;
+	while(IN_OVERLAY(pChild))
+	    pChild = pChild->parent;
+
+	pTree = MIOVERLAY_GET_WINDOW_TREE(pChild);
+
+	while (1) {
+	    if((mival = pTree->valdata)) {
+		if(!((*pPriv->InOverlay)(pTree->pWin))) {
+		    if (REGION_NOTEMPTY(pScreen, &mival->borderExposed))
+			(*pWin->drawable.pScreen->PaintWindowBorder)(
+				pTree->pWin, &mival->borderExposed, PW_BORDER);
+		    REGION_UNINIT(pScreen, &mival->borderExposed);
+
+		    (*WindowExposures)(pTree->pWin,&mival->exposed,NullRegion);
+		    REGION_UNINIT(pScreen, &mival->exposed);
+		}
+		xfree(mival);
+		pTree->valdata = NULL;
+		if (pTree->firstChild) {
+		    pTree = pTree->firstChild;
+		    continue;
+		}
+	    }
+	    while (!pTree->nextSib && (pTree->pWin != pChild))
+	    	pTree = pTree->parent;
+	    if (pTree->pWin == pChild)
+		break;
+	    pTree = pTree->nextSib;
+        }
+	pPriv->underlayMarked = FALSE;
+    }
+
+    pChild = pWin;
+    while (1) {
+	if ( (val = pChild->valdata) ) {
+	    if(!((*pPriv->InOverlay)(pChild))) {
+		REGION_UNION(pScreen, &val->after.exposed, &val->after.exposed,
+			&val->after.borderExposed);
+
+		if (REGION_NOTEMPTY(pScreen, &val->after.exposed)) {
+		   (*(MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent))(
+				pScreen, 
+				REGION_NUM_RECTS(&val->after.exposed),
+				REGION_RECTS(&val->after.exposed));
+		}
+	    } else {
+		if (REGION_NOTEMPTY(pScreen, &val->after.borderExposed))
+		    (*pChild->drawable.pScreen->PaintWindowBorder)(pChild,
+						    &val->after.borderExposed,
+						    PW_BORDER);
+		(*WindowExposures)(pChild, &val->after.exposed, NullRegion);
+	    }
+	    REGION_UNINIT(pScreen, &val->after.borderExposed);
+	    REGION_UNINIT(pScreen, &val->after.exposed);
+	    xfree(val);
+	    pChild->valdata = (ValidatePtr)NULL;
+	    if (pChild->firstChild)
+	    {
+		pChild = pChild->firstChild;
+		continue;
+	    }
+	}
+	while (!pChild->nextSib && (pChild != pWin))
+	    pChild = pChild->parent;
+	if (pChild == pWin)
+	    break;
+	pChild = pChild->nextSib;
+    }
+}
+
+
+static void
+miOverlayMoveWindow(
+    WindowPtr pWin,
+    int x,
+    int y,
+    WindowPtr pNextSib,
+    VTKind kind
+){
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    WindowPtr pParent, windowToValidate;
+    Bool WasViewable = (Bool)(pWin->viewable);
+    short bw;
+    RegionRec overReg, underReg;
+    DDXPointRec oldpt;
+#ifdef DO_SAVE_UNDERS
+    Bool dosave = FALSE;
+#endif
+
+    if (!(pParent = pWin->parent))
+       return ;
+    bw = wBorderWidth (pWin);
+
+    oldpt.x = pWin->drawable.x;
+    oldpt.y = pWin->drawable.y;
+    if (WasViewable) {
+	REGION_INIT(pScreen, &overReg, NullBox, 1);
+	REGION_INIT(pScreen, &underReg, NullBox, 0);
+	if(pTree) {
+	    REGION_COPY(pScreen, &overReg, &pWin->borderClip);
+	    REGION_COPY(pScreen, &underReg, &pTree->borderClip);
+        } else {
+	    REGION_COPY(pScreen, &overReg, &pWin->borderClip);
+	    CollectUnderlayChildrenRegions(pWin, &underReg);
+	}
+	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+    }
+    pWin->origin.x = x + (int)bw;
+    pWin->origin.y = y + (int)bw;
+    x = pWin->drawable.x = pParent->drawable.x + x + (int)bw;
+    y = pWin->drawable.y = pParent->drawable.y + y + (int)bw;
+
+    SetWinSize (pWin);
+    SetBorderSize (pWin);
+
+    (*pScreen->PositionWindow)(pWin, x, y);
+
+    windowToValidate = MoveWindowInStack(pWin, pNextSib);
+
+    ResizeChildrenWinSize(pWin, x - oldpt.x, y - oldpt.y, 0, 0);
+
+    if (WasViewable) {
+	miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+	(*pScreen->MarkOverlappedWindows) (pWin, windowToValidate, NULL);
+
+#ifdef DO_SAVE_UNDERS
+	if (DO_SAVE_UNDERS(pWin))
+	    dosave = (*pScreen->ChangeSaveUnder)(pWin, windowToValidate);
+#endif /* DO_SAVE_UNDERS */
+
+	(*pScreen->ValidateTree)(pWin->parent, NullWindow, kind);
+	if(REGION_NOTEMPTY(pScreen, &underReg)) {
+	    pPriv->copyUnderlay = TRUE;
+	    (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, &underReg);
+	}
+	REGION_UNINIT(pScreen, &underReg);
+	if(REGION_NOTEMPTY(pScreen, &overReg)) {
+	    pPriv->copyUnderlay = FALSE;
+	    (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, &overReg);
+	}
+	REGION_UNINIT(pScreen, &overReg);
+	(*pScreen->HandleExposures)(pWin->parent);
+
+#ifdef DO_SAVE_UNDERS
+	if (dosave)
+	    (*pScreen->PostChangeSaveUnder)(pWin, windowToValidate);
+#endif /* DO_SAVE_UNDERS */
+	if (pScreen->PostValidateTree)
+	    (*pScreen->PostValidateTree)(pWin->parent, NullWindow, kind);
+    }
+    if (pWin->realized)
+	WindowsRestructured ();
+}
+
+#ifndef RECTLIMIT
+#define RECTLIMIT 25
+#endif
+
+static void 
+miOverlayWindowExposures(
+    WindowPtr pWin,
+    register RegionPtr prgn,
+    RegionPtr other_exposed
+){
+    RegionPtr   exposures = prgn;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+
+    if (pWin->backStorage && prgn)
+	exposures = (*pScreen->RestoreAreas)(pWin, prgn);
+    if ((prgn && !REGION_NIL(prgn)) || 
+	(exposures && !REGION_NIL(exposures)) || other_exposed)
+    {
+	RegionRec   expRec;
+	int	    clientInterested;
+
+	clientInterested = (pWin->eventMask|wOtherEventMasks(pWin)) &
+		 	    ExposureMask;
+	if (other_exposed) {
+	    if (exposures) {
+		REGION_UNION(pScreen, other_exposed, exposures, other_exposed);
+		if (exposures != prgn)
+		    REGION_DESTROY(pScreen, exposures);
+	    }
+	    exposures = other_exposed;
+	}
+	if (clientInterested && exposures && 
+	   (REGION_NUM_RECTS(exposures) > RECTLIMIT))
+	{
+            miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+	    BoxRec box;
+
+	    box = *REGION_EXTENTS(pScreen, exposures);
+	    if (exposures == prgn) {
+		exposures = &expRec;
+		REGION_INIT(pScreen, exposures, &box, 1);
+		REGION_RESET(pScreen, prgn, &box);
+	    } else {
+		REGION_RESET(pScreen, exposures, &box);
+		REGION_UNION(pScreen, prgn, prgn, exposures);
+	    }
+	    /* This is the only reason why we are replacing mi's version
+               of this file */
+	    
+	    if(!((*pPriv->InOverlay)(pWin))) {
+		miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+		REGION_INTERSECT(pScreen, prgn, prgn, &pTree->clipList);
+	    } else
+		REGION_INTERSECT(pScreen, prgn, prgn, &pWin->clipList);
+
+	    /* need to clear out new areas of backing store, too */
+	    if (pWin->backStorage)
+		(void) (*pScreen->ClearBackingStore)(
+					     pWin,
+					     box.x1 - pWin->drawable.x,
+					     box.y1 - pWin->drawable.y,
+					     box.x2 - box.x1,
+					     box.y2 - box.y1,
+					     FALSE);
+	}
+	if (prgn && !REGION_NIL(prgn))
+	    (*pScreen->PaintWindowBackground)(
+			pWin, prgn, PW_BACKGROUND);
+	if (clientInterested && exposures && !REGION_NIL(exposures))
+	    miSendExposures(pWin, exposures,
+			    pWin->drawable.x, pWin->drawable.y);
+	if (exposures == &expRec) {
+	    REGION_UNINIT(pScreen, exposures);
+	} 
+	else if (exposures && exposures != prgn && exposures != other_exposed)
+	    REGION_DESTROY(pScreen, exposures);
+	if (prgn)
+	    REGION_EMPTY(pScreen, prgn);
+    }
+    else if (exposures && exposures != prgn)
+	REGION_DESTROY(pScreen, exposures);
+}
+
+
+typedef struct {
+   RegionPtr over;
+   RegionPtr under;
+} miOverlayTwoRegions; 
+
+static int
+miOverlayRecomputeExposures (
+    WindowPtr	pWin,
+    pointer	value 
+){
+    register ScreenPtr pScreen;
+    miOverlayTwoRegions	*pValid = (miOverlayTwoRegions*)value;
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+
+    /* This prevents warning about pScreen not being used. */
+    pWin->drawable.pScreen = pScreen = pWin->drawable.pScreen;
+
+    if (pWin->valdata) {
+	/*
+	 * compute exposed regions of this window
+	 */
+	REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+			&pWin->clipList, pValid->over);
+	/*
+	 * compute exposed regions of the border
+	 */
+	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+			     &pWin->borderClip, &pWin->winSize);
+	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+			     &pWin->valdata->after.borderExposed, pValid->over);
+    } 
+
+    if(pTree && pTree->valdata) {
+	REGION_SUBTRACT(pScreen, &pTree->valdata->exposed,
+			&pTree->clipList, pValid->under);
+	REGION_SUBTRACT(pScreen, &pTree->valdata->borderExposed,
+			     &pTree->borderClip, &pWin->winSize);
+	REGION_SUBTRACT(pScreen, &pTree->valdata->borderExposed,
+			     &pTree->valdata->borderExposed, pValid->under);    
+    } else if (!pWin->valdata)
+	return WT_NOMATCH;
+
+    return WT_WALKCHILDREN;
+}
+
+static void
+miOverlayResizeWindow(
+    WindowPtr pWin,
+    int x, int y,
+    unsigned int w, unsigned int h,
+    WindowPtr pSib
+){
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    WindowPtr pParent;
+    miOverlayTreePtr tChild, pTree;
+    Bool WasViewable = (Bool)(pWin->viewable);
+    unsigned short width = pWin->drawable.width;
+    unsigned short height = pWin->drawable.height;
+    short oldx = pWin->drawable.x;
+    short oldy = pWin->drawable.y;
+    int bw = wBorderWidth (pWin);
+    short dw, dh;
+    DDXPointRec oldpt;
+    RegionPtr oldRegion = NULL, oldRegion2 = NULL;
+    WindowPtr pFirstChange;
+    register WindowPtr pChild;
+    RegionPtr	gravitate[StaticGravity + 1];
+    RegionPtr	gravitate2[StaticGravity + 1];
+    register unsigned g;
+    int		nx, ny;		/* destination x,y */
+    int		newx, newy;	/* new inner window position */
+    RegionPtr	pRegion = NULL;
+    RegionPtr	destClip, destClip2;
+    RegionPtr	oldWinClip = NULL, oldWinClip2 = NULL;	
+    RegionPtr	borderVisible = NullRegion; 
+    RegionPtr	borderVisible2 = NullRegion; 
+    RegionPtr	bsExposed = NullRegion;	    /* backing store exposures */
+    Bool	shrunk = FALSE; /* shrunk in an inner dimension */
+    Bool	moved = FALSE;	/* window position changed */
+#ifdef DO_SAVE_UNDERS
+    Bool	dosave = FALSE;
+#endif
+    Bool	doUnderlay;
+
+    /* if this is a root window, can't be resized */
+    if (!(pParent = pWin->parent))
+	return ;
+
+    pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    doUnderlay = ((pTree) || HasUnderlayChildren(pWin));
+    newx = pParent->drawable.x + x + bw;
+    newy = pParent->drawable.y + y + bw;
+    if (WasViewable)
+    {
+	/*
+	 * save the visible region of the window
+	 */
+	oldRegion = REGION_CREATE(pScreen, NullBox, 1);
+	REGION_COPY(pScreen, oldRegion, &pWin->winSize);
+	if(doUnderlay) {
+	    oldRegion2 = REGION_CREATE(pScreen, NullBox, 1);
+	    REGION_COPY(pScreen, oldRegion2, &pWin->winSize);
+	}
+
+	/*
+	 * categorize child windows into regions to be moved
+	 */
+	for (g = 0; g <= StaticGravity; g++)
+	    gravitate[g] = gravitate2[g] = NULL;
+	for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
+	    g = pChild->winGravity;
+	    if (g != UnmapGravity) {
+		if (!gravitate[g])
+		    gravitate[g] = REGION_CREATE(pScreen, NullBox, 1);
+		REGION_UNION(pScreen, gravitate[g],
+				   gravitate[g], &pChild->borderClip);
+		
+		if(doUnderlay) {
+		    if (!gravitate2[g])
+			gravitate2[g] = REGION_CREATE(pScreen, NullBox, 0);
+		
+		    if((tChild = MIOVERLAY_GET_WINDOW_TREE(pChild))) {
+		        REGION_UNION(pScreen, gravitate2[g],
+				   gravitate2[g], &tChild->borderClip);
+		    } else 
+			CollectUnderlayChildrenRegions(pChild, gravitate2[g]);
+		}
+	    } else {
+		UnmapWindow(pChild, TRUE);
+	    }
+	}
+	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+
+	oldWinClip = oldWinClip2 = NULL;
+	if (pWin->bitGravity != ForgetGravity) {
+	    oldWinClip = REGION_CREATE(pScreen, NullBox, 1);
+	    REGION_COPY(pScreen, oldWinClip, &pWin->clipList);
+	    if(pTree) {
+		oldWinClip2 = REGION_CREATE(pScreen, NullBox, 1);
+		REGION_COPY(pScreen, oldWinClip2, &pTree->clipList);
+	    }
+	}
+	/*
+	 * if the window is changing size, borderExposed
+	 * can't be computed correctly without some help.
+	 */
+	if (pWin->drawable.height > h || pWin->drawable.width > w)
+	    shrunk = TRUE;
+
+	if (newx != oldx || newy != oldy)
+	    moved = TRUE;
+
+	if ((pWin->drawable.height != h || pWin->drawable.width != w) &&
+	    HasBorder (pWin))
+	{
+	    borderVisible = REGION_CREATE(pScreen, NullBox, 1);
+	    if(pTree)
+		borderVisible2 = REGION_CREATE(pScreen, NullBox, 1);
+	    /* for tiled borders, we punt and draw the whole thing */
+	    if (pWin->borderIsPixel || !moved)
+	    {
+		if (shrunk || moved)
+		    REGION_SUBTRACT(pScreen, borderVisible,
+					  &pWin->borderClip,
+					  &pWin->winSize);
+		else
+		    REGION_COPY(pScreen, borderVisible,
+					    &pWin->borderClip);
+		if(pTree) {
+		    if (shrunk || moved)
+			REGION_SUBTRACT(pScreen, borderVisible,
+					  &pTree->borderClip,
+					  &pWin->winSize);
+		    else
+			REGION_COPY(pScreen, borderVisible,
+					    &pTree->borderClip);
+		}
+	    }
+	}
+    }
+    pWin->origin.x = x + bw;
+    pWin->origin.y = y + bw;
+    pWin->drawable.height = h;
+    pWin->drawable.width = w;
+
+    x = pWin->drawable.x = newx;
+    y = pWin->drawable.y = newy;
+
+    SetWinSize (pWin);
+    SetBorderSize (pWin);
+
+    dw = (int)w - (int)width;
+    dh = (int)h - (int)height;
+    ResizeChildrenWinSize(pWin, x - oldx, y - oldy, dw, dh);
+
+    /* let the hardware adjust background and border pixmaps, if any */
+    (*pScreen->PositionWindow)(pWin, x, y);
+
+    pFirstChange = MoveWindowInStack(pWin, pSib);
+
+    if (WasViewable) {
+	pRegion = REGION_CREATE(pScreen, NullBox, 1);
+	if (pWin->backStorage)
+	    REGION_COPY(pScreen, pRegion, &pWin->clipList);
+
+	(*pScreen->MarkOverlappedWindows)(pWin, pFirstChange, NULL);
+
+	pWin->valdata->before.resized = TRUE;
+	pWin->valdata->before.borderVisible = borderVisible;
+	if(pTree)
+	    pTree->valdata->borderVisible = borderVisible2;
+
+#ifdef DO_SAVE_UNDERS
+	if (DO_SAVE_UNDERS(pWin))
+	    dosave = (*pScreen->ChangeSaveUnder)(pWin, pFirstChange);
+#endif /* DO_SAVE_UNDERS */
+
+	(*pScreen->ValidateTree)(pWin->parent, pFirstChange, VTOther);
+	/*
+	 * the entire window is trashed unless bitGravity
+	 * recovers portions of it
+	 */
+	REGION_COPY(pScreen, &pWin->valdata->after.exposed, &pWin->clipList);
+	if(pTree)
+	    REGION_COPY(pScreen, &pTree->valdata->exposed, &pTree->clipList);
+    }
+
+    GravityTranslate (x, y, oldx, oldy, dw, dh, pWin->bitGravity, &nx, &ny);
+
+    if (pWin->backStorage && ((pWin->backingStore == Always) || WasViewable)) {
+	if (!WasViewable)
+	    pRegion = &pWin->clipList; /* a convenient empty region */
+	if (pWin->bitGravity == ForgetGravity)
+	    bsExposed = (*pScreen->TranslateBackingStore)
+				(pWin, 0, 0, NullRegion, oldx, oldy);
+	else
+	    bsExposed = (*pScreen->TranslateBackingStore)
+			     (pWin, nx - x, ny - y, pRegion, oldx, oldy);
+    }
+
+    if (WasViewable) {
+	miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+	miOverlayTwoRegions TwoRegions;
+
+	/* avoid the border */
+	if (HasBorder (pWin)) {
+	    int	offx, offy, dx, dy;
+
+	    /* kruft to avoid double translates for each gravity */
+	    offx = 0;
+	    offy = 0;
+	    for (g = 0; g <= StaticGravity; g++) {
+		if (!gravitate[g] && !gravitate2[g])
+		    continue;
+
+		/* align winSize to gravitate[g].
+		 * winSize is in new coordinates,
+		 * gravitate[g] is still in old coordinates */
+		GravityTranslate (x, y, oldx, oldy, dw, dh, g, &nx, &ny);
+		
+		dx = (oldx - nx) - offx;
+		dy = (oldy - ny) - offy;
+		if (dx || dy) {
+		    REGION_TRANSLATE(pScreen, &pWin->winSize, dx, dy);
+		    offx += dx;
+		    offy += dy;
+		}
+		if(gravitate[g])
+		    REGION_INTERSECT(pScreen, gravitate[g], gravitate[g],
+				 &pWin->winSize);
+		if(gravitate2[g])
+		    REGION_INTERSECT(pScreen, gravitate2[g], gravitate2[g],
+				 &pWin->winSize);
+	    }
+	    /* get winSize back where it belongs */
+	    if (offx || offy)
+		REGION_TRANSLATE(pScreen, &pWin->winSize, -offx, -offy);
+	}
+	/*
+	 * add screen bits to the appropriate bucket
+	 */
+
+	if (oldWinClip2)
+	{
+	    REGION_COPY(pScreen, pRegion, oldWinClip2);
+	    REGION_TRANSLATE(pScreen, pRegion, nx - oldx, ny - oldy);
+	    REGION_INTERSECT(pScreen, oldWinClip2, pRegion, &pTree->clipList);
+
+	    for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) {
+		if (gravitate2[g])
+		    REGION_SUBTRACT(pScreen, oldWinClip2, oldWinClip2,
+					gravitate2[g]);
+	    }
+	    REGION_TRANSLATE(pScreen, oldWinClip2, oldx - nx, oldy - ny);
+	    g = pWin->bitGravity;
+	    if (!gravitate2[g])
+		gravitate2[g] = oldWinClip2;
+	    else {
+		REGION_UNION(pScreen,gravitate2[g],gravitate2[g],oldWinClip2);
+		REGION_DESTROY(pScreen, oldWinClip2);
+	    }
+	}
+
+	if (oldWinClip)
+	{
+	    /*
+	     * clip to new clipList
+	     */
+	    REGION_COPY(pScreen, pRegion, oldWinClip);
+	    REGION_TRANSLATE(pScreen, pRegion, nx - oldx, ny - oldy);
+	    REGION_INTERSECT(pScreen, oldWinClip, pRegion, &pWin->clipList);
+	    /*
+	     * don't step on any gravity bits which will be copied after this
+	     * region.	Note -- this assumes that the regions will be copied
+	     * in gravity order.
+	     */
+	    for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) {
+		if (gravitate[g])
+		    REGION_SUBTRACT(pScreen, oldWinClip, oldWinClip,
+					gravitate[g]);
+	    }
+	    REGION_TRANSLATE(pScreen, oldWinClip, oldx - nx, oldy - ny);
+	    g = pWin->bitGravity;
+	    if (!gravitate[g])
+		gravitate[g] = oldWinClip;
+	    else {
+		REGION_UNION(pScreen, gravitate[g], gravitate[g], oldWinClip);
+		REGION_DESTROY(pScreen, oldWinClip);
+	    }
+	}
+
+	/*
+	 * move the bits on the screen
+	 */
+
+	destClip = destClip2 = NULL;
+
+	for (g = 0; g <= StaticGravity; g++) {
+	    if (!gravitate[g] && !gravitate2[g])
+		continue;
+
+	    GravityTranslate (x, y, oldx, oldy, dw, dh, g, &nx, &ny);
+
+	    oldpt.x = oldx + (x - nx);
+	    oldpt.y = oldy + (y - ny);
+
+	    /* Note that gravitate[g] is *translated* by CopyWindow */
+
+	    /* only copy the remaining useful bits */
+
+	    if(gravitate[g])
+		REGION_INTERSECT(pScreen, gravitate[g], 
+				 gravitate[g], oldRegion);
+	    if(gravitate2[g])
+		REGION_INTERSECT(pScreen, gravitate2[g], 
+				 gravitate2[g], oldRegion2);
+
+	    /* clip to not overwrite already copied areas */
+
+	    if (destClip && gravitate[g]) {
+		REGION_TRANSLATE(pScreen, destClip, oldpt.x - x, oldpt.y - y);
+		REGION_SUBTRACT(pScreen, gravitate[g], gravitate[g], destClip);
+		REGION_TRANSLATE(pScreen, destClip, x - oldpt.x, y - oldpt.y);
+	    }
+	    if (destClip2 && gravitate2[g]) {
+		REGION_TRANSLATE(pScreen, destClip2, oldpt.x - x, oldpt.y - y);
+		REGION_SUBTRACT(pScreen,gravitate2[g],gravitate2[g],destClip2);
+		REGION_TRANSLATE(pScreen, destClip2, x - oldpt.x, y - oldpt.y);
+	    }
+
+	    /* and move those bits */
+
+	    if (oldpt.x != x || oldpt.y != y) {
+		if(gravitate2[g]) {
+		    pPriv->copyUnderlay = TRUE;
+		    (*pWin->drawable.pScreen->CopyWindow)(
+						pWin, oldpt, gravitate2[g]);
+		}
+		if(gravitate[g]) {
+		    pPriv->copyUnderlay = FALSE;
+		    (*pWin->drawable.pScreen->CopyWindow)(
+						pWin, oldpt, gravitate[g]);
+		}
+	    }
+
+	    /* remove any overwritten bits from the remaining useful bits */
+
+	    if(gravitate[g])
+		REGION_SUBTRACT(pScreen, oldRegion, oldRegion, gravitate[g]);
+	    if(gravitate2[g])
+		REGION_SUBTRACT(pScreen, oldRegion2, oldRegion2, gravitate2[g]);
+
+	    /*
+	     * recompute exposed regions of child windows
+	     */
+	
+
+	    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
+		if (pChild->winGravity != g)
+		    continue;
+
+		TwoRegions.over = gravitate[g];
+		TwoRegions.under = gravitate2[g];
+
+		TraverseTree (pChild, miOverlayRecomputeExposures, 
+					(pointer)(&TwoRegions));
+	    }
+
+	    /*
+	     * remove the successfully copied regions of the
+	     * window from its exposed region
+	     */
+
+	    if (g == pWin->bitGravity) {
+		if(gravitate[g])
+		    REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+				&pWin->valdata->after.exposed, gravitate[g]);
+		if(gravitate2[g] && pTree) 
+		    REGION_SUBTRACT(pScreen, &pTree->valdata->exposed,
+				&pTree->valdata->exposed, gravitate2[g]);
+	    }
+	    if(gravitate[g]) {
+		if (!destClip)
+		    destClip = gravitate[g];
+		else {
+		    REGION_UNION(pScreen, destClip, destClip, gravitate[g]);
+		    REGION_DESTROY(pScreen, gravitate[g]);
+		}
+	    }
+	    if(gravitate2[g]) {
+		if (!destClip2)
+		    destClip2 = gravitate2[g];
+		else {
+		    REGION_UNION(pScreen, destClip2, destClip2, gravitate2[g]);
+		    REGION_DESTROY(pScreen, gravitate2[g]);
+		}
+	    }
+	}
+
+	REGION_DESTROY(pScreen, pRegion);
+	REGION_DESTROY(pScreen, oldRegion);
+	if(doUnderlay)
+	    REGION_DESTROY(pScreen, oldRegion2);
+	if (destClip)
+	    REGION_DESTROY(pScreen, destClip);
+	if (destClip2)
+	    REGION_DESTROY(pScreen, destClip2);
+	if (bsExposed) {
+	    RegionPtr	valExposed = NullRegion;
+
+	    if (pWin->valdata)
+		valExposed = &pWin->valdata->after.exposed;
+	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
+	    if (valExposed)
+		REGION_EMPTY(pScreen, valExposed);
+	    REGION_DESTROY(pScreen, bsExposed);
+	}
+	(*pScreen->HandleExposures)(pWin->parent);
+#ifdef DO_SAVE_UNDERS
+	if (dosave)
+	    (*pScreen->PostChangeSaveUnder)(pWin, pFirstChange);
+#endif /* DO_SAVE_UNDERS */
+	if (pScreen->PostValidateTree)
+	    (*pScreen->PostValidateTree)(pWin->parent, pFirstChange, VTOther);
+    }
+    else if (bsExposed) {
+	(*pScreen->WindowExposures) (pWin, NullRegion, bsExposed);
+	REGION_DESTROY(pScreen, bsExposed);
+    }
+    if (pWin->realized)
+	WindowsRestructured ();
+}
+
+
+#ifdef SHAPE
+static void
+miOverlaySetShape(WindowPtr pWin)
+{
+    Bool	WasViewable = (Bool)(pWin->viewable);
+    ScreenPtr 	pScreen = pWin->drawable.pScreen;
+    RegionPtr	pOldClip = NULL, bsExposed;
+#ifdef DO_SAVE_UNDERS
+    Bool	dosave = FALSE;
+#endif
+
+    if (WasViewable) {
+	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+	if (HasBorder (pWin)) {
+	    RegionPtr borderVisible;
+
+	    borderVisible = REGION_CREATE(pScreen, NullBox, 1);
+	    REGION_SUBTRACT(pScreen, borderVisible,
+				      &pWin->borderClip, &pWin->winSize);
+	    pWin->valdata->before.borderVisible = borderVisible;
+	    pWin->valdata->before.resized = TRUE;
+	    if(IN_UNDERLAY(pWin)) {
+		miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+		RegionPtr borderVisible2;
+
+		borderVisible2 = REGION_CREATE(pScreen, NULL, 1);
+		REGION_SUBTRACT(pScreen, borderVisible2,
+				      &pTree->borderClip, &pWin->winSize);
+		pTree->valdata->borderVisible = borderVisible2;
+	    }
+	}
+    }
+
+    SetWinSize (pWin);
+    SetBorderSize (pWin);
+
+    ResizeChildrenWinSize(pWin, 0, 0, 0, 0);
+
+    if (WasViewable) {
+	if (pWin->backStorage) {
+	    pOldClip = REGION_CREATE(pScreen, NullBox, 1);
+	    REGION_COPY(pScreen, pOldClip, &pWin->clipList);
+	}
+
+	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+#ifdef DO_SAVE_UNDERS
+	if (DO_SAVE_UNDERS(pWin))
+	    dosave = (*pScreen->ChangeSaveUnder)(pWin, pWin);
+#endif /* DO_SAVE_UNDERS */
+
+	(*pScreen->ValidateTree)(pWin->parent, NullWindow, VTOther);
+    }
+
+    if (pWin->backStorage && ((pWin->backingStore == Always) || WasViewable)) {
+	if (!WasViewable)
+	    pOldClip = &pWin->clipList; /* a convenient empty region */
+	bsExposed = (*pScreen->TranslateBackingStore)
+			     (pWin, 0, 0, pOldClip,
+			      pWin->drawable.x, pWin->drawable.y);
+	if (WasViewable)
+	    REGION_DESTROY(pScreen, pOldClip);
+	if (bsExposed)
+	{
+	    RegionPtr	valExposed = NullRegion;
+    
+	    if (pWin->valdata)
+		valExposed = &pWin->valdata->after.exposed;
+	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
+	    if (valExposed)
+		REGION_EMPTY(pScreen, valExposed);
+	    REGION_DESTROY(pScreen, bsExposed);
+	}
+    }
+    if (WasViewable) {
+	(*pScreen->HandleExposures)(pWin->parent);
+#ifdef DO_SAVE_UNDERS
+	if (dosave)
+	    (*pScreen->PostChangeSaveUnder)(pWin, pWin);
+#endif /* DO_SAVE_UNDERS */
+	if (pScreen->PostValidateTree)
+	    (*pScreen->PostValidateTree)(pWin->parent, NullWindow, VTOther);
+    }
+    if (pWin->realized)
+	WindowsRestructured ();
+    CheckCursorConfinement(pWin);
+}
+#endif
+
+
+
+static void
+miOverlayChangeBorderWidth(
+    WindowPtr pWin,
+    unsigned int width
+){
+    WindowPtr pParent;
+    int oldwidth;
+    register ScreenPtr pScreen;
+    Bool WasViewable = (Bool)(pWin->viewable);
+    Bool HadBorder;
+#ifdef DO_SAVE_UNDERS
+    Bool	dosave = FALSE;
+#endif
+
+    oldwidth = wBorderWidth (pWin);
+    if (oldwidth == width)
+	return;
+    HadBorder = HasBorder(pWin);
+    pScreen = pWin->drawable.pScreen;
+    pParent = pWin->parent;
+    if (WasViewable && (width < oldwidth))
+	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+    pWin->borderWidth = width;
+    SetBorderSize (pWin);
+
+    if (WasViewable) {
+	if (width > oldwidth) {
+	    (*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
+
+	    if (HadBorder) {
+		RegionPtr   borderVisible;
+		borderVisible = REGION_CREATE(pScreen, NULL, 1);
+		REGION_SUBTRACT(pScreen, borderVisible,
+				      &pWin->borderClip, &pWin->winSize);
+		pWin->valdata->before.borderVisible = borderVisible;
+		if(IN_UNDERLAY(pWin)) {
+		    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+		    RegionPtr borderVisible2;
+
+		    borderVisible2 = REGION_CREATE(pScreen, NULL, 1);
+		    REGION_SUBTRACT(pScreen, borderVisible2,
+				      &pTree->borderClip, &pWin->winSize);
+		    pTree->valdata->borderVisible = borderVisible2;
+		}
+	    }
+	}
+#ifdef DO_SAVE_UNDERS
+	if (DO_SAVE_UNDERS(pWin))
+	    dosave = (*pScreen->ChangeSaveUnder)(pWin, pWin->nextSib);
+#endif /* DO_SAVE_UNDERS */
+	(*pScreen->ValidateTree)(pWin->parent, pWin, VTOther);
+	(*pScreen->HandleExposures)(pWin->parent);
+
+#ifdef DO_SAVE_UNDERS
+	if (dosave)
+	    (*pScreen->PostChangeSaveUnder)(pWin, pWin->nextSib);
+#endif /* DO_SAVE_UNDERS */
+	if (pScreen->PostValidateTree)
+	    (*pScreen->PostValidateTree)(pWin->parent, pWin, VTOther);
+    }
+    if (pWin->realized)
+	WindowsRestructured ();
+}
+
+/*  We need this as an addition since the xf86 common code doesn't
+    know about the second tree which is static to this file.  */
+
+void
+miOverlaySetRootClip(ScreenPtr pScreen, Bool enable)
+{
+    WindowPtr pRoot = WindowTable[pScreen->myNum];
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pRoot);
+
+    MARK_UNDERLAY(pRoot);
+
+    if(enable) {
+	BoxRec box;
+	
+	box.x1 = 0;
+	box.y1 = 0;
+	box.x2 = pScreen->width;
+	box.y2 = pScreen->height;
+
+	REGION_RESET(pScreen, &pTree->borderClip, &box);
+    } else 
+	REGION_EMPTY(pScreen, &pTree->borderClip);
+
+    REGION_BREAK(pScreen, &pTree->clipList);
+}
+
+static void 
+miOverlayClearToBackground(
+    WindowPtr pWin,
+    int x, int y,
+    int w, int h,
+    Bool generateExposures
+)
+{
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    BoxRec box;
+    RegionRec reg;
+    RegionPtr pBSReg = NullRegion;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    miOverlayScreenPtr pScreenPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
+    RegionPtr clipList;
+    BoxPtr  extents;
+    int     x1, y1, x2, y2;
+
+    x1 = pWin->drawable.x + x;
+    y1 = pWin->drawable.y + y;
+    if (w)
+        x2 = x1 + (int) w;
+    else
+        x2 = x1 + (int) pWin->drawable.width - (int) x;
+    if (h)
+        y2 = y1 + h;    
+    else
+        y2 = y1 + (int) pWin->drawable.height - (int) y;
+
+    clipList = ((*pScreenPriv->InOverlay)(pWin)) ? &pWin->clipList :
+                                                 &pTree->clipList;
+
+    extents = REGION_EXTENTS(pScreen, clipList);
+    
+    if (x1 < extents->x1) x1 = extents->x1;
+    if (x2 > extents->x2) x2 = extents->x2;
+    if (y1 < extents->y1) y1 = extents->y1;
+    if (y2 > extents->y2) y2 = extents->y2;
+
+    if (x2 <= x1 || y2 <= y1) 
+        x2 = x1 = y2 = y1 = 0;
+
+    box.x1 = x1; box.x2 = x2;
+    box.y1 = y1; box.y2 = y2;
+
+    REGION_INIT(pScreen, &reg, &box, 1);
+    if (pWin->backStorage) {
+        pBSReg = (* pScreen->ClearBackingStore)(pWin, x, y, w, h,
+                                                 generateExposures);
+    }
+
+    REGION_INTERSECT(pScreen, &reg, &reg, clipList);
+    if (generateExposures)
+        (*pScreen->WindowExposures)(pWin, &reg, pBSReg);
+    else if (pWin->backgroundState != None)
+        (*pScreen->PaintWindowBackground)(pWin, &reg, PW_BACKGROUND);
+    REGION_UNINIT(pScreen, &reg);
+    if (pBSReg)
+        REGION_DESTROY(pScreen, pBSReg);
+}
+
+
+/****************************************************************/
+
+/* not used */
+Bool
+miOverlayGetPrivateClips(
+    WindowPtr pWin,
+    RegionPtr *borderClip,
+    RegionPtr *clipList
+){
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+	
+    if(pTree) {
+ 	*borderClip = &(pTree->borderClip);
+	*clipList = &(pTree->clipList);
+	return TRUE;
+    }
+
+    *borderClip = *clipList = NULL;
+
+    return FALSE;
+}
+
+void 
+miOverlaySetTransFunction (
+   ScreenPtr pScreen, 
+   miOverlayTransFunc transFunc
+){
+    MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent = transFunc;
+}
+
+Bool 
+miOverlayCopyUnderlay(ScreenPtr pScreen)
+{
+    return MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->copyUnderlay;
+}
+
+void
+miOverlayComputeCompositeClip(GCPtr pGC, WindowPtr pWin)
+{
+    ScreenPtr       pScreen = pGC->pScreen;
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    RegionPtr       pregWin;
+    Bool            freeTmpClip, freeCompClip;
+
+    if(!pTree) {
+	miComputeCompositeClip(pGC, &pWin->drawable);
+	return;
+    }
+
+    if (pGC->subWindowMode == IncludeInferiors) {
+	pregWin = REGION_CREATE(pScreen, NullBox, 1);
+	freeTmpClip = TRUE;
+	if (pWin->parent || (screenIsSaved != SCREEN_SAVER_ON) ||
+		!HasSaverWindow (pScreen->myNum))
+	{
+            REGION_INTERSECT(pScreen,pregWin,&pTree->borderClip,&pWin->winSize);
+	}
+    } else {
+	pregWin = &pTree->clipList;
+	freeTmpClip = FALSE;
+    }
+    freeCompClip = pGC->freeCompClip;
+    if (pGC->clientClipType == CT_NONE) {
+	if (freeCompClip) 
+	    REGION_DESTROY(pScreen, pGC->pCompositeClip);
+	pGC->pCompositeClip = pregWin;
+	pGC->freeCompClip = freeTmpClip;
+    } else {
+	REGION_TRANSLATE(pScreen, pGC->clientClip,
+				pWin->drawable.x + pGC->clipOrg.x,
+				pWin->drawable.y + pGC->clipOrg.y);
+
+	if (freeCompClip) {
+	    REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
+					    pregWin, pGC->clientClip);
+	    if (freeTmpClip)
+		REGION_DESTROY(pScreen, pregWin);
+	} else if (freeTmpClip) {
+	    REGION_INTERSECT(pScreen, pregWin, pregWin, pGC->clientClip);
+	    pGC->pCompositeClip = pregWin;
+	} else {
+	    pGC->pCompositeClip = REGION_CREATE(pScreen, NullBox, 0);
+	    REGION_INTERSECT(pScreen, pGC->pCompositeClip,
+				       pregWin, pGC->clientClip);
+	}
+	pGC->freeCompClip = TRUE;
+	REGION_TRANSLATE(pScreen, pGC->clientClip,
+				-(pWin->drawable.x + pGC->clipOrg.x),
+				-(pWin->drawable.y + pGC->clipOrg.y));
+    }
+}
+
+Bool
+miOverlayCollectUnderlayRegions(
+    WindowPtr pWin,
+    RegionPtr *region
+){
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+
+    if(pTree) {
+	*region = &pTree->borderClip;
+	return FALSE;
+    }
+
+    *region = REGION_CREATE(pWin->drawable.pScreen, NullBox, 0);
+    
+    CollectUnderlayChildrenRegions(pWin, *region);
+
+    return TRUE;
+}
+
+
+static miOverlayTreePtr
+DoLeaf(
+    WindowPtr pWin, 
+    miOverlayTreePtr parent, 
+    miOverlayTreePtr prevSib
+){
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+    
+    pTree->parent = parent;
+    pTree->firstChild = NULL;
+    pTree->lastChild = NULL;
+    pTree->prevSib = prevSib;
+    pTree->nextSib = NULL;
+
+    if(prevSib)
+	prevSib->nextSib = pTree;
+
+    if(!parent->firstChild)
+	parent->firstChild = parent->lastChild = pTree;
+    else if(parent->lastChild == prevSib)
+	parent->lastChild = pTree;
+   
+    return pTree;
+}
+
+static void 
+RebuildTree(WindowPtr pWin)
+{
+    miOverlayTreePtr parent, prevSib, tChild;
+    WindowPtr pChild;
+
+    prevSib = tChild = NULL;
+
+    pWin = pWin->parent;
+
+    while(IN_OVERLAY(pWin))
+	pWin = pWin->parent;
+
+    parent = MIOVERLAY_GET_WINDOW_TREE(pWin);
+
+    pChild = pWin->firstChild;
+    parent->firstChild = parent->lastChild = NULL;
+
+    while(1) {
+	if(IN_UNDERLAY(pChild))
+	   prevSib = tChild = DoLeaf(pChild, parent, prevSib);
+
+	if(pChild->firstChild) {
+	    if(IN_UNDERLAY(pChild)) {
+		parent = tChild;
+		prevSib = NULL;
+	    }
+	    pChild = pChild->firstChild;
+	    continue;
+	}
+
+	while(!pChild->nextSib) {
+	    pChild = pChild->parent;
+	    if(pChild == pWin) return;
+	    if(IN_UNDERLAY(pChild)) {
+		prevSib = tChild = MIOVERLAY_GET_WINDOW_TREE(pChild);
+		parent = tChild->parent;
+	    }
+	}
+
+	pChild = pChild->nextSib;
+    }
+}
+
+
+static Bool
+HasUnderlayChildren(WindowPtr pWin)
+{
+    WindowPtr pChild;
+
+    if(!(pChild = pWin->firstChild)) 
+	return FALSE;
+
+    while(1) {
+	if(IN_UNDERLAY(pChild))
+	   return TRUE;
+
+	if(pChild->firstChild) {
+	    pChild = pChild->firstChild;
+	    continue;
+	}
+
+	while(!pChild->nextSib && (pWin != pChild))
+	    pChild = pChild->parent;
+
+	if(pChild == pWin) break;
+
+	pChild = pChild->nextSib;
+    }
+
+    return FALSE;
+}
+
+
+static Bool
+CollectUnderlayChildrenRegions(WindowPtr pWin, RegionPtr pReg)
+{
+    WindowPtr pChild;
+    miOverlayTreePtr pTree;
+    Bool hasUnderlay;
+
+    if(!(pChild = pWin->firstChild)) 
+	return FALSE;
+
+    hasUnderlay = FALSE;
+
+    while(1) {
+	if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) {
+	    REGION_APPEND(pScreen, pReg, &pTree->borderClip);
+	    hasUnderlay = TRUE;
+	} else
+	if(pChild->firstChild) {
+	    pChild = pChild->firstChild;
+	    continue;
+	}
+
+	while(!pChild->nextSib && (pWin != pChild))
+	    pChild = pChild->parent;
+
+	if(pChild == pWin) break;
+
+	pChild = pChild->nextSib;
+    }
+
+    if(hasUnderlay) {
+	Bool overlap;
+	REGION_VALIDATE(pScreen, pReg, &overlap);
+    } 
+
+    return hasUnderlay;
+}
+
+
+static void 
+MarkUnderlayWindow(WindowPtr pWin)
+{
+    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
+
+    if(pTree->valdata) return;
+    pTree->valdata = (miOverlayValDataPtr)xnfalloc(sizeof(miOverlayValDataRec));
+    pTree->valdata->oldAbsCorner.x = pWin->drawable.x;
+    pTree->valdata->oldAbsCorner.y = pWin->drawable.y;
+    pTree->valdata->borderVisible = NullRegion;
+}
diff --git a/mi/mioverlay.h b/mi/mioverlay.h
new file mode 100644
index 000000000..6098f9c39
--- /dev/null
+++ b/mi/mioverlay.h
@@ -0,0 +1,29 @@
+/* $XFree86: xc/programs/Xserver/mi/mioverlay.h,v 3.4 2001/04/14 21:15:26 mvojkovi Exp $ */
+
+#ifndef __MIOVERLAY_H
+#define __MIOVERLAY_H
+
+typedef void (*miOverlayTransFunc)(ScreenPtr, int, BoxPtr);
+typedef Bool (*miOverlayInOverlayFunc)(WindowPtr);
+
+Bool
+miInitOverlay(
+   ScreenPtr pScreen, 
+   miOverlayInOverlayFunc inOverlay,
+   miOverlayTransFunc trans
+);
+
+Bool
+miOverlayGetPrivateClips(
+    WindowPtr pWin,
+    RegionPtr *borderClip,
+    RegionPtr *clipList
+);
+
+Bool miOverlayCollectUnderlayRegions(WindowPtr, RegionPtr*);
+void miOverlayComputeCompositeClip(GCPtr, WindowPtr);
+Bool miOverlayCopyUnderlay(ScreenPtr);
+void miOverlaySetTransFunction(ScreenPtr, miOverlayTransFunc);
+void miOverlaySetRootClip(ScreenPtr, Bool);
+
+#endif /* __MIOVERLAY_H */
diff --git a/mi/mizerclip.c b/mi/mizerclip.c
new file mode 100644
index 000000000..fa1863b54
--- /dev/null
+++ b/mi/mizerclip.c
@@ -0,0 +1,632 @@
+/* $XFree86: xc/programs/Xserver/mi/mizerclip.c,v 1.3 2001/12/14 20:00:29 dawes Exp $ */
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+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.
+
+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 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.
+
+******************************************************************/
+#include "X.h"
+
+#include "misc.h"
+#include "scrnintstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmap.h"
+#include "mi.h"
+#include "miline.h"
+
+/*
+
+The bresenham error equation used in the mi/mfb/cfb line routines is:
+
+	e = error
+	dx = difference in raw X coordinates
+	dy = difference in raw Y coordinates
+	M = # of steps in X direction
+	N = # of steps in Y direction
+	B = 0 to prefer diagonal steps in a given octant,
+	    1 to prefer axial steps in a given octant
+
+	For X major lines:
+		e = 2Mdy - 2Ndx - dx - B
+		-2dx <= e < 0
+
+	For Y major lines:
+		e = 2Ndx - 2Mdy - dy - B
+		-2dy <= e < 0
+
+At the start of the line, we have taken 0 X steps and 0 Y steps,
+so M = 0 and N = 0:
+
+	X major	e = 2Mdy - 2Ndx - dx - B
+		  = -dx - B
+
+	Y major	e = 2Ndx - 2Mdy - dy - B
+		  = -dy - B
+
+At the end of the line, we have taken dx X steps and dy Y steps,
+so M = dx and N = dy:
+
+	X major	e = 2Mdy - 2Ndx - dx - B
+		  = 2dxdy - 2dydx - dx - B
+		  = -dx - B
+	Y major e = 2Ndx - 2Mdy - dy - B
+		  = 2dydx - 2dxdy - dy - B
+		  = -dy - B
+
+Thus, the error term is the same at the start and end of the line.
+
+Let us consider clipping an X coordinate.  There are 4 cases which
+represent the two independent cases of clipping the start vs. the
+end of the line and an X major vs. a Y major line.  In any of these
+cases, we know the number of X steps (M) and we wish to find the
+number of Y steps (N).  Thus, we will solve our error term equation.
+If we are clipping the start of the line, we will find the smallest
+N that satisfies our error term inequality.  If we are clipping the
+end of the line, we will find the largest number of Y steps that
+satisfies the inequality.  In that case, since we are representing
+the Y steps as (dy - N), we will actually want to solve for the
+smallest N in that equation.
+
+Case 1:  X major, starting X coordinate moved by M steps
+
+		-2dx <= 2Mdy - 2Ndx - dx - B < 0
+	2Ndx <= 2Mdy - dx - B + 2dx	2Ndx > 2Mdy - dx - B
+	2Ndx <= 2Mdy + dx - B		N > (2Mdy - dx - B) / 2dx
+	N <= (2Mdy + dx - B) / 2dx
+
+Since we are trying to find the smallest N that satisfies these
+equations, we should use the > inequality to find the smallest:
+
+	N = floor((2Mdy - dx - B) / 2dx) + 1
+	  = floor((2Mdy - dx - B + 2dx) / 2dx)
+	  = floor((2Mdy + dx - B) / 2dx)
+
+Case 1b: X major, ending X coordinate moved to M steps
+
+Same derivations as Case 1, but we want the largest N that satisfies
+the equations, so we use the <= inequality:
+
+	N = floor((2Mdy + dx - B) / 2dx)
+
+Case 2: X major, ending X coordinate moved by M steps
+
+		-2dx <= 2(dx - M)dy - 2(dy - N)dx - dx - B < 0
+		-2dx <= 2dxdy - 2Mdy - 2dxdy + 2Ndx - dx - B < 0
+		-2dx <= 2Ndx - 2Mdy - dx - B < 0
+	2Ndx >= 2Mdy + dx + B - 2dx	2Ndx < 2Mdy + dx + B
+	2Ndx >= 2Mdy - dx + B		N < (2Mdy + dx + B) / 2dx
+	N >= (2Mdy - dx + B) / 2dx
+
+Since we are trying to find the highest number of Y steps that
+satisfies these equations, we need to find the smallest N, so
+we should use the >= inequality to find the smallest:
+
+	N = ceiling((2Mdy - dx + B) / 2dx)
+	  = floor((2Mdy - dx + B + 2dx - 1) / 2dx)
+	  = floor((2Mdy + dx + B - 1) / 2dx)
+
+Case 2b: X major, starting X coordinate moved to M steps from end
+
+Same derivations as Case 2, but we want the smallest number of Y
+steps, so we want the highest N, so we use the < inequality:
+
+	N = ceiling((2Mdy + dx + B) / 2dx) - 1
+	  = floor((2Mdy + dx + B + 2dx - 1) / 2dx) - 1
+	  = floor((2Mdy + dx + B + 2dx - 1 - 2dx) / 2dx)
+	  = floor((2Mdy + dx + B - 1) / 2dx)
+
+Case 3: Y major, starting X coordinate moved by M steps
+
+		-2dy <= 2Ndx - 2Mdy - dy - B < 0
+	2Ndx >= 2Mdy + dy + B - 2dy	2Ndx < 2Mdy + dy + B
+	2Ndx >= 2Mdy - dy + B		N < (2Mdy + dy + B) / 2dx
+	N >= (2Mdy - dy + B) / 2dx
+
+Since we are trying to find the smallest N that satisfies these
+equations, we should use the >= inequality to find the smallest:
+
+	N = ceiling((2Mdy - dy + B) / 2dx)
+	  = floor((2Mdy - dy + B + 2dx - 1) / 2dx)
+	  = floor((2Mdy - dy + B - 1) / 2dx) + 1
+
+Case 3b: Y major, ending X coordinate moved to M steps
+
+Same derivations as Case 3, but we want the largest N that satisfies
+the equations, so we use the < inequality:
+
+	N = ceiling((2Mdy + dy + B) / 2dx) - 1
+	  = floor((2Mdy + dy + B + 2dx - 1) / 2dx) - 1
+	  = floor((2Mdy + dy + B + 2dx - 1 - 2dx) / 2dx)
+	  = floor((2Mdy + dy + B - 1) / 2dx)
+
+Case 4: Y major, ending X coordinate moved by M steps
+
+		-2dy <= 2(dy - N)dx - 2(dx - M)dy - dy - B < 0
+		-2dy <= 2dxdy - 2Ndx - 2dxdy + 2Mdy - dy - B < 0
+		-2dy <= 2Mdy - 2Ndx - dy - B < 0
+	2Ndx <= 2Mdy - dy - B + 2dy	2Ndx > 2Mdy - dy - B
+	2Ndx <= 2Mdy + dy - B		N > (2Mdy - dy - B) / 2dx
+	N <= (2Mdy + dy - B) / 2dx
+
+Since we are trying to find the highest number of Y steps that
+satisfies these equations, we need to find the smallest N, so
+we should use the > inequality to find the smallest:
+
+	N = floor((2Mdy - dy - B) / 2dx) + 1
+
+Case 4b: Y major, starting X coordinate moved to M steps from end
+
+Same analysis as Case 4, but we want the smallest number of Y steps
+which means the largest N, so we use the <= inequality:
+
+	N = floor((2Mdy + dy - B) / 2dx)
+
+Now let's try the Y coordinates, we have the same 4 cases.
+
+Case 5: X major, starting Y coordinate moved by N steps
+
+		-2dx <= 2Mdy - 2Ndx - dx - B < 0
+	2Mdy >= 2Ndx + dx + B - 2dx	2Mdy < 2Ndx + dx + B
+	2Mdy >= 2Ndx - dx + B		M < (2Ndx + dx + B) / 2dy
+	M >= (2Ndx - dx + B) / 2dy
+
+Since we are trying to find the smallest M, we use the >= inequality:
+
+	M = ceiling((2Ndx - dx + B) / 2dy)
+	  = floor((2Ndx - dx + B + 2dy - 1) / 2dy)
+	  = floor((2Ndx - dx + B - 1) / 2dy) + 1
+
+Case 5b: X major, ending Y coordinate moved to N steps
+
+Same derivations as Case 5, but we want the largest M that satisfies
+the equations, so we use the < inequality:
+
+	M = ceiling((2Ndx + dx + B) / 2dy) - 1
+	  = floor((2Ndx + dx + B + 2dy - 1) / 2dy) - 1
+	  = floor((2Ndx + dx + B + 2dy - 1 - 2dy) / 2dy)
+	  = floor((2Ndx + dx + B - 1) / 2dy)
+
+Case 6: X major, ending Y coordinate moved by N steps
+
+		-2dx <= 2(dx - M)dy - 2(dy - N)dx - dx - B < 0
+		-2dx <= 2dxdy - 2Mdy - 2dxdy + 2Ndx - dx - B < 0
+		-2dx <= 2Ndx - 2Mdy - dx - B < 0
+	2Mdy <= 2Ndx - dx - B + 2dx	2Mdy > 2Ndx - dx - B
+	2Mdy <= 2Ndx + dx - B		M > (2Ndx - dx - B) / 2dy
+	M <= (2Ndx + dx - B) / 2dy
+
+Largest # of X steps means smallest M, so use the > inequality:
+
+	M = floor((2Ndx - dx - B) / 2dy) + 1
+
+Case 6b: X major, starting Y coordinate moved to N steps from end
+
+Same derivations as Case 6, but we want the smallest # of X steps
+which means the largest M, so use the <= inequality:
+
+	M = floor((2Ndx + dx - B) / 2dy)
+
+Case 7: Y major, starting Y coordinate moved by N steps
+
+		-2dy <= 2Ndx - 2Mdy - dy - B < 0
+	2Mdy <= 2Ndx - dy - B + 2dy	2Mdy > 2Ndx - dy - B
+	2Mdy <= 2Ndx + dy - B		M > (2Ndx - dy - B) / 2dy
+	M <= (2Ndx + dy - B) / 2dy
+
+To find the smallest M, use the > inequality:
+
+	M = floor((2Ndx - dy - B) / 2dy) + 1
+	  = floor((2Ndx - dy - B + 2dy) / 2dy)
+	  = floor((2Ndx + dy - B) / 2dy)
+
+Case 7b: Y major, ending Y coordinate moved to N steps
+
+Same derivations as Case 7, but we want the largest M that satisfies
+the equations, so use the <= inequality:
+
+	M = floor((2Ndx + dy - B) / 2dy)
+
+Case 8: Y major, ending Y coordinate moved by N steps
+
+		-2dy <= 2(dy - N)dx - 2(dx - M)dy - dy - B < 0
+		-2dy <= 2dxdy - 2Ndx - 2dxdy + 2Mdy - dy - B < 0
+		-2dy <= 2Mdy - 2Ndx - dy - B < 0
+	2Mdy >= 2Ndx + dy + B - 2dy	2Mdy < 2Ndx + dy + B
+	2Mdy >= 2Ndx - dy + B		M < (2Ndx + dy + B) / 2dy
+	M >= (2Ndx - dy + B) / 2dy
+
+To find the highest X steps, find the smallest M, use the >= inequality:
+
+	M = ceiling((2Ndx - dy + B) / 2dy)
+	  = floor((2Ndx - dy + B + 2dy - 1) / 2dy)
+	  = floor((2Ndx + dy + B - 1) / 2dy)
+
+Case 8b: Y major, starting Y coordinate moved to N steps from the end
+
+Same derivations as Case 8, but we want to find the smallest # of X
+steps which means the largest M, so we use the < inequality:
+
+	M = ceiling((2Ndx + dy + B) / 2dy) - 1
+	  = floor((2Ndx + dy + B + 2dy - 1) / 2dy) - 1
+	  = floor((2Ndx + dy + B + 2dy - 1 - 2dy) / 2dy)
+	  = floor((2Ndx + dy + B - 1) / 2dy)
+
+So, our equations are:
+
+	1:  X major move x1 to x1+M	floor((2Mdy + dx - B) / 2dx)
+	1b: X major move x2 to x1+M	floor((2Mdy + dx - B) / 2dx)
+	2:  X major move x2 to x2-M	floor((2Mdy + dx + B - 1) / 2dx)
+	2b: X major move x1 to x2-M	floor((2Mdy + dx + B - 1) / 2dx)
+
+	3:  Y major move x1 to x1+M	floor((2Mdy - dy + B - 1) / 2dx) + 1
+	3b: Y major move x2 to x1+M	floor((2Mdy + dy + B - 1) / 2dx)
+	4:  Y major move x2 to x2-M	floor((2Mdy - dy - B) / 2dx) + 1
+	4b: Y major move x1 to x2-M	floor((2Mdy + dy - B) / 2dx)
+
+	5:  X major move y1 to y1+N	floor((2Ndx - dx + B - 1) / 2dy) + 1
+	5b: X major move y2 to y1+N	floor((2Ndx + dx + B - 1) / 2dy)
+	6:  X major move y2 to y2-N	floor((2Ndx - dx - B) / 2dy) + 1
+	6b: X major move y1 to y2-N	floor((2Ndx + dx - B) / 2dy)
+
+	7:  Y major move y1 to y1+N	floor((2Ndx + dy - B) / 2dy)
+	7b: Y major move y2 to y1+N	floor((2Ndx + dy - B) / 2dy)
+	8:  Y major move y2 to y2-N	floor((2Ndx + dy + B - 1) / 2dy)
+	8b: Y major move y1 to y2-N	floor((2Ndx + dy + B - 1) / 2dy)
+
+We have the following constraints on all of the above terms:
+
+	0 < M,N <= 2^15		 2^15 can be imposed by miZeroClipLine
+	0 <= dx/dy <= 2^16 - 1
+	0 <= B <= 1
+
+The floor in all of the above equations can be accomplished with a
+simple C divide operation provided that both numerator and denominator
+are positive.
+
+Since dx,dy >= 0 and since moving an X coordinate implies that dx != 0
+and moving a Y coordinate implies dy != 0, we know that the denominators
+are all > 0.
+
+For all lines, (-B) and (B-1) are both either 0 or -1, depending on the
+bias.  Thus, we have to show that the 2MNdxy +/- dxy terms are all >= 1
+or > 0 to prove that the numerators are positive (or zero).
+
+For X Major lines we know that dx > 0 and since 2Mdy is >= 0 due to the
+constraints, the first four equations all have numerators >= 0.
+
+For the second four equations, M > 0, so 2Mdy >= 2dy so (2Mdy - dy) >= dy
+So (2Mdy - dy) > 0, since they are Y major lines.  Also, (2Mdy + dy) >= 3dy
+or (2Mdy + dy) > 0.  So all of their numerators are >= 0.
+
+For the third set of four equations, N > 0, so 2Ndx >= 2dx so (2Ndx - dx)
+>= dx > 0.  Similarly (2Ndx + dx) >= 3dx > 0.  So all numerators >= 0.
+
+For the fourth set of equations, dy > 0 and 2Ndx >= 0, so all numerators
+are > 0.
+
+To consider overflow, consider the case of 2 * M,N * dx,dy + dx,dy.  This
+is bounded <= 2 * 2^15 * (2^16 - 1) + (2^16 - 1)
+	   <= 2^16 * (2^16 - 1) + (2^16 - 1)
+	   <= 2^32 - 2^16 + 2^16 - 1
+	   <= 2^32 - 1
+Since the (-B) and (B-1) terms are all 0 or -1, the maximum value of
+the numerator is therefore (2^32 - 1), which does not overflow an unsigned
+32 bit variable.
+
+*/
+
+/* Bit codes for the terms of the 16 clipping equations defined below. */
+
+#define T_2NDX		(1 << 0)
+#define T_2MDY		(0)				/* implicit term */
+#define T_DXNOTY	(1 << 1)
+#define T_DYNOTX	(0)				/* implicit term */
+#define T_SUBDXORY	(1 << 2)
+#define T_ADDDX		(T_DXNOTY)			/* composite term */
+#define T_SUBDX		(T_DXNOTY | T_SUBDXORY)		/* composite term */
+#define T_ADDDY		(T_DYNOTX)			/* composite term */
+#define T_SUBDY		(T_DYNOTX | T_SUBDXORY)		/* composite term */
+#define T_BIASSUBONE	(1 << 3)
+#define T_SUBBIAS	(0)				/* implicit term */
+#define T_DIV2DX	(1 << 4)
+#define T_DIV2DY	(0)				/* implicit term */
+#define T_ADDONE	(1 << 5)
+
+/* Bit masks defining the 16 equations used in miZeroClipLine. */
+
+#define EQN1	(T_2MDY | T_ADDDX | T_SUBBIAS    | T_DIV2DX)
+#define EQN1B	(T_2MDY | T_ADDDX | T_SUBBIAS    | T_DIV2DX)
+#define EQN2	(T_2MDY | T_ADDDX | T_BIASSUBONE | T_DIV2DX)
+#define EQN2B	(T_2MDY | T_ADDDX | T_BIASSUBONE | T_DIV2DX)
+
+#define EQN3	(T_2MDY | T_SUBDY | T_BIASSUBONE | T_DIV2DX | T_ADDONE)
+#define EQN3B	(T_2MDY | T_ADDDY | T_BIASSUBONE | T_DIV2DX)
+#define EQN4	(T_2MDY | T_SUBDY | T_SUBBIAS    | T_DIV2DX | T_ADDONE)
+#define EQN4B	(T_2MDY | T_ADDDY | T_SUBBIAS    | T_DIV2DX)
+
+#define EQN5	(T_2NDX | T_SUBDX | T_BIASSUBONE | T_DIV2DY | T_ADDONE)
+#define EQN5B	(T_2NDX | T_ADDDX | T_BIASSUBONE | T_DIV2DY)
+#define EQN6	(T_2NDX | T_SUBDX | T_SUBBIAS    | T_DIV2DY | T_ADDONE)
+#define EQN6B	(T_2NDX | T_ADDDX | T_SUBBIAS    | T_DIV2DY)
+
+#define EQN7	(T_2NDX | T_ADDDY | T_SUBBIAS    | T_DIV2DY)
+#define EQN7B	(T_2NDX | T_ADDDY | T_SUBBIAS    | T_DIV2DY)
+#define EQN8	(T_2NDX | T_ADDDY | T_BIASSUBONE | T_DIV2DY)
+#define EQN8B	(T_2NDX | T_ADDDY | T_BIASSUBONE | T_DIV2DY)
+
+/* miZeroClipLine
+ *
+ * returns:  1 for partially clipped line
+ *          -1 for completely clipped line
+ *
+ */
+int
+miZeroClipLine(xmin, ymin, xmax, ymax,
+	       new_x1, new_y1, new_x2, new_y2,
+	       adx, ady,
+	       pt1_clipped, pt2_clipped, octant, bias, oc1, oc2)
+    int xmin, ymin, xmax, ymax;
+    int *new_x1, *new_y1, *new_x2, *new_y2;
+    int *pt1_clipped, *pt2_clipped;
+    unsigned int adx, ady;
+    int octant;
+    unsigned int bias;
+    int oc1, oc2;
+{
+    int swapped = 0;
+    int clipDone = 0;
+    CARD32 utmp = 0;
+    int clip1, clip2;
+    int x1, y1, x2, y2;
+    int x1_orig, y1_orig, x2_orig, y2_orig;
+    int xmajor;
+    int negslope = 0, anchorval = 0;
+    unsigned int eqn = 0;
+
+    x1 = x1_orig = *new_x1;
+    y1 = y1_orig = *new_y1;
+    x2 = x2_orig = *new_x2;
+    y2 = y2_orig = *new_y2;
+
+    clip1 = 0;
+    clip2 = 0;
+
+    xmajor = IsXMajorOctant(octant);
+    bias = ((bias >> octant) & 1);
+
+    while (1)
+    {
+        if ((oc1 & oc2) != 0)			/* trivial reject */
+	{
+	    clipDone = -1;
+	    clip1 = oc1;
+	    clip2 = oc2;
+	    break;
+	}
+        else if ((oc1 | oc2) == 0)		/* trivial accept */
+        {
+	    clipDone = 1;
+	    if (swapped)
+	    {
+	        SWAPINT_PAIR(x1, y1, x2, y2);
+	        SWAPINT(clip1, clip2);
+	    }
+	    break;
+        }
+        else			/* have to clip */
+        {
+	    /* only clip one point at a time */
+	    if (oc1 == 0)
+	    {
+	        SWAPINT_PAIR(x1, y1, x2, y2);
+	        SWAPINT_PAIR(x1_orig, y1_orig, x2_orig, y2_orig);
+	        SWAPINT(oc1, oc2);
+	        SWAPINT(clip1, clip2);
+	        swapped = !swapped;
+	    }
+    
+	    clip1 |= oc1;
+	    if (oc1 & OUT_LEFT)
+	    {
+		negslope = IsYDecreasingOctant(octant);
+		utmp = xmin - x1_orig;
+		if (utmp <= 32767)		/* clip based on near endpt */
+		{
+		    if (xmajor)
+			eqn = (swapped) ? EQN2 : EQN1;
+		    else
+			eqn = (swapped) ? EQN4 : EQN3;
+		    anchorval = y1_orig;
+		}
+		else				/* clip based on far endpt */
+		{
+		    utmp = x2_orig - xmin;
+		    if (xmajor)
+			eqn = (swapped) ? EQN1B : EQN2B;
+		    else
+			eqn = (swapped) ? EQN3B : EQN4B;
+		    anchorval = y2_orig;
+		    negslope = !negslope;
+		}
+		x1 = xmin;
+	    }
+	    else if (oc1 & OUT_ABOVE)
+	    {
+		negslope = IsXDecreasingOctant(octant);
+		utmp = ymin - y1_orig;
+		if (utmp <= 32767)		/* clip based on near endpt */
+		{
+		    if (xmajor)
+			eqn = (swapped) ? EQN6 : EQN5;
+		    else
+			eqn = (swapped) ? EQN8 : EQN7;
+		    anchorval = x1_orig;
+		}
+		else				/* clip based on far endpt */
+		{
+		    utmp = y2_orig - ymin;
+		    if (xmajor)
+			eqn = (swapped) ? EQN5B : EQN6B;
+		    else
+			eqn = (swapped) ? EQN7B : EQN8B;
+		    anchorval = x2_orig;
+		    negslope = !negslope;
+		}
+		y1 = ymin;
+	    }
+	    else if (oc1 & OUT_RIGHT)
+	    {
+		negslope = IsYDecreasingOctant(octant);
+		utmp = x1_orig - xmax;
+		if (utmp <= 32767)		/* clip based on near endpt */
+		{
+		    if (xmajor)
+			eqn = (swapped) ? EQN2 : EQN1;
+		    else
+			eqn = (swapped) ? EQN4 : EQN3;
+		    anchorval = y1_orig;
+		}
+		else				/* clip based on far endpt */
+		{
+		    /*
+		     * Technically since the equations can handle
+		     * utmp == 32768, this overflow code isn't
+		     * needed since X11 protocol can't generate
+		     * a line which goes more than 32768 pixels
+		     * to the right of a clip rectangle.
+		     */
+		    utmp = xmax - x2_orig;
+		    if (xmajor)
+			eqn = (swapped) ? EQN1B : EQN2B;
+		    else
+			eqn = (swapped) ? EQN3B : EQN4B;
+		    anchorval = y2_orig;
+		    negslope = !negslope;
+		}
+		x1 = xmax;
+	    }
+	    else if (oc1 & OUT_BELOW)
+	    {
+		negslope = IsXDecreasingOctant(octant);
+		utmp = y1_orig - ymax;
+		if (utmp <= 32767)		/* clip based on near endpt */
+		{
+		    if (xmajor)
+			eqn = (swapped) ? EQN6 : EQN5;
+		    else
+			eqn = (swapped) ? EQN8 : EQN7;
+		    anchorval = x1_orig;
+		}
+		else				/* clip based on far endpt */
+		{
+		    /*
+		     * Technically since the equations can handle
+		     * utmp == 32768, this overflow code isn't
+		     * needed since X11 protocol can't generate
+		     * a line which goes more than 32768 pixels
+		     * below the bottom of a clip rectangle.
+		     */
+		    utmp = ymax - y2_orig;
+		    if (xmajor)
+			eqn = (swapped) ? EQN5B : EQN6B;
+		    else
+			eqn = (swapped) ? EQN7B : EQN8B;
+		    anchorval = x2_orig;
+		    negslope = !negslope;
+		}
+		y1 = ymax;
+	    }
+
+	    if (swapped)
+		negslope = !negslope;
+
+	    utmp <<= 1;			/* utmp = 2N or 2M */
+	    if (eqn & T_2NDX)
+		utmp = (utmp * adx);
+	    else /* (eqn & T_2MDY) */
+		utmp = (utmp * ady);
+	    if (eqn & T_DXNOTY)
+		if (eqn & T_SUBDXORY)
+		    utmp -= adx;
+		else
+		    utmp += adx;
+	    else /* (eqn & T_DYNOTX) */
+		if (eqn & T_SUBDXORY)
+		    utmp -= ady;
+		else
+		    utmp += ady;
+	    if (eqn & T_BIASSUBONE)
+		utmp += bias - 1;
+	    else /* (eqn & T_SUBBIAS) */
+		utmp -= bias;
+	    if (eqn & T_DIV2DX)
+		utmp /= (adx << 1);
+	    else /* (eqn & T_DIV2DY) */
+		utmp /= (ady << 1);
+	    if (eqn & T_ADDONE)
+		utmp++;
+
+	    if (negslope)
+		utmp = -utmp;
+
+	    if (eqn & T_2NDX)	/* We are calculating X steps */
+		x1 = anchorval + utmp;
+	    else		/* else, Y steps */
+		y1 = anchorval + utmp;
+
+	    oc1 = 0;
+	    MIOUTCODES(oc1, x1, y1, xmin, ymin, xmax, ymax);
+        }
+    }
+
+    *new_x1 = x1;
+    *new_y1 = y1;
+    *new_x2 = x2;
+    *new_y2 = y2;
+    
+    *pt1_clipped = clip1;
+    *pt2_clipped = clip2;
+
+    return clipDone;
+}