Initial revision

35 files changed, 10997 insertions, 0 deletions

diff --git a/iplan2p4/ipl.h b/iplan2p4/ipl.h
new file mode 100644
index 000000000..631d6719a
--- /dev/null
+++ b/iplan2p4/ipl.h
@@ -0,0 +1,1493 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/ipl.h,v 3.5 2001/01/30 22:06:21 tsi Exp $ */
+/* $XConsortium: ipl.h,v 5.37 94/04/17 20:28:38 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.
+
+********************************************************/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "pixmap.h"
+#include "region.h"
+#include "gc.h"
+#include "colormap.h"
+#include "miscstruct.h"
+#include "servermd.h"
+#include "windowstr.h"
+#include "mfb.h"
+#undef PixelType
+
+#include "iplmap.h"
+
+/*
+   private filed of pixmap
+   pixmap.devPrivate = (unsigned int *)pointer_to_bits
+   pixmap.devKind = width_of_pixmap_in_bytes
+*/
+
+extern int  iplGCPrivateIndex;
+extern int  iplWindowPrivateIndex;
+
+/* private field of GC */
+typedef struct {
+    unsigned char       rop;            /* special case rop values */
+    /* next two values unused in ipl, included for compatibility with mfb */
+    unsigned char       ropOpStip;      /* rop for opaque stipple */
+    /* this value is ropFillArea in mfb, usurped for ipl */
+    unsigned char       oneRect;	/*  drawable has one clip rect */
+    unsigned long	xor, and;	/* reduced rop values */
+    unsigned short 	xorg[INTER_PLANES],andg[INTER_PLANES];
+    } iplPrivGC;
+
+typedef iplPrivGC	*iplPrivGCPtr;
+
+#define iplGetGCPrivate(pGC)	((iplPrivGCPtr)\
+	(pGC)->devPrivates[iplGCPrivateIndex].ptr)
+
+#define iplGetCompositeClip(pGC) ((pGC)->pCompositeClip)
+
+/* way to carry RROP info around */
+typedef struct {
+    unsigned char	rop;
+    unsigned long	xor, and;
+    unsigned short 	xorg[INTER_PLANES],andg[INTER_PLANES];
+} iplRRopRec, *iplRRopPtr;
+
+/* private field of window */
+typedef struct {
+    unsigned	char fastBorder; /* non-zero if border is 32 bits wide */
+    unsigned	char fastBackground;
+    unsigned short unused; /* pad for alignment with Sun compiler */
+    DDXPointRec	oldRotate;
+    PixmapPtr	pRotatedBackground;
+    PixmapPtr	pRotatedBorder;
+    } iplPrivWin;
+
+#define iplGetWindowPrivate(_pWin) ((iplPrivWin *)\
+	(_pWin)->devPrivates[iplWindowPrivateIndex].ptr)
+
+
+/* ipl8bit.c */
+
+extern int iplSetStipple(
+#if NeedFunctionPrototypes
+    int /*alu*/,
+    unsigned long /*fg*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern int iplSetOpaqueStipple(
+#if NeedFunctionPrototypes
+    int /*alu*/,
+    unsigned long /*fg*/,
+    unsigned long /*bg*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern int iplComputeClipMasks32(
+#if NeedFunctionPrototypes
+    BoxPtr /*pBox*/,
+    int /*numRects*/,
+    int /*x*/,
+    int /*y*/,
+    int /*w*/,
+    int /*h*/,
+    CARD32 * /*clips*/
+#endif
+);
+/* ipl8cppl.c */
+
+extern void iplCopyImagePlane(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    int /*rop*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplCopyPlane8to1(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    int /*rop*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/,
+    unsigned long /*bitPlane*/
+#endif
+);
+/* ipl8lineCO.c */
+
+extern int ipl8LineSS1RectCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pptInit*/,
+    DDXPointPtr /*pptInitOrig*/,
+    int * /*x1p*/,
+    int * /*y1p*/,
+    int * /*x2p*/,
+    int * /*y2p*/
+#endif
+);
+
+extern void ipl8LineSS1Rect(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pptInit*/
+#endif
+);
+
+extern void ipl8ClippedLineCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x1*/,
+    int /*y1*/,
+    int /*x2*/,
+    int /*y2*/,
+    BoxPtr /*boxp*/,
+    Bool /*shorten*/
+#endif
+);
+/* ipl8lineCP.c */
+
+extern int ipl8LineSS1RectPreviousCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pptInit*/,
+    DDXPointPtr /*pptInitOrig*/,
+    int * /*x1p*/,
+    int * /*y1p*/,
+    int * /*x2p*/,
+    int * /*y2p*/
+
+#endif
+);
+/* ipl8lineG.c */
+
+extern int ipl8LineSS1RectGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pptInit*/,
+    DDXPointPtr /*pptInitOrig*/,
+    int * /*x1p*/,
+    int * /*y1p*/,
+    int * /*x2p*/,
+    int * /*y2p*/
+#endif
+);
+
+extern void ipl8ClippedLineGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x1*/,
+    int /*y1*/,
+    int /*x2*/,
+    int /*y2*/,
+    BoxPtr /*boxp*/,
+    Bool /*shorten*/
+#endif
+);
+/* ipl8lineX.c */
+
+extern int ipl8LineSS1RectXor(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pptInit*/,
+    DDXPointPtr /*pptInitOrig*/,
+    int * /*x1p*/,
+    int * /*y1p*/,
+    int * /*x2p*/,
+    int * /*y2p*/
+#endif
+);
+
+extern void ipl8ClippedLineXor(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x1*/,
+    int /*y1*/,
+    int /*x2*/,
+    int /*y2*/,
+    BoxPtr /*boxp*/,
+    Bool /*shorten*/
+#endif
+);
+/* ipl8segC.c */
+
+extern int ipl8SegmentSS1RectCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSegInit*/
+#endif
+);
+/* ipl8segCS.c */
+
+extern int ipl8SegmentSS1RectShiftCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSegInit*/
+#endif
+);
+
+extern void ipl8SegmentSS1Rect(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSegInit*/
+#endif
+);
+/* ipl8segG.c */
+
+extern int ipl8SegmentSS1RectGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSegInit*/
+#endif
+);
+/* iplsegX.c */
+
+extern int ipl8SegmentSS1RectXor(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSegInit*/
+#endif
+);
+/* iplallpriv.c */
+
+extern Bool iplAllocatePrivates(
+#if NeedFunctionPrototypes
+    ScreenPtr /*pScreen*/,
+    int * /*window_index*/,
+    int * /*gc_index*/
+#endif
+);
+/* iplbitblt.c */
+
+extern RegionPtr iplBitBlt(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    GCPtr/*pGC*/,
+    int /*srcx*/,
+    int /*srcy*/,
+    int /*width*/,
+    int /*height*/,
+    int /*dstx*/,
+    int /*dsty*/,
+    void (* /*doBitBlt*/)(),
+    unsigned long /*bitPlane*/
+#endif
+);
+
+extern void iplDoBitblt(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrc*/,
+    DrawablePtr /*pDst*/,
+    int /*alu*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern RegionPtr iplCopyArea(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    GCPtr/*pGC*/,
+    int /*srcx*/,
+    int /*srcy*/,
+    int /*width*/,
+    int /*height*/,
+    int /*dstx*/,
+    int /*dsty*/
+#endif
+);
+
+extern void iplCopyPlane1to8(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    int /*rop*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/,
+    unsigned long /*bitPlane*/
+#endif
+);
+
+extern RegionPtr iplCopyPlane(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrcDrawable*/,
+    DrawablePtr /*pDstDrawable*/,
+    GCPtr /*pGC*/,
+    int /*srcx*/,
+    int /*srcy*/,
+    int /*width*/,
+    int /*height*/,
+    int /*dstx*/,
+    int /*dsty*/,
+    unsigned long /*bitPlane*/
+#endif
+);
+/* iplbltC.c */
+
+extern void iplDoBitbltCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrc*/,
+    DrawablePtr /*pDst*/,
+    int /*alu*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/
+#endif
+);
+/* iplbltG.c */
+
+extern void iplDoBitbltGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrc*/,
+    DrawablePtr /*pDst*/,
+    int /*alu*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/
+#endif
+);
+/* iplbltO.c */
+
+extern void iplDoBitbltOr(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrc*/,
+    DrawablePtr /*pDst*/,
+    int /*alu*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/
+#endif
+);
+/* iplbltX.c */
+
+extern void iplDoBitbltXor(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pSrc*/,
+    DrawablePtr /*pDst*/,
+    int /*alu*/,
+    RegionPtr /*prgnDst*/,
+    DDXPointPtr /*pptSrc*/,
+    unsigned long /*planemask*/
+#endif
+);
+/* iplbres.c */
+
+extern void iplBresS(
+#if NeedFunctionPrototypes
+    int /*rop*/,
+    unsigned short * /*and*/,
+    unsigned short * /*xor*/,
+    unsigned short * /*addrl*/,
+    int /*nlwidth*/,
+    int /*signdx*/,
+    int /*signdy*/,
+    int /*axis*/,
+    int /*x1*/,
+    int /*y1*/,
+    int /*e*/,
+    int /*e1*/,
+    int /*e2*/,
+    int /*len*/
+#endif
+);
+/* iplbresd.c */
+
+extern void iplBresD(
+#if NeedFunctionPrototypes
+    iplRRopPtr /*rrops*/,
+    int * /*pdashIndex*/,
+    unsigned char * /*pDash*/,
+    int /*numInDashList*/,
+    int * /*pdashOffset*/,
+    int /*isDoubleDash*/,
+    unsigned short * /*addrl*/,
+    int /*nlwidth*/,
+    int /*signdx*/,
+    int /*signdy*/,
+    int /*axis*/,
+    int /*x1*/,
+    int /*y1*/,
+    int /*e*/,
+    int /*e1*/,
+    int /*e2*/,
+    int /*len*/
+#endif
+);
+/* iplbstore.c */
+
+extern void iplSaveAreas(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pPixmap*/,
+    RegionPtr /*prgnSave*/,
+    int /*xorg*/,
+    int /*yorg*/,
+    WindowPtr /*pWin*/
+#endif
+);
+
+extern void iplRestoreAreas(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pPixmap*/,
+    RegionPtr /*prgnRestore*/,
+    int /*xorg*/,
+    int /*yorg*/,
+    WindowPtr /*pWin*/
+#endif
+);
+/* iplcmap.c */
+
+extern int iplListInstalledColormaps(
+#if NeedFunctionPrototypes
+    ScreenPtr	/*pScreen*/,
+    Colormap	* /*pmaps*/
+#endif
+);
+
+extern void iplInstallColormap(
+#if NeedFunctionPrototypes
+    ColormapPtr	/*pmap*/
+#endif
+);
+
+extern void iplUninstallColormap(
+#if NeedFunctionPrototypes
+    ColormapPtr	/*pmap*/
+#endif
+);
+
+extern void iplResolveColor(
+#if NeedFunctionPrototypes
+    unsigned short * /*pred*/,
+    unsigned short * /*pgreen*/,
+    unsigned short * /*pblue*/,
+    VisualPtr /*pVisual*/
+#endif
+);
+
+extern Bool iplInitializeColormap(
+#if NeedFunctionPrototypes
+    ColormapPtr /*pmap*/
+#endif
+);
+
+extern int iplExpandDirectColors(
+#if NeedFunctionPrototypes
+    ColormapPtr /*pmap*/,
+    int /*ndef*/,
+    xColorItem * /*indefs*/,
+    xColorItem * /*outdefs*/
+#endif
+);
+
+extern Bool iplCreateDefColormap(
+#if NeedFunctionPrototypes
+    ScreenPtr /*pScreen*/
+#endif
+);
+
+extern Bool iplSetVisualTypes(
+#if NeedFunctionPrototypes
+    int /*depth*/,
+    int /*visuals*/,
+    int /*bitsPerRGB*/
+#endif
+);
+
+extern Bool iplInitVisuals(
+#if NeedFunctionPrototypes
+    VisualPtr * /*visualp*/,
+    DepthPtr * /*depthp*/,
+    int * /*nvisualp*/,
+    int * /*ndepthp*/,
+    int * /*rootDepthp*/,
+    VisualID * /*defaultVisp*/,
+    unsigned long /*sizes*/,
+    int /*bitsPerRGB*/
+#endif
+);
+/* iplfillarcC.c */
+
+extern void iplPolyFillArcSolidCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+#endif
+);
+/* iplfillarcG.c */
+
+extern void iplPolyFillArcSolidGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+#endif
+);
+/* iplfillrct.c */
+
+extern void iplFillBoxTileOdd(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*n*/,
+    BoxPtr /*rects*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/
+#endif
+);
+
+extern void iplFillRectTileOdd(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void iplPolyFillRect(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nrectFill*/,
+    xRectangle * /*prectInit*/
+#endif
+);
+/* iplfillsp.c */
+
+extern void iplUnnaturalTileFS(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr/*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+
+extern void iplUnnaturalStippleFS(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr/*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+
+extern void ipl8Stipple32FS(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+
+extern void ipl8OpaqueStipple32FS(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+/* iplgc.c */
+
+extern GCOpsPtr iplMatchCommon(
+#if NeedFunctionPrototypes
+    GCPtr /*pGC*/,
+    iplPrivGCPtr /*devPriv*/
+#endif
+);
+
+extern Bool iplCreateGC(
+#if NeedFunctionPrototypes
+    GCPtr /*pGC*/
+#endif
+);
+
+extern void iplValidateGC(
+#if NeedFunctionPrototypes
+    GCPtr /*pGC*/,
+    unsigned long /*changes*/,
+    DrawablePtr /*pDrawable*/
+#endif
+);
+
+/* iplgetsp.c */
+
+extern void iplGetSpans(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*wMax*/,
+    DDXPointPtr /*ppt*/,
+    int * /*pwidth*/,
+    int /*nspans*/,
+    char * /*pdstStart*/
+#endif
+);
+/* iplglblt8.c */
+
+extern void iplPolyGlyphBlt8(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    unsigned int /*nglyph*/,
+    CharInfoPtr * /*ppci*/,
+    pointer /*pglyphBase*/
+#endif
+);
+/* iplglrop8.c */
+
+extern void iplPolyGlyphRop8(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    unsigned int /*nglyph*/,
+    CharInfoPtr * /*ppci*/,
+    pointer /*pglyphBase*/
+#endif
+);
+/* iplhrzvert.c */
+
+extern int iplHorzS(
+#if NeedFunctionPrototypes
+    int /*rop*/,
+    unsigned short * /*and*/,
+    unsigned short * /*xor*/,
+    unsigned short * /*addrg*/,
+    int /*nlwidth*/,
+    int /*x1*/,
+    int /*y1*/,
+    int /*len*/
+#endif
+);
+
+extern int iplVertS(
+#if NeedFunctionPrototypes
+    int /*rop*/,
+    unsigned short * /*and*/,
+    unsigned short * /*xor*/,
+    unsigned short * /*addrg*/,
+    int /*nlwidth*/,
+    int /*x1*/,
+    int /*y1*/,
+    int /*len*/
+#endif
+);
+/* ipligblt8.c */
+
+extern void iplImageGlyphBlt8(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    unsigned int /*nglyph*/,
+    CharInfoPtr * /*ppci*/,
+    pointer /*pglyphBase*/
+#endif
+);
+/* iplimage.c */
+
+extern void iplPutImage(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*depth*/,
+    int /*x*/,
+    int /*y*/,
+    int /*w*/,
+    int /*h*/,
+    int /*leftPad*/,
+    int /*format*/,
+    char * /*pImage*/
+#endif
+);
+
+extern void iplGetImage(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*sx*/,
+    int /*sy*/,
+    int /*w*/,
+    int /*h*/,
+    unsigned int /*format*/,
+    unsigned long /*planeMask*/,
+    char * /*pdstLine*/
+#endif
+);
+/* iplline.c */
+
+extern void iplLineSS(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pptInit*/
+#endif
+);
+
+extern void iplLineSD(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    DDXPointPtr /*pptInit*/
+#endif
+);
+/* iplmskbits.c */
+/* iplpixmap.c */
+
+extern PixmapPtr iplCreatePixmap(
+#if NeedFunctionPrototypes
+    ScreenPtr /*pScreen*/,
+    int /*width*/,
+    int /*height*/,
+    int /*depth*/
+#endif
+);
+
+extern Bool iplDestroyPixmap(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pPixmap*/
+#endif
+);
+
+extern PixmapPtr iplCopyPixmap(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pSrc*/
+#endif
+);
+
+extern void iplPadPixmap(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pPixmap*/
+#endif
+);
+
+extern void iplXRotatePixmap(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pPix*/,
+    int /*rw*/
+#endif
+);
+
+extern void iplYRotatePixmap(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pPix*/,
+    int /*rh*/
+#endif
+);
+
+extern void iplCopyRotatePixmap(
+#if NeedFunctionPrototypes
+    PixmapPtr /*psrcPix*/,
+    PixmapPtr * /*ppdstPix*/,
+    int /*xrot*/,
+    int /*yrot*/
+#endif
+);
+/* iplply1rctC.c */
+
+extern void iplFillPoly1RectCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*shape*/,
+    int /*mode*/,
+    int /*count*/,
+    DDXPointPtr /*ptsIn*/
+#endif
+);
+/* iplply1rctG.c */
+
+extern void iplFillPoly1RectGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*shape*/,
+    int /*mode*/,
+    int /*count*/,
+    DDXPointPtr /*ptsIn*/
+#endif
+);
+/* iplpntwin.c */
+
+extern void iplPaintWindow(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWin*/,
+    RegionPtr /*pRegion*/,
+    int /*what*/
+#endif
+);
+
+extern void iplFillBoxSolid(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/,
+    unsigned long /*pixel*/
+#endif
+);
+
+extern void iplFillBoxTile32(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/,
+    PixmapPtr /*tile*/
+#endif
+);
+/* iplpolypnt.c */
+
+extern void iplPolyPoint(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*mode*/,
+    int /*npt*/,
+    xPoint * /*pptInit*/
+#endif
+);
+/* iplpush8.c */
+
+extern void iplPushPixels8(
+#if NeedFunctionPrototypes
+    GCPtr /*pGC*/,
+    PixmapPtr /*pBitmap*/,
+    DrawablePtr /*pDrawable*/,
+    int /*dx*/,
+    int /*dy*/,
+    int /*xOrg*/,
+    int /*yOrg*/
+#endif
+);
+/* iplrctstp8.c */
+
+extern void ipl8FillRectOpaqueStippled32(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void ipl8FillRectTransparentStippled32(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void ipl8FillRectStippledUnnatural(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+/* iplrrop.c */
+
+extern int iplReduceRasterOp(
+#if NeedFunctionPrototypes
+    int /*rop*/,
+    unsigned long /*fg*/,
+    unsigned long /*pm*/,
+    unsigned short * /*andp*/,
+    unsigned short * /*xorp*/
+#endif
+);
+/* iplscrinit.c */
+
+extern Bool iplCloseScreen(
+#if NeedFunctionPrototypes
+    int /*index*/,
+    ScreenPtr /*pScreen*/
+#endif
+);
+
+extern Bool iplSetupScreen(
+#if NeedFunctionPrototypes
+    ScreenPtr /*pScreen*/,
+    pointer /*pbits*/,
+    int /*xsize*/,
+    int /*ysize*/,
+    int /*dpix*/,
+    int /*dpiy*/,
+    int /*width*/
+#endif
+);
+
+extern int iplFinishScreenInit(
+#if NeedFunctionPrototypes
+    ScreenPtr /*pScreen*/,
+    pointer /*pbits*/,
+    int /*xsize*/,
+    int /*ysize*/,
+    int /*dpix*/,
+    int /*dpiy*/,
+    int /*width*/
+#endif
+);
+
+extern Bool iplScreenInit(
+#if NeedFunctionPrototypes
+    ScreenPtr /*pScreen*/,
+    pointer /*pbits*/,
+    int /*xsize*/,
+    int /*ysize*/,
+    int /*dpix*/,
+    int /*dpiy*/,
+    int /*width*/
+#endif
+);
+
+extern PixmapPtr iplGetScreenPixmap(
+#if NeedFunctionPrototypes
+    ScreenPtr /*pScreen*/
+#endif
+);
+
+extern void iplSetScreenPixmap(
+#if NeedFunctionPrototypes
+    PixmapPtr /*pPix*/
+#endif
+);
+
+/* iplseg.c */
+
+extern void iplSegmentSS(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSeg*/
+#endif
+);
+
+extern void iplSegmentSD(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nseg*/,
+    xSegment * /*pSeg*/
+#endif
+);
+/* iplsetsp.c */
+
+extern int iplSetScanline(
+#if NeedFunctionPrototypes
+    int /*y*/,
+    int /*xOrigin*/,
+    int /*xStart*/,
+    int /*xEnd*/,
+    unsigned int * /*psrc*/,
+    int /*alu*/,
+    unsigned short * /*pdstBase*/,
+    int /*widthDst*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplSetSpans(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    char * /*psrc*/,
+    DDXPointPtr /*ppt*/,
+    int * /*pwidth*/,
+    int /*nspans*/,
+    int /*fSorted*/
+#endif
+);
+/* iplsolidC.c */
+
+extern void iplFillRectSolidCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void iplSolidSpansCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+/* iplsolidG.c */
+
+extern void iplFillRectSolidGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void iplSolidSpansGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+/* iplsolidX.c */
+
+extern void iplFillRectSolidXor(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void iplSolidSpansXor(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+/* iplteblt8.c */
+
+extern void iplTEGlyphBlt8(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr/*pGC*/,
+    int /*xInit*/,
+    int /*yInit*/,
+    unsigned int /*nglyph*/,
+    CharInfoPtr * /*ppci*/,
+    pointer /*pglyphBase*/
+#endif
+);
+/* ipltegblt.c */
+
+extern void iplTEGlyphBlt(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr/*pGC*/,
+    int /*x*/,
+    int /*y*/,
+    unsigned int /*nglyph*/,
+    CharInfoPtr * /*ppci*/,
+    pointer /*pglyphBase*/
+#endif
+);
+/* ipltile32C.c */
+
+extern void iplFillRectTile32Copy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void iplTile32FSCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+/* ipltile32G.c */
+
+extern void iplFillRectTile32General(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/
+#endif
+);
+
+extern void iplTile32FSGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    GCPtr /*pGC*/,
+    int /*nInit*/,
+    DDXPointPtr /*pptInit*/,
+    int * /*pwidthInit*/,
+    int /*fSorted*/
+#endif
+);
+/* ipltileoddC.c */
+
+extern void iplFillBoxTileOddCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplFillSpanTileOddCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*n*/,
+    DDXPointPtr /*ppt*/,
+    int * /*pwidth*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplFillBoxTile32sCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplFillSpanTile32sCopy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*n*/,
+    DDXPointPtr /*ppt*/,
+    int * /*pwidth*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+/* ipltileoddG.c */
+
+extern void iplFillBoxTileOddGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplFillSpanTileOddGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*n*/,
+    DDXPointPtr /*ppt*/,
+    int * /*pwidth*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplFillBoxTile32sGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*nBox*/,
+    BoxPtr /*pBox*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+
+extern void iplFillSpanTile32sGeneral(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDrawable*/,
+    int /*n*/,
+    DDXPointPtr /*ppt*/,
+    int * /*pwidth*/,
+    PixmapPtr /*tile*/,
+    int /*xrot*/,
+    int /*yrot*/,
+    int /*alu*/,
+    unsigned long /*planemask*/
+#endif
+);
+/* iplwindow.c */
+
+extern Bool iplCreateWindow(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWin*/
+#endif
+);
+
+extern Bool iplDestroyWindow(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWin*/
+#endif
+);
+
+extern Bool iplMapWindow(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWindow*/
+#endif
+);
+
+extern Bool iplPositionWindow(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWin*/,
+    int /*x*/,
+    int /*y*/
+#endif
+);
+
+extern Bool iplUnmapWindow(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWindow*/
+#endif
+);
+
+extern void iplCopyWindow(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWin*/,
+    DDXPointRec /*ptOldOrg*/,
+    RegionPtr /*prgnSrc*/
+#endif
+);
+
+extern Bool iplChangeWindowAttributes(
+#if NeedFunctionPrototypes
+    WindowPtr /*pWin*/,
+    unsigned long /*mask*/
+#endif
+);
+/* iplzerarcC.c */
+
+extern void iplZeroPolyArcSS8Copy(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+#endif
+);
+/* iplzerarcG.c */
+
+extern void iplZeroPolyArcSS8General(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+#endif
+);
+/* iplzerarcX.c */
+
+extern void iplZeroPolyArcSS8Xor(
+#if NeedFunctionPrototypes
+    DrawablePtr /*pDraw*/,
+    GCPtr /*pGC*/,
+    int /*narcs*/,
+    xArc * /*parcs*/
+#endif
+);
+
+/* Common macros for extracting drawing information */
+
+#if (!defined(SINGLEDEPTH) && PSZ != 8) || defined(FORCE_SEPARATE_PRIVATE)
+
+#define CFB_NEED_SCREEN_PRIVATE
+
+extern int iplScreenPrivateIndex;
+#endif
+
+#define iplGetWindowPixmap(d) \
+    ((* ((DrawablePtr)(d))->pScreen->GetWindowPixmap)((WindowPtr)(d)))
+
+#define iplGetTypedWidth(pDrawable,wtype) (\
+    (((pDrawable)->type != DRAWABLE_PIXMAP) ? \
+     (int) (iplGetWindowPixmap(pDrawable)->devKind) : \
+     (int)(((PixmapPtr)pDrawable)->devKind)) / sizeof (wtype))
+
+#define iplGetByteWidth(pDrawable) iplGetTypedWidth(pDrawable, unsigned char)
+
+#define iplGetPixelWidth(pDrawable) iplGetTypedWidth(pDrawable, PixelType)
+
+#define iplGetLongWidth(pDrawable) iplGetTypedWidth(pDrawable, unsigned long)
+    
+#define iplGetTypedWidthAndPointer(pDrawable, width, pointer, wtype, ptype) {\
+    PixmapPtr   _pPix; \
+    if ((pDrawable)->type != DRAWABLE_PIXMAP) \
+	_pPix = iplGetWindowPixmap(pDrawable); \
+    else \
+	_pPix = (PixmapPtr) (pDrawable); \
+    (pointer) = (ptype *) _pPix->devPrivate.ptr; \
+    (width) = ((int) _pPix->devKind) / sizeof (wtype); \
+}
+
+#define iplGetByteWidthAndPointer(pDrawable, width, pointer) \
+    iplGetTypedWidthAndPointer(pDrawable, width, pointer, unsigned char, unsigned char)
+
+#define iplGetLongWidthAndPointer(pDrawable, width, pointer) \
+    iplGetTypedWidthAndPointer(pDrawable, width, pointer, unsigned long, unsigned long)
+
+#define iplGetPixelWidthAndPointer(pDrawable, width, pointer) \
+    iplGetTypedWidthAndPointer(pDrawable, width, pointer, PixelType, PixelType)
+
+#define iplGetWindowTypedWidthAndPointer(pWin, width, pointer, wtype, ptype) {\
+    PixmapPtr	_pPix = iplGetWindowPixmap((DrawablePtr) (pWin)); \
+    (pointer) = (ptype *) _pPix->devPrivate.ptr; \
+    (width) = ((int) _pPix->devKind) / sizeof (wtype); \
+}
+
+#define iplGetWindowLongWidthAndPointer(pWin, width, pointer) \
+    iplGetWindowTypedWidthAndPointer(pWin, width, pointer, unsigned long, unsigned long)
+
+#define iplGetWindowByteWidthAndPointer(pWin, width, pointer) \
+    iplGetWindowTypedWidthAndPointer(pWin, width, pointer, unsigned char, unsigned char)
+
+#define iplGetWindowPixelWidthAndPointer(pDrawable, width, pointer) \
+    iplGetWindowTypedWidthAndPointer(pDrawable, width, pointer, PixelType, PixelType)
+
+/* Macros which handle a coordinate in a single register */
+
+/* Most compilers will convert divide by 65536 into a shift, 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(__alpha) || defined(__alpha__)
+#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))
+#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))
+#define intToX(i)	((int) ((short) (i)))
+#define intToY(i)	(GetHighWord(i))
+#endif
diff --git a/iplan2p4/iplallpriv.c b/iplan2p4/iplallpriv.c
new file mode 100644
index 000000000..57b8fce57
--- /dev/null
+++ b/iplan2p4/iplallpriv.c
@@ -0,0 +1,89 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplallpriv.c,v 3.0 1996/08/18 01:54:33 dawes Exp $ */
+/*
+ * $XConsortium: iplallpriv.c,v 1.5 94/04/17 20:28:42 dpw Exp $
+ *
+Copyright (c) 1991  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "resource.h"
+#include "colormap.h"
+#include "colormapst.h"
+#include "ipl.h"
+#include "mi.h"
+#include "mistruct.h"
+#include "dix.h"
+#include "mibstore.h"
+
+int iplWindowPrivateIndex;
+int iplGCPrivateIndex;
+#ifdef CFB_NEED_SCREEN_PRIVATE
+int iplScreenPrivateIndex;
+#endif
+
+extern RegionPtr (*iplPuntCopyPlane)();
+
+Bool
+iplAllocatePrivates(pScreen, window_index, gc_index)
+    ScreenPtr	pScreen;
+    int		*window_index, *gc_index;
+{
+    if (!window_index || !gc_index ||
+	*window_index == -1 && *gc_index == -1)
+    {
+    	if (!mfbAllocatePrivates(pScreen,
+			     	 &iplWindowPrivateIndex, &iplGCPrivateIndex))
+	    return FALSE;
+    	if (window_index)
+	    *window_index = iplWindowPrivateIndex;
+    	if (gc_index)
+	    *gc_index = iplGCPrivateIndex;
+    }
+    else
+    {
+	iplWindowPrivateIndex = *window_index;
+	iplGCPrivateIndex = *gc_index;
+    }
+    if (!AllocateWindowPrivate(pScreen, iplWindowPrivateIndex,
+			       sizeof(iplPrivWin)) ||
+	!AllocateGCPrivate(pScreen, iplGCPrivateIndex, sizeof(iplPrivGC)))
+	return FALSE;
+	
+    iplPuntCopyPlane = miCopyPlane;
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    iplScreenPrivateIndex = AllocateScreenPrivateIndex ();
+    if (iplScreenPrivateIndex == -1)
+	return FALSE;
+#endif
+    return TRUE;
+}
diff --git a/iplan2p4/iplbitblt.c b/iplan2p4/iplbitblt.c
new file mode 100644
index 000000000..50927e14f
--- /dev/null
+++ b/iplan2p4/iplbitblt.c
@@ -0,0 +1,384 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplbitblt.c,v 3.1 1998/03/20 21:08:08 hohndel Exp $ */
+/*
+ * ipl copy area
+ */
+
+/*
+
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+Author: Keith Packard
+
+*/
+/* $XConsortium: iplbitblt.c,v 5.51 94/05/27 11:00:56 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include	"X.h"
+#include	"Xmd.h"
+#include	"Xproto.h"
+#include	"gcstruct.h"
+#include	"windowstr.h"
+#include	"scrnintstr.h"
+#include	"pixmapstr.h"
+#include	"regionstr.h"
+#include	"ipl.h"
+#include	"fastblt.h"
+#define MFB_CONSTS_ONLY
+#include	"maskbits.h"
+
+#include 	"iplmskbits.h"
+
+RegionPtr
+iplBitBlt (pSrcDrawable, pDstDrawable,
+            pGC, srcx, srcy, width, height, dstx, dsty, doBitBlt, bitPlane)
+    register DrawablePtr pSrcDrawable;
+    register DrawablePtr pDstDrawable;
+    GC *pGC;
+    int srcx, srcy;
+    int width, height;
+    int dstx, dsty;
+    void (*doBitBlt)();
+    unsigned long bitPlane;
+{
+    RegionPtr prgnSrcClip;	/* may be a new region, or just a copy */
+    Bool freeSrcClip = FALSE;
+
+    RegionPtr prgnExposed;
+    RegionRec rgnDst;
+    DDXPointPtr pptSrc;
+    register DDXPointPtr ppt;
+    register BoxPtr pbox;
+    int i;
+    register int dx;
+    register int dy;
+    xRectangle origSource;
+    DDXPointRec origDest;
+    int numRects;
+    BoxRec fastBox;
+    int fastClip = 0;		/* for fast clipping with pixmap source */
+    int fastExpose = 0;		/* for fast exposures with pixmap source */
+
+    origSource.x = srcx;
+    origSource.y = srcy;
+    origSource.width = width;
+    origSource.height = height;
+    origDest.x = dstx;
+    origDest.y = dsty;
+
+    if ((pSrcDrawable != pDstDrawable) &&
+	pSrcDrawable->pScreen->SourceValidate)
+    {
+	(*pSrcDrawable->pScreen->SourceValidate) (pSrcDrawable, srcx, srcy, width, height);
+    }
+
+    srcx += pSrcDrawable->x;
+    srcy += pSrcDrawable->y;
+
+    /* clip the source */
+
+    if (pSrcDrawable->type == DRAWABLE_PIXMAP)
+    {
+	if ((pSrcDrawable == pDstDrawable) &&
+	    (pGC->clientClipType == CT_NONE))
+	{
+	    prgnSrcClip = iplGetCompositeClip(pGC);
+	}
+	else
+	{
+	    fastClip = 1;
+	}
+    }
+    else
+    {
+	if (pGC->subWindowMode == IncludeInferiors)
+	{
+	    if (!((WindowPtr) pSrcDrawable)->parent)
+	    {
+		/*
+		 * special case bitblt from root window in
+		 * IncludeInferiors mode; just like from a pixmap
+		 */
+		fastClip = 1;
+	    }
+	    else if ((pSrcDrawable == pDstDrawable) &&
+		(pGC->clientClipType == CT_NONE))
+	    {
+		prgnSrcClip = iplGetCompositeClip(pGC);
+	    }
+	    else
+	    {
+		prgnSrcClip = NotClippedByChildren((WindowPtr)pSrcDrawable);
+		freeSrcClip = TRUE;
+	    }
+	}
+	else
+	{
+	    prgnSrcClip = &((WindowPtr)pSrcDrawable)->clipList;
+	}
+    }
+
+    fastBox.x1 = srcx;
+    fastBox.y1 = srcy;
+    fastBox.x2 = srcx + width;
+    fastBox.y2 = srcy + height;
+
+    /* Don't create a source region if we are doing a fast clip */
+    if (fastClip)
+    {
+	fastExpose = 1;
+	/*
+	 * clip the source; if regions extend beyond the source size,
+ 	 * make sure exposure events get sent
+	 */
+	if (fastBox.x1 < pSrcDrawable->x)
+	{
+	    fastBox.x1 = pSrcDrawable->x;
+	    fastExpose = 0;
+	}
+	if (fastBox.y1 < pSrcDrawable->y)
+	{
+	    fastBox.y1 = pSrcDrawable->y;
+	    fastExpose = 0;
+	}
+	if (fastBox.x2 > pSrcDrawable->x + (int) pSrcDrawable->width)
+	{
+	    fastBox.x2 = pSrcDrawable->x + (int) pSrcDrawable->width;
+	    fastExpose = 0;
+	}
+	if (fastBox.y2 > pSrcDrawable->y + (int) pSrcDrawable->height)
+	{
+	    fastBox.y2 = pSrcDrawable->y + (int) pSrcDrawable->height;
+	    fastExpose = 0;
+	}
+    }
+    else
+    {
+	REGION_INIT(pGC->pScreen, &rgnDst, &fastBox, 1);
+	REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst, prgnSrcClip);
+    }
+
+    dstx += pDstDrawable->x;
+    dsty += pDstDrawable->y;
+
+    if (pDstDrawable->type == DRAWABLE_WINDOW)
+    {
+	if (!((WindowPtr)pDstDrawable)->realized)
+	{
+	    if (!fastClip)
+		REGION_UNINIT(pGC->pScreen, &rgnDst);
+	    if (freeSrcClip)
+		REGION_DESTROY(pGC->pScreen, prgnSrcClip);
+	    return NULL;
+	}
+    }
+
+    dx = srcx - dstx;
+    dy = srcy - dsty;
+
+    /* Translate and clip the dst to the destination composite clip */
+    if (fastClip)
+    {
+	RegionPtr cclip;
+
+        /* Translate the region directly */
+        fastBox.x1 -= dx;
+        fastBox.x2 -= dx;
+        fastBox.y1 -= dy;
+        fastBox.y2 -= dy;
+
+	/* If the destination composite clip is one rectangle we can
+	   do the clip directly.  Otherwise we have to create a full
+	   blown region and call intersect */
+
+	/* XXX because CopyPlane uses this routine for 8-to-1 bit
+	 * copies, this next line *must* also correctly fetch the
+	 * composite clip from an mfb gc
+	 */
+
+	cclip = iplGetCompositeClip(pGC);
+        if (REGION_NUM_RECTS(cclip) == 1)
+        {
+	    BoxPtr pBox = REGION_RECTS(cclip);
+
+	    if (fastBox.x1 < pBox->x1) fastBox.x1 = pBox->x1;
+	    if (fastBox.x2 > pBox->x2) fastBox.x2 = pBox->x2;
+	    if (fastBox.y1 < pBox->y1) fastBox.y1 = pBox->y1;
+	    if (fastBox.y2 > pBox->y2) fastBox.y2 = pBox->y2;
+
+	    /* Check to see if the region is empty */
+	    if (fastBox.x1 >= fastBox.x2 || fastBox.y1 >= fastBox.y2)
+	    {
+		REGION_INIT(pGC->pScreen, &rgnDst, NullBox, 0);
+	    }
+	    else
+	    {
+		REGION_INIT(pGC->pScreen, &rgnDst, &fastBox, 1);
+	    }
+	}
+        else
+	{
+	    /* We must turn off fastClip now, since we must create
+	       a full blown region.  It is intersected with the
+	       composite clip below. */
+	    fastClip = 0;
+	    REGION_INIT(pGC->pScreen, &rgnDst, &fastBox,1);
+	}
+    }
+    else
+    {
+        REGION_TRANSLATE(pGC->pScreen, &rgnDst, -dx, -dy);
+    }
+
+    if (!fastClip)
+    {
+	REGION_INTERSECT(pGC->pScreen, &rgnDst,
+				   &rgnDst,
+				   iplGetCompositeClip(pGC));
+    }
+
+    /* Do bit blitting */
+    numRects = REGION_NUM_RECTS(&rgnDst);
+    if (numRects && width && height)
+    {
+	if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(numRects *
+						  sizeof(DDXPointRec))))
+	{
+	    REGION_UNINIT(pGC->pScreen, &rgnDst);
+	    if (freeSrcClip)
+		REGION_DESTROY(pGC->pScreen, prgnSrcClip);
+	    return NULL;
+	}
+	pbox = REGION_RECTS(&rgnDst);
+	ppt = pptSrc;
+	for (i = numRects; --i >= 0; pbox++, ppt++)
+	{
+	    ppt->x = pbox->x1 + dx;
+	    ppt->y = pbox->y1 + dy;
+	}
+
+	(*doBitBlt) (pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc, pGC->planemask, bitPlane);
+	DEALLOCATE_LOCAL(pptSrc);
+    }
+
+    prgnExposed = NULL;
+    if (pGC->fExpose)
+    {
+	extern RegionPtr    miHandleExposures();
+
+        /* Pixmap sources generate a NoExposed (we return NULL to do this) */
+        if (!fastExpose)
+	    prgnExposed =
+		miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
+				  origSource.x, origSource.y,
+				  (int)origSource.width,
+				  (int)origSource.height,
+				  origDest.x, origDest.y, bitPlane);
+    }
+    REGION_UNINIT(pGC->pScreen, &rgnDst);
+    if (freeSrcClip)
+	REGION_DESTROY(pGC->pScreen, prgnSrcClip);
+    return prgnExposed;
+}
+
+
+void
+iplDoBitblt (pSrc, pDst, alu, prgnDst, pptSrc, planemask)
+    DrawablePtr	    pSrc, pDst;
+    int		    alu;
+    RegionPtr	    prgnDst;
+    DDXPointPtr	    pptSrc;
+    unsigned long   planemask;
+{
+    void (*blt)() = iplDoBitbltGeneral;
+    if ((planemask & INTER_PMSK) == INTER_PMSK) {
+	switch (alu) {
+	case GXcopy:
+	    blt = iplDoBitbltCopy;
+	    break;
+	case GXxor:
+	    blt = iplDoBitbltXor;
+	    break;
+	case GXor:
+	    blt = iplDoBitbltOr;
+	    break;
+	}
+    }
+    (*blt) (pSrc, pDst, alu, prgnDst, pptSrc, planemask);
+}
+
+RegionPtr
+iplCopyArea(pSrcDrawable, pDstDrawable,
+            pGC, srcx, srcy, width, height, dstx, dsty)
+    register DrawablePtr pSrcDrawable;
+    register DrawablePtr pDstDrawable;
+    GC *pGC;
+    int srcx, srcy;
+    int width, height;
+    int dstx, dsty;
+{
+    void (*doBitBlt) ();
+    
+    doBitBlt = iplDoBitbltCopy;
+    if (pGC->alu != GXcopy || (pGC->planemask & INTER_PMSK) != INTER_PMSK)
+    {
+	doBitBlt = iplDoBitbltGeneral;
+	if ((pGC->planemask & INTER_PMSK) == INTER_PMSK)
+	{
+	    switch (pGC->alu) {
+	    case GXxor:
+		doBitBlt = iplDoBitbltXor;
+		break;
+	    case GXor:
+		doBitBlt = iplDoBitbltOr;
+		break;
+	    }
+	}
+    }
+    return iplBitBlt (pSrcDrawable, pDstDrawable,
+            pGC, srcx, srcy, width, height, dstx, dsty, doBitBlt, 0L);
+}
+
+/* shared among all different ipl depths through linker magic */
+RegionPtr   (*iplPuntCopyPlane)();
+
+RegionPtr iplCopyPlane(pSrcDrawable, pDstDrawable,
+	    pGC, srcx, srcy, width, height, dstx, dsty, bitPlane)
+    DrawablePtr 	pSrcDrawable;
+    DrawablePtr		pDstDrawable;
+    GCPtr		pGC;
+    int 		srcx, srcy;
+    int 		width, height;
+    int 		dstx, dsty;
+    unsigned long	bitPlane;
+{
+    RegionPtr	ret;
+    extern RegionPtr    miHandleExposures();
+    void		(*doBitBlt)();
+
+    ret = (*iplPuntCopyPlane) (pSrcDrawable, pDstDrawable,
+	    pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
+    return ret;
+}
diff --git a/iplan2p4/iplblt.c b/iplan2p4/iplblt.c
new file mode 100644
index 000000000..8a48bd9da
--- /dev/null
+++ b/iplan2p4/iplblt.c
@@ -0,0 +1,427 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplblt.c,v 3.0 1996/08/18 01:54:35 dawes Exp $ */
+/*
+ * ipl copy area
+ */
+
+/*
+
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+Author: Keith Packard
+
+*/
+/* $XConsortium: iplblt.c,v 1.13 94/04/17 20:28:44 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include	"X.h"
+#include	"Xmd.h"
+#include	"Xproto.h"
+#include	"gcstruct.h"
+#include	"windowstr.h"
+#include	"scrnintstr.h"
+#include	"pixmapstr.h"
+#include	"regionstr.h"
+#include	"ipl.h"
+#include	"fastblt.h"
+#include	"iplmergerop.h"
+#include	"iplmskbits.h"
+
+void
+INTER_MROP_NAME(iplDoBitblt)(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
+    DrawablePtr	    pSrc, pDst;
+    int		    alu;
+    RegionPtr	    prgnDst;
+    DDXPointPtr	    pptSrc;
+    unsigned long   planemask;
+{
+    INTER_DECLAREG(*psrcBase);
+    INTER_DECLAREG(*pdstBase);	/* start of src and dst bitmaps */
+    int widthSrc, widthDst;	/* add to get to same position in next line */
+
+    BoxPtr pbox;
+    int nbox;
+
+    BoxPtr pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
+				/* temporaries for shuffling rectangles */
+    DDXPointPtr pptTmp, pptNew1, pptNew2;
+				/* shuffling boxes entails shuffling the
+				   source points too */
+    int w, h;
+    int xdir;			/* 1 = left right, -1 = right left/ */
+    int ydir;			/* 1 = top down, -1 = bottom up */
+
+    INTER_DECLAREG(*psrcLine);
+    INTER_DECLAREG(*pdstLine); 	/* pointers to line with current src and dst */
+    INTER_DECLAREG(*psrc);	/* pointer to current src group */
+    INTER_DECLAREG(*pdst);	/* pointer to current dst group */
+
+    INTER_MROP_DECLARE_REG()
+
+				/* following used for looping through a line */
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);	/* masks for writing ends of dst */
+    int ngMiddle;		/* whole groups in dst */
+    int xoffSrc, xoffDst;
+    register int leftShift, rightShift;
+    INTER_DECLAREGP(bits);
+    INTER_DECLAREGP(bits1);
+    INTER_DECLAREGP(bits2);
+    register int ng;		/* temp copy of ngMiddle */
+
+				/* place to store full source word */
+    int nstart;			/* number of ragged bits at start of dst */
+    int nend;			/* number of ragged bits at end of dst */
+    int srcStartOver;		/* pulling nstart bits from src
+				   overflows into the next word? */
+    int careful;
+    int tmpSrc;
+
+    INTER_MROP_INITIALIZE(alu,planemask);
+
+    iplGetGroupWidthAndPointer (pSrc, widthSrc, psrcBase)
+
+    iplGetGroupWidthAndPointer (pDst, widthDst, pdstBase)
+
+    /* XXX we have to err on the side of safety when both are windows,
+     * because we don't know if IncludeInferiors is being used.
+     */
+    careful = ((pSrc == pDst) ||
+	       ((pSrc->type == DRAWABLE_WINDOW) &&
+		(pDst->type == DRAWABLE_WINDOW)));
+
+    pbox = REGION_RECTS(prgnDst);
+    nbox = REGION_NUM_RECTS(prgnDst);
+
+    pboxNew1 = NULL;
+    pptNew1 = NULL;
+    pboxNew2 = NULL;
+    pptNew2 = NULL;
+    if (careful && (pptSrc->y < pbox->y1))
+    {
+        /* walk source botttom to top */
+	ydir = -1;
+	widthSrc = -widthSrc;
+	widthDst = -widthDst;
+
+	if (nbox > 1)
+	{
+	    /* keep ordering in each band, reverse order of bands */
+	    pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
+	    if(!pboxNew1)
+		return;
+	    pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
+	    if(!pptNew1)
+	    {
+	        DEALLOCATE_LOCAL(pboxNew1);
+	        return;
+	    }
+	    pboxBase = pboxNext = pbox+nbox-1;
+	    while (pboxBase >= pbox)
+	    {
+	        while ((pboxNext >= pbox) &&
+		       (pboxBase->y1 == pboxNext->y1))
+		    pboxNext--;
+	        pboxTmp = pboxNext+1;
+	        pptTmp = pptSrc + (pboxTmp - pbox);
+	        while (pboxTmp <= pboxBase)
+	        {
+		    *pboxNew1++ = *pboxTmp++;
+		    *pptNew1++ = *pptTmp++;
+	        }
+	        pboxBase = pboxNext;
+	    }
+	    pboxNew1 -= nbox;
+	    pbox = pboxNew1;
+	    pptNew1 -= nbox;
+	    pptSrc = pptNew1;
+        }
+    }
+    else
+    {
+	/* walk source top to bottom */
+	ydir = 1;
+    }
+
+    if (careful && (pptSrc->x < pbox->x1))
+    {
+	/* walk source right to left */
+        xdir = -1;
+
+	if (nbox > 1)
+	{
+	    /* reverse order of rects in each band */
+	    pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
+	    pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
+	    if(!pboxNew2 || !pptNew2)
+	    {
+		if (pptNew2) DEALLOCATE_LOCAL(pptNew2);
+		if (pboxNew2) DEALLOCATE_LOCAL(pboxNew2);
+		if (pboxNew1)
+		{
+		    DEALLOCATE_LOCAL(pptNew1);
+		    DEALLOCATE_LOCAL(pboxNew1);
+		}
+	        return;
+	    }
+	    pboxBase = pboxNext = pbox;
+	    while (pboxBase < pbox+nbox)
+	    {
+	        while ((pboxNext < pbox+nbox) &&
+		       (pboxNext->y1 == pboxBase->y1))
+		    pboxNext++;
+	        pboxTmp = pboxNext;
+	        pptTmp = pptSrc + (pboxTmp - pbox);
+	        while (pboxTmp != pboxBase)
+	        {
+		    *pboxNew2++ = *--pboxTmp;
+		    *pptNew2++ = *--pptTmp;
+	        }
+	        pboxBase = pboxNext;
+	    }
+	    pboxNew2 -= nbox;
+	    pbox = pboxNew2;
+	    pptNew2 -= nbox;
+	    pptSrc = pptNew2;
+	}
+    }
+    else
+    {
+	/* walk source left to right */
+        xdir = 1;
+    }
+
+    while(nbox--)
+    {
+	w = pbox->x2 - pbox->x1;
+	h = pbox->y2 - pbox->y1;
+
+	if (ydir == -1) /* start at last scanline of rectangle */
+	{
+	    psrcLine = psrcBase + ((pptSrc->y+h-1) * -widthSrc);
+	    pdstLine = pdstBase + ((pbox->y2-1) * -widthDst);
+	}
+	else /* start at first scanline */
+	{
+	    psrcLine = psrcBase + (pptSrc->y * widthSrc);
+	    pdstLine = pdstBase + (pbox->y1 * widthDst);
+	}
+	if ((pbox->x1 & INTER_PIM) + w <= INTER_PPG)
+	{
+	    INTER_maskpartialbits (pbox->x1, w, endmask);
+	    startmask = 0;
+	    ngMiddle = 0;
+	}
+	else
+	{
+	    INTER_maskbits(pbox->x1, w, startmask, endmask, ngMiddle);
+	}
+
+	if (xdir == 1)
+	{
+	    xoffSrc = pptSrc->x & INTER_PIM;
+	    xoffDst = pbox->x1 & INTER_PIM;
+	    pdstLine += (pbox->x1 >> INTER_PGSH) * INTER_PLANES;
+	    psrcLine += (pptSrc->x >> INTER_PGSH) * INTER_PLANES;
+	    ng = xoffSrc - xoffDst;
+	    if (xoffSrc == xoffDst)
+	    {
+		while (h--)
+		{
+		    psrc = psrcLine;
+		    pdst = pdstLine;
+		    pdstLine += widthDst;
+		    psrcLine += widthSrc;
+		    if (startmask)
+		    {
+			INTER_MROP_MASK(psrc, pdst, startmask, pdst);
+			INTER_NEXT_GROUP(psrc);
+			INTER_NEXT_GROUP(pdst);
+		    }
+		    ng = ngMiddle;
+
+		    DuffL(ng, label1,
+			INTER_MROP_SOLID(psrc, pdst, pdst);
+			INTER_NEXT_GROUP(psrc);
+			INTER_NEXT_GROUP(pdst);
+		    )
+		    if (endmask)
+			INTER_MROP_MASK(psrc, pdst, endmask, pdst);
+		}
+	    }
+	    else
+	    {
+		if (xoffSrc > xoffDst)
+		{
+		    leftShift = xoffSrc - xoffDst;
+		    rightShift = (INTER_PIM+1) - leftShift;
+		}
+		else
+		{
+		    rightShift = xoffDst - xoffSrc;
+		    leftShift = (INTER_PIM+1) - rightShift;
+		}
+		while (h--)
+		{
+		    psrc = psrcLine;
+		    pdst = pdstLine;
+		    pdstLine += widthDst;
+		    psrcLine += widthSrc;
+		    INTER_CLR(bits);
+		    if (xoffSrc > xoffDst) {
+			INTER_COPY(psrc, bits);
+			INTER_NEXT_GROUP(psrc);
+		    }
+		    if (startmask)
+		    {
+			INTER_GETLRC(leftShift, rightShift, psrc, bits, bits1);
+			INTER_MROP_MASK(bits1, pdst, startmask, pdst);
+			INTER_NEXT_GROUP(psrc);
+			INTER_NEXT_GROUP(pdst);
+		    }
+		    ng = ngMiddle;
+		    DuffL (ng,label2,
+			INTER_GETLRC(leftShift, rightShift, psrc, bits, bits1);
+			INTER_MROP_SOLID(bits1, pdst, pdst);
+			INTER_NEXT_GROUP(psrc);
+			INTER_NEXT_GROUP(pdst);
+		    )
+		    if (endmask)
+		    {
+			if ((endmask << rightShift) & 0xffff) {
+			    INTER_GETLRC(leftShift, rightShift, psrc, bits, 
+				bits1);
+			}
+			else {
+			    INTER_SCRLEFT(leftShift, bits, bits1);
+			}
+			INTER_MROP_MASK(bits1, pdst, endmask, pdst);
+		    }
+		}
+	    }
+	}
+	else	/* xdir == -1 */
+	{
+	    xoffSrc = (pptSrc->x + w - 1) & INTER_PIM;
+	    xoffDst = (pbox->x2 - 1) & INTER_PIM;
+	    pdstLine += (((pbox->x2-1) >> INTER_PGSH) + 1) * INTER_PLANES;
+	    psrcLine += (((pptSrc->x+w - 1) >> INTER_PGSH) + 1) * INTER_PLANES;
+	    if (xoffSrc == xoffDst)
+	    {
+		while (h--)
+		{
+		    psrc = psrcLine;
+		    pdst = pdstLine;
+		    pdstLine += widthDst;
+		    psrcLine += widthSrc;
+		    if (endmask)
+		    {
+			INTER_PREV_GROUP(psrc);
+			INTER_PREV_GROUP(pdst);
+			INTER_MROP_MASK(psrc, pdst, endmask, pdst);
+		    }
+		    ng = ngMiddle;
+
+		    DuffL(ng,label3,
+			INTER_PREV_GROUP(psrc);
+			INTER_PREV_GROUP(pdst);
+			INTER_MROP_SOLID(psrc, pdst, pdst);
+		    )
+
+		    if (startmask)
+		    {
+			INTER_PREV_GROUP(psrc);
+			INTER_PREV_GROUP(pdst);
+			INTER_MROP_MASK(psrc, pdst, startmask, pdst);
+		    }
+		}
+	    }
+	    else
+	    {
+		if (xoffDst > xoffSrc)
+		{
+		    rightShift = xoffDst - xoffSrc;
+		    leftShift = (INTER_PIM + 1) - rightShift;
+		}
+		else
+		{
+		    leftShift = xoffSrc - xoffDst;
+		    rightShift = (INTER_PIM + 1) - leftShift;
+		}
+		while (h--)
+		{
+		    psrc = psrcLine;
+		    pdst = pdstLine;
+		    pdstLine += widthDst;
+		    psrcLine += widthSrc;
+		    INTER_CLR(bits);
+		    if (xoffDst > xoffSrc) {
+			INTER_PREV_GROUP(psrc);
+			INTER_COPY(psrc, bits);
+		    }
+		    if (endmask)
+		    {
+			INTER_PREV_GROUP(psrc);
+			INTER_PREV_GROUP(pdst);
+			INTER_GETRLC(rightShift, leftShift, psrc, bits, bits1);
+			INTER_MROP_MASK(bits1, pdst, endmask, pdst);
+		    }
+		    ng = ngMiddle;
+		    DuffL (ng, label4,
+			INTER_PREV_GROUP(psrc);
+			INTER_PREV_GROUP(pdst);
+			INTER_GETRLC(rightShift, leftShift, psrc, bits, bits1);
+			INTER_MROP_SOLID(bits1, pdst, pdst);
+		    )
+		    if (startmask)
+		    {
+			INTER_PREV_GROUP(psrc);
+			INTER_PREV_GROUP(pdst);
+			if ((startmask >> leftShift) & 0xffff) {
+			    INTER_GETRLC(rightShift, leftShift, psrc, bits, 
+				bits1);
+			}
+			else {
+			    INTER_SCRRIGHT(rightShift, bits, bits1);
+			}
+			INTER_MROP_MASK(bits1, pdst, startmask, pdst);
+		    }
+		}
+	    }
+	}
+	pbox++;
+	pptSrc++;
+    }
+    if (pboxNew2)
+    {
+	DEALLOCATE_LOCAL(pptNew2);
+	DEALLOCATE_LOCAL(pboxNew2);
+    }
+    if (pboxNew1)
+    {
+	DEALLOCATE_LOCAL(pptNew1);
+	DEALLOCATE_LOCAL(pboxNew1);
+    }
+}
diff --git a/iplan2p4/iplbres.c b/iplan2p4/iplbres.c
new file mode 100644
index 000000000..9d2b571db
--- /dev/null
+++ b/iplan2p4/iplbres.c
@@ -0,0 +1,182 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplbres.c,v 3.0 1996/08/18 01:54:36 dawes Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+/* $XConsortium: iplbres.c,v 1.15 94/04/17 20:28:45 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "misc.h"
+#include "ipl.h"
+#include "servermd.h"
+#include "miline.h"
+
+#include "iplmskbits.h"
+
+/* Solid bresenham line */
+/* NOTES
+   e2 is used less often than e1, so it's not in a register
+*/
+
+void
+iplBresS(rop, andp, xorp, addrg, ngwidth, signdx, signdy, axis, x1, y1, e, e1,
+	 e2, len)
+    int		    rop;
+    INTER_DECLARERRAX(andp);
+    INTER_DECLARERRAX(xorp);
+    INTER_DECLAREG(*addrg);		/* pointer to base of bitmap */
+    int		    ngwidth;		/* width in longwords of bitmap */
+    register int    signdx;
+    int		    signdy;		/* signs of directions */
+    int		    axis;		/* major axis (Y_AXIS or X_AXIS) */
+    int		    x1, y1;		/* initial point */
+    register int    e;			/* error accumulator */
+    register int    e1;			/* bresenham increments */
+    int		    e2;
+    int		    len;		/* length of line */
+{
+    register int	e3 = e2-e1;
+    INTER_DECLAREG(bit);
+    INTER_DECLAREG(leftbit);
+    INTER_DECLAREG(rightbit);
+
+    /* point to longword containing first point */
+    addrg = addrg + y1 * ngwidth + (x1 >> INTER_PGSH) * INTER_PLANES; 
+
+    if (signdy < 0)
+	    ngwidth = -ngwidth;
+    e = e-e1;			/* to make looping easier */
+
+    leftbit = iplmask[0];
+    rightbit = iplmask[INTER_PPG-1];
+    bit = iplmask[x1 & INTER_PIM];
+
+    if (axis == X_AXIS)
+    {
+	if (signdx > 0)
+	{
+	    while (len--)
+	    { 
+		INTER_DoMaskRRop(addrg, andp, xorp, bit, addrg);
+		bit = bit >> 1;
+		e += e1;
+		if (e >= 0)
+		{
+		    addrg += ngwidth;
+		    e += e3;
+		}
+		if (!bit)
+		{
+		    bit = leftbit;
+		    addrg += INTER_PLANES;
+		}
+	    }
+	}
+	else
+	{
+	    while (len--)
+	    { 
+		INTER_DoMaskRRop(addrg, andp, xorp, bit, addrg);
+		e += e1;
+		bit = bit << 1;
+		if (e >= 0)
+		{
+		    addrg += ngwidth;
+		    e += e3;
+		}
+		if (!bit)
+		{
+		    bit = rightbit;
+		    addrg -= INTER_PLANES;
+		}
+	    }
+	}
+    } /* if X_AXIS */
+    else
+    {
+	if (signdx > 0)
+	{
+	    while(len--)
+	    {
+		INTER_DoMaskRRop(addrg, andp, xorp, bit, addrg);
+		e += e1;
+		if (e >= 0)
+		{
+		    bit = bit >> 1;
+		    if (!bit)
+		    {
+			bit = leftbit;
+			addrg += INTER_PLANES;
+		    }
+		    e += e3;
+		}
+		addrg += ngwidth;
+	    }
+	}
+	else
+	{
+	    while(len--)
+	    {
+		INTER_DoMaskRRop(addrg, andp, xorp, bit, addrg);
+		e += e1;
+		if (e >= 0)
+		{
+		    bit = bit << 1;
+		    if (!bit)
+		    {
+			bit = rightbit;
+			addrg -= INTER_PLANES;
+		    }
+		    e += e3;
+		}
+		addrg += ngwidth;
+	    }
+	}
+    } /* else Y_AXIS */
+}
diff --git a/iplan2p4/iplbresd.c b/iplan2p4/iplbresd.c
new file mode 100644
index 000000000..7cc93e90c
--- /dev/null
+++ b/iplan2p4/iplbresd.c
@@ -0,0 +1,208 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplbresd.c,v 3.0 1996/08/18 01:54:38 dawes Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+/* $XConsortium: iplbresd.c,v 1.16 94/04/17 20:28:45 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "misc.h"
+#include "ipl.h"
+#include "miline.h"
+#include "iplmskbits.h"
+
+/* Dashed bresenham line */
+
+void
+iplBresD(rrops,
+	 pdashIndex, pDash, numInDashList, pdashOffset, isDoubleDash,
+	 addrg, ngwidth,
+	 signdx, signdy, axis, x1, y1, e, e1, e2, len)
+    iplRRopPtr	    rrops;
+    int		    *pdashIndex;	/* current dash */
+    unsigned char   *pDash;		/* dash list */
+    int		    numInDashList;	/* total length of dash list */
+    int		    *pdashOffset;	/* offset into current dash */
+    int		    isDoubleDash;
+    INTER_DECLAREG(*addrg);		/* pointer to base of bitmap */
+    int		    ngwidth;		/* width in groups of bitmap */
+    int		    signdx, signdy;	/* signs of directions */
+    int		    axis;		/* major axis (Y_AXIS or X_AXIS) */
+    int		    x1, y1;		/* initial point */
+    register int    e;			/* error accumulator */
+    register int    e1;			/* bresenham increments */
+    int		    e2;
+    int		    len;		/* length of line */
+{
+    register		int e3 = e2-e1;
+    int			dashIndex;
+    int			dashOffset;
+    int			dashRemaining;
+    INTER_DECLARERRAX(xorFg);
+    INTER_DECLARERRAX(andFg);
+    INTER_DECLARERRAX(xorBg);
+    INTER_DECLARERRAX(andBg);
+    int			thisDash;
+
+    dashOffset = *pdashOffset;
+    dashIndex = *pdashIndex;
+    xorFg = rrops[0].xorg;
+    andFg = rrops[0].andg;
+    xorBg = rrops[1].xorg;
+    andBg = rrops[1].andg;
+    dashRemaining = pDash[dashIndex] - dashOffset;
+    if ((thisDash = dashRemaining) >= len)
+    {
+	thisDash = len;
+	dashRemaining -= len;
+    }
+    e = e-e1;			/* to make looping easier */
+
+#define BresStep(minor,major) {if ((e += e1) >= 0) { e += e3; minor; } major;}
+
+#define NextDash {\
+    dashIndex++; \
+    if (dashIndex == numInDashList) \
+	dashIndex = 0; \
+    dashRemaining = pDash[dashIndex]; \
+    if ((thisDash = dashRemaining) >= len) \
+    { \
+	dashRemaining -= len; \
+	thisDash = len; \
+    } \
+}
+
+    {
+	INTER_DECLAREG(startbit);
+	INTER_DECLAREG(bit);
+
+    	/* point to longword containing first point */
+    	addrg = addrg + (y1 * ngwidth) + (x1 >> INTER_PGSH) * INTER_PLANES;
+    	signdy = signdy * ngwidth;
+	signdx = signdx * INTER_PLANES;
+
+	if (signdx > 0)
+	    startbit = iplmask[0];
+	else
+	    startbit = iplmask[INTER_PPG-1];
+    	bit = iplmask[x1 & INTER_PIM];
+
+#define X_Loop(store)	while(thisDash--) {\
+			    store; \
+		    	    BresStep(addrg += signdy, \
+		    	     	     if (signdx > 0) \
+		    	     	     	 bit >>= 1; \
+		    	     	     else \
+		    	     	     	 bit <<= 1; \
+		    	     	     if (!bit) \
+		    	     	     { \
+		    	     	     	 bit = startbit; \
+		    	     	     	 addrg += signdx; \
+		    	     	     }) \
+			}
+#define Y_Loop(store)	while(thisDash--) {\
+			    store; \
+		    	    BresStep(if (signdx > 0) \
+					 bit >>= 1; \
+		    	     	     else \
+		    	     	     	 bit <<= 1; \
+		    	     	     if (!bit) \
+		    	     	     { \
+		    	     	     	 bit = startbit; \
+		    	     	     	 addrg += signdx; \
+		    	     	     }, \
+				     addrg += signdy) \
+			}
+
+    	if (axis == X_AXIS)
+    	{
+	    for (;;)
+	    {
+	    	len -= thisDash;
+	    	if (dashIndex & 1) {
+		    if (isDoubleDash) {
+		    	X_Loop(
+			INTER_DoMaskRRop(addrg, andBg, xorBg, bit, addrg);
+			)
+		    } else {
+		    	X_Loop(;)
+		    }
+	    	} else {
+		    X_Loop(INTER_DoMaskRRop(addrg, andFg, xorFg, bit, addrg));
+	    	}
+	    	if (!len)
+		    break;
+	    	NextDash
+	    }
+    	} /* if X_AXIS */
+    	else
+    	{
+	    for (;;)
+	    {
+	    	len -= thisDash;
+	    	if (dashIndex & 1) {
+		    if (isDoubleDash) {
+		    	Y_Loop(
+			INTER_DoMaskRRop(addrg, andBg, xorBg, bit, addrg);
+			)
+		    } else {
+		    	Y_Loop(;)
+		    }
+	    	} else {
+		    Y_Loop(INTER_DoMaskRRop(addrg, andFg, xorFg, bit, addrg));
+	    	}
+	    	if (!len)
+		    break;
+	    	NextDash
+	    }
+    	} /* else Y_AXIS */
+    }
+    *pdashIndex = dashIndex;
+    *pdashOffset = pDash[dashIndex] - dashRemaining;
+}
diff --git a/iplan2p4/iplbstore.c b/iplan2p4/iplbstore.c
new file mode 100644
index 000000000..5719ca308
--- /dev/null
+++ b/iplan2p4/iplbstore.c
@@ -0,0 +1,155 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplbstore.c,v 3.0 1996/08/18 01:54:39 dawes Exp $ */
+
+/*-
+ * iplbstore.c --
+ *	Functions required by the backing-store implementation in MI.
+ *
+ * Copyright (c) 1987 by the Regents of the University of California
+ *
+ * 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.  The University of California
+ * makes no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without
+ * express or implied warranty.
+ *
+ *
+ */
+#ifndef lint
+static char rcsid[] =
+"$XConsortium: iplbstore.c,v 5.8 93/12/13 17:21:51 dpw Exp $ SPRITE (Berkeley)";
+#endif
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include    "ipl.h"
+#include    "X.h"
+#include    "mibstore.h"
+#include    "regionstr.h"
+#include    "scrnintstr.h"
+#include    "pixmapstr.h"
+#include    "windowstr.h"
+
+/*-
+ *-----------------------------------------------------------------------
+ * iplSaveAreas --
+ *	Function called by miSaveAreas to actually fetch the areas to be
+ *	saved into the backing pixmap. This is very simple to do, since
+ *	iplDoBitblt is designed for this very thing. The region to save is
+ *	already destination-relative and we're given the offset to the
+ *	window origin, so we have only to create an array of points of the
+ *	u.l. corners of the boxes in the region translated to the screen
+ *	coordinate system and fetch the screen pixmap out of its devPrivate
+ *	field....
+ *
+ * Results:
+ *	None.
+ *
+ * Side Effects:
+ *	Data are copied from the screen into the pixmap.
+ *
+ *-----------------------------------------------------------------------
+ */
+void
+iplSaveAreas(pPixmap, prgnSave, xorg, yorg, pWin)
+    PixmapPtr	  	pPixmap;  	/* Backing pixmap */
+    RegionPtr	  	prgnSave; 	/* Region to save (pixmap-relative) */
+    int	    	  	xorg;	    	/* X origin of region */
+    int	    	  	yorg;	    	/* Y origin of region */
+    WindowPtr		pWin;
+{
+    register DDXPointPtr pPt;
+    DDXPointPtr		pPtsInit;
+    register BoxPtr	pBox;
+    register int	i;
+    ScreenPtr		pScreen = pPixmap->drawable.pScreen;
+    PixmapPtr		pScrPix;
+    
+    i = REGION_NUM_RECTS(prgnSave);
+    pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i * sizeof(DDXPointRec));
+    if (!pPtsInit)
+	return;
+    
+    pBox = REGION_RECTS(prgnSave);
+    pPt = pPtsInit;
+    while (--i >= 0) {
+	pPt->x = pBox->x1 + xorg;
+	pPt->y = pBox->y1 + yorg;
+	pPt++;
+	pBox++;
+    }
+
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    pScrPix = (PixmapPtr) pScreen->devPrivates[iplScreenPrivateIndex].ptr;
+#else
+    pScrPix = (PixmapPtr) pScreen->devPrivate;
+#endif
+
+    iplDoBitbltCopy((DrawablePtr) pScrPix, (DrawablePtr)pPixmap,
+		    GXcopy, prgnSave, pPtsInit, ~0L);
+
+    DEALLOCATE_LOCAL (pPtsInit);
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * iplRestoreAreas --
+ *	Function called by miRestoreAreas to actually fetch the areas to be
+ *	restored from the backing pixmap. This is very simple to do, since
+ *	iplDoBitblt is designed for this very thing. The region to restore is
+ *	already destination-relative and we're given the offset to the
+ *	window origin, so we have only to create an array of points of the
+ *	u.l. corners of the boxes in the region translated to the pixmap
+ *	coordinate system and fetch the screen pixmap out of its devPrivate
+ *	field....
+ *
+ * Results:
+ *	None.
+ *
+ * Side Effects:
+ *	Data are copied from the pixmap into the screen.
+ *
+ *-----------------------------------------------------------------------
+ */
+void
+iplRestoreAreas(pPixmap, prgnRestore, xorg, yorg, pWin)
+    PixmapPtr	  	pPixmap;  	/* Backing pixmap */
+    RegionPtr	  	prgnRestore; 	/* Region to restore (screen-relative)*/
+    int	    	  	xorg;	    	/* X origin of window */
+    int	    	  	yorg;	    	/* Y origin of window */
+    WindowPtr		pWin;
+{
+    register DDXPointPtr pPt;
+    DDXPointPtr		pPtsInit;
+    register BoxPtr	pBox;
+    register int	i;
+    ScreenPtr		pScreen = pPixmap->drawable.pScreen;
+    PixmapPtr		pScrPix;
+    
+    i = REGION_NUM_RECTS(prgnRestore);
+    pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i*sizeof(DDXPointRec));
+    if (!pPtsInit)
+	return;
+    
+    pBox = REGION_RECTS(prgnRestore);
+    pPt = pPtsInit;
+    while (--i >= 0) {
+	pPt->x = pBox->x1 - xorg;
+	pPt->y = pBox->y1 - yorg;
+	pPt++;
+	pBox++;
+    }
+
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    pScrPix = (PixmapPtr) pScreen->devPrivates[iplScreenPrivateIndex].ptr;
+#else
+    pScrPix = (PixmapPtr) pScreen->devPrivate;
+#endif
+
+    iplDoBitbltCopy((DrawablePtr)pPixmap, (DrawablePtr) pScrPix,
+		    GXcopy, prgnRestore, pPtsInit, ~0L);
+
+    DEALLOCATE_LOCAL (pPtsInit);
+}
diff --git a/iplan2p4/iplcmap.c b/iplan2p4/iplcmap.c
new file mode 100644
index 000000000..21abfdbb3
--- /dev/null
+++ b/iplan2p4/iplcmap.c
@@ -0,0 +1,122 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplcmap.c,v 3.1 1998/11/22 10:37:41 dawes Exp $ */
+/* $XConsortium: iplcmap.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.
+
+********************************************************/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xproto.h"
+#include "scrnintstr.h"
+#include "colormapst.h"
+#include "resource.h"
+#include "micmap.h"
+
+int
+iplListInstalledColormaps(pScreen, pmaps)
+    ScreenPtr	pScreen;
+    Colormap	*pmaps;
+{
+    return miListInstalledColormaps(pScreen, pmaps);
+}
+
+
+void
+iplInstallColormap(pmap)
+    ColormapPtr	pmap;
+{
+    miInstallColormap(pmap);
+}
+
+void
+iplUninstallColormap(pmap)
+    ColormapPtr	pmap;
+{
+    miUninstallColormap(pmap);
+}
+
+void
+iplResolveColor(pred, pgreen, pblue, pVisual)
+    unsigned short	*pred, *pgreen, *pblue;
+    register VisualPtr	pVisual;
+{
+    miResolveColor(pred, pgreen, pblue, pVisual);
+}
+
+Bool
+iplInitializeColormap(pmap)
+    register ColormapPtr	pmap;
+{
+    return miInitializeColormap(pmap);
+}
+
+int
+iplExpandDirectColors (pmap, ndef, indefs, outdefs)
+    ColormapPtr	pmap;
+    int		ndef;
+    xColorItem	*indefs, *outdefs;
+{
+    return miExpandDirectColors(pmap, ndef, indefs, outdefs);
+}
+
+Bool
+iplCreateDefColormap(pScreen)
+    ScreenPtr pScreen;
+{
+    return miCreateDefColormap(pScreen);
+}
+
+Bool
+iplSetVisualTypes (depth, visuals, bitsPerRGB)
+    int	    depth;
+    int	    visuals;
+{
+    return miSetVisualTypes(depth, visuals, bitsPerRGB, -1);
+}
+
+/*
+ * Given a list of formats for a screen, create a list
+ * of visuals and depths for the screen which coorespond to
+ * the set which can be used with this version of ipl.
+ */
+
+Bool
+iplInitVisuals (visualp, depthp, nvisualp, ndepthp, rootDepthp, defaultVisp, sizes, bitsPerRGB)
+    VisualPtr	*visualp;
+    DepthPtr	*depthp;
+    int		*nvisualp, *ndepthp;
+    int		*rootDepthp;
+    VisualID	*defaultVisp;
+    unsigned long   sizes;
+    int		bitsPerRGB;
+{
+    return miInitVisuals(visualp, depthp, nvisualp, ndepthp, rootDepthp,
+			 defaultVisp, sizes, bitsPerRGB, -1);
+}
diff --git a/iplan2p4/iplfillarc.c b/iplan2p4/iplfillarc.c
new file mode 100644
index 000000000..c77db6b63
--- /dev/null
+++ b/iplan2p4/iplfillarc.c
@@ -0,0 +1,267 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplfillarc.c,v 3.0 1996/08/18 01:54:41 dawes Exp $ */
+/************************************************************
+
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+********************************************************/
+
+/* $XConsortium: iplfillarc.c,v 5.15 94/04/17 20:28:47 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xprotostr.h"
+#include "miscstruct.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "ipl.h"
+#include "mifillarc.h"
+#include "iplrrop.h"
+#include "mi.h"
+#include "iplmskbits.h"
+
+static void
+INTER_RROP_NAME(iplFillEllipseSolid) (pDraw, pGC, arc)
+    DrawablePtr pDraw;
+    GCPtr pGC;
+    xArc *arc;
+{
+    int x, y, e;
+    int yk, xk, ym, xm, dx, dy, xorg, yorg;
+    miFillArcRec info;
+    INTER_DECLAREG(*addrgt);
+    INTER_DECLAREG(*addrgb);
+    INTER_DECLAREG(*addrg);
+    register int n;
+    int ngwidth;
+    INTER_RROP_DECLARE
+    register int xpos;
+    register int slw;
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);
+    int	nlmiddle;
+
+    iplGetGroupWidthAndPointer (pDraw, ngwidth, addrgt);
+
+    INTER_RROP_FETCH_GC(pGC);
+    miFillArcSetup(arc, &info);
+    MIFILLARCSETUP();
+    xorg += pDraw->x;
+    yorg += pDraw->y;
+    addrgb = addrgt;
+    addrgt += ngwidth * (yorg - y);
+    addrgb += ngwidth * (yorg + y + dy);
+    while (y)
+    {
+	addrgt += ngwidth;
+	addrgb -= ngwidth;
+	MIFILLARCSTEP(slw);
+	if (!slw)
+	    continue;
+	xpos = xorg - x;
+	addrg = addrgt + (xpos >> INTER_PGSH) * INTER_PLANES;
+	if (((xpos & INTER_PIM) + slw) <= INTER_PPG)
+	{
+	    INTER_maskpartialbits(xpos, slw, startmask);
+	    INTER_RROP_SOLID_MASK(addrg,startmask);
+	    if (miFillArcLower(slw))
+	    {
+		addrg = addrgb + (xpos >> INTER_PGSH) * INTER_PLANES;
+		INTER_RROP_SOLID_MASK(addrg, startmask);
+	    }
+	    continue;
+	}
+	INTER_maskbits(xpos, slw, startmask, endmask, nlmiddle);
+	if (startmask)
+	{
+	    INTER_RROP_SOLID_MASK(addrg, startmask);
+	    INTER_NEXT_GROUP(addrg);
+	}
+	n = nlmiddle;
+	INTER_RROP_SPAN(addrg,n)
+
+	if (endmask)
+	    INTER_RROP_SOLID_MASK(addrg, endmask);
+	if (!miFillArcLower(slw))
+	    continue;
+	addrg = addrgb + (xpos >> INTER_PGSH) * INTER_PLANES;
+	if (startmask)
+	{
+	    INTER_RROP_SOLID_MASK(addrg, startmask);
+	    INTER_NEXT_GROUP(addrg);
+	}
+	n = nlmiddle;
+	INTER_RROP_SPAN(addrg, n);
+	if (endmask)
+	    INTER_RROP_SOLID_MASK(addrg, endmask);
+    }
+}
+
+#define FILLSPAN(xl,xr,addr) \
+    if (xr >= xl) \
+    { \
+	n = xr - xl + 1; \
+	addrg = addr + (xl >> INTER_PGSH) * INTER_PLANES; \
+	if (((xl & INTER_PIM) + n) <= INTER_PPG) \
+	{ \
+	    INTER_maskpartialbits(xl, n, startmask); \
+	    INTER_RROP_SOLID_MASK(addrg, startmask); \
+	} \
+	else \
+	{ \
+	    INTER_maskbits(xl, n, startmask, endmask, n); \
+	    if (startmask) \
+	    { \
+		INTER_RROP_SOLID_MASK(addrg, startmask); \
+		INTER_NEXT_GROUP(addrg); \
+	    } \
+	    while (n--) \
+	    { \
+		INTER_RROP_SOLID(addrg); \
+		INTER_NEXT_GROUP(addrg); \
+	    } \
+	    if (endmask) \
+		INTER_RROP_SOLID_MASK(addrg, endmask); \
+	} \
+    }
+
+#define FILLSLICESPANS(flip,addr) \
+    if (!flip) \
+    { \
+	FILLSPAN(xl, xr, addr); \
+    } \
+    else \
+    { \
+	xc = xorg - x; \
+	FILLSPAN(xc, xr, addr); \
+	xc += slw - 1; \
+	FILLSPAN(xl, xc, addr); \
+    }
+
+static void
+INTER_RROP_NAME(iplFillArcSliceSolid)(pDraw, pGC, arc)
+    DrawablePtr pDraw;
+    GCPtr pGC;
+    xArc *arc;
+{
+    int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
+    register int x, y, e;
+    miFillArcRec info;
+    miArcSliceRec slice;
+    int xl, xr, xc;
+    INTER_DECLAREG(*addrgt);
+    INTER_DECLAREG(*addrgb);
+    INTER_DECLAREG(*addrg);
+    register int n;
+    int ngwidth;
+    INTER_RROP_DECLARE
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);
+
+    iplGetGroupWidthAndPointer (pDraw, ngwidth, addrgt);
+
+    INTER_RROP_FETCH_GC(pGC);
+    miFillArcSetup(arc, &info);
+    miFillArcSliceSetup(arc, &slice, pGC);
+    MIFILLARCSETUP();
+    xorg += pDraw->x;
+    yorg += pDraw->y;
+    addrgb = addrgt;
+    addrgt += ngwidth * (yorg - y);
+    addrgb += ngwidth * (yorg + y + dy);
+    slice.edge1.x += pDraw->x;
+    slice.edge2.x += pDraw->x;
+    while (y > 0)
+    {
+	addrgt += ngwidth;
+	addrgb -= ngwidth;
+	MIFILLARCSTEP(slw);
+	MIARCSLICESTEP(slice.edge1);
+	MIARCSLICESTEP(slice.edge2);
+	if (miFillSliceUpper(slice))
+	{
+	    MIARCSLICEUPPER(xl, xr, slice, slw);
+	    FILLSLICESPANS(slice.flip_top, addrgt);
+	}
+	if (miFillSliceLower(slice))
+	{
+	    MIARCSLICELOWER(xl, xr, slice, slw);
+	    FILLSLICESPANS(slice.flip_bot, addrgb);
+	}
+    }
+}
+
+void
+INTER_RROP_NAME(iplPolyFillArcSolid) (pDraw, pGC, narcs, parcs)
+    DrawablePtr	pDraw;
+    GCPtr	pGC;
+    int		narcs;
+    xArc	*parcs;
+{
+    register xArc *arc;
+    register int i;
+    int x2, y2;
+    BoxRec box;
+    RegionPtr cclip;
+
+    cclip = iplGetCompositeClip(pGC);
+    for (arc = parcs, i = narcs; --i >= 0; arc++)
+    {
+	if (miFillArcEmpty(arc))
+	    continue;
+	if (miCanFillArc(arc))
+	{
+	    box.x1 = arc->x + pDraw->x;
+	    box.y1 = arc->y + pDraw->y;
+ 	    /*
+ 	     * Because box.x2 and box.y2 get truncated to 16 bits, and the
+ 	     * RECT_IN_REGION test treats the resulting number as a signed
+ 	     * integer, the RECT_IN_REGION test alone can go the wrong way.
+ 	     * This can result in a server crash because the rendering
+ 	     * routines in this file deal directly with cpu addresses
+ 	     * of pixels to be stored, and do not clip or otherwise check
+ 	     * that all such addresses are within their respective pixmaps.
+ 	     * So we only allow the RECT_IN_REGION test to be used for
+ 	     * values that can be expressed correctly in a signed short.
+ 	     */
+ 	    x2 = box.x1 + (int)arc->width + 1;
+ 	    box.x2 = x2;
+ 	    y2 = box.y1 + (int)arc->height + 1;
+ 	    box.y2 = y2;
+ 	    if ( (x2 <= MAXSHORT) && (y2 <= MAXSHORT) &&
+ 		    (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
+	    {
+		if ((arc->angle2 >= FULLCIRCLE) ||
+		    (arc->angle2 <= -FULLCIRCLE))
+		    INTER_RROP_NAME(iplFillEllipseSolid)(pDraw, pGC, arc);
+		else
+		    INTER_RROP_NAME(iplFillArcSliceSolid)(pDraw, pGC, arc);
+		continue;
+	    }
+	}
+	miPolyFillArc(pDraw, pGC, 1, arc);
+    }
+}
diff --git a/iplan2p4/iplfillrct.c b/iplan2p4/iplfillrct.c
new file mode 100644
index 000000000..512c48048
--- /dev/null
+++ b/iplan2p4/iplfillrct.c
@@ -0,0 +1,277 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplfillrct.c,v 3.1 1998/03/20 21:08:08 hohndel Exp $ */
+/*
+ * Fill rectangles.
+ */
+
+/*
+
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+*/
+
+/* $XConsortium: iplfillrct.c,v 5.18 94/04/17 20:28:47 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+#include "gcstruct.h"
+#include "window.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+
+#include "ipl.h"
+#include "iplmskbits.h"
+#include "mergerop.h"
+
+
+void
+iplFillBoxTileOdd (pDrawable, n, rects, tile, xrot, yrot)
+    DrawablePtr	pDrawable;
+    int		n;
+    BoxPtr	rects;
+    PixmapPtr	tile;
+    int		xrot, yrot;
+{
+    if (tile->drawable.width & INTER_PIM)
+	iplFillBoxTileOddCopy (pDrawable, n, rects, tile, xrot, yrot, GXcopy, ~0L);
+    else
+	iplFillBoxTile32sCopy (pDrawable, n, rects, tile, xrot, yrot, GXcopy, ~0L);
+}
+
+void
+iplFillRectTileOdd (pDrawable, pGC, nBox, pBox)
+    DrawablePtr	pDrawable;
+    GCPtr	pGC;
+    int		nBox;
+    BoxPtr	pBox;
+{
+    int	xrot, yrot;
+    void    (*fill)();
+
+    xrot = pDrawable->x + pGC->patOrg.x;
+    yrot = pDrawable->y + pGC->patOrg.y;
+    if (pGC->tile.pixmap->drawable.width & INTER_PIM)
+    {
+    	fill = iplFillBoxTileOddGeneral;
+    	if ((pGC->planemask & INTER_PMSK) == INTER_PMSK)
+    	{
+	    if (pGC->alu == GXcopy)
+	    	fill = iplFillBoxTileOddCopy;
+    	}
+    }
+    else
+    {
+    	fill = iplFillBoxTile32sGeneral;
+    	if ((pGC->planemask & INTER_PMSK) == INTER_PMSK)
+    	{
+	    if (pGC->alu == GXcopy)
+	    	fill = iplFillBoxTile32sCopy;
+    	}
+    }
+    (*fill) (pDrawable, nBox, pBox, pGC->tile.pixmap, xrot, yrot, pGC->alu, pGC->planemask);
+}
+
+#define NUM_STACK_RECTS	1024
+
+void
+iplPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
+    DrawablePtr pDrawable;
+    register GCPtr pGC;
+    int		nrectFill; 	/* number of rectangles to fill */
+    xRectangle	*prectInit;  	/* Pointer to first rectangle to fill */
+{
+    xRectangle	    *prect;
+    RegionPtr	    prgnClip;
+    register BoxPtr pbox;
+    register BoxPtr pboxClipped;
+    BoxPtr	    pboxClippedBase;
+    BoxPtr	    pextent;
+    BoxRec	    stackRects[NUM_STACK_RECTS];
+    iplPrivGC	    *priv;
+    int		    numRects;
+    void	    (*BoxFill)();
+    int		    n;
+    int		    xorg, yorg;
+
+    priv = iplGetGCPrivate(pGC);
+    prgnClip = pGC->pCompositeClip;
+
+    BoxFill = 0;
+    switch (pGC->fillStyle)
+    {
+    case FillSolid:
+	switch (priv->rop) {
+	case GXcopy:
+	    BoxFill = iplFillRectSolidCopy;
+	    break;
+	case GXxor:
+	    BoxFill = iplFillRectSolidXor;
+	    break;
+	default:
+	    BoxFill = iplFillRectSolidGeneral;
+	    break;
+	}
+	break;
+    case FillTiled:
+	if (!pGC->pRotatedPixmap)
+	    BoxFill = iplFillRectTileOdd;
+	else
+	{
+	    if (pGC->alu == GXcopy && (pGC->planemask & INTER_PMSK) == INTER_PMSK)
+		BoxFill = iplFillRectTile32Copy;
+	    else
+		BoxFill = iplFillRectTile32General;
+	}
+	break;
+    }
+    prect = prectInit;
+    xorg = pDrawable->x;
+    yorg = pDrawable->y;
+    if (xorg || yorg)
+    {
+	prect = prectInit;
+	n = nrectFill;
+	while(n--)
+	{
+	    prect->x += xorg;
+	    prect->y += yorg;
+	    prect++;
+	}
+    }
+
+    prect = prectInit;
+
+    numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
+    if (numRects > NUM_STACK_RECTS)
+    {
+	pboxClippedBase = (BoxPtr)ALLOCATE_LOCAL(numRects * sizeof(BoxRec));
+	if (!pboxClippedBase)
+	    return;
+    }
+    else
+	pboxClippedBase = stackRects;
+
+    pboxClipped = pboxClippedBase;
+	
+    if (REGION_NUM_RECTS(prgnClip) == 1)
+    {
+	int x1, y1, x2, y2, bx2, by2;
+
+	pextent = REGION_RECTS(prgnClip);
+	x1 = pextent->x1;
+	y1 = pextent->y1;
+	x2 = pextent->x2;
+	y2 = pextent->y2;
+    	while (nrectFill--)
+    	{
+	    if ((pboxClipped->x1 = prect->x) < x1)
+		pboxClipped->x1 = x1;
+    
+	    if ((pboxClipped->y1 = prect->y) < y1)
+		pboxClipped->y1 = y1;
+    
+	    bx2 = (int) prect->x + (int) prect->width;
+	    if (bx2 > x2)
+		bx2 = x2;
+	    pboxClipped->x2 = bx2;
+    
+	    by2 = (int) prect->y + (int) prect->height;
+	    if (by2 > y2)
+		by2 = y2;
+	    pboxClipped->y2 = by2;
+
+	    prect++;
+	    if ((pboxClipped->x1 < pboxClipped->x2) &&
+		(pboxClipped->y1 < pboxClipped->y2))
+	    {
+		pboxClipped++;
+	    }
+    	}
+    }
+    else
+    {
+	int x1, y1, x2, y2, bx2, by2;
+
+	pextent = REGION_EXTENTS(pGC->pScreen, prgnClip);
+	x1 = pextent->x1;
+	y1 = pextent->y1;
+	x2 = pextent->x2;
+	y2 = pextent->y2;
+    	while (nrectFill--)
+    	{
+	    BoxRec box;
+    
+	    if ((box.x1 = prect->x) < x1)
+		box.x1 = x1;
+    
+	    if ((box.y1 = prect->y) < y1)
+		box.y1 = y1;
+    
+	    bx2 = (int) prect->x + (int) prect->width;
+	    if (bx2 > x2)
+		bx2 = x2;
+	    box.x2 = bx2;
+    
+	    by2 = (int) prect->y + (int) prect->height;
+	    if (by2 > y2)
+		by2 = y2;
+	    box.y2 = by2;
+    
+	    prect++;
+    
+	    if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
+	    	continue;
+    
+	    n = REGION_NUM_RECTS (prgnClip);
+	    pbox = REGION_RECTS(prgnClip);
+    
+	    /* clip the rectangle to each box in the clip region
+	       this is logically equivalent to calling Intersect()
+	    */
+	    while(n--)
+	    {
+		pboxClipped->x1 = max(box.x1, pbox->x1);
+		pboxClipped->y1 = max(box.y1, pbox->y1);
+		pboxClipped->x2 = min(box.x2, pbox->x2);
+		pboxClipped->y2 = min(box.y2, pbox->y2);
+		pbox++;
+
+		/* see if clipping left anything */
+		if(pboxClipped->x1 < pboxClipped->x2 && 
+		   pboxClipped->y1 < pboxClipped->y2)
+		{
+		    pboxClipped++;
+		}
+	    }
+    	}
+    }
+    if (pboxClipped != pboxClippedBase)
+	(*BoxFill) (pDrawable, pGC,
+		    pboxClipped-pboxClippedBase, pboxClippedBase);
+    if (pboxClippedBase != stackRects)
+    	DEALLOCATE_LOCAL(pboxClippedBase);
+}
diff --git a/iplan2p4/iplfillsp.c b/iplan2p4/iplfillsp.c
new file mode 100644
index 000000000..010f911f6
--- /dev/null
+++ b/iplan2p4/iplfillsp.c
@@ -0,0 +1,380 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplfillsp.c,v 3.0 1996/08/18 01:54:43 dawes 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.
+
+********************************************************/
+
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+
+/* $XConsortium: iplfillsp.c,v 5.24 94/04/17 20:28:48 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+#include "gcstruct.h"
+#include "window.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+
+#include "ipl.h"
+
+#include "mergerop.h"
+
+#define MFB_CONSTS_ONLY
+#include "maskbits.h"
+
+#include "mi.h"
+#include "mispans.h"
+
+#include "iplmskbits.h"
+
+/* scanline filling for color frame buffer
+   written by drewry, oct 1986 modified by smarks
+   changes for compatibility with Little-endian systems Jul 1987; MIT:yba.
+
+   these routines all clip.  they assume that anything that has called
+them has already translated the points (i.e. pGC->miTranslate is
+non-zero, which is howit gets set in iplCreateGC().)
+
+   the number of new scnalines created by clipping ==
+MaxRectsPerBand * nSpans.
+
+    FillSolid is overloaded to be used for OpaqueStipple as well,
+if fgPixel == bgPixel.  
+Note that for solids, PrivGC.rop == PrivGC.ropOpStip
+
+
+    FillTiled is overloaded to be used for OpaqueStipple, if
+fgPixel != bgPixel.  based on the fill style, it uses
+{RotatedTile, gc.alu} or {RotatedStipple, PrivGC.ropOpStip}
+*/
+
+#ifdef	notdef
+#include	<stdio.h>
+static
+dumpspans(n, ppt, pwidth)
+    int	n;
+    DDXPointPtr ppt;
+    int *pwidth;
+{
+    fprintf(stderr,"%d spans\n", n);
+    while (n--) {
+	fprintf(stderr, "[%d,%d] %d\n", ppt->x, ppt->y, *pwidth);
+	ppt++;
+	pwidth++;
+    }
+    fprintf(stderr, "\n");
+}
+#endif
+
+/* Fill spans with tiles that aren't 32 bits wide */
+void
+iplUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
+DrawablePtr pDrawable;
+GC		*pGC;
+int		nInit;		/* number of spans to fill */
+DDXPointPtr pptInit;		/* pointer to list of start points */
+int *pwidthInit;		/* pointer to list of n widths */
+int fSorted;
+{
+    int n;			/* number of spans to fill */
+    register DDXPointPtr ppt;	/* pointer to list of start points */
+    register int *pwidth;	/* pointer to list of n widths */
+    void    (*fill)();
+    int	xrot, yrot;
+
+    if (!(pGC->planemask))
+	return;
+
+    if (pGC->tile.pixmap->drawable.width & INTER_PIM)
+    {
+    	fill = iplFillSpanTileOddGeneral;
+    	if ((pGC->planemask & INTER_PMSK) == INTER_PMSK)
+    	{
+	    if (pGC->alu == GXcopy)
+	    	fill = iplFillSpanTileOddCopy;
+    	}
+    }
+    else
+    {
+	fill = iplFillSpanTile32sGeneral;
+    	if ((pGC->planemask & INTER_PMSK) == INTER_PMSK)
+    	{
+	    if (pGC->alu == GXcopy)
+		fill = iplFillSpanTile32sCopy;
+	}
+    }
+    n = nInit * miFindMaxBand( iplGetCompositeClip(pGC) );
+    if ( n == 0 )
+	return;
+    pwidth = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    ppt = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    if(!ppt || !pwidth)
+    {
+	if (ppt) DEALLOCATE_LOCAL(ppt);
+	if (pwidth) DEALLOCATE_LOCAL(pwidth);
+	return;
+    }
+    n = miClipSpans( iplGetCompositeClip(pGC),
+		     pptInit, pwidthInit, nInit, 
+		     ppt, pwidth, fSorted);
+
+    xrot = pDrawable->x + pGC->patOrg.x;
+    yrot = pDrawable->y + pGC->patOrg.y;
+
+    (*fill) (pDrawable, n, ppt, pwidth, pGC->tile.pixmap, xrot, yrot, pGC->alu, pGC->planemask);
+
+    DEALLOCATE_LOCAL(ppt);
+    DEALLOCATE_LOCAL(pwidth);
+}
+
+/* Fill spans with stipples that aren't 32 bits wide */
+void
+iplUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
+DrawablePtr pDrawable;
+GC		*pGC;
+int		nInit;		/* number of spans to fill */
+DDXPointPtr pptInit;		/* pointer to list of start points */
+int *pwidthInit;		/* pointer to list of n widths */
+int fSorted;
+{
+				/* next three parameters are post-clip */
+    int			    n;		/* number of spans to fill */
+    register DDXPointPtr    ppt;	/* pointer to list of start points */
+    register int	    *pwidth;	/* pointer to list of n widths */
+    int			    iline;	/* first line of tile to use */
+    INTER_DECLAREG(*addrgBase);		/* pointer to start of bitmap */
+    int			    ngwidth;	/* width in groups of bitmap */
+    INTER_DECLAREG(*pdst);		/* pointer to current group in bitmap */
+    PixmapPtr		    pStipple;	/* pointer to stipple we want to fill with */
+    register int	    w;
+    int			    width,  x, xrem, xSrc, ySrc;
+    INTER_DECLAREGP(tmpSrc); 
+    INTER_DECLAREGP(tmpDst1);
+    INTER_DECLAREGP(tmpDst2);
+    int			    stwidth, stippleWidth;
+    unsigned long	    *psrcS;
+    int			    rop, stiprop;
+    int			    stippleHeight;
+    int			    *pwidthFree;    /* copies of the pointers to free */
+    DDXPointPtr		    pptFree;
+    INTER_DECLARERRAXP(bgfill);
+    INTER_DECLARERRAXP(fgfill);
+
+    if (!(pGC->planemask))
+	return;
+
+    n = nInit * miFindMaxBand( iplGetCompositeClip(pGC) );
+    if ( n == 0 )
+	return;
+    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    if(!pptFree || !pwidthFree)
+    {
+	if (pptFree) DEALLOCATE_LOCAL(pptFree);
+	if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+	return;
+    }
+    pwidth = pwidthFree;
+    ppt = pptFree;
+    n = miClipSpans( iplGetCompositeClip(pGC),
+		     pptInit, pwidthInit, nInit, 
+		     ppt, pwidth, fSorted);
+    rop = pGC->alu;
+    if (pGC->fillStyle == FillStippled) {
+	switch (rop) {
+	    case GXand:
+	    case GXcopy:
+	    case GXnoop:
+	    case GXor:
+		stiprop = rop;
+		break;
+	    default:
+		stiprop = rop;
+		rop = GXcopy;
+	}
+    }
+    INTER_PFILL(pGC->fgPixel, fgfill);
+    INTER_PFILL(pGC->bgPixel, bgfill);
+
+    /*
+     *  OK,  so what's going on here?  We have two Drawables:
+     *
+     *  The Stipple:
+     *		Depth = 1
+     *		Width = stippleWidth
+     *		Words per scanline = stwidth
+     *		Pointer to pixels = pStipple->devPrivate.ptr
+     */
+    pStipple = pGC->stipple;
+
+    stwidth = pStipple->devKind / MFB_PGSZB;
+    stippleWidth = pStipple->drawable.width;
+    stippleHeight = pStipple->drawable.height;
+
+    /*
+     *	The Target:
+     *		Depth = INTER_PLANES
+     *		Width = determined from *pwidth
+     *		Groups per scanline = ngwidth
+     *		Pointer to pixels = addrgBase
+     */
+
+    iplGetGroupWidthAndPointer (pDrawable, ngwidth, addrgBase)
+
+    /* this replaces rotating the stipple. Instead we just adjust the offset
+     * at which we start grabbing bits from the stipple.
+     * Ensure that ppt->x - xSrc >= 0 and ppt->y - ySrc >= 0,
+     * so that iline and xrem always stay within the stipple bounds.
+     */
+    modulus (pGC->patOrg.x, stippleWidth, xSrc);
+    xSrc += pDrawable->x - stippleWidth;
+    modulus (pGC->patOrg.y, stippleHeight, ySrc);
+    ySrc += pDrawable->y - stippleHeight;
+
+    while (n--)
+    {
+	iline = (ppt->y - ySrc) % stippleHeight;
+	x = ppt->x;
+	pdst = addrgBase + (ppt->y * ngwidth);
+        psrcS = (unsigned long *) pStipple->devPrivate.ptr + (iline * stwidth);
+
+	if (*pwidth)
+	{
+	    width = *pwidth;
+	    while(width > 0)
+	    {
+	        int xtemp, tmpx;
+		register unsigned long *ptemp;
+		INTER_DECLAREG(*pdsttmp);
+		/*
+		 *  Do a stripe through the stipple & destination w pixels
+		 *  wide.  w is not more than:
+		 *	-	the width of the destination
+		 *	-	the width of the stipple
+		 *	-	the distance between x and the next word 
+		 *		boundary in the destination
+		 *	-	the distance between x and the next word
+		 *		boundary in the stipple
+		 */
+
+		/* width of dest/stipple */
+                xrem = (x - xSrc) % stippleWidth;
+	        w = min((stippleWidth - xrem), width);
+		/* dist to word bound in dest */
+		w = min(w, INTER_PPG - (x & INTER_PIM));
+		/* dist to word bound in stip */
+		w = min(w, MFB_PPW - (x & MFB_PIM));
+
+	        xtemp = (xrem & MFB_PIM);
+	        ptemp = (unsigned long *)(psrcS + (xrem >> MFB_PWSH));
+		tmpx = x & INTER_PIM;
+		pdsttmp = pdst + (x >> INTER_PGSH) * INTER_PLANES;
+		switch ( pGC->fillStyle ) {
+		    case FillOpaqueStippled:
+			INTER_getstipplepixelsb(ptemp,xtemp,w,bgfill,fgfill,
+				tmpDst1);
+			INTER_putbitsrop(tmpDst1, tmpx, w, pdsttmp, 
+				pGC->planemask, rop);
+			break;
+		    case FillStippled:
+			/* Fill tmpSrc with the source pixels */
+			INTER_getbits(pdsttmp, tmpx, w, tmpSrc);
+			INTER_getstipplepixels(ptemp, xtemp, w, 0, tmpSrc, 
+				tmpDst1);
+			if (rop != stiprop) {
+			    INTER_putbitsrop(fgfill, 0, w, tmpSrc, pGC->planemask, stiprop);
+			} else {
+			    INTER_COPY(fgfill, tmpSrc);
+			}
+			INTER_getstipplepixels(ptemp, xtemp, w, 1, tmpSrc, tmpDst2);
+			INTER_OR(tmpDst1,tmpDst2,tmpDst2);
+			INTER_putbitsrop(tmpDst2, tmpx, w, pdsttmp, 
+				pGC->planemask, rop);
+		}
+		x += w;
+		width -= w;
+	    }
+	}
+	ppt++;
+	pwidth++;
+    }
+
+    DEALLOCATE_LOCAL(pptFree);
+    DEALLOCATE_LOCAL(pwidthFree);
+}
+
diff --git a/iplan2p4/iplgc.c b/iplan2p4/iplgc.c
new file mode 100644
index 000000000..794a62609
--- /dev/null
+++ b/iplan2p4/iplgc.c
@@ -0,0 +1,782 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplgc.c,v 3.1 1998/03/20 21:08:08 hohndel Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+
+/* $XConsortium: iplgc.c,v 5.62 94/04/17 20:28:49 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ipl.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "region.h"
+
+#include "mistruct.h"
+#include "mibstore.h"
+#include "migc.h"
+
+#include "iplmskbits.h"
+
+# ifdef WriteBitGroup
+#  define useTEGlyphBlt	iplImageGlyphBlt8
+# else
+#  define useTEGlyphBlt	iplTEGlyphBlt
+# endif
+
+#ifdef WriteBitGroup
+# define useImageGlyphBlt	iplImageGlyphBlt8
+# define usePolyGlyphBlt	iplPolyGlyphBlt8
+#else
+# define useImageGlyphBlt	miImageGlyphBlt
+# define usePolyGlyphBlt	miPolyGlyphBlt
+#endif
+
+#ifdef FOUR_BIT_CODE
+# define usePushPixels	iplPushPixels8
+#else
+# define usePushPixels	mfbPushPixels
+#endif
+
+#ifdef PIXEL_ADDR
+# define ZeroPolyArc	iplZeroPolyArcSS8Copy
+#else
+# define ZeroPolyArc	miZeroPolyArc
+#endif
+
+GCFuncs iplGCFuncs = {
+    iplValidateGC,
+    miChangeGC,
+    miCopyGC,
+    miDestroyGC,
+    miChangeClip,
+    miDestroyClip,
+    miCopyClip,
+};
+
+GCOps	iplTEOps1Rect = {
+    iplSolidSpansCopy,
+    iplSetSpans,
+    iplPutImage,
+    iplCopyArea,
+    iplCopyPlane,
+    iplPolyPoint,
+#ifdef PIXEL_ADDR
+    ipl8LineSS1Rect,
+    ipl8SegmentSS1Rect,
+#else
+    iplLineSS,
+    iplSegmentSS,
+#endif
+    miPolyRectangle,
+    ZeroPolyArc,
+    iplFillPoly1RectCopy,
+    iplPolyFillRect,
+    iplPolyFillArcSolidCopy,
+    miPolyText8,
+    miPolyText16,
+    miImageText8,
+    miImageText16,
+    useTEGlyphBlt,
+    usePolyGlyphBlt,
+    usePushPixels
+#ifdef NEED_LINEHELPER
+    ,NULL
+#endif
+};
+
+GCOps	iplNonTEOps1Rect = {
+    iplSolidSpansCopy,
+    iplSetSpans,
+    iplPutImage,
+    iplCopyArea,
+    iplCopyPlane,
+    iplPolyPoint,
+#ifdef PIXEL_ADDR
+    ipl8LineSS1Rect,
+    ipl8SegmentSS1Rect,
+#else
+    iplLineSS,
+    iplSegmentSS,
+#endif
+    miPolyRectangle,
+    ZeroPolyArc,
+    iplFillPoly1RectCopy,
+    iplPolyFillRect,
+    iplPolyFillArcSolidCopy,
+    miPolyText8,
+    miPolyText16,
+    miImageText8,
+    miImageText16,
+    useImageGlyphBlt,
+    usePolyGlyphBlt,
+    usePushPixels
+#ifdef NEED_LINEHELPER
+    ,NULL
+#endif
+};
+
+GCOps	iplTEOps = {
+    iplSolidSpansCopy,
+    iplSetSpans,
+    iplPutImage,
+    iplCopyArea,
+    iplCopyPlane,
+    iplPolyPoint,
+    iplLineSS,
+    iplSegmentSS,
+    miPolyRectangle,
+    ZeroPolyArc,
+    miFillPolygon,
+    iplPolyFillRect,
+    iplPolyFillArcSolidCopy,
+    miPolyText8,
+    miPolyText16,
+    miImageText8,
+    miImageText16,
+    useTEGlyphBlt,
+    usePolyGlyphBlt,
+    usePushPixels
+#ifdef NEED_LINEHELPER
+    ,NULL
+#endif
+};
+
+GCOps	iplNonTEOps = {
+    iplSolidSpansCopy,
+    iplSetSpans,
+    iplPutImage,
+    iplCopyArea,
+    iplCopyPlane,
+    iplPolyPoint,
+    iplLineSS,
+    iplSegmentSS,
+    miPolyRectangle,
+#ifdef PIXEL_ADDR
+    iplZeroPolyArcSS8Copy,
+#else
+    miZeroPolyArc,
+#endif
+    miFillPolygon,
+    iplPolyFillRect,
+    iplPolyFillArcSolidCopy,
+    miPolyText8,
+    miPolyText16,
+    miImageText8,
+    miImageText16,
+    useImageGlyphBlt,
+    usePolyGlyphBlt,
+    usePushPixels
+#ifdef NEED_LINEHELPER
+    ,NULL
+#endif
+};
+
+GCOps *
+iplMatchCommon (pGC, devPriv)
+    GCPtr	    pGC;
+    iplPrivGCPtr    devPriv;
+{
+    if (pGC->lineWidth != 0)
+	return 0;
+    if (pGC->lineStyle != LineSolid)
+	return 0;
+    if (pGC->fillStyle != FillSolid)
+	return 0;
+    if (devPriv->rop != GXcopy)
+	return 0;
+    if (pGC->font &&
+	FONTMAXBOUNDS(pGC->font,rightSideBearing) -
+        FONTMINBOUNDS(pGC->font,leftSideBearing) <= 32 &&
+	FONTMINBOUNDS(pGC->font,characterWidth) >= 0)
+    {
+	if (TERMINALFONT(pGC->font)
+#ifdef FOUR_BIT_CODE
+	    && FONTMAXBOUNDS(pGC->font,characterWidth) >= PGSZB
+#endif
+	)
+#ifdef NO_ONE_RECT
+            return &iplTEOps1Rect;
+#else
+	    if (devPriv->oneRect)
+		return &iplTEOps1Rect;
+	    else
+		return &iplTEOps;
+#endif
+	else
+#ifdef NO_ONE_RECT
+	    return &iplNonTEOps1Rect;
+#else
+	    if (devPriv->oneRect)
+		return &iplNonTEOps1Rect;
+	    else
+		return &iplNonTEOps;
+#endif
+    }
+    return 0;
+}
+
+Bool
+iplCreateGC(pGC)
+    register GCPtr pGC;
+{
+    iplPrivGC  *pPriv;
+
+    if (PixmapWidthPaddingInfo[pGC->depth].padPixelsLog2 == LOG2_BITMAP_PAD)
+	return (mfbCreateGC(pGC));
+    pGC->clientClip = NULL;
+    pGC->clientClipType = CT_NONE;
+
+    /*
+     * some of the output primitives aren't really necessary, since they
+     * will be filled in ValidateGC because of dix/CreateGC() setting all
+     * the change bits.  Others are necessary because although they depend
+     * on being a color frame buffer, they don't change 
+     */
+
+    pGC->ops = &iplNonTEOps;
+    pGC->funcs = &iplGCFuncs;
+
+    /* ipl wants to translate before scan conversion */
+    pGC->miTranslate = 1;
+
+    pPriv = iplGetGCPrivate(pGC);
+    pPriv->rop = pGC->alu;
+    pPriv->oneRect = FALSE;
+    pGC->fExpose = TRUE;
+    pGC->freeCompClip = FALSE;
+    pGC->pRotatedPixmap = (PixmapPtr) NULL;
+    return TRUE;
+}
+
+/* Clipping conventions
+	if the drawable is a window
+	    CT_REGION ==> pCompositeClip really is the composite
+	    CT_other ==> pCompositeClip is the window clip region
+	if the drawable is a pixmap
+	    CT_REGION ==> pCompositeClip is the translated client region
+		clipped to the pixmap boundary
+	    CT_other ==> pCompositeClip is the pixmap bounding box
+*/
+
+void
+iplValidateGC(pGC, changes, pDrawable)
+    register GCPtr  pGC;
+    unsigned long   changes;
+    DrawablePtr	    pDrawable;
+{
+    int         mask;		/* stateChanges */
+    int         index;		/* used for stepping through bitfields */
+    int		new_rrop;
+    int         new_line, new_text, new_fillspans, new_fillarea;
+    int		new_rotate;
+    int		xrot, yrot;
+    /* flags for changing the proc vector */
+    iplPrivGCPtr devPriv;
+    int		oneRect;
+
+    new_rotate = pGC->lastWinOrg.x != pDrawable->x ||
+		 pGC->lastWinOrg.y != pDrawable->y;
+
+    pGC->lastWinOrg.x = pDrawable->x;
+    pGC->lastWinOrg.y = pDrawable->y;
+    devPriv = iplGetGCPrivate(pGC);
+
+    new_rrop = FALSE;
+    new_line = FALSE;
+    new_text = FALSE;
+    new_fillspans = FALSE;
+    new_fillarea = FALSE;
+
+    /*
+     * if the client clip is different or moved OR the subwindowMode has
+     * changed OR the window's clip has changed since the last validation
+     * we need to recompute the composite clip 
+     */
+
+    if ((changes & (GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode)) ||
+	(pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS))
+	)
+    {
+	miComputeCompositeClip (pGC, pDrawable);
+#ifdef NO_ONE_RECT
+	devPriv->oneRect = FALSE;
+#else
+	oneRect = REGION_NUM_RECTS(pGC->pCompositeClip) == 1;
+	if (oneRect != devPriv->oneRect)
+	    new_line = TRUE;
+	devPriv->oneRect = oneRect;
+#endif
+    }
+
+    mask = changes;
+    while (mask) {
+	index = lowbit (mask);
+	mask &= ~index;
+
+	/*
+	 * this switch acculmulates a list of which procedures might have
+	 * to change due to changes in the GC.  in some cases (e.g.
+	 * changing one 16 bit tile for another) we might not really need
+	 * a change, but the code is being paranoid. this sort of batching
+	 * wins if, for example, the alu and the font have been changed,
+	 * or any other pair of items that both change the same thing. 
+	 */
+	switch (index) {
+	case GCFunction:
+	case GCForeground:
+	    new_rrop = TRUE;
+	    break;
+	case GCPlaneMask:
+	    new_rrop = TRUE;
+	    new_text = TRUE;
+	    break;
+	case GCBackground:
+	    break;
+	case GCLineStyle:
+	case GCLineWidth:
+	    new_line = TRUE;
+	    break;
+	case GCJoinStyle:
+	case GCCapStyle:
+	    break;
+	case GCFillStyle:
+	    new_text = TRUE;
+	    new_fillspans = TRUE;
+	    new_line = TRUE;
+	    new_fillarea = TRUE;
+	    break;
+	case GCFillRule:
+	    break;
+	case GCTile:
+	    new_fillspans = TRUE;
+	    new_fillarea = TRUE;
+	    break;
+
+	case GCStipple:
+	    if (pGC->stipple)
+	    {
+		int width = pGC->stipple->drawable.width;
+		PixmapPtr nstipple;
+
+		if ((width <= INTER_PGSZ) && !(width & (width - 1)) &&
+		    (nstipple = iplCopyPixmap(pGC->stipple)))
+		{
+		    iplPadPixmap(nstipple);
+		    (*pGC->pScreen->DestroyPixmap)(pGC->stipple);
+		    pGC->stipple = nstipple;
+		}
+	    }
+	    new_fillspans = TRUE;
+	    new_fillarea = TRUE;
+	    break;
+
+	case GCTileStipXOrigin:
+	    new_rotate = TRUE;
+	    break;
+
+	case GCTileStipYOrigin:
+	    new_rotate = TRUE;
+	    break;
+
+	case GCFont:
+	    new_text = TRUE;
+	    break;
+	case GCSubwindowMode:
+	    break;
+	case GCGraphicsExposures:
+	    break;
+	case GCClipXOrigin:
+	    break;
+	case GCClipYOrigin:
+	    break;
+	case GCClipMask:
+	    break;
+	case GCDashOffset:
+	    break;
+	case GCDashList:
+	    break;
+	case GCArcMode:
+	    break;
+	default:
+	    break;
+	}
+    }
+
+    /*
+     * If the drawable has changed,  ensure suitable
+     * entries are in the proc vector. 
+     */
+    if (pDrawable->serialNumber != (pGC->serialNumber & (DRAWABLE_SERIAL_BITS))) {
+	new_fillspans = TRUE;	/* deal with FillSpans later */
+    }
+
+    if (new_rotate || new_fillspans)
+    {
+	Bool new_pix = FALSE;
+
+	xrot = pGC->patOrg.x + pDrawable->x;
+	yrot = pGC->patOrg.y + pDrawable->y;
+
+	switch (pGC->fillStyle)
+	{
+	case FillTiled:
+	    if (!pGC->tileIsPixel)
+	    {
+		int width = pGC->tile.pixmap->drawable.width;
+
+		if ((width <= INTER_PGSZ) && !(width & (width - 1)))
+		{
+		    iplCopyRotatePixmap(pGC->tile.pixmap,
+					&pGC->pRotatedPixmap,
+					xrot, yrot);
+		    new_pix = TRUE;
+		}
+	    }
+	    break;
+#ifdef FOUR_BIT_CODE
+	case FillStippled:
+	case FillOpaqueStippled:
+	    {
+		int width = pGC->stipple->drawable.width;
+
+		if ((width <= INTER_PGSZ) && !(width & (width - 1)))
+		{
+		    mfbCopyRotatePixmap(pGC->stipple,
+					&pGC->pRotatedPixmap, xrot, yrot);
+		    new_pix = TRUE;
+		}
+	    }
+	    break;
+#endif
+	}
+	if (!new_pix && pGC->pRotatedPixmap)
+	{
+	    (*pGC->pScreen->DestroyPixmap)(pGC->pRotatedPixmap);
+	    pGC->pRotatedPixmap = (PixmapPtr) NULL;
+	}
+    }
+
+    if (new_rrop)
+    {
+	int old_rrop;
+
+	old_rrop = devPriv->rop;
+	devPriv->rop = iplReduceRasterOp(pGC->alu, pGC->fgPixel, 
+		pGC->planemask, devPriv->andg, devPriv->xorg);
+	if (old_rrop == devPriv->rop)
+	    new_rrop = FALSE;
+	else
+	{
+#ifdef PIXEL_ADDR
+	    new_line = TRUE;
+#endif
+#ifdef WriteBitGroup
+	    new_text = TRUE;
+#endif
+	    new_fillspans = TRUE;
+	    new_fillarea = TRUE;
+	}
+    }
+
+    if (new_rrop || new_fillspans || new_text || new_fillarea || new_line)
+    {
+	GCOps	*newops;
+
+	if (newops = iplMatchCommon (pGC, devPriv))
+ 	{
+	    if (pGC->ops->devPrivate.val)
+		miDestroyGCOps (pGC->ops);
+	    pGC->ops = newops;
+	    new_rrop = new_line = new_fillspans = new_text = new_fillarea = 0;
+	}
+ 	else
+ 	{
+	    if (!pGC->ops->devPrivate.val)
+	    {
+		pGC->ops = miCreateGCOps (pGC->ops);
+		pGC->ops->devPrivate.val = 1;
+	    }
+	}
+    }
+
+    /* deal with the changes we've collected */
+    if (new_line)
+    {
+	pGC->ops->FillPolygon = miFillPolygon;
+#ifdef NO_ONE_RECT
+	if (pGC->fillStyle == FillSolid)
+	{
+	    switch (devPriv->rop) {
+	    case GXcopy:
+		pGC->ops->FillPolygon = iplFillPoly1RectCopy;
+		break;
+	    default:
+		pGC->ops->FillPolygon = iplFillPoly1RectGeneral;
+		break;
+	    }
+	}
+#else
+	if (devPriv->oneRect && pGC->fillStyle == FillSolid)
+	{
+	    switch (devPriv->rop) {
+	    case GXcopy:
+		pGC->ops->FillPolygon = iplFillPoly1RectCopy;
+		break;
+	    default:
+		pGC->ops->FillPolygon = iplFillPoly1RectGeneral;
+		break;
+	    }
+	}
+#endif
+	if (pGC->lineWidth == 0)
+	{
+#ifdef PIXEL_ADDR
+	    if ((pGC->lineStyle == LineSolid) && (pGC->fillStyle == FillSolid))
+	    {
+		switch (devPriv->rop)
+		{
+		case GXxor:
+		    pGC->ops->PolyArc = iplZeroPolyArcSS8Xor;
+		    break;
+		case GXcopy:
+		    pGC->ops->PolyArc = iplZeroPolyArcSS8Copy;
+		    break;
+		default:
+		    pGC->ops->PolyArc = iplZeroPolyArcSS8General;
+		    break;
+		}
+	    }
+	    else
+#endif
+		pGC->ops->PolyArc = miZeroPolyArc;
+	}
+	else
+	    pGC->ops->PolyArc = miPolyArc;
+	pGC->ops->PolySegment = miPolySegment;
+	switch (pGC->lineStyle)
+	{
+	case LineSolid:
+	    if(pGC->lineWidth == 0)
+	    {
+		if (pGC->fillStyle == FillSolid)
+		{
+#if defined(PIXEL_ADDR) && !defined(NO_ONE_RECT)
+		    if (devPriv->oneRect &&
+			((pDrawable->x >= pGC->pScreen->width - 32768) &&
+			 (pDrawable->y >= pGC->pScreen->height - 32768)))
+		    {
+			pGC->ops->Polylines = ipl8LineSS1Rect;
+			pGC->ops->PolySegment = ipl8SegmentSS1Rect;
+		    } else
+#endif
+#ifdef NO_ONE_RECT
+		    {
+			pGC->ops->Polylines = ipl8LineSS1Rect;
+			pGC->ops->PolySegment = ipl8SegmentSS1Rect;
+		    }
+#else
+		    {
+		    	pGC->ops->Polylines = iplLineSS;
+		    	pGC->ops->PolySegment = iplSegmentSS;
+		    }
+#endif
+		}
+ 		else
+		    pGC->ops->Polylines = miZeroLine;
+	    }
+	    else
+		pGC->ops->Polylines = miWideLine;
+	    break;
+	case LineOnOffDash:
+	case LineDoubleDash:
+	    if (pGC->lineWidth == 0 && pGC->fillStyle == FillSolid)
+	    {
+		pGC->ops->Polylines = iplLineSD;
+		pGC->ops->PolySegment = iplSegmentSD;
+	    } else
+		pGC->ops->Polylines = miWideDash;
+	    break;
+	}
+    }
+
+    if (new_text && (pGC->font))
+    {
+        if (FONTMAXBOUNDS(pGC->font,rightSideBearing) -
+            FONTMINBOUNDS(pGC->font,leftSideBearing) > 32 ||
+	    FONTMINBOUNDS(pGC->font,characterWidth) < 0)
+        {
+            pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
+            pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
+        }
+        else
+        {
+#ifdef WriteBitGroup
+	    if (pGC->fillStyle == FillSolid)
+	    {
+		if (devPriv->rop == GXcopy)
+		    pGC->ops->PolyGlyphBlt = iplPolyGlyphBlt8;
+		else
+#ifdef FOUR_BIT_CODE
+		    pGC->ops->PolyGlyphBlt = iplPolyGlyphRop8;
+#else
+		    pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
+#endif
+	    }
+	    else
+#endif
+		pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
+            /* special case ImageGlyphBlt for terminal emulator fonts */
+#if !defined(WriteBitGroup)
+	    if (TERMINALFONT(pGC->font) &&
+		(pGC->planemask & INTER_PMSK) == INTER_PMSK
+#ifdef FOUR_BIT_CODE
+		&& FONTMAXBOUNDS(pGC->font,characterWidth) >= PGSZB
+#endif
+		)
+	    {
+		pGC->ops->ImageGlyphBlt = useTEGlyphBlt;
+	    }
+            else
+#endif
+	    {
+#ifdef WriteBitGroup
+		if (devPriv->rop == GXcopy &&
+		    pGC->fillStyle == FillSolid &&
+		    (pGC->planemask & INTER_PMSK) == INTER_PMSK)
+		    pGC->ops->ImageGlyphBlt = iplImageGlyphBlt8;
+		else
+#endif
+		    pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
+	    }
+        }
+    }    
+
+
+    if (new_fillspans) {
+	switch (pGC->fillStyle) {
+	case FillSolid:
+	    switch (devPriv->rop) {
+	    case GXcopy:
+		pGC->ops->FillSpans = iplSolidSpansCopy;
+		break;
+	    case GXxor:
+		pGC->ops->FillSpans = iplSolidSpansXor;
+		break;
+	    default:
+		pGC->ops->FillSpans = iplSolidSpansGeneral;
+		break;
+	    }
+	    break;
+	case FillTiled:
+	    if (pGC->pRotatedPixmap)
+	    {
+		if (pGC->alu == GXcopy && (pGC->planemask & INTER_PMSK) == INTER_PMSK)
+		    pGC->ops->FillSpans = iplTile32FSCopy;
+		else
+		    pGC->ops->FillSpans = iplTile32FSGeneral;
+	    }
+	    else
+		pGC->ops->FillSpans = iplUnnaturalTileFS;
+	    break;
+	case FillStippled:
+#ifdef FOUR_BIT_CODE
+	    if (pGC->pRotatedPixmap)
+		pGC->ops->FillSpans = ipl8Stipple32FS;
+	    else
+#endif
+		pGC->ops->FillSpans = iplUnnaturalStippleFS;
+	    break;
+	case FillOpaqueStippled:
+#ifdef FOUR_BIT_CODE
+	    if (pGC->pRotatedPixmap)
+		pGC->ops->FillSpans = ipl8OpaqueStipple32FS;
+	    else
+#endif
+		pGC->ops->FillSpans = iplUnnaturalStippleFS;
+	    break;
+	default:
+	    FatalError("iplValidateGC: illegal fillStyle\n");
+	}
+    } /* end of new_fillspans */
+
+    if (new_fillarea) {
+#ifndef FOUR_BIT_CODE
+	pGC->ops->PolyFillRect = miPolyFillRect;
+	if (pGC->fillStyle == FillSolid || pGC->fillStyle == FillTiled)
+	{
+	    pGC->ops->PolyFillRect = iplPolyFillRect;
+	}
+#endif
+#ifdef FOUR_BIT_CODE
+	pGC->ops->PushPixels = mfbPushPixels;
+	if (pGC->fillStyle == FillSolid && devPriv->rop == GXcopy)
+	    pGC->ops->PushPixels = iplPushPixels8;
+#endif
+	pGC->ops->PolyFillArc = miPolyFillArc;
+	if (pGC->fillStyle == FillSolid)
+	{
+	    switch (devPriv->rop)
+	    {
+	    case GXcopy:
+		pGC->ops->PolyFillArc = iplPolyFillArcSolidCopy;
+		break;
+	    default:
+		pGC->ops->PolyFillArc = iplPolyFillArcSolidGeneral;
+		break;
+	    }
+	}
+    }
+}
diff --git a/iplan2p4/iplgetsp.c b/iplan2p4/iplgetsp.c
new file mode 100644
index 000000000..271656bda
--- /dev/null
+++ b/iplan2p4/iplgetsp.c
@@ -0,0 +1,162 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplgetsp.c,v 3.0 1996/08/18 01:54:47 dawes Exp $ */
+/* $XConsortium: iplgetsp.c,v 5.14 94/04/17 20:28:50 dpw Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+
+#include "misc.h"
+#include "region.h"
+#include "gc.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ipl.h"
+#include "iplmskbits.h"
+#include "iplpack.h"
+
+/* GetSpans -- for each span, gets bits from drawable starting at ppt[i]
+ * and continuing for pwidth[i] bits
+ * Each scanline returned will be server scanline padded, i.e., it will come
+ * out to an integral number of words.
+ */
+void
+iplGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pchardstStart)
+    DrawablePtr		pDrawable;	/* drawable from which to get bits */
+    int			wMax;		/* largest value of all *pwidths */
+    register DDXPointPtr ppt;		/* points to start copying from */
+    int			*pwidth;	/* list of number of bits to copy */
+    int			nspans;		/* number of scanlines to copy */
+    char		*pchardstStart; /* where to put the bits */
+{
+    unsigned long *pdst = (unsigned long *)pchardstStart;
+    INTER_DECLAREG(*psrc);		/* where to get the bits */
+    INTER_DECLAREGP(tmpSrc);		/* scratch buffer for bits */
+    INTER_DECLAREG(*psrcBase);		/* start of src bitmap */
+    int			widthSrc;	/* width of pixmap in bytes */
+    register DDXPointPtr pptLast;	/* one past last point to get */
+    int         	xEnd;		/* last pixel to copy from */
+    register int	nstart; 
+    int	 		nend; 
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);
+    int			nlMiddle, nl, srcBit;
+    int			w,longs;
+    INTER_DECLAREG(*tmppdst);
+    INTER_DECLAREG(*ipdst);
+
+    switch (pDrawable->bitsPerPixel) {
+	case 1:
+	    mfbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pchardstStart);
+	    return;
+	case INTER_PLANES:
+	    break;
+	default:
+	    FatalError("iplGetSpans: invalid depth\n");
+    }
+
+    longs = NUM_LONGS(INTER_PLANES, 0, wMax);
+    tmppdst = (unsigned short *) 
+	ALLOCATE_LOCAL(NUM_TEMP_BYTES(INTER_PLANES, longs));
+    iplGetGroupWidthAndPointer (pDrawable, widthSrc, psrcBase) 
+
+    pptLast = ppt + nspans;
+    while(ppt < pptLast)
+    {
+	xEnd = min(ppt->x + *pwidth, (widthSrc / INTER_PLANES) << INTER_PGSH);
+	psrc = psrcBase + ppt->y * widthSrc + 
+		(ppt->x >> INTER_PGSH) * INTER_PLANES; 
+	w = xEnd - ppt->x;
+	srcBit = ppt->x & INTER_PIM;
+        ipdst = tmppdst;
+
+	if (srcBit + w <= INTER_PPG) 
+	{ 
+	    INTER_getbits(psrc, srcBit, w, tmpSrc);
+	    INTER_putbits(tmpSrc, 0, w, ipdst, ~((unsigned long)0)); 
+	} 
+	else 
+	{ 
+	    INTER_maskbits(ppt->x, w, startmask, endmask, nlMiddle);
+	    nstart = 0; 
+	    if (startmask) 
+	    { 
+		nstart = INTER_PPG - srcBit; 
+		INTER_getbits(psrc, srcBit, nstart, tmpSrc);
+		INTER_putbits(tmpSrc, 0, nstart, ipdst, ~((unsigned long)0));
+		if(srcBit + nstart >= INTER_PPG)
+		    INTER_NEXT_GROUP(psrc);
+	    } 
+	    nl = nlMiddle; 
+	    while (nl--) 
+	    { 
+		INTER_putbits(psrc, nstart, INTER_PPG, ipdst, ~((unsigned long)0));
+		INTER_NEXT_GROUP(psrc);
+		INTER_NEXT_GROUP(ipdst);
+	    } 
+	    if (endmask) 
+	    { 
+		nend = xEnd & INTER_PIM; 
+		INTER_getbits(psrc, 0, nend, tmpSrc);
+		INTER_putbits(tmpSrc, nstart, nend, ipdst, ~((unsigned long)0));
+	    } 
+	} 
+	longs=(w * INTER_PLANES + 31)/32;
+	iplPackLine(INTER_PLANES, longs, tmppdst, pdst);
+	pdst+=longs;
+        ppt++;
+	pwidth++;
+    }
+    DEALLOCATE_LOCAL(tmppdst);
+}
diff --git a/iplan2p4/iplhrzvert.c b/iplan2p4/iplhrzvert.c
new file mode 100644
index 000000000..6374e4d19
--- /dev/null
+++ b/iplan2p4/iplhrzvert.c
@@ -0,0 +1,124 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplhrzvert.c,v 3.0 1996/08/18 01:54:48 dawes Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+/* $XConsortium: iplhrzvert.c,v 1.8 94/04/17 20:28:51 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+
+#include "gc.h"
+#include "window.h"
+#include "pixmap.h"
+#include "region.h"
+
+#include "ipl.h"
+
+#include "iplmskbits.h"
+
+/* horizontal solid line
+   abs(len) > 1
+*/
+iplHorzS(rop, andp, xorp, addrg, ngwidth, x1, y1, len)
+register int rop;
+INTER_DECLARERRAX(andp);
+INTER_DECLARERRAX(xorp);
+INTER_DECLAREG(*addrg); /* pointer to base of bitmap */
+int ngwidth;		/* width in groups of bitmap */
+int x1;			/* initial point */ 
+int y1;
+int len;		/* length of line */
+{
+    register int ngmiddle;
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);
+
+    addrg = addrg + y1 * ngwidth + (x1 >> INTER_PGSH) * INTER_PLANES; 
+    /* all bits inside same group */
+    if ( ((x1 & INTER_PIM) + len) < INTER_PPG)
+    {
+	INTER_maskpartialbits(x1, len, startmask);
+	INTER_DoMaskRRop(addrg, andp, xorp, startmask, addrg);
+    }
+    else
+    {
+	INTER_maskbits(x1, len, startmask, endmask, ngmiddle);
+	    if (startmask)
+	    {
+		INTER_DoMaskRRop(addrg, andp, xorp, startmask, addrg);
+		addrg += INTER_PLANES;
+	    }
+		while (ngmiddle--)
+		{
+		    INTER_DoRRop(addrg, andp, xorp, addrg);
+		    addrg += INTER_PLANES;
+		}
+	    if (endmask)
+		INTER_DoMaskRRop(addrg, andp, xorp, endmask, addrg);
+    }
+}
+
+/* vertical solid line */
+
+iplVertS(rop, andp, xorp, addrg, ngwidth, x1, y1, len)
+int rop;
+INTER_DECLARERRAX(andp);
+INTER_DECLARERRAX(xorp);
+INTER_DECLAREG(*addrg);	/* pointer to base of bitmap */
+register int ngwidth;	/* width in groups of bitmap */
+int x1, y1;		/* initial point */
+register int len;	/* length of line */
+{
+    addrg = addrg + (y1 * ngwidth) + (x1 >> INTER_PGSH) * INTER_PLANES;
+    while (len--)
+    {
+	INTER_DoMaskRRop(addrg, andp, xorp, iplmask[x1 & INTER_PIM], addrg);
+	addrg += ngwidth;
+    }
+}
diff --git a/iplan2p4/iplimage.c b/iplan2p4/iplimage.c
new file mode 100644
index 000000000..0522309b4
--- /dev/null
+++ b/iplan2p4/iplimage.c
@@ -0,0 +1,83 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplimage.c,v 3.0 1996/08/18 01:54:49 dawes Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+/* $XConsortium: iplimage.c,v 1.18 94/04/17 20:28:52 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "gcstruct.h"
+#include "ipl.h"
+#include "servermd.h"
+
+void
+iplPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage)
+    DrawablePtr pDraw;
+    GCPtr	pGC;
+    int		depth, x, y, w, h;
+    int		leftPad;
+    int		format;
+    char 	*pImage;
+{
+    miPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage);
+}
+
+void
+iplGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine)
+    DrawablePtr pDrawable;
+    int		sx, sy, w, h;
+    unsigned int format;
+    unsigned long planeMask;
+    char	*pdstLine;
+{
+    miGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
+}
diff --git a/iplan2p4/iplline.c b/iplan2p4/iplline.c
new file mode 100644
index 000000000..479bfb00a
--- /dev/null
+++ b/iplan2p4/iplline.c
@@ -0,0 +1,754 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplline.c,v 3.1 1998/03/20 21:08:08 hohndel Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+/* $XConsortium: iplline.c,v 1.23 94/04/17 20:28:53 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+#include "mistruct.h"
+
+#include "ipl.h"
+#include "miline.h"
+
+#include "iplmskbits.h"
+
+/* single-pixel lines on a color frame buffer
+
+   NON-SLOPED LINES
+   horizontal lines are always drawn left to right; we have to
+move the endpoints right by one after they're swapped.
+   horizontal lines will be confined to a single band of a
+region.  the code finds that band (giving up if the lower
+bound of the band is above the line we're drawing); then it
+finds the first box in that band that contains part of the
+line.  we clip the line to subsequent boxes in that band.
+   vertical lines are always drawn top to bottom (y-increasing.)
+this requires adding one to the y-coordinate of each endpoint
+after swapping.
+
+   SLOPED LINES
+   when clipping a sloped line, we bring the second point inside
+the clipping box, rather than one beyond it, and then add 1 to
+the length of the line before drawing it.  this lets us use
+the same box for finding the outcodes for both endpoints.  since
+the equation for clipping the second endpoint to an edge gives us
+1 beyond the edge, we then have to move the point towards the
+first point by one step on the major axis.
+   eventually, there will be a diagram here to explain what's going
+on.  the method uses Cohen-Sutherland outcodes to determine
+outsideness, and a method similar to Pike's layers for doing the
+actual clipping.
+
+*/
+
+void
+#ifdef POLYSEGMENT
+iplSegmentSS (pDrawable, pGC, nseg, pSeg)
+    DrawablePtr	pDrawable;
+    GCPtr	pGC;
+    int		nseg;
+    register xSegment	*pSeg;
+#else
+iplLineSS (pDrawable, pGC, mode, npt, pptInit)
+    DrawablePtr pDrawable;
+    GCPtr	pGC;
+    int		mode;		/* Origin or Previous */
+    int		npt;		/* number of points */
+    DDXPointPtr pptInit;
+#endif
+{
+    int nboxInit;
+    register int nbox;
+    BoxPtr pboxInit;
+    register BoxPtr pbox;
+#ifndef POLYSEGMENT
+    register DDXPointPtr ppt;	/* pointer to list of translated points */
+#endif
+
+    unsigned int oc1;		/* outcode of point 1 */
+    unsigned int oc2;		/* outcode of point 2 */
+
+    INTER_DECLAREG(*addrg);	/* address of destination pixmap */
+    int ngwidth;		/* width in groups of destination pixmap */
+    int xorg, yorg;		/* origin of window */
+
+    int adx;		/* abs values of dx and dy */
+    int ady;
+    int signdx;		/* sign of dx and dy */
+    int signdy;
+    int e, e1, e2;		/* bresenham error and increments */
+    int len;			/* length of segment */
+    int axis;			/* major axis */
+    int octant;
+    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
+
+				/* a bunch of temporaries */
+    int tmp;
+    register int y1, y2;
+    register int x1, x2;
+    RegionPtr cclip;
+    iplPrivGCPtr    devPriv;
+    INTER_DECLARERRAX(xor);
+    INTER_DECLARERRAX(and);
+    int		    alu;
+
+    devPriv = iplGetGCPrivate(pGC);
+    cclip = pGC->pCompositeClip;
+    pboxInit = REGION_RECTS(cclip);
+    nboxInit = REGION_NUM_RECTS(cclip);
+
+    iplGetGroupWidthAndPointer (pDrawable, ngwidth, addrg)
+
+    alu = devPriv->rop;
+    xor = devPriv->xorg;
+    and = devPriv->andg;
+    xorg = pDrawable->x;
+    yorg = pDrawable->y;
+#ifdef POLYSEGMENT
+    while (nseg--)
+#else
+    ppt = pptInit;
+    x2 = ppt->x + xorg;
+    y2 = ppt->y + yorg;
+    while(--npt)
+#endif
+    {
+	nbox = nboxInit;
+	pbox = pboxInit;
+
+#ifdef POLYSEGMENT
+	x1 = pSeg->x1 + xorg;
+	y1 = pSeg->y1 + yorg;
+	x2 = pSeg->x2 + xorg;
+	y2 = pSeg->y2 + yorg;
+	pSeg++;
+#else
+	x1 = x2;
+	y1 = y2;
+	++ppt;
+	if (mode == CoordModePrevious)
+	{
+	    xorg = x1;
+	    yorg = y1;
+	}
+	x2 = ppt->x + xorg;
+	y2 = ppt->y + yorg;
+#endif
+
+	if (x1 == x2)  /* vertical line */
+	{
+	    /* make the line go top to bottom of screen, keeping
+	       endpoint semantics
+	    */
+	    if (y1 > y2)
+	    {
+		register int tmp;
+
+		tmp = y2;
+		y2 = y1 + 1;
+		y1 = tmp + 1;
+#ifdef POLYSEGMENT
+		if (pGC->capStyle != CapNotLast)
+		    y1--;
+#endif
+	    }
+#ifdef POLYSEGMENT
+	    else if (pGC->capStyle != CapNotLast)
+		y2++;
+#endif
+	    /* get to first band that might contain part of line */
+	    while ((nbox) && (pbox->y2 <= y1))
+	    {
+		pbox++;
+		nbox--;
+	    }
+
+	    if (nbox)
+	    {
+		/* stop when lower edge of box is beyond end of line */
+		while((nbox) && (y2 >= pbox->y1))
+		{
+		    if ((x1 >= pbox->x1) && (x1 < pbox->x2))
+		    {
+			int y1t, y2t;
+			/* this box has part of the line in it */
+			y1t = max(y1, pbox->y1);
+			y2t = min(y2, pbox->y2);
+			if (y1t != y2t)
+			{
+			    iplVertS (alu, and, xor,
+				      addrg, ngwidth, 
+				      x1, y1t, y2t-y1t);
+			}
+		    }
+		    nbox--;
+		    pbox++;
+		}
+	    }
+#ifndef POLYSEGMENT
+	    y2 = ppt->y + yorg;
+#endif
+	}
+	else if (y1 == y2)  /* horizontal line */
+	{
+	    /* force line from left to right, keeping
+	       endpoint semantics
+	    */
+	    if (x1 > x2)
+	    {
+		register int tmp;
+
+		tmp = x2;
+		x2 = x1 + 1;
+		x1 = tmp + 1;
+#ifdef POLYSEGMENT
+		if (pGC->capStyle != CapNotLast)
+		    x1--;
+#endif
+	    }
+#ifdef POLYSEGMENT
+	    else if (pGC->capStyle != CapNotLast)
+		x2++;
+#endif
+
+	    /* find the correct band */
+	    while( (nbox) && (pbox->y2 <= y1))
+	    {
+		pbox++;
+		nbox--;
+	    }
+
+	    /* try to draw the line, if we haven't gone beyond it */
+	    if ((nbox) && (pbox->y1 <= y1))
+	    {
+		/* when we leave this band, we're done */
+		tmp = pbox->y1;
+		while((nbox) && (pbox->y1 == tmp))
+		{
+		    int	x1t, x2t;
+
+		    if (pbox->x2 <= x1)
+		    {
+			/* skip boxes until one might contain start point */
+			nbox--;
+			pbox++;
+			continue;
+		    }
+
+		    /* stop if left of box is beyond right of line */
+		    if (pbox->x1 >= x2)
+		    {
+			nbox = 0;
+			break;
+		    }
+
+		    x1t = max(x1, pbox->x1);
+		    x2t = min(x2, pbox->x2);
+		    if (x1t != x2t)
+		    {
+			iplHorzS (alu, and, xor,
+				  addrg, ngwidth, 
+				  x1t, y1, x2t-x1t);
+		    }
+		    nbox--;
+		    pbox++;
+		}
+	    }
+#ifndef POLYSEGMENT
+	    x2 = ppt->x + xorg;
+#endif
+	}
+	else	/* sloped line */
+	{
+	    CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy,
+			   1, 1, octant);
+
+	    if (adx > ady)
+	    {
+		axis = X_AXIS;
+		e1 = ady << 1;
+		e2 = e1 - (adx << 1);
+		e = e1 - adx;
+ 	    }
+	    else
+	    {
+		axis = Y_AXIS;
+		e1 = adx << 1;
+		e2 = e1 - (ady << 1);
+		e = e1 - ady;
+		SetYMajorOctant(octant);
+	    }
+
+	    FIXUP_ERROR(e, octant, bias);
+
+	    /* we have bresenham parameters and two points.
+	       all we have to do now is clip and draw.
+	    */
+
+	    while(nbox--)
+	    {
+		oc1 = 0;
+		oc2 = 0;
+		OUTCODES(oc1, x1, y1, pbox);
+		OUTCODES(oc2, x2, y2, pbox);
+		if ((oc1 | oc2) == 0)
+		{
+		    if (axis == X_AXIS)
+			len = adx;
+		    else
+			len = ady;
+#ifdef POLYSEGMENT
+		    if (pGC->capStyle != CapNotLast)
+			len++;
+#endif
+		    iplBresS (alu, and, xor,
+			  addrg, ngwidth,
+			  signdx, signdy, axis, x1, y1,
+			  e, e1, e2, len);
+		    break;
+		}
+		else if (oc1 & oc2)
+		{
+		    pbox++;
+		}
+		else
+		{
+		    int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
+		    int clip1 = 0, clip2 = 0;
+		    int clipdx, clipdy;
+		    int err;
+		    
+		    if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1,
+				       pbox->y2-1,
+				       &new_x1, &new_y1, &new_x2, &new_y2,
+				       adx, ady, &clip1, &clip2,
+				       octant, bias, oc1, oc2) == -1)
+		    {
+			pbox++;
+			continue;
+		    }
+
+		    if (axis == X_AXIS)
+			len = abs(new_x2 - new_x1);
+		    else
+			len = abs(new_y2 - new_y1);
+#ifdef POLYSEGMENT
+		    if (clip2 != 0 || pGC->capStyle != CapNotLast)
+			len++;
+#else
+		    len += (clip2 != 0);
+#endif
+		    if (len)
+		    {
+			/* unwind bresenham error term to first point */
+			if (clip1)
+			{
+			    clipdx = abs(new_x1 - x1);
+			    clipdy = abs(new_y1 - y1);
+			    if (axis == X_AXIS)
+				err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
+			    else
+				err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
+			}
+			else
+			    err = e;
+			    iplBresS(alu, and, xor,
+				     addrg, ngwidth,
+				     signdx, signdy, axis, new_x1, new_y1,
+				     err, e1, e2, len);
+		    }
+		    pbox++;
+		}
+	    } /* while (nbox--) */
+	} /* sloped line */
+    } /* while (nline--) */
+
+#ifndef POLYSEGMENT
+    /* paint the last point if the end style isn't CapNotLast.
+       (Assume that a projecting, butt, or round cap that is one
+        pixel wide is the same as the single pixel of the endpoint.)
+    */
+
+    if ((pGC->capStyle != CapNotLast) &&
+	((ppt->x + xorg != pptInit->x + pDrawable->x) ||
+	 (ppt->y + yorg != pptInit->y + pDrawable->y) ||
+	 (ppt == pptInit + 1)))
+    {
+	nbox = nboxInit;
+	pbox = pboxInit;
+	while (nbox--)
+	{
+	    if ((x2 >= pbox->x1) &&
+		(y2 >= pbox->y1) &&
+		(x2 <  pbox->x2) &&
+		(y2 <  pbox->y2))
+	    {
+		INTER_DECLAREG(mask);
+		INTER_DECLAREGP(temp);
+
+		mask = iplmask[x2 & INTER_PIM];
+		addrg += (y2 * ngwidth) + (x2 >> INTER_PGSH) * INTER_PLANES;
+		
+		INTER_DoRRop(addrg, and, xor, temp);
+		INTER_COPYM(temp, addrg, mask, addrg);
+		break;
+	    }
+	    else
+		pbox++;
+	}
+    }
+#endif
+}
+
+/*
+ * Draw dashed 1-pixel lines.
+ */
+
+void
+#ifdef POLYSEGMENT
+iplSegmentSD (pDrawable, pGC, nseg, pSeg)
+    DrawablePtr	pDrawable;
+    register GCPtr	pGC;
+    int		nseg;
+    register xSegment	*pSeg;
+#else
+iplLineSD( pDrawable, pGC, mode, npt, pptInit)
+    DrawablePtr pDrawable;
+    register GCPtr pGC;
+    int mode;		/* Origin or Previous */
+    int npt;		/* number of points */
+    DDXPointPtr pptInit;
+#endif
+{
+    int nboxInit;
+    register int nbox;
+    BoxPtr pboxInit;
+    register BoxPtr pbox;
+#ifndef POLYSEGMENT
+    register DDXPointPtr ppt;	/* pointer to list of translated points */
+#endif
+
+    register unsigned int oc1;		/* outcode of point 1 */
+    register unsigned int oc2;		/* outcode of point 2 */
+
+    INTER_DECLAREG(*addrg);	/* address of destination pixmap */
+    int ngwidth;		/* width in groups of destination pixmap */
+    int xorg, yorg;		/* origin of window */
+
+    int adx;		/* abs values of dx and dy */
+    int ady;
+    int signdx;		/* sign of dx and dy */
+    int signdy;
+    int e, e1, e2;		/* bresenham error and increments */
+    int len;			/* length of segment */
+    int axis;			/* major axis */
+    int octant;
+    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
+    int x1, x2, y1, y2;
+    RegionPtr cclip;
+    iplRRopRec	    rrops[2];
+    unsigned char   *pDash;
+    int		    dashOffset;
+    int		    numInDashList;
+    int		    dashIndex;
+    int		    isDoubleDash;
+    int		    dashIndexTmp, dashOffsetTmp;
+    int		    unclippedlen;
+    iplPrivGCPtr    devPriv;
+
+    devPriv = iplGetGCPrivate(pGC);
+    cclip = pGC->pCompositeClip;
+    rrops[0].rop = devPriv->rop;
+    INTER_COPY(devPriv->andg, rrops[0].andg)
+    INTER_COPY(devPriv->xorg, rrops[0].xorg)
+#if 0
+    if (pGC->alu == GXcopy)
+    {
+	rrops[1].rop = GXcopy;
+	rrops[1].and = 0;
+	rrops[1].xor = PFILL (pGC->bgPixel);
+    }
+    else
+#endif
+    {
+	rrops[1].rop = iplReduceRasterOp (pGC->alu, 
+					  pGC->bgPixel, pGC->planemask,
+					  rrops[1].andg, rrops[1].xorg);
+    }
+    pboxInit = REGION_RECTS(cclip);
+    nboxInit = REGION_NUM_RECTS(cclip);
+
+    iplGetGroupWidthAndPointer (pDrawable, ngwidth, addrg)
+
+    /* compute initial dash values */
+     
+    pDash = (unsigned char *) pGC->dash;
+    numInDashList = pGC->numInDashList;
+    isDoubleDash = (pGC->lineStyle == LineDoubleDash);
+    dashIndex = 0;
+    dashOffset = 0;
+    miStepDash ((int)pGC->dashOffset, &dashIndex, pDash,
+		numInDashList, &dashOffset);
+
+    xorg = pDrawable->x;
+    yorg = pDrawable->y;
+#ifdef POLYSEGMENT
+    while (nseg--)
+#else
+    ppt = pptInit;
+    x2 = ppt->x + xorg;
+    y2 = ppt->y + yorg;
+    while(--npt)
+#endif
+    {
+	nbox = nboxInit;
+	pbox = pboxInit;
+
+#ifdef POLYSEGMENT
+	x1 = pSeg->x1 + xorg;
+	y1 = pSeg->y1 + yorg;
+	x2 = pSeg->x2 + xorg;
+	y2 = pSeg->y2 + yorg;
+	pSeg++;
+#else
+	x1 = x2;
+	y1 = y2;
+	++ppt;
+	if (mode == CoordModePrevious)
+	{
+	    xorg = x1;
+	    yorg = y1;
+	}
+	x2 = ppt->x + xorg;
+	y2 = ppt->y + yorg;
+#endif
+
+	CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy, 1, 1, octant);
+
+	if (adx > ady)
+	{
+	    axis = X_AXIS;
+	    e1 = ady << 1;
+	    e2 = e1 - (adx << 1);
+	    e = e1 - adx;
+	    unclippedlen = adx;
+	}
+	else
+	{
+	    axis = Y_AXIS;
+	    e1 = adx << 1;
+	    e2 = e1 - (ady << 1);
+	    e = e1 - ady;
+	    unclippedlen = ady;
+	    SetYMajorOctant(octant);
+	}
+
+	FIXUP_ERROR(e, octant, bias);
+
+	/* we have bresenham parameters and two points.
+	   all we have to do now is clip and draw.
+	*/
+
+	while(nbox--)
+	{
+	    oc1 = 0;
+	    oc2 = 0;
+	    OUTCODES(oc1, x1, y1, pbox);
+	    OUTCODES(oc2, x2, y2, pbox);
+	    if ((oc1 | oc2) == 0)
+	    {
+#ifdef POLYSEGMENT
+		if (pGC->capStyle != CapNotLast)
+		    unclippedlen++;
+		dashIndexTmp = dashIndex;
+		dashOffsetTmp = dashOffset;
+		iplBresD (rrops,
+		      &dashIndexTmp, pDash, numInDashList,
+		      &dashOffsetTmp, isDoubleDash,
+		      addrg, ngwidth,
+		      signdx, signdy, axis, x1, y1,
+		      e, e1, e2, unclippedlen);
+		break;
+#else
+		iplBresD (rrops,
+		      &dashIndex, pDash, numInDashList,
+		      &dashOffset, isDoubleDash,
+		      addrg, ngwidth,
+		      signdx, signdy, axis, x1, y1,
+		      e, e1, e2, unclippedlen);
+		goto dontStep;
+#endif
+	    }
+	    else if (oc1 & oc2)
+	    {
+		pbox++;
+	    }
+	    else /* have to clip */
+	    {
+		int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
+		int clip1 = 0, clip2 = 0;
+		int clipdx, clipdy;
+		int err;
+		int dashIndexTmp, dashOffsetTmp;
+		
+		if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1,
+				   pbox->y2-1,
+				   &new_x1, &new_y1, &new_x2, &new_y2,
+				   adx, ady, &clip1, &clip2,
+				   octant, bias, oc1, oc2) == -1)
+		{
+		    pbox++;
+		    continue;
+		}
+
+		dashIndexTmp = dashIndex;
+		dashOffsetTmp = dashOffset;
+
+		if (clip1)
+		{
+		    int dlen;
+    
+		    if (axis == X_AXIS)
+			dlen = abs(new_x1 - x1);
+		    else
+			dlen = abs(new_y1 - y1);
+		    miStepDash (dlen, &dashIndexTmp, pDash,
+				numInDashList, &dashOffsetTmp);
+		}
+		
+		if (axis == X_AXIS)
+		    len = abs(new_x2 - new_x1);
+		else
+		    len = abs(new_y2 - new_y1);
+#ifdef POLYSEGMENT
+		if (clip2 != 0 || pGC->capStyle != CapNotLast)
+		    len++;
+#else
+		len += (clip2 != 0);
+#endif
+		if (len)
+		{
+		    /* unwind bresenham error term to first point */
+		    if (clip1)
+		    {
+			clipdx = abs(new_x1 - x1);
+			clipdy = abs(new_y1 - y1);
+			if (axis == X_AXIS)
+			    err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
+			else
+			    err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
+		    }
+		    else
+			err = e;
+		    iplBresD (rrops,
+			      &dashIndexTmp, pDash, numInDashList,
+			      &dashOffsetTmp, isDoubleDash,
+			      addrg, ngwidth,
+			      signdx, signdy, axis, new_x1, new_y1,
+			      err, e1, e2, len);
+		}
+		pbox++;
+	    }
+	} /* while (nbox--) */
+#ifndef POLYSEGMENT
+	/*
+	 * walk the dash list around to the next line
+	 */
+	miStepDash (unclippedlen, &dashIndex, pDash,
+		    numInDashList, &dashOffset);
+dontStep:	;
+#endif
+    } /* while (nline--) */
+
+#ifndef POLYSEGMENT
+    /* paint the last point if the end style isn't CapNotLast.
+       (Assume that a projecting, butt, or round cap that is one
+        pixel wide is the same as the single pixel of the endpoint.)
+    */
+
+    if ((pGC->capStyle != CapNotLast) &&
+        ((dashIndex & 1) == 0 || isDoubleDash) &&
+	((ppt->x + xorg != pptInit->x + pDrawable->x) ||
+	 (ppt->y + yorg != pptInit->y + pDrawable->y) ||
+	 (ppt == pptInit + 1)))
+    {
+	nbox = nboxInit;
+	pbox = pboxInit;
+	while (nbox--)
+	{
+	    if ((x2 >= pbox->x1) &&
+		(y2 >= pbox->y1) &&
+		(x2 <  pbox->x2) &&
+		(y2 <  pbox->y2))
+	    {
+		INTER_DECLAREG(mask);
+		int		pix;
+
+		pix = 0;
+		if (dashIndex & 1)
+		    pix = 1;
+		mask = iplmask[x2 & INTER_PIM];
+		addrg += (y2 * ngwidth) + (x2 >> INTER_PGSH) * INTER_PLANES;
+		INTER_DoMaskRRop(addrg, rrops[pix].andg, rrops[pix].xorg,
+				 mask, addrg);
+		break;
+	    }
+	    else
+		pbox++;
+	}
+    }
+#endif
+}
diff --git a/iplan2p4/iplmap.h b/iplan2p4/iplmap.h
new file mode 100644
index 000000000..2e0a2b3cc
--- /dev/null
+++ b/iplan2p4/iplmap.h
@@ -0,0 +1,172 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplmap.h,v 3.2 2001/07/25 15:05:09 dawes Exp $ */
+/*
+ * $XConsortium: iplmap.h,v 1.9 94/04/17 20:28:54 dpw Exp $
+ *
+Copyright (c) 1991  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+/*
+ * Map names around so that multiple depths can be supported simultaneously
+ */
+
+/* a losing vendor cpp dumps core if we define NAME in terms of CATNAME */
+
+#if INTER_PLANES == 2
+#define NAME(subname) ipl2p2##subname
+#elif INTER_PLANES == 4
+#define NAME(subname) ipl2p4##subname
+#elif INTER_PLANES == 8
+#define NAME(subname) ipl2p8##subname
+#endif
+
+
+#if !defined(UNIXCPP) || defined(ANSICPP)
+#define CATNAME(prefix,subname) prefix##subname
+#else
+#define CATNAME(prefix,subname) prefix/**/subname
+#endif
+
+#define iplScreenPrivateIndex NAME(ScreenPrivateIndex)
+#define QuartetBitsTable NAME(QuartetBitsTable)
+#define QuartetPixelMaskTable NAME(QuartetPixelMaskTable)
+#define iplAllocatePrivates NAME(AllocatePrivates)
+#define iplBSFuncRec NAME(BSFuncRec)
+#define iplBitBlt NAME(BitBlt)
+#define iplBresD NAME(BresD)
+#define iplBresS NAME(BresS)
+#define iplChangeWindowAttributes NAME(ChangeWindowAttributes)
+#define iplCloseScreen NAME(CloseScreen)
+#define iplCopyArea NAME(CopyArea)
+#define iplCopyImagePlane NAME(CopyImagePlane)
+#define iplCopyPixmap NAME(CopyPixmap)
+#define iplCopyPlane NAME(CopyPlane)
+#define iplCopyRotatePixmap NAME(CopyRotatePixmap)
+#define iplCopyWindow NAME(CopyWindow)
+#define iplCreateGC NAME(CreateGC)
+#define iplCreatePixmap NAME(CreatePixmap)
+#define iplCreateWindow NAME(CreateWindow)
+#define iplCreateScreenResources NAME(CreateScreenResoures)
+#define iplDestroyPixmap NAME(DestroyPixmap)
+#define iplDestroyWindow NAME(DestroyWindow)
+#define iplDoBitblt NAME(DoBitblt)
+#define iplDoBitbltCopy NAME(DoBitbltCopy)
+#define iplDoBitbltGeneral NAME(DoBitbltGeneral)
+#define iplDoBitbltOr NAME(DoBitbltOr)
+#define iplDoBitbltXor NAME(DoBitbltXor)
+#define iplFillBoxSolid NAME(FillBoxSolid)
+#define iplFillBoxTile32 NAME(FillBoxTile32)
+#define iplFillBoxTile32sCopy NAME(FillBoxTile32sCopy)
+#define iplFillBoxTile32sGeneral NAME(FillBoxTile32sGeneral)
+#define iplFillBoxTileOdd NAME(FillBoxTileOdd)
+#define iplFillBoxTileOddCopy NAME(FillBoxTileOddCopy)
+#define iplFillBoxTileOddGeneral NAME(FillBoxTileOddGeneral)
+#define iplFillPoly1RectCopy NAME(FillPoly1RectCopy)
+#define iplFillPoly1RectGeneral NAME(FillPoly1RectGeneral)
+#define iplFillRectSolidCopy NAME(FillRectSolidCopy)
+#define iplFillRectSolidGeneral NAME(FillRectSolidGeneral)
+#define iplFillRectSolidXor NAME(FillRectSolidXor)
+#define iplFillRectTile32Copy NAME(FillRectTile32Copy)
+#define iplFillRectTile32General NAME(FillRectTile32General)
+#define iplFillRectTileOdd NAME(FillRectTileOdd)
+#define iplFillSpanTile32sCopy NAME(FillSpanTile32sCopy)
+#define iplFillSpanTile32sGeneral NAME(FillSpanTile32sGeneral)
+#define iplFillSpanTileOddCopy NAME(FillSpanTileOddCopy)
+#define iplFillSpanTileOddGeneral NAME(FillSpanTileOddGeneral)
+#define iplFinishScreenInit NAME(FinishScreenInit)
+#define iplGCFuncs NAME(GCFuncs)
+#define iplGetImage NAME(GetImage)
+#define iplGetScreenPixmap NAME(GetScreenPixmap)
+#define iplGetSpans NAME(GetSpans)
+#define iplHorzS NAME(HorzS)
+#define iplImageGlyphBlt8 NAME(ImageGlyphBlt8)
+#define iplLineSD NAME(LineSD)
+#define iplLineSS NAME(LineSS)
+#define iplMapWindow NAME(MapWindow)
+#define iplMatchCommon NAME(MatchCommon)
+#define iplNonTEOps NAME(NonTEOps)
+#define iplNonTEOps1Rect NAME(NonTEOps1Rect)
+#define iplPadPixmap NAME(PadPixmap)
+#define iplPaintWindow NAME(PaintWindow)
+#define iplPolyGlyphBlt8 NAME(PolyGlyphBlt8)
+#define iplPolyGlyphRop8 NAME(PolyGlyphRop8)
+#define iplPolyFillArcSolidCopy NAME(PolyFillArcSolidCopy)
+#define iplPolyFillArcSolidGeneral NAME(PolyFillArcSolidGeneral)
+#define iplPolyFillRect NAME(PolyFillRect)
+#define iplPolyPoint NAME(PolyPoint)
+#define iplPositionWindow NAME(PositionWindow)
+#define iplPutImage NAME(PutImage)
+#define iplReduceRasterOp NAME(ReduceRasterOp)
+#define iplRestoreAreas NAME(RestoreAreas)
+#define iplSaveAreas NAME(SaveAreas)
+#define iplScreenInit NAME(ScreenInit)
+#define iplSegmentSD NAME(SegmentSD)
+#define iplSegmentSS NAME(SegmentSS)
+#define iplSetScanline NAME(SetScanline)
+#define iplSetScreenPixmap NAME(SetScreenPixmap)
+#define iplSetSpans NAME(SetSpans)
+#define iplSetupScreen NAME(SetupScreen)
+#define iplSolidSpansCopy NAME(SolidSpansCopy)
+#define iplSolidSpansGeneral NAME(SolidSpansGeneral)
+#define iplSolidSpansXor NAME(SolidSpansXor)
+#define iplStippleStack NAME(StippleStack)
+#define iplStippleStackTE NAME(StippleStackTE)
+#define iplTEGlyphBlt NAME(TEGlyphBlt)
+#define iplTEOps NAME(TEOps)
+#define iplTEOps1Rect NAME(TEOps1Rect)
+#define iplTile32FSCopy NAME(Tile32FSCopy)
+#define iplTile32FSGeneral NAME(Tile32FSGeneral)
+#define iplUnmapWindow NAME(UnmapWindow)
+#define iplUnnaturalStippleFS NAME(UnnaturalStippleFS)
+#define iplUnnaturalTileFS NAME(UnnaturalTileFS)
+#define iplValidateGC NAME(ValidateGC)
+#define iplVertS NAME(VertS)
+#define iplXRotatePixmap NAME(XRotatePixmap)
+#define iplYRotatePixmap NAME(YRotatePixmap)
+#define iplendpartial NAME(endpartial)
+#define iplendtab NAME(endtab)
+#define iplmask NAME(mask)
+#define iplrmask NAME(rmask)
+#define iplstartpartial NAME(startpartial)
+#define iplstarttab NAME(starttab)
+#define ipl8LineSS1Rect NAME(LineSS1Rect)
+#define ipl8SegmentSS1Rect NAME(SegmentSS1Rect)
+#define ipl8ClippedLineCopy NAME(ClippedLineCopy)
+#define ipl8ClippedLineXor NAME(ClippedLineXor)
+#define ipl8ClippedLineGeneral  NAME(ClippedLineGeneral )
+#define ipl8SegmentSS1RectCopy NAME(SegmentSS1RectCopy)
+#define ipl8SegmentSS1RectXor NAME(SegmentSS1RectXor)
+#define ipl8SegmentSS1RectGeneral  NAME(SegmentSS1RectGeneral )
+#define ipl8SegmentSS1RectShiftCopy NAME(SegmentSS1RectShiftCopy)
+#define ipl8LineSS1RectCopy NAME(LineSS1RectCopy)
+#define ipl8LineSS1RectXor NAME(LineSS1RectXor)
+#define ipl8LineSS1RectGeneral  NAME(LineSS1RectGeneral )
+#define ipl8LineSS1RectPreviousCopy NAME(LineSS1RectPreviousCopy)
+#define iplZeroPolyArcSS8Copy NAME(ZeroPolyArcSSCopy)
+#define iplZeroPolyArcSS8Xor NAME(ZeroPolyArcSSXor)
+#define iplZeroPolyArcSS8General NAME(ZeroPolyArcSSGeneral)
diff --git a/iplan2p4/iplmergerop.h b/iplan2p4/iplmergerop.h
new file mode 100644
index 000000000..fa537d3a7
--- /dev/null
+++ b/iplan2p4/iplmergerop.h
@@ -0,0 +1,142 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplmergerop.h,v 3.1 2001/07/25 15:05:09 dawes Exp $ */
+#ifndef _IPLANMERGEROP_H_
+#define _IPLANMERGEROP_H_
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+/* defines: 
+   INTER_MROP_NAME
+   INTER_MROP_DECLARE_REG()
+   INTER_MROP_INITIALIZE(alu, pm)
+   INTER_MROP_SOLID(src1, src2, dst)
+   INTER_MROP_MASK(src1, src2, mask, dst)
+   INTER_MROP_PREBUILD(src)
+   INTER_MROP_PREBUILT_DECLARE()
+   INTER_MROP_PREBUILT_SOLID(src,dst)
+   INTER_MROP_PREBUILT_MASK(src,dst,mask)
+*/
+ 
+#ifndef GXcopy
+#include "X.h"
+#endif
+
+typedef struct _mergeRopBits {
+    unsigned long   ca1, cx1, ca2, cx2;
+} mergeRopRec, *mergeRopPtr;
+
+extern mergeRopRec	mergeRopBits[16];
+
+#define INTER_DeclareMergeRop() \
+	INTER_DECLAREGP(_ca1);	\
+	INTER_DECLAREGP(_cx1);	\
+	INTER_DECLAREGP(_ca2);	\
+	INTER_DECLAREGP(_cx2);	
+
+#define INTER_DeclarePrebuiltMergeRop() \
+	INTER_DECLAREGP(_cca);  	\
+	INTER_DECLAREGP(_ccx);
+	
+#define INTER_InitializeMergeRop(alu,pm) {	\
+    INTER_DECLAREGP(_pm);			\
+    mergeRopPtr  _bits; 			\
+    INTER_PFILL(pm, _pm);			\
+    _bits = &mergeRopBits[alu];			\
+    INTER_ANDMSK(_pm, _bits->ca1, _ca1);	\
+    INTER_ANDMSK(_pm, _bits->ca2, _ca2);	\
+    INTER_ANDMSK(_pm, _bits->cx2, _cx2);	\
+    INTER_NOT(_pm, _pm);			\
+    INTER_ORMSK(_pm, _bits->cx1, _cx1);		\
+}
+
+#define INTER_DoMergeRop(src1, src2, dst) \
+	INTER_CPLX(src1, src2, _ca1, _cx1, _ca2, _cx2, dst)
+
+#define INTER_DoMaskMergeRop(src1, src2, mask, dst) \
+	INTER_CPLXM(src1, src2, _ca1, _cx1, _ca2, _cx2, mask, dst)
+
+#define INTER_DoPrebuiltMergeRop(src, dst) \
+	INTER_DoRRop(src, _cca, _ccx, dst)
+
+#define INTER_DoMaskPrebuiltMergeRop(src, mask, dst) \
+	INTER_DoMaskRRop(src, _cca, _ccx, mask, dst)
+
+#define INTER_PrebuildMergeRop(src) 		\
+	INTER_DoRRop(src, _ca1, _cx1, _cca);  	\
+	INTER_DoRRop(src, _ca2, _cx2, _ccx);
+
+#ifndef MROP
+#define MROP 0
+#endif
+
+#define Mclear		(1<<GXclear)
+#define Mand		(1<<GXand)
+#define MandReverse	(1<<GXandReverse)
+#define Mcopy		(1<<GXcopy)
+#define MandInverted	(1<<GXandInverted)
+#define Mnoop		(1<<GXnoop)
+#define Mxor		(1<<GXxor)
+#define Mor		(1<<GXor)
+#define Mnor		(1<<GXnor)
+#define Mequiv		(1<<GXequiv)
+#define Minvert		(1<<GXinvert)
+#define MorReverse	(1<<GXorReverse)
+#define McopyInverted	(1<<GXcopyInverted)
+#define MorInverted	(1<<GXorInverted)
+#define Mnand		(1<<GXnand)
+#define Mset		(1<<GXset)
+
+#if (MROP) == Mcopy
+#define INTER_MROP_NAME(prefix) INTER_MROP_NAME_CAT(prefix,Copy)
+#define INTER_MROP_DECLARE_REG()
+#define INTER_MROP_INITIALIZE(alu,pm)
+#define INTER_MROP_SOLID(src,dst,dst2) INTER_COPY(src, dst2)
+#define INTER_MROP_MASK(src,dst,mask, dst2) INTER_COPYM(src,dst,mask,dst2)
+#endif
+
+#if (MROP) == Mxor
+#define INTER_MROP_NAME(prefix) INTER_MROP_NAME_CAT(prefix,Xor)
+#define INTER_MROP_DECLARE_REG()
+#define INTER_MROP_INITIALIZE(alu,pm)
+#define INTER_MROP_SOLID(src,dst,dst2)	INTER_XOR(src,dst,dst2)
+#define INTER_MROP_MASK(src,dst,mask,dst2) INTER_XORM(src,dst,mask,dst2)
+#endif
+
+#if (MROP) == Mor
+#define INTER_MROP_NAME(prefix) INTER_MROP_NAME_CAT(prefix,Or)
+#define INTER_MROP_DECLARE_REG()
+#define INTER_MROP_INITIALIZE(alu,pm)
+#define INTER_MROP_SOLID(src,dst,dst2)	INTER_OR(src,dst,dst2)
+#define INTER_MROP_MASK(src,dst,mask,dst2) INTER_ORM(src,dst,mask,dst2)
+#endif
+
+#if (MROP) == 0
+#define INTER_MROP_NAME(prefix) INTER_MROP_NAME_CAT(prefix,General)
+#define INTER_MROP_DECLARE_REG() INTER_DeclareMergeRop()
+#define INTER_MROP_INITIALIZE(alu,pm) INTER_InitializeMergeRop(alu,pm)
+#define INTER_MROP_SOLID(src,dst,dst2) INTER_DoMergeRop(src, dst, dst2)
+#define INTER_MROP_MASK(src,dst,mask,dst2) \
+	INTER_DoMaskMergeRop(src, dst, mask, dst2)
+#define INTER_MROP_PREBUILD(src) INTER_PrebuildMergeRop(src)
+#define INTER_MROP_PREBUILT_DECLARE() INTER_DeclarePrebuiltMergeRop()
+#define INTER_MROP_PREBUILT_SOLID(src,dst, dst2) \
+	INTER_DoPrebuiltMergeRop(dst,dst2)
+#define INTER_MROP_PREBUILT_MASK(src,dst,mask,dst2) \
+	INTER_DoMaskPrebuiltMergeRop(dst,mask, dst2)
+#endif
+
+#ifndef INTER_MROP_PREBUILD
+#define INTER_MROP_PREBUILD(src)
+#define INTER_MROP_PREBUILT_DECLARE()
+#define INTER_MROP_PREBUILT_SOLID(src,dst,dst2)	INTER_MROP_SOLID(src,dst,dst2)
+#define INTER_MROP_PREBUILT_MASK(src,dst,mask,dst2) \
+	INTER_MROP_MASK(src,dst,mask,dst2)
+#endif
+
+#if !defined(UNIXCPP) || defined(ANSICPP)
+#define INTER_MROP_NAME_CAT(prefix,suffix)	prefix##suffix
+#else
+#define INTER_MROP_NAME_CAT(prefix,suffix)	prefix/**/suffix
+#endif
+
+#endif /* _IPLANMERGEROP_H_ */
diff --git a/iplan2p4/iplmskbits.c b/iplan2p4/iplmskbits.c
new file mode 100644
index 000000000..9f1d37dfb
--- /dev/null
+++ b/iplan2p4/iplmskbits.c
@@ -0,0 +1,104 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplmskbits.c,v 3.0 1996/08/18 01:54:54 dawes Exp $ */
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+#include "iplmap.h"
+
+unsigned short iplmask[] =
+	{	0x8000,
+		0x4000,
+		0x2000,
+		0x1000,
+		0x0800,	
+		0x0400,
+		0x0200,
+		0x0100,
+		0x0080,	
+		0x0040,
+		0x0020,
+		0x0010,
+		0x0008,	
+		0x0004,
+		0x0002,
+		0x0001
+	};
+
+unsigned short iplstarttab[] =
+	{
+		0x0000,
+		0x7fff,
+		0x3fff,
+		0x1fff,
+		0x0fff,
+		0x07ff,
+		0x03ff,
+		0x01ff,
+		0x00ff,
+		0x007f,
+		0x003f,
+		0x001f,
+		0x000f,
+		0x0007,
+		0x0003,
+		0x0001
+	};
+			
+unsigned short iplendtab[] =
+	{
+		0x0000,
+		0x8000,
+		0xc000,
+		0xe000,
+		0xf000,
+		0xf800,
+		0xfc00,
+		0xfe00,
+		0xff00,
+		0xff80,
+		0xffc0,
+		0xffe0,
+		0xfff0,
+		0xfff8,
+		0xfffc,
+		0xfffe
+	};
+
+unsigned short iplstartpartial[] =
+	{
+		0xffff,
+		0x7fff,
+		0x3fff,
+		0x1fff,
+		0x0fff,
+		0x07ff,
+		0x03ff,
+		0x01ff,
+		0x00ff,
+		0x007f,
+		0x003f,
+		0x001f,
+		0x000f,
+		0x0007,
+		0x0003,
+		0x0001
+	};
+
+unsigned short iplendpartial[] =
+	{
+		0xffff,
+		0x8000,
+		0xc000,
+		0xe000,
+		0xf000,
+		0xf800,
+		0xfc00,
+		0xfe00,
+		0xff00,
+		0xff80,
+		0xffc0,
+		0xffe0,
+		0xfff0,
+		0xfff8,
+		0xfffc,
+		0xfffe
+	};
+
diff --git a/iplan2p4/iplmskbits.h b/iplan2p4/iplmskbits.h
new file mode 100644
index 000000000..4fb3fe066
--- /dev/null
+++ b/iplan2p4/iplmskbits.h
@@ -0,0 +1,496 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplmskbits.h,v 3.0 1996/08/18 01:54:55 dawes Exp $ */
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#define INTER_PIXGRP unsigned short
+
+#define INTER_PGSZ	   16
+#define INTER_PGSZB	    2
+#define INTER_PPG	   16
+#define INTER_PPGMSK   0xffff
+#define INTER_PLST	   15
+#define INTER_PIM	   15
+#define INTER_PGSH	    4
+#define INTER_PMSK ((1 << (INTER_PLANES)) - 1)
+
+extern INTER_PIXGRP iplmask[];
+extern INTER_PIXGRP iplstarttab[];
+extern INTER_PIXGRP iplendtab[];
+extern INTER_PIXGRP iplstartpartial[];
+extern INTER_PIXGRP iplendpartial[];
+
+#define MFB_PSZ		    1
+
+#define INTER_NEXT(x) ((x) + INTER_PLANES)
+#define INTER_NEXT_GROUP(x) (x) += INTER_PLANES
+#define INTER_PREV_GROUP(x) (x) -= INTER_PLANES
+
+#define _I(x)	(((unsigned long *) (x))[_INDEX])
+#define _IG(x)  ((x)[_INDEX])
+
+#define INTER_DECLAREG(x) INTER_PIXGRP x
+#define INTER_DECLAREGP(x) INTER_PIXGRP x[INTER_PLANES]
+
+#define INTER_DECLARERRAX(x) INTER_PIXGRP *(x)
+#define INTER_DECLARERRAXP(x) INTER_PIXGRP x[INTER_PLANES]
+
+/* and |= PLANE_FILL(~fg), or &= PLANE_FILL(fg) */ 
+#define INTER_ANDXOR_PM(pm, and, xor)					\
+	PLANE_TIMESG(							\
+	if (!(pm & INTER_PLANE(_INDEX))) {				\
+		_IG(and) = INTER_PPGMSK;				\
+		_IG(xor) = 0;						\
+	})
+
+#if INTER_PLANES == 2
+
+#define PLANE_TIMESCONDG(x)					\
+	({	int _INDEX;					\
+		int _ret;					\
+		_ret=(_INDEX=0, (x)) &&				\
+		     (_INDEX=1, (x)) &&				\
+		_ret;						\
+	})
+
+#define PLANE_TIMESCOND(x)					\
+	({	int _INDEX;					\
+		(_INDEX=0, x)					\
+	})
+
+#define PLANE_TIMESG(x)						\
+	{	int _INDEX;					\
+		_INDEX=0; x;					\
+		_INDEX=1; x;					\
+	}
+
+#define PLANE_TIMES(x)						\
+	{	int _INDEX;					\
+		_INDEX=0; x;					\
+	}	
+
+#elif INTER_PLANES == 4
+
+#define PLANE_TIMESCONDG(x)					\
+	({	int _INDEX;					\
+		int _ret;					\
+		_ret=(_INDEX=0, (x)) &&				\
+		     (_INDEX=1, (x)) &&				\
+		     (_INDEX=2, (x)) &&				\
+		     (_INDEX=3, (x)); 				\
+		_ret;						\
+	})
+
+#define PLANE_TIMESCOND(x)					\
+	({	int _INDEX;					\
+		((_INDEX=0, x) &&				\
+		(_INDEX=1, x))					\
+	})
+
+#define PLANE_TIMESG(x)						\
+	{	int _INDEX;					\
+		_INDEX=0; x;					\
+		_INDEX=1; x;					\
+		_INDEX=2; x;					\
+		_INDEX=3; x;					\
+	}
+
+#define PLANE_TIMES(x)						\
+	{	int _INDEX;					\
+		_INDEX=0; x;					\
+		_INDEX=1; x;					\
+	}	
+
+#elif INTER_PLANES == 8
+
+#define PLANE_TIMESCONDG(x)					\
+	({	int _INDEX;					\
+		int _ret;					\
+		_ret=((_INDEX=0, (x)) &&				\
+		     (_INDEX=1, (x)) &&				\
+		     (_INDEX=2, (x)) &&				\
+		     (_INDEX=3, (x)) &&				\
+		     (_INDEX=4, (x)) &&				\
+		     (_INDEX=5, (x)) &&				\
+		     (_INDEX=6, (x)) &&				\
+		     (_INDEX=7, (x))); 				\
+		_ret;						\
+	})
+
+#define PLANE_TIMESCOND(x)					\
+	({	int _INDEX;					\
+		((_INDEX=0, x) &&				\
+		 (_INDEX=1, x) &&				\
+		 (_INDEX=2, x) &&				\
+		 (_INDEX=3, x))					\
+	})
+
+#define PLANE_TIMESG(x)						\
+	{	int _INDEX;					\
+		_INDEX=0; x;					\
+		_INDEX=1; x;					\
+		_INDEX=2; x;					\
+		_INDEX=3; x;					\
+		_INDEX=4; x;					\
+		_INDEX=5; x;					\
+		_INDEX=6; x;					\
+		_INDEX=7; x;					\
+	}
+
+#define PLANE_TIMES(x)						\
+	{	int _INDEX;					\
+		_INDEX=0; x;					\
+		_INDEX=1; x;					\
+		_INDEX=2; x;					\
+		_INDEX=3; x;					\
+	}	
+
+#endif
+
+/* src = 0 */
+#define INTER_IS_CLR(src)					\
+	PLANE_TIMESCONDG(_IG(src) == 0)	
+
+/* src = PPGMSK ? */
+#define INTER_IS_SET(src)					\
+	PLANE_TIMESCONDG(_IG(src) == INTER_PPGMSK)
+
+/* (src1 ^ scr2) = PPGMSK ? */
+#define INTER_IS_XOR_SET(src1, src2)				\
+	PLANE_TIMESCONDG((_IG(src1) ^ _IG(src2)) == INTER_PPGMSK) 
+
+/* dst = ~src */
+#define INTER_NOT(src, dst)					\
+	PLANE_TIMES(_I(dst) = ~_I(src))
+
+/* dst = 0 */
+#define INTER_CLR(dst)						\
+	PLANE_TIMES(_I(dst) = 0)
+
+/* dst = PPGMSK */
+#define INTER_SET(dst)						\
+	PLANE_TIMESG(_IG(dst) = INTER_PPGMSK)
+
+/* dst = src */
+#define INTER_COPY(src,dst)					\
+	PLANE_TIMES(_I(dst) = _I(src))
+
+/* dst2 = (dst & ~mask) | (src & mask) */
+#define INTER_COPYM(src,dst,mask,dst2)					\
+	PLANE_TIMESG(							\
+	    _IG(dst2) = (_IG(dst) & ~mask) | (_IG(src) & mask) 		\
+	)
+
+/* dst2 = dst ^ src */
+#define INTER_XOR(src,dst,dst2)					\
+	PLANE_TIMES(_I(dst2) = _I(dst) ^ _I(src))  
+
+/* dst2 = dst ^ (src & mask) */
+#define INTER_XORM(src,dst,mask,dst2)				\
+	PLANE_TIMESG(_IG(dst2) = _IG(dst) ^ (_IG(src) & (mask))) 
+
+/* dst2 = dst & src */
+#define INTER_AND(src,dst,dst2)					\
+	PLANE_TIMES(_I(dst2) = _I(dst) & _I(src))  
+
+/* dst2 = dst & (src | ~mask) */
+#define INTER_ANDM(mask,src,dst,dst2)				\
+	PLANE_TIMESG(_IG(dst2) = _IG(dst) & (_IG(src) | ~(mask)))
+
+/* dst2 = dst | src */
+#define INTER_OR(src,dst,dst2) 					\
+	PLANE_TIMES(_I(dst2) = _I(dst) | _I(src))  
+
+/* dst2 = dst | (src & mask) */
+#define INTER_ORM(src,dst,mask,dst2)				\
+	PLANE_TIMESG(_IG(dst2) = _IG(dst) | (_IG(src)  & (mask)))
+
+/* dst = src | msk */
+#define INTER_ORMSK(src,msk,dst)				\
+	PLANE_TIMESG(_IG(dst) = _IG(src) | (msk))
+
+/* dst = src & msk */
+#define INTER_ANDMSK(src,msk,dst)				\
+	PLANE_TIMESG(_IG(dst) = _IG(src) & (msk))
+
+/* dst = (src1 & msk1) | (src2 & msk2) */
+#define INTER_ANDMSK2(src1,msk1,src2,msk2,dst)			\
+	PLANE_TIMESG(_IG(dst) = (_IG(src1) & (msk1)) | (_IG(src2) & (msk2)))
+
+#define INTER_PLANE(x)	(1<<(x))
+
+#define INTER_PFILL(col, fill)					\
+	PLANE_TIMESG(_IG(fill) = 				\
+		((col) & INTER_PLANE(_INDEX)) ? INTER_PPGMSK : 0)
+
+/* dst = src >> cnt */
+#define INTER_SCRRIGHT(cnt, src, dst)				\
+	PLANE_TIMESG(_IG(dst) = _IG(src) >> (cnt))
+	
+/* dst = src << cnt */
+#define INTER_SCRLEFT(cnt, src, dst)				\
+	PLANE_TIMESG(_IG(dst) = _IG(src) << (cnt))
+
+/* bits1=(bits >> right) | (bits=psrc) << left) */
+#define INTER_GETRLC(right, left, psrc, bits, bits1)		\
+	PLANE_TIMESG( _IG(bits1)=(_IG(bits) >> (right)) | 	\
+	((_IG(bits) = _IG(psrc)) << (left)))
+
+/* bits1=(bits << left) | (bits=psrc) >> right) */
+#define INTER_GETLRC(left, right, psrc, bits, bits1)		\
+	PLANE_TIMESG( _IG(bits1)=(_IG(bits) << (left)) |	\
+	((_IG(bits) = _IG(psrc)) >> (right))) 
+
+/* dst=src2 & (src1 & a1 ^ x1) ^ (src1 & a2 ^ x2) */
+#define INTER_CPLX(src1, src2, a1, x1, a2, x2, dst) 	\
+	PLANE_TIMES( _I(dst) = (_I(src2) 		\
+	& (_I(src1) & _I(a1) ^ _I(x1))			\
+	^ (_I(src1) & _I(a2) ^ _I(x2))))		\
+
+/* dst=src2 & ((src1 & a1 ^ x1) | ~mask) ^ ((src1 & a2 ^ x2) & mask) */
+#define INTER_CPLXM(src1, src2, a1, x1, a2, x2, mask, dst) 	\
+	PLANE_TIMESG( _IG(dst) = (_IG(src2)			\
+	& ((_IG(src1) & _IG(a1) ^ _IG(x1)) | ~mask)		\
+	^ ((_IG(src1) & _IG(a2) ^ _IG(x2)) & mask)))
+
+/* dst = (src & ~(bitmask | planemask)) | (insert | (bitmask | planemask)) */
+#define INTER_PMSKINS(bitmask, planemask, insert, src, dst)		\
+	PLANE_TIMESG(							\
+    	if (planemask & INTER_PLANE(_INDEX)) 				\
+	    _IG(dst) = (_IG(src) & ~bitmask) | (_IG(insert) & bitmask) 	\
+	)
+
+/* dst = (src & ~bitmask) | ((insert >> shift) & bitmask) */
+#define INTER_SCRRMSKINS(bitmask, planemask, insert, shift, src, dst)	\
+	PLANE_TIMESG(							\
+    	if (planemask & INTER_PLANE(_INDEX)) 				\
+	    _IG(dst) = (_IG(src) & ~(bitmask)) | 			\
+		((_IG(insert) >> shift) & (bitmask)) 			\
+	)
+
+/* dst = (src & ~bitmask) | ((insert << shift) & bitmask) */
+#define INTER_SCRLMSKINS(bitmask, planemask, insert, shift, src, dst)	\
+	PLANE_TIMESG(							\
+    	if (planemask & INTER_PLANE(_INDEX)) 				\
+	    _IG(dst) = (_IG(src) & ~bitmask) | 				\
+		((_IG(insert) << shift) & bitmask) 			\
+	)
+
+/* dst = ((src1 << sl1) & bitmask1) | ((src2 >> sr2) & bitmask2) */  
+#define INTER_MSKINSM(bitmask1, sl1, src1, bitmask2, sr2, src2, dst)	\
+	PLANE_TIMESG(							\
+	    _IG(dst) = ((_IG(src1) << sl1) & (bitmask1)) |		\
+	    		    ((_IG(src2) >> sr2) & (bitmask2))		\
+	)
+
+/* dst = src & and ^ xor */
+#define INTER_DoRRop(src, and, xor, dst)				\
+	PLANE_TIMES(_I(dst) = (_I(src) & _I(and) ^ _I(xor)))		\
+
+#define INTER_DoMaskRRop(src, and, xor, mask, dst)			\
+	PLANE_TIMESG(							\
+	_IG(dst) = (_IG(src) & ((_IG(and) | ~(mask)))			\
+		^ (_IG(xor) & mask))) 
+		
+#define INTER_DoRop(result, alu, src, dst)				\
+{									\
+	if (alu == GXcopy) {						\
+		PLANE_TIMES(						\
+		_I(result) = fnCOPY (_I(src), _I(dst))); 		\
+	} else if (alu == GXxor) {					\
+		PLANE_TIMES(						\
+		_I(result) = fnXOR (_I(src), _I(dst))); 		\
+	}								\
+	else {								\
+	    switch (alu)						\
+	    {								\
+	      case GXclear:						\
+		PLANE_TIMES(						\
+		_I(result) = fnCLEAR (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXand:						\
+		PLANE_TIMES(						\
+		_I(result) = fnAND (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXandReverse:					\
+		PLANE_TIMES(						\
+		_I(result) = fnANDREVERSE (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXandInverted:					\
+		PLANE_TIMES(						\
+		_I(result) = fnANDINVERTED (_I(src), _I(dst))); 	\
+		break;							\
+	      case GXnoop:						\
+		PLANE_TIMES(						\
+		_I(result) = fnNOOP (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXor:						\
+		PLANE_TIMES(						\
+		_I(result) = fnOR (_I(src), _I(dst))); 			\
+		break;							\
+	      case GXnor:						\
+		PLANE_TIMES(						\
+		_I(result) = fnNOR (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXequiv:						\
+		PLANE_TIMES(						\
+		_I(result) = fnEQUIV (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXinvert:						\
+		PLANE_TIMES(						\
+		_I(result) = fnINVERT (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXorReverse:						\
+		PLANE_TIMES(						\
+		_I(result) = fnORREVERSE (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXcopyInverted:					\
+		PLANE_TIMES(						\
+		_I(result) = fnCOPYINVERTED (_I(src), _I(dst))); 	\
+		break;							\
+	      case GXorInverted:					\
+		PLANE_TIMES(						\
+		_I(result) = fnORINVERTED (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXnand:						\
+		PLANE_TIMES(						\
+		_I(result) = fnNAND (_I(src), _I(dst))); 		\
+		break;							\
+	      case GXset:						\
+		PLANE_TIMES(						\
+		_I(result) = fnSET (_I(src), _I(dst))); 		\
+		break;							\
+	      }								\
+	}								\
+}
+
+#define iplGetGroupWidthAndPointer(pDrawable, width, pointer) \
+    iplGetTypedWidthAndPointer(pDrawable, width, pointer, INTER_PIXGRP, INTER_PIXGRP) 
+
+#define INTER_getstipplepixels(psrcstip, x, w, ones, psrcpix, pdstpix) 	\
+{									\
+	unsigned long q;						\
+	int m;								\
+	if (ones) {							\
+		if ((m = ((x) - ((MFB_PPW*MFB_PSZ)-MFB_PPW))) > 0) {	\
+			q = (*(psrcstip)) << m;				\
+			if ( (x)+(w) > (MFB_PPW*MFB_PSZ) )		\
+			     q |= *((psrcstip)+1) >> ((MFB_PPW*MFB_PSZ)-m); \
+		}							\
+		else							\
+			q = (*(psrcstip)) >> -m;			\
+	}								\
+	else {								\
+		if ((m = ((x) - ((MFB_PPW*MFB_PSZ)-MFB_PPW))) > 0) {	\
+			q = (~ *(psrcstip)) << m; 			\
+		if ( (x)+(w) > (MFB_PPW*MFB_PSZ) )			\
+			     q |= (~*((psrcstip)+1)) >> ((MFB_PPW*MFB_PSZ)-m); \
+		}							\
+		else							\
+			q = (~ *(psrcstip)) >> -m;			\
+	}								\
+	q >>=16;							\
+	INTER_ANDMSK(psrcpix,q,pdstpix);				\
+}
+
+#define INTER_getstipplepixelsb(psrcstip, x, w, psrcpix0, psrcpix1, pdstpix) \
+{									\
+	unsigned long q,qn;						\
+	int m;								\
+	if ((m = ((x) - ((MFB_PPW*MFB_PSZ)-MFB_PPW))) > 0) {		\
+		q = (*(psrcstip)) << m;					\
+		qn = (~ *(psrcstip)) << m;				\
+		if ( (x)+(w) > (MFB_PPW*MFB_PSZ) ) {			\
+		     q |= *((psrcstip)+1) >> ((MFB_PPW*MFB_PSZ)-m); \
+		     qn |= (~ *((psrcstip)+1)) >> ((MFB_PPW*MFB_PSZ)-m); \
+		}							\
+	}								\
+	else	{							\
+		q = (*(psrcstip)) >> -m;				\
+		qn = (~ *(psrcstip)) >> -m;				\
+	}								\
+	q >>=16;							\
+	qn >>=16;							\
+	INTER_ANDMSK2(psrcpix0,qn,psrcpix1,q,pdstpix);			\
+}
+
+#define INTER_maskbits(x, w, startmask, endmask, nlg)			\
+	startmask = iplstarttab[(x) & INTER_PIM];			\
+	endmask = iplendtab[((x)+(w)) & INTER_PIM];			\
+	if (startmask)							\
+		nlg = (((w) - (INTER_PPG - ((x) & INTER_PIM))) >> INTER_PGSH); \
+	else								\
+		nlg = (w) >> INTER_PGSH;
+
+#define INTER_maskpartialbits(x, w, mask) 				\
+    mask = iplstartpartial[(x) & INTER_PIM] & 			\
+	   iplendpartial[((x) + (w)) & INTER_PIM];
+
+#define INTER_mask32bits(x, w, startmask, endmask, nlw)			\
+    	startmask = iplstarttab[(x) & INTER_PIM];			\
+	endmask = iplendtab[((x)+(w)) & INTER_PIM];
+
+#define INTER_getbits(psrc, x, w, pdst)					\
+	if ( ((x) + (w)) <= INTER_PPG) 					\
+	{ 								\
+	    INTER_SCRLEFT((x), psrc, pdst); 				\
+	} 								\
+	else 								\
+	{ 								\
+ 	    int m; 							\
+	    m = INTER_PPG-(x);						\
+	    INTER_MSKINSM(iplendtab[m], x, psrc, 			\
+			  iplstarttab[m], m, INTER_NEXT(psrc), pdst);	\
+	}
+
+#define INTER_putbits(psrc, x, w, pdst, planemask)			\
+	if ( ((x)+(w)) <= INTER_PPG) 					\
+	{ 								\
+	    INTER_DECLAREG(tmpmask);					\
+	    INTER_maskpartialbits((x), (w), tmpmask); 			\
+	    INTER_SCRRMSKINS(tmpmask, planemask, psrc, x, pdst, pdst);	\
+	} 								\
+	else 								\
+	{ 								\
+	    unsigned long m; 						\
+	    unsigned long n; 						\
+	    m = INTER_PPG-(x); 						\
+	    n = (w) - m; 						\
+	    INTER_SCRRMSKINS(iplstarttab[x], planemask, psrc, x, 	\
+		pdst, pdst);						\
+	    INTER_SCRLMSKINS(iplendtab[n], planemask, psrc, m, 	\
+		INTER_NEXT(pdst), INTER_NEXT(pdst));			\
+	}
+
+#define INTER_putbitsrop(psrc, x, w, pdst, planemask, rop)		\
+if ( ((x)+(w)) <= INTER_PPG)						\
+{									\
+	INTER_DECLAREG(tmpmask);					\
+	INTER_DECLAREGP(t1); INTER_DECLAREGP(t2);			\
+	INTER_maskpartialbits((x), (w), tmpmask);			\
+	INTER_SCRRIGHT((x), (psrc), (t1));				\
+	INTER_DoRop(t2, rop, t1, pdst);					\
+	INTER_PMSKINS(tmpmask, planemask, t2, pdst, pdst);		\
+}									\
+else									\
+{									\
+	unsigned long m;						\
+	unsigned long n;						\
+	INTER_DECLAREGP(t1); INTER_DECLAREGP(t2);			\
+	m = INTER_PPG-(x);						\
+	n = (w) - m;							\
+	INTER_SCRRIGHT((x), (psrc), (t1));				\
+	INTER_DoRop(t2, rop, t1, pdst);					\
+	INTER_PMSKINS(iplstarttab[x], planemask, t2, pdst, pdst);	\
+	INTER_SCRLEFT(m, (psrc), (t1));					\
+	INTER_DoRop(t2, rop, t1, pdst+1);				\
+	INTER_PMSKINS(iplendtab[n], planemask, t2, pdst, pdst);	\
+}
+
+#define INTER_putbitsmropshort(src, x, w, pdst) {		\
+	INTER_DECLAREG(_tmpmask);				\
+	INTER_DECLAREGP(_t1);					\
+	INTER_maskpartialbits((x), (w), _tmpmask);		\
+	INTER_SCRRIGHT((x), (src), _t1);			\
+	INTER_DoMaskMergeRop(_t1, pdst, _tmpmask, pdst);	\
+}
+ 
diff --git a/iplan2p4/iplpack.c b/iplan2p4/iplpack.c
new file mode 100644
index 000000000..96072895c
--- /dev/null
+++ b/iplan2p4/iplpack.c
@@ -0,0 +1,316 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplpack.c,v 3.0 1996/08/18 01:54:56 dawes Exp $ */
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+/* abcd abcd abcd abcd abcd abcd abcd abcd */
+/* aaaa aaaa bbbb bbbb cccc cccc dddd dddd */
+
+unsigned long tabi[256] = {
+	0x00000000,0x00001000,0x10000000,0x10001000,
+	0x00002000,0x00003000,0x10002000,0x10003000,
+	0x20000000,0x20001000,0x30000000,0x30001000,
+	0x20002000,0x20003000,0x30002000,0x30003000,
+	0x00004000,0x00005000,0x10004000,0x10005000,
+	0x00006000,0x00007000,0x10006000,0x10007000,
+	0x20004000,0x20005000,0x30004000,0x30005000,
+	0x20006000,0x20007000,0x30006000,0x30007000,
+	0x40000000,0x40001000,0x50000000,0x50001000,
+	0x40002000,0x40003000,0x50002000,0x50003000,
+	0x60000000,0x60001000,0x70000000,0x70001000,
+	0x60002000,0x60003000,0x70002000,0x70003000,
+	0x40004000,0x40005000,0x50004000,0x50005000,
+	0x40006000,0x40007000,0x50006000,0x50007000,
+	0x60004000,0x60005000,0x70004000,0x70005000,
+	0x60006000,0x60007000,0x70006000,0x70007000,
+	0x00008000,0x00009000,0x10008000,0x10009000,
+	0x0000a000,0x0000b000,0x1000a000,0x1000b000,
+	0x20008000,0x20009000,0x30008000,0x30009000,
+	0x2000a000,0x2000b000,0x3000a000,0x3000b000,
+	0x0000c000,0x0000d000,0x1000c000,0x1000d000,
+	0x0000e000,0x0000f000,0x1000e000,0x1000f000,
+	0x2000c000,0x2000d000,0x3000c000,0x3000d000,
+	0x2000e000,0x2000f000,0x3000e000,0x3000f000,
+	0x40008000,0x40009000,0x50008000,0x50009000,
+	0x4000a000,0x4000b000,0x5000a000,0x5000b000,
+	0x60008000,0x60009000,0x70008000,0x70009000,
+	0x6000a000,0x6000b000,0x7000a000,0x7000b000,
+	0x4000c000,0x4000d000,0x5000c000,0x5000d000,
+	0x4000e000,0x4000f000,0x5000e000,0x5000f000,
+	0x6000c000,0x6000d000,0x7000c000,0x7000d000,
+	0x6000e000,0x6000f000,0x7000e000,0x7000f000,
+	0x80000000,0x80001000,0x90000000,0x90001000,
+	0x80002000,0x80003000,0x90002000,0x90003000,
+	0xa0000000,0xa0001000,0xb0000000,0xb0001000,
+	0xa0002000,0xa0003000,0xb0002000,0xb0003000,
+	0x80004000,0x80005000,0x90004000,0x90005000,
+	0x80006000,0x80007000,0x90006000,0x90007000,
+	0xa0004000,0xa0005000,0xb0004000,0xb0005000,
+	0xa0006000,0xa0007000,0xb0006000,0xb0007000,
+	0xc0000000,0xc0001000,0xd0000000,0xd0001000,
+	0xc0002000,0xc0003000,0xd0002000,0xd0003000,
+	0xe0000000,0xe0001000,0xf0000000,0xf0001000,
+	0xe0002000,0xe0003000,0xf0002000,0xf0003000,
+	0xc0004000,0xc0005000,0xd0004000,0xd0005000,
+	0xc0006000,0xc0007000,0xd0006000,0xd0007000,
+	0xe0004000,0xe0005000,0xf0004000,0xf0005000,
+	0xe0006000,0xe0007000,0xf0006000,0xf0007000,
+	0x80008000,0x80009000,0x90008000,0x90009000,
+	0x8000a000,0x8000b000,0x9000a000,0x9000b000,
+	0xa0008000,0xa0009000,0xb0008000,0xb0009000,
+	0xa000a000,0xa000b000,0xb000a000,0xb000b000,
+	0x8000c000,0x8000d000,0x9000c000,0x9000d000,
+	0x8000e000,0x8000f000,0x9000e000,0x9000f000,
+	0xa000c000,0xa000d000,0xb000c000,0xb000d000,
+	0xa000e000,0xa000f000,0xb000e000,0xb000f000,
+	0xc0008000,0xc0009000,0xd0008000,0xd0009000,
+	0xc000a000,0xc000b000,0xd000a000,0xd000b000,
+	0xe0008000,0xe0009000,0xf0008000,0xf0009000,
+	0xe000a000,0xe000b000,0xf000a000,0xf000b000,
+	0xc000c000,0xc000d000,0xd000c000,0xd000d000,
+	0xc000e000,0xc000f000,0xd000e000,0xd000f000,
+	0xe000c000,0xe000d000,0xf000c000,0xf000d000,
+	0xe000e000,0xe000f000,0xf000e000,0xf000f000,
+	};
+static unsigned long tabp[256] = {
+	0x00000000,0x00020000,0x00080000,0x000a0000,
+	0x00200000,0x00220000,0x00280000,0x002a0000,
+	0x00800000,0x00820000,0x00880000,0x008a0000,
+	0x00a00000,0x00a20000,0x00a80000,0x00aa0000,
+	0x02000000,0x02020000,0x02080000,0x020a0000,
+	0x02200000,0x02220000,0x02280000,0x022a0000,
+	0x02800000,0x02820000,0x02880000,0x028a0000,
+	0x02a00000,0x02a20000,0x02a80000,0x02aa0000,
+	0x08000000,0x08020000,0x08080000,0x080a0000,
+	0x08200000,0x08220000,0x08280000,0x082a0000,
+	0x08800000,0x08820000,0x08880000,0x088a0000,
+	0x08a00000,0x08a20000,0x08a80000,0x08aa0000,
+	0x0a000000,0x0a020000,0x0a080000,0x0a0a0000,
+	0x0a200000,0x0a220000,0x0a280000,0x0a2a0000,
+	0x0a800000,0x0a820000,0x0a880000,0x0a8a0000,
+	0x0aa00000,0x0aa20000,0x0aa80000,0x0aaa0000,
+	0x20000000,0x20020000,0x20080000,0x200a0000,
+	0x20200000,0x20220000,0x20280000,0x202a0000,
+	0x20800000,0x20820000,0x20880000,0x208a0000,
+	0x20a00000,0x20a20000,0x20a80000,0x20aa0000,
+	0x22000000,0x22020000,0x22080000,0x220a0000,
+	0x22200000,0x22220000,0x22280000,0x222a0000,
+	0x22800000,0x22820000,0x22880000,0x228a0000,
+	0x22a00000,0x22a20000,0x22a80000,0x22aa0000,
+	0x28000000,0x28020000,0x28080000,0x280a0000,
+	0x28200000,0x28220000,0x28280000,0x282a0000,
+	0x28800000,0x28820000,0x28880000,0x288a0000,
+	0x28a00000,0x28a20000,0x28a80000,0x28aa0000,
+	0x2a000000,0x2a020000,0x2a080000,0x2a0a0000,
+	0x2a200000,0x2a220000,0x2a280000,0x2a2a0000,
+	0x2a800000,0x2a820000,0x2a880000,0x2a8a0000,
+	0x2aa00000,0x2aa20000,0x2aa80000,0x2aaa0000,
+	0x80000000,0x80020000,0x80080000,0x800a0000,
+	0x80200000,0x80220000,0x80280000,0x802a0000,
+	0x80800000,0x80820000,0x80880000,0x808a0000,
+	0x80a00000,0x80a20000,0x80a80000,0x80aa0000,
+	0x82000000,0x82020000,0x82080000,0x820a0000,
+	0x82200000,0x82220000,0x82280000,0x822a0000,
+	0x82800000,0x82820000,0x82880000,0x828a0000,
+	0x82a00000,0x82a20000,0x82a80000,0x82aa0000,
+	0x88000000,0x88020000,0x88080000,0x880a0000,
+	0x88200000,0x88220000,0x88280000,0x882a0000,
+	0x88800000,0x88820000,0x88880000,0x888a0000,
+	0x88a00000,0x88a20000,0x88a80000,0x88aa0000,
+	0x8a000000,0x8a020000,0x8a080000,0x8a0a0000,
+	0x8a200000,0x8a220000,0x8a280000,0x8a2a0000,
+	0x8a800000,0x8a820000,0x8a880000,0x8a8a0000,
+	0x8aa00000,0x8aa20000,0x8aa80000,0x8aaa0000,
+	0xa0000000,0xa0020000,0xa0080000,0xa00a0000,
+	0xa0200000,0xa0220000,0xa0280000,0xa02a0000,
+	0xa0800000,0xa0820000,0xa0880000,0xa08a0000,
+	0xa0a00000,0xa0a20000,0xa0a80000,0xa0aa0000,
+	0xa2000000,0xa2020000,0xa2080000,0xa20a0000,
+	0xa2200000,0xa2220000,0xa2280000,0xa22a0000,
+	0xa2800000,0xa2820000,0xa2880000,0xa28a0000,
+	0xa2a00000,0xa2a20000,0xa2a80000,0xa2aa0000,
+	0xa8000000,0xa8020000,0xa8080000,0xa80a0000,
+	0xa8200000,0xa8220000,0xa8280000,0xa82a0000,
+	0xa8800000,0xa8820000,0xa8880000,0xa88a0000,
+	0xa8a00000,0xa8a20000,0xa8a80000,0xa8aa0000,
+	0xaa000000,0xaa020000,0xaa080000,0xaa0a0000,
+	0xaa200000,0xaa220000,0xaa280000,0xaa2a0000,
+	0xaa800000,0xaa820000,0xaa880000,0xaa8a0000,
+	0xaaa00000,0xaaa20000,0xaaa80000,0xaaaa0000,
+	};
+
+void
+iplUnpackLine(int planes, int longs, unsigned int *psrc, unsigned short *ipsrc)
+{
+	unsigned long temp,m;
+	unsigned char *t=(unsigned char *) &temp;
+	unsigned char *i=(unsigned char *) ipsrc;
+	unsigned char *s=(unsigned char *) psrc;
+	int j,off;
+	switch (planes) {
+	case 2:
+		for (j = 0 ; j < longs ; j++)
+		{
+			*((long *) ipsrc)++=(tabi[s[0]] >>  0) 	|
+			        	    (tabi[s[1]] >>  4) 	|
+					    (tabi[s[2]] >>  8) 	|
+				            (tabi[s[3]] >> 12);
+			s+=4;
+		}
+		break;
+	case 4:
+		for (j = 0 ; j < longs ; j++)
+		{
+			temp=	(tabi[s[0]] >>  0) 	|
+			        (tabi[s[1]] >>  4) 	|
+				(tabi[s[2]] >>  8) 	|
+				(tabi[s[3]] >> 12);
+			temp=	(tabi[t[0]] >>  0) 	|
+			        (tabi[t[1]] >>  4) 	|
+				(tabi[t[2]] >>  8) 	|
+				(tabi[t[3]] >> 12);
+			s+=4;
+			if (j & 1) {
+				i[7]=t[0];
+				i[5]=t[1];
+				i[3]=t[2];
+				i[1]=t[3];
+				i += 8;
+			}	
+			else {
+				i[6]=t[0];
+				i[4]=t[1];
+				i[2]=t[2];
+				i[0]=t[3];
+			}
+		}
+		break;
+	case 8:
+		for (j = 0 ; j < longs ; j++)
+		{
+			temp=   (tabi[s[0]] >>  0) 	|
+			        (tabi[s[1]] >>  4) 	|
+				(tabi[s[2]] >>  8) 	|
+				(tabi[s[3]] >> 12);
+
+			temp=   (tabi[t[0]] >>  0) 	|
+			        (tabi[t[1]] >>  4) 	|
+				(tabi[t[2]] >>  8) 	|
+				(tabi[t[3]] >> 12);
+
+			temp=   (tabi[t[0]] >>  0) 	|
+			        (tabi[t[1]] >>  4) 	|
+				(tabi[t[2]] >>  8) 	|
+				(tabi[t[3]] >> 12);
+
+			off=12-(j & 3)*4;
+			m=0xf << off;
+			ipsrc[7]=(ipsrc[7] & ~m) | (((temp >> 28) << off) & m); 
+			ipsrc[6]=(ipsrc[6] & ~m) | (((temp >> 24) << off) & m); 
+			ipsrc[5]=(ipsrc[5] & ~m) | (((temp >> 20) << off) & m); 
+			ipsrc[4]=(ipsrc[4] & ~m) | (((temp >> 16) << off) & m); 
+			ipsrc[3]=(ipsrc[3] & ~m) | (((temp >> 12) << off) & m); 
+			ipsrc[2]=(ipsrc[2] & ~m) | (((temp >>  8) << off) & m); 
+			ipsrc[1]=(ipsrc[1] & ~m) | (((temp >>  4) << off) & m); 
+			ipsrc[0]=(ipsrc[0] & ~m) | (((temp >>  0) << off) & m); 
+			if (! off)
+				ipsrc +=8; 
+			s+=4;
+		}
+	}
+}
+
+void
+iplPackLine(int planes, int longs, unsigned short *ipdst, unsigned int *pdst)
+{
+	unsigned long temp,m;
+	unsigned char *t=(unsigned char *) &temp;
+	unsigned char *i=(unsigned char *) ipdst;
+	int j,off;
+	switch (planes) {
+	case 2:
+		for (j = 0 ; j < longs ; j++)
+		{
+			*pdst++=(tabp[i[2]] >>  0) 	|
+			        (tabp[i[0]] >>  1) 	|
+				(tabp[i[3]] >> 16) 	|
+				(tabp[i[1]] >> 17);
+			i+=4;
+		}
+		break;
+	case 4:
+		for (j = 0 ; j < longs ; j++)
+		{
+			if (j & 1) {
+				temp=	(tabp[i[7]] >>  0) 	|
+				        (tabp[i[3]] >>  1) 	|
+					(tabp[i[5]] >> 16) 	|
+					(tabp[i[1]] >> 17);
+				i += 8;
+			}	
+			else {
+				temp=	(tabp[i[6]] >>  0) 	|
+				        (tabp[i[2]] >>  1) 	|
+					(tabp[i[4]] >> 16) 	|
+					(tabp[i[0]] >> 17);
+			}
+			*pdst++=(tabp[t[0]] >>  0) 	|
+			        (tabp[t[2]] >>  1) 	|
+				(tabp[t[1]] >> 16) 	|
+				(tabp[t[3]] >> 17);
+		}
+		break;
+	case 8:
+		for (j = 0 ; j < longs ; j++)
+		{
+			off=12-(j & 3)*4;
+			m=0xf;
+			temp=(((ipdst[7] >> off) & m) << 28)    | 
+			     (((ipdst[6] >> off) & m) << 24)    | 
+			     (((ipdst[5] >> off) & m) << 20)    |
+			     (((ipdst[4] >> off) & m) << 16)    |
+			     (((ipdst[3] >> off) & m) << 12)    | 
+			     (((ipdst[2] >> off) & m) <<  8)    |
+			     (((ipdst[1] >> off) & m) <<  4)    |
+			     (((ipdst[0] >> off) & m) <<  0);
+
+			if (! off)
+				ipdst +=8; 
+
+			temp=   (tabp[t[0]] >>  0) 	|
+			        (tabp[t[2]] >>  1) 	|
+				(tabp[t[1]] >> 16) 	|
+				(tabp[t[3]] >> 17);
+
+			temp=   (tabp[t[0]] >>  0) 	|
+			        (tabp[t[2]] >>  1) 	|
+				(tabp[t[1]] >> 16) 	|
+				(tabp[t[3]] >> 17);
+
+			*pdst++=(tabp[t[0]] >>  0) 	|
+			        (tabp[t[2]] >>  1) 	|
+				(tabp[t[1]] >> 16) 	|
+				(tabp[t[3]] >> 17);
+		}
+	}
+}
+
+unsigned long
+iplpack(unsigned long ipl)
+{
+	unsigned char *ic=(unsigned char *) &ipl;
+	return  (tabp[ic[0]]) 		| /* a0a0a0a0a0a0a0a00000000000000000 */
+		(tabp[ic[2]] >> 1)	| /* abababababababab0000000000000000 */
+		(tabp[ic[1]] >> 16)	| /* ababababababababa0a0a0a0a0a0a0a0 */
+		(tabp[ic[3]] >> 17);      /* abababababababababababababababab */
+}
+
+unsigned long
+iplunpack(unsigned long pack)
+{
+	unsigned char *ip=(unsigned char *) &pack;
+	return  (tabi[ip[0]])		| /* aaaa000000000000bbbb000000000000 */
+		(tabi[ip[1]] >>  4)	| /* aaaaaaaa00000000bbbbbbbb00000000 */
+		(tabi[ip[2]] >>  8)     | /* aaaaaaaaaaaa0000bbbbbbbbbbbb0000 */
+		(tabi[ip[3]] >> 12);	  /* aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb */
+}	
+
diff --git a/iplan2p4/iplpack.h b/iplan2p4/iplpack.h
new file mode 100644
index 000000000..9545c75ec
--- /dev/null
+++ b/iplan2p4/iplpack.h
@@ -0,0 +1,10 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplpack.h,v 3.0 1996/08/18 01:54:57 dawes Exp $ */
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#define NUM_LONGS(planes, xs, xe)		\
+	(((((xe) * (planes) + 31) & ~31) - 	\
+	  (((xs) * (planes)) & ~31))/32)
+
+#define NUM_TEMP_BYTES(planes, longs)		\
+	(((2 * (longs) + (planes) - 1) / planes + 1) * planes * 2)
diff --git a/iplan2p4/iplpixmap.c b/iplan2p4/iplpixmap.c
new file mode 100644
index 000000000..212f94979
--- /dev/null
+++ b/iplan2p4/iplpixmap.c
@@ -0,0 +1,380 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplpixmap.c,v 3.1 2001/12/17 20:00:46 dawes Exp $ */
+/* $XConsortium: iplpixmap.c,v 5.14 94/04/17 20:28:56 dpw Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+/* pixmap management
+   written by drewry, september 1986
+
+   on a monchrome device, a pixmap is a bitmap.
+*/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "Xmd.h"
+#include "servermd.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "mi.h"
+#include "ipl.h"
+#include "iplmskbits.h"
+
+extern unsigned long endtab[];
+
+PixmapPtr
+iplCreatePixmap (pScreen, width, height, depth)
+    ScreenPtr	pScreen;
+    int		width;
+    int		height;
+    int		depth;
+{
+    PixmapPtr pPixmap;
+    int datasize;
+    int paddedWidth;
+    int ipad=INTER_PLANES*2 - 1;
+
+    paddedWidth = PixmapBytePad(width, depth);
+    paddedWidth = (paddedWidth + ipad) & ~ipad;
+    datasize = height * paddedWidth;
+    pPixmap = AllocatePixmap(pScreen, datasize);
+    if (!pPixmap)
+	return NullPixmap;
+    pPixmap->drawable.type = DRAWABLE_PIXMAP;
+    pPixmap->drawable.class = 0;
+    pPixmap->drawable.pScreen = pScreen;
+    pPixmap->drawable.depth = depth;
+    pPixmap->drawable.bitsPerPixel = BitsPerPixel(depth);
+    pPixmap->drawable.id = 0;
+    pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+    pPixmap->drawable.x = 0;
+    pPixmap->drawable.y = 0;
+    pPixmap->drawable.width = width;
+    pPixmap->drawable.height = height;
+    pPixmap->devKind = paddedWidth;
+    pPixmap->refcnt = 1;
+#ifdef PIXPRIV
+    pPixmap->devPrivate.ptr = datasize ?
+		(pointer)((char *)pPixmap + pScreen->totalPixmapSize) : NULL;
+#else
+    pPixmap->devPrivate.ptr = (pointer)((long)(pPixmap + 1));
+#endif
+    return pPixmap;
+}
+
+Bool
+iplDestroyPixmap(pPixmap)
+    PixmapPtr pPixmap;
+{
+    if(--pPixmap->refcnt)
+	return TRUE;
+    xfree(pPixmap);
+    return TRUE;
+}
+
+PixmapPtr
+iplCopyPixmap(pSrc)
+    register PixmapPtr	pSrc;
+{
+    register PixmapPtr	pDst;
+    int		size;
+    ScreenPtr pScreen;
+
+    size = pSrc->drawable.height * pSrc->devKind;
+    pScreen = pSrc->drawable.pScreen;
+    pDst = (*pScreen->CreatePixmap) (pScreen, pSrc->drawable.width, 
+				pSrc->drawable.height, pSrc->drawable.depth);
+    if (!pDst)
+	return NullPixmap;
+    memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
+    return pDst;
+}
+
+
+/* replicates a pattern to be a full 32 bits wide.
+   relies on the fact that each scnaline is longword padded.
+   doesn't do anything if pixmap is not a factor of 32 wide.
+   changes width field of pixmap if successful, so that the fast
+	iplXRotatePixmap code gets used if we rotate the pixmap later.
+	iplYRotatePixmap code gets used if we rotate the pixmap later.
+
+   calculate number of times to repeat
+   for each scanline of pattern
+      zero out area to be filled with replicate
+      left shift and or in original as many times as needed
+*/
+
+void
+iplPadPixmap(pPixmap)
+    PixmapPtr pPixmap;
+{
+    register int width = pPixmap->drawable.width;
+    register int h;
+    register unsigned short mask;
+    register unsigned short *p;
+    register unsigned short bits; /* real pattern bits */
+    register int i;
+    int rep;                    /* repeat count for pattern */
+ 
+    if (width >= INTER_PGSZ)
+        return;
+
+    rep = INTER_PGSZ/width;
+/*    if (rep*width != INTER_PGSZ)
+        return; */
+ 
+    mask = iplendtab[width];
+ 
+    p = (unsigned short *)(pPixmap->devPrivate.ptr);
+    for (h=0; h < pPixmap->drawable.height * INTER_PLANES; h++)
+    {
+	*p &= mask;
+	bits = *p ;
+        for(i=1; i<rep; i++)
+        {
+#if (BITMAP_BIT_ORDER == MSBFirst) 
+            bits >>= width;
+#else
+	    bits <<= width;
+#endif
+	    *p |= bits; 
+        }
+        p++;
+    }    
+    pPixmap->drawable.width = rep*width; /* PGSZ/(pPixmap->drawable.bitsPerPixel); */
+}
+
+
+#ifdef notdef
+/*
+ * ipl debugging routine -- assumes pixmap is 1 byte deep 
+ */
+static ipldumppixmap(pPix)
+    PixmapPtr	pPix;
+{
+    unsigned int *pw;
+    char *psrc, *pdst;
+    int	i, j;
+    char	line[66];
+
+    ErrorF(  "pPixmap: 0x%x\n", pPix);
+    ErrorF(  "%d wide %d high\n", pPix->drawable.width, pPix->drawable.height);
+    if (pPix->drawable.width > 64)
+    {
+	ErrorF(  "too wide to see\n");
+	return;
+    }
+
+    pw = (unsigned int *) pPix->devPrivate.ptr;
+    psrc = (char *) pw;
+
+/*
+    for ( i=0; i<pPix->drawable.height; ++i )
+	ErrorF( "0x%x\n", pw[i] );
+*/
+
+    for ( i = 0; i < pPix->drawable.height; ++i ) {
+	pdst = line;
+	for(j = 0; j < pPix->drawable.width; j++) {
+	    *pdst++ = *psrc++ ? 'X' : ' ' ;
+	}
+	*pdst++ = '\n';
+	*pdst++ = '\0';
+	ErrorF( "%s", line);
+    }
+}
+#endif /* notdef */
+
+/* Rotates pixmap pPix by w pixels to the right on the screen. Assumes that
+ * words are PGSZ bits wide, and that the least significant bit appears on the
+ * left.
+ */
+void
+iplXRotatePixmap(pPix, rw)
+    PixmapPtr	pPix;
+    register int rw;
+{
+    INTER_DECLAREG(*pw);
+    INTER_DECLAREG(*pwFinal);
+    INTER_DECLAREGP(t);
+    int				rot;
+
+    if (pPix == NullPixmap)
+        return;
+
+    switch (((DrawablePtr) pPix)->bitsPerPixel) {
+	case INTER_PLANES:
+	    break;
+	case 1:
+	    mfbXRotatePixmap(pPix, rw);
+	    return;
+	default:
+	    ErrorF("iplXRotatePixmap: unsupported bitsPerPixel %d\n", ((DrawablePtr) pPix)->bitsPerPixel);
+	    return;
+    }
+    pw = (unsigned short *)pPix->devPrivate.ptr;
+    modulus (rw, (int) pPix->drawable.width, rot);
+    if(pPix->drawable.width == 16)
+    {
+        pwFinal = pw + pPix->drawable.height * INTER_PLANES;
+	while(pw < pwFinal)
+	{
+	    INTER_COPY(pw, t);
+	    INTER_MSKINSM(iplendtab[rot], INTER_PPG-rot, t,
+			  ~0, rot, t, pw)
+	    INTER_NEXT_GROUP(pw);
+	}
+    }
+    else
+    {
+        ErrorF("ipl internal error: trying to rotate odd-sized pixmap.\n");
+#ifdef notdef
+	register unsigned long *pwTmp;
+	int size, tsize;
+
+	tsize = PixmapBytePad(pPix->drawable.width - rot, pPix->drawable.depth);
+	pwTmp = (unsigned long *) ALLOCATE_LOCAL(pPix->drawable.height * tsize);
+	if (!pwTmp)
+	    return;
+	/* divide pw (the pixmap) in two vertically at (w - rot) and swap */
+	tsize >>= 2;
+	size = pPix->devKind >> SIZE0F(PixelGroup);
+	iplQuickBlt((long *)pw, (long *)pwTmp,
+		    0, 0, 0, 0,
+		    (int)pPix->drawable.width - rot, (int)pPix->drawable.height,
+		    size, tsize);
+	iplQuickBlt((long *)pw, (long *)pw,
+		    (int)pPix->drawable.width - rot, 0, 0, 0,
+		    rot, (int)pPix->drawable.height,
+		    size, size);
+	iplQuickBlt((long *)pwTmp, (long *)pw,
+		    0, 0, rot, 0,
+		    (int)pPix->drawable.width - rot, (int)pPix->drawable.height,
+		    tsize, size);
+	DEALLOCATE_LOCAL(pwTmp);
+#endif
+    }
+}
+
+/* Rotates pixmap pPix by h lines.  Assumes that h is always less than
+   pPix->drawable.height
+   works on any width.
+ */
+void
+iplYRotatePixmap(pPix, rh)
+    register PixmapPtr	pPix;
+    int	rh;
+{
+    int nbyDown;	/* bytes to move down to row 0; also offset of
+			   row rh */
+    int nbyUp;		/* bytes to move up to line rh; also
+			   offset of first line moved down to 0 */
+    char *pbase;
+    char *ptmp;
+    int	rot;
+
+    if (pPix == NullPixmap)
+	return;
+    switch (((DrawablePtr) pPix)->bitsPerPixel) {
+	case INTER_PLANES:
+	    break;
+	case 1:
+	    mfbYRotatePixmap(pPix, rh);
+	    return;
+	default:
+	    ErrorF("iplYRotatePixmap: unsupported bitsPerPixel %d\n", ((DrawablePtr) pPix)->bitsPerPixel);
+	    return;
+    }
+
+    modulus (rh, (int) pPix->drawable.height, rot);
+    pbase = (char *)pPix->devPrivate.ptr;
+
+    nbyDown = rot * pPix->devKind;
+    nbyUp = (pPix->devKind * pPix->drawable.height) - nbyDown;
+    if(!(ptmp = (char *)ALLOCATE_LOCAL(nbyUp)))
+	return;
+
+    memmove(ptmp, pbase, nbyUp);		/* save the low rows */
+    memmove(pbase, pbase+nbyUp, nbyDown);	/* slide the top rows down */
+    memmove(pbase+nbyDown, ptmp, nbyUp);	/* move lower rows up to row rot */
+    DEALLOCATE_LOCAL(ptmp);
+}
+
+void
+iplCopyRotatePixmap(psrcPix, ppdstPix, xrot, yrot)
+    register PixmapPtr psrcPix, *ppdstPix;
+    int	xrot, yrot;
+{
+    register PixmapPtr pdstPix;
+
+    if ((pdstPix = *ppdstPix) &&
+	(pdstPix->devKind == psrcPix->devKind) &&
+	(pdstPix->drawable.height == psrcPix->drawable.height))
+    {
+	memmove((char *)pdstPix->devPrivate.ptr,
+		(char *)psrcPix->devPrivate.ptr,
+	      psrcPix->drawable.height * psrcPix->devKind);
+	pdstPix->drawable.width = psrcPix->drawable.width;
+	pdstPix->drawable.depth = psrcPix->drawable.depth;
+	pdstPix->drawable.bitsPerPixel = psrcPix->drawable.bitsPerPixel;
+	pdstPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+    }
+    else
+    {
+	if (pdstPix)
+	    /* FIX XBUG 6168 */
+	    (*pdstPix->drawable.pScreen->DestroyPixmap)(pdstPix);
+	*ppdstPix = pdstPix = iplCopyPixmap(psrcPix);
+	if (!pdstPix)
+	    return;
+    }
+    iplPadPixmap(pdstPix);
+    if (xrot)
+	iplXRotatePixmap(pdstPix, xrot);
+    if (yrot)
+	iplYRotatePixmap(pdstPix, yrot);
+}
diff --git a/iplan2p4/iplply1rct.c b/iplan2p4/iplply1rct.c
new file mode 100644
index 000000000..f73bc8864
--- /dev/null
+++ b/iplan2p4/iplply1rct.c
@@ -0,0 +1,306 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplply1rct.c,v 3.1 1998/03/20 21:08:09 hohndel Exp $ */
+/*
+ * $XConsortium: iplply1rct.c,v 1.14 94/04/17 20:28:56 dpw Exp $
+ *
+Copyright (c) 1990  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+#include "mistruct.h"
+
+#include "ipl.h"
+#include "iplrrop.h"
+
+#include "iplmskbits.h"
+
+void
+INTER_RROP_NAME(iplFillPoly1Rect) (pDrawable, pGC, shape, mode, count, ptsIn)
+    DrawablePtr	pDrawable;
+    GCPtr	pGC;
+    int		count;
+    DDXPointPtr	ptsIn;
+{
+    iplPrivGCPtr    devPriv;
+    int		    ngwidth;
+    unsigned short  *addrl, *addr;
+    int		    maxy;
+    int		    origin;
+    register int    vertex1, vertex2;
+    int		    c;
+    BoxPtr	    extents;
+    int		    clip;
+    int		    y;
+    int		    *vertex1p, *vertex2p;
+    int		    *endp;
+    int		    x1, x2;
+    int		    dx1, dx2;
+    int		    dy1, dy2;
+    int		    e1, e2;
+    int		    step1, step2;
+    int		    sign1, sign2;
+    int		    h;
+    int		    l, r;
+    INTER_DECLAREG(mask); 
+    INTER_DECLAREG(bits);
+    int		    nmiddle;
+    INTER_RROP_DECLARE
+    bits=~0;
+
+    if (mode == CoordModePrevious)
+    {
+	miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
+	return;
+    }
+    
+    devPriv = iplGetGCPrivate(pGC);
+#ifdef NO_ONE_RECT
+    if (REGION_NUM_RECTS(pGC->pCompositeClip) != 1)
+    {
+	miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
+	return;
+    }
+#endif
+    origin = *((int *) &pDrawable->x);
+    origin -= (origin & 0x8000) << 1;
+    extents = &pGC->pCompositeClip->extents;
+    INTER_RROP_FETCH_GCPRIV(devPriv);
+    vertex1 = *((int *) &extents->x1) - origin;
+    vertex2 = *((int *) &extents->x2) - origin - 0x00010001;
+    clip = 0;
+    y = 32767;
+    maxy = 0;
+    vertex2p = (int *) ptsIn;
+    endp = vertex2p + count;
+    if (shape == Convex)
+    {
+    	while (count--)
+    	{
+	    c = *vertex2p;
+	    clip |= (c - vertex1) | (vertex2 - c);
+	    c = intToY(c);
+	    if (c < y) 
+	    {
+	    	y = c;
+	    	vertex1p = vertex2p;
+	    }
+	    vertex2p++;
+	    if (c > maxy)
+	    	maxy = c;
+    	}
+    }
+    else
+    {
+	int yFlip = 0;
+	dx1 = 1;
+	x2 = -1;
+	x1 = -1;
+    	while (count--)
+    	{
+	    c = *vertex2p;
+	    clip |= (c - vertex1) | (vertex2 - c);
+	    c = intToY(c);
+	    if (c < y) 
+	    {
+	    	y = c;
+	    	vertex1p = vertex2p;
+	    }
+	    vertex2p++;
+	    if (c > maxy)
+	    	maxy = c;
+	    if (c == x1)
+		continue;
+	    if (dx1 > 0)
+	    {
+		if (x2 < 0)
+		    x2 = c;
+		else
+		    dx2 = dx1 = (c - x1) >> 31;
+	    }
+	    else
+		if ((c - x1) >> 31 != dx1) 
+		{
+		    dx1 = ~dx1;
+		    yFlip++;
+		}
+	    x1 = c;
+       	}
+	x1 = (x2 - c) >> 31;
+	if (x1 != dx1)
+	    yFlip++;
+	if (x1 != dx2)
+	    yFlip++;
+	if (yFlip != 2) 
+	    clip = 0x8000;
+    }
+    if (y == maxy)
+	return;
+
+    if (clip & 0x80008000)
+    {
+	miFillPolygon (pDrawable, pGC, shape, mode, vertex2p - (int *) ptsIn, ptsIn);
+	return;
+    }
+
+#define AddrYPlus(a,y)  ((a) + (y) * ngwidth)
+
+    iplGetGroupWidthAndPointer(pDrawable, ngwidth, addrl);
+    addrl = AddrYPlus(addrl,y + pDrawable->y);
+    origin = intToX(origin);
+    vertex2p = vertex1p;
+    vertex2 = vertex1 = *vertex2p++;
+    if (vertex2p == endp)
+	vertex2p = (int *) ptsIn;
+#define Setup(c,x,vertex,dx,dy,e,sign,step) {\
+    x = intToX(vertex); \
+    if (dy = intToY(c) - y) { \
+    	dx = intToX(c) - x; \
+	step = 0; \
+    	if (dx >= 0) \
+    	{ \
+	    e = 0; \
+	    sign = 1; \
+	    if (dx >= dy) {\
+	    	step = dx / dy; \
+	    	dx = dx % dy; \
+	    } \
+    	} \
+    	else \
+    	{ \
+	    e = 1 - dy; \
+	    sign = -1; \
+	    dx = -dx; \
+	    if (dx >= dy) { \
+		step = - (dx / dy); \
+		dx = dx % dy; \
+	    } \
+    	} \
+    } \
+    x += origin; \
+    vertex = c; \
+}
+
+#define Step(x,dx,dy,e,sign,step) {\
+    x += step; \
+    if ((e += dx) > 0) \
+    { \
+	x += sign; \
+	e -= dy; \
+    } \
+}
+    for (;;)
+    {
+	if (y == intToY(vertex1))
+	{
+	    do
+	    {
+	    	if (vertex1p == (int *) ptsIn)
+		    vertex1p = endp;
+	    	c = *--vertex1p;
+	    	Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1)
+	    } while (y >= intToY(vertex1));
+	    h = dy1;
+	}
+	else
+	{
+	    Step(x1,dx1,dy1,e1,sign1,step1)
+	    h = intToY(vertex1) - y;
+	}
+	if (y == intToY(vertex2))
+	{
+	    do
+	    {
+	    	c = *vertex2p++;
+	    	if (vertex2p == endp)
+		    vertex2p = (int *) ptsIn;
+	    	Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2)
+	    } while (y >= intToY(vertex2));
+	    if (dy2 < h)
+		h = dy2;
+	}
+	else
+	{
+	    Step(x2,dx2,dy2,e2,sign2,step2)
+	    if ((c = (intToY(vertex2) - y)) < h)
+		h = c;
+	}
+	/* fill spans for this segment */
+	y += h;
+	for (;;)
+	{
+	    l = x1;
+	    r = x2;
+	    nmiddle = x2 - x1;
+    	    if (nmiddle < 0)
+	    {
+	    	nmiddle = -nmiddle;
+	    	l = x2;
+	    	r = x1;
+    	    }
+	    c = l & INTER_PIM;
+	    l -= c;
+
+	    addr = addrl + (l >> INTER_PGSH) * INTER_PLANES;
+	    if (c + nmiddle < INTER_PPG)
+	    {
+	    	mask = (bits >> c) ^ (bits >> (c+nmiddle));
+	    	INTER_RROP_SOLID_MASK(addr,mask);
+	    }
+	    else
+	    {
+	    	if (c)
+	    	{
+	    	    mask = bits >> c;
+	    	    INTER_RROP_SOLID_MASK(addr,mask);
+	    	    nmiddle += c - INTER_PPG;
+	    	    INTER_NEXT_GROUP(addr);
+	    	}
+	    	nmiddle >>= INTER_PGSH;
+		while (--nmiddle >= 0) {
+		    INTER_RROP_SOLID(addr); INTER_NEXT_GROUP(addr);
+		}
+	    	if (mask = ~(bits >> (r & INTER_PIM)))
+	    	    INTER_RROP_SOLID_MASK(addr,mask);
+	    }
+	    if (!--h)
+		break;
+	    addrl = AddrYPlus (addrl, 1);
+	    Step(x1,dx1,dy1,e1,sign1,step1)
+	    Step(x2,dx2,dy2,e2,sign2,step2)
+	}
+	if (y == maxy)
+	    break;
+	addrl = AddrYPlus (addrl, 1);
+    }
+}
diff --git a/iplan2p4/iplpntwin.c b/iplan2p4/iplpntwin.c
new file mode 100644
index 000000000..a5a61194a
--- /dev/null
+++ b/iplan2p4/iplpntwin.c
@@ -0,0 +1,337 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplpntwin.c,v 3.0 1996/08/18 01:55:01 dawes Exp $ */
+/* $XConsortium: iplpntwin.c,v 5.18 94/04/17 20:28:57 dpw Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+
+#include "windowstr.h"
+#include "regionstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ipl.h"
+#include "mi.h"
+
+void
+iplPaintWindow(pWin, pRegion, what)
+    WindowPtr	pWin;
+    RegionPtr	pRegion;
+    int		what;
+{
+    register iplPrivWin	*pPrivWin;
+    WindowPtr	pBgWin;
+
+    pPrivWin = iplGetWindowPrivate(pWin);
+
+    switch (what) {
+    case PW_BACKGROUND:
+	switch (pWin->backgroundState) {
+	case None:
+	    break;
+	case ParentRelative:
+	    do {
+		pWin = pWin->parent;
+	    } while (pWin->backgroundState == ParentRelative);
+	    (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
+							     what);
+	    break;
+	case BackgroundPixmap:
+	    if (pPrivWin->fastBackground)
+	    {
+		iplFillBoxTile32 ((DrawablePtr)pWin,
+				  (int)REGION_NUM_RECTS(pRegion),
+				  REGION_RECTS(pRegion),
+				  pPrivWin->pRotatedBackground);
+	    }
+	    else
+	    {
+		iplFillBoxTileOdd ((DrawablePtr)pWin,
+				   (int)REGION_NUM_RECTS(pRegion),
+				   REGION_RECTS(pRegion),
+				   pWin->background.pixmap,
+				   (int) pWin->drawable.x, (int) pWin->drawable.y);
+	    }
+	    break;
+	case BackgroundPixel:
+	    iplFillBoxSolid ((DrawablePtr)pWin,
+			     (int)REGION_NUM_RECTS(pRegion),
+			     REGION_RECTS(pRegion),
+			     pWin->background.pixel);
+	    break;
+    	}
+    	break;
+    case PW_BORDER:
+	if (pWin->borderIsPixel)
+	{
+	    iplFillBoxSolid ((DrawablePtr)pWin,
+			     (int)REGION_NUM_RECTS(pRegion),
+			     REGION_RECTS(pRegion),
+			     pWin->border.pixel);
+	}
+	else if (pPrivWin->fastBorder)
+	{
+	    iplFillBoxTile32 ((DrawablePtr)pWin,
+			      (int)REGION_NUM_RECTS(pRegion),
+			      REGION_RECTS(pRegion),
+			      pPrivWin->pRotatedBorder);
+	}
+	else
+	{
+	    for (pBgWin = pWin;
+		 pBgWin->backgroundState == ParentRelative;
+		 pBgWin = pBgWin->parent);
+
+	    iplFillBoxTileOdd ((DrawablePtr)pWin,
+			       (int)REGION_NUM_RECTS(pRegion),
+			       REGION_RECTS(pRegion),
+			       pWin->border.pixmap,
+			       (int) pBgWin->drawable.x,
+ 			       (int) pBgWin->drawable.y);
+	}
+	break;
+    }
+}
+
+/*
+ * Use the RROP macros in copy mode
+ */
+
+#define RROP GXcopy
+#include "iplrrop.h"
+#include "iplmskbits.h"
+
+
+# define Expand(left, right, leftAdjust) { \
+    int widthStep; \
+    widthStep = widthDst - (nmiddle + leftAdjust) * INTER_PLANES; \
+    while (h--) { \
+	left \
+	m = nmiddle; \
+	INTER_RROP_SPAN(pdst, m); \
+	right \
+	pdst += widthStep; \
+    } \
+}
+
+void
+iplFillBoxSolid (pDrawable, nBox, pBox, pixel)
+    DrawablePtr	    pDrawable;
+    int		    nBox;
+    BoxPtr	    pBox;
+    unsigned long   pixel;
+{
+    INTER_DECLAREG(*pdstBase);
+    int		    widthDst;
+    register int    h;
+    INTER_DECLAREGP(rrop_xor);
+    INTER_DECLAREG(*pdst);
+    INTER_DECLAREG(leftMask);
+    INTER_DECLAREG(rightMask);
+    int		    nmiddle;
+    register int    m;
+    int		    w;
+
+    iplGetGroupWidthAndPointer(pDrawable, widthDst, pdstBase);
+
+    INTER_PFILL(pixel, rrop_xor);
+    for (; nBox; nBox--, pBox++)
+    {
+    	pdst = pdstBase + pBox->y1 * widthDst;
+    	h = pBox->y2 - pBox->y1;
+	w = pBox->x2 - pBox->x1;
+	pdst += (pBox->x1 >> INTER_PGSH) * INTER_PLANES;
+	if ((pBox->x1 & INTER_PIM) + w <= INTER_PPG)
+	{
+	    INTER_maskpartialbits(pBox->x1, w, leftMask);
+	    while (h--) {
+		INTER_COPYM(rrop_xor, pdst, leftMask, pdst);
+		pdst += widthDst;
+	    }
+	}
+	else
+	{
+	    INTER_maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
+	    if (leftMask)
+	    {
+		if (rightMask)
+		{
+		    Expand (INTER_RROP_SOLID_MASK (pdst, leftMask); 
+			    INTER_NEXT_GROUP(pdst);,
+			    INTER_RROP_SOLID_MASK (pdst, rightMask); ,
+			    1)
+		}
+		else
+		{
+		    Expand (INTER_RROP_SOLID_MASK (pdst, leftMask); 
+			    INTER_NEXT_GROUP(pdst);,
+			    ;,
+			    1)
+		}
+	    }
+	    else
+	    {
+		if (rightMask)
+		{
+		    Expand (;,
+			    INTER_RROP_SOLID_MASK (pdst, rightMask);,
+			    0)
+		}
+		else
+		{
+		    Expand (;,
+			    ;,
+			    0)
+		}
+	    }
+	}
+    }
+}
+
+void
+iplFillBoxTile32 (pDrawable, nBox, pBox, tile)
+    DrawablePtr	    pDrawable;
+    int		    nBox;	/* number of boxes to fill */
+    BoxPtr 	    pBox;	/* pointer to list of boxes to fill */
+    PixmapPtr	    tile;	/* rotated, expanded tile */
+{
+    INTER_DECLAREGP(rrop_xor);	
+    INTER_DECLAREG(*pdst);
+    register int	    m;
+    INTER_DECLAREG(*psrc);
+    int			    tileHeight;
+
+    int			    widthDst;
+    int			    w;
+    int			    h;
+    INTER_DECLAREG(leftMask);
+    INTER_DECLAREG(rightMask);
+    int			    nmiddle;
+    int			    y;
+    int			    srcy;
+
+    INTER_DECLAREG(*pdstBase);
+
+    tileHeight = tile->drawable.height;
+    psrc = (unsigned short *)tile->devPrivate.ptr;
+
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pdstBase);
+
+    while (nBox--)
+    {
+	w = pBox->x2 - pBox->x1;
+	h = pBox->y2 - pBox->y1;
+	y = pBox->y1;
+	pdst = pdstBase + (pBox->y1 * widthDst) + 
+		(pBox->x1 >> INTER_PGSH) * INTER_PLANES;
+	srcy = y % tileHeight;
+
+#define StepTile    INTER_COPY(psrc + srcy * INTER_PLANES, rrop_xor); \
+		    ++srcy; \
+		    if (srcy == tileHeight) \
+		        srcy = 0;
+
+	if ( ((pBox->x1 & INTER_PIM) + w) < INTER_PPG)
+	{
+	    INTER_maskpartialbits(pBox->x1, w, leftMask);
+	    rightMask = ~leftMask;
+	    while (h--)
+	    {
+		StepTile
+		INTER_MSKINSM(rightMask, 0, pdst, leftMask, 0, rrop_xor, pdst);
+		pdst += widthDst;
+	    }
+	}
+	else
+	{
+	    INTER_maskbits(pBox->x1, w, leftMask, rightMask, nmiddle);
+
+	    if (leftMask)
+	    {
+		if (rightMask)
+		{
+		    Expand (StepTile
+			    INTER_RROP_SOLID_MASK(pdst, leftMask); 
+			    INTER_NEXT_GROUP(pdst);,
+			    INTER_RROP_SOLID_MASK(pdst, rightMask);,
+			    1)
+		}
+		else
+		{
+		    Expand (StepTile
+			    INTER_RROP_SOLID_MASK(pdst, leftMask); 
+			    INTER_NEXT_GROUP(pdst);,
+			    ;,
+			    1)
+		}
+	    }
+	    else
+	    {
+		if (rightMask)
+		{
+		    Expand (StepTile
+			    ,
+			    INTER_RROP_SOLID_MASK(pdst, rightMask);,
+			    0)
+		}
+		else
+		{
+		    Expand (StepTile
+			    ,
+			    ;,
+			    0)
+		}
+	    }
+	}
+        pBox++;
+    }
+}
diff --git a/iplan2p4/iplpolypnt.c b/iplan2p4/iplpolypnt.c
new file mode 100644
index 000000000..3d90edea4
--- /dev/null
+++ b/iplan2p4/iplpolypnt.c
@@ -0,0 +1,119 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplpolypnt.c,v 3.1 1998/03/20 21:08:09 hohndel Exp $ */
+/************************************************************
+
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+********************************************************/
+
+/* $XConsortium: iplpolypnt.c,v 5.17 94/04/17 20:28:57 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+#include "ipl.h"
+#include "iplmskbits.h"
+
+#define isClipped(c,ul,lr)  ((((c) - (ul)) | ((lr) - (c))) & ClipMask)
+
+/* WARNING: pbox contains two shorts. This code assumes they are packed
+ * and can be referenced together as an INT32.
+ */
+
+#define PointLoop(fill) { \
+    for (nbox = REGION_NUM_RECTS(cclip), pbox = REGION_RECTS(cclip); \
+	 --nbox >= 0; \
+	 pbox++) \
+    { \
+	c1 = *((INT32 *) &pbox->x1) - off; \
+	c2 = *((INT32 *) &pbox->x2) - off - 0x00010001; \
+	for (ppt = (INT32 *) pptInit, i = npt; --i >= 0;) \
+	{ \
+	    pt = *ppt++; \
+	    if (!isClipped(pt,c1,c2)) { \
+		fill \
+	    } \
+	} \
+    } \
+}
+
+void
+iplPolyPoint(pDrawable, pGC, mode, npt, pptInit)
+    DrawablePtr pDrawable;
+    GCPtr pGC;
+    int mode;
+    int npt;
+    xPoint *pptInit;
+{
+    register INT32   pt;
+    register INT32   c1, c2;
+    register unsigned long   ClipMask = 0x80008000;
+    INTER_DECLAREG(*addrg);
+    register int    ngwidth;
+    register int    xoffset;
+    INTER_DECLAREG(*addrgt);
+    register INT32  *ppt;
+    RegionPtr	    cclip;
+    int		    nbox;
+    register int    i;
+    register BoxPtr pbox;
+    INTER_DECLARERRAX(and);
+    INTER_DECLARERRAX(xor);
+    int		    rop = pGC->alu;
+    int		    off;
+    iplPrivGCPtr    devPriv;
+    xPoint	    *pptPrev;
+
+    devPriv =iplGetGCPrivate(pGC);
+    rop = devPriv->rop;
+    if (rop == GXnoop)
+	return;
+    cclip = pGC->pCompositeClip;
+    xor = devPriv->xorg;
+    and = devPriv->andg;
+    if ((mode == CoordModePrevious) && (npt > 1))
+    {
+	for (pptPrev = pptInit + 1, i = npt - 1; --i >= 0; pptPrev++)
+	{
+	    pptPrev->x += (pptPrev-1)->x;
+	    pptPrev->y += (pptPrev-1)->y;
+	}
+    }
+    off = *((int *) &pDrawable->x);
+    off -= (off & 0x8000) << 1;
+    iplGetGroupWidthAndPointer(pDrawable, ngwidth, addrg);
+    addrg = addrg + pDrawable->y * ngwidth + 
+		(pDrawable->x >> INTER_PGSH) * INTER_PLANES;
+    xoffset = pDrawable->x & INTER_PIM;
+    PointLoop(   addrgt = addrg + intToY(pt) * ngwidth
+ 	               + ((intToX(pt) + xoffset) >> INTER_PGSH) * INTER_PLANES;
+		   INTER_DoMaskRRop(addrgt, and, xor, 
+			iplmask[(intToX(pt) + xoffset) & INTER_PIM], addrgt);
+	     )
+}
diff --git a/iplan2p4/iplrrop.c b/iplan2p4/iplrrop.c
new file mode 100644
index 000000000..cfc43c130
--- /dev/null
+++ b/iplan2p4/iplrrop.c
@@ -0,0 +1,215 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplrrop.c,v 3.0 1996/08/18 01:55:03 dawes Exp $ */
+/*
+ * $XConsortium: iplrrop.c,v 1.8 94/04/17 20:28:59 dpw Exp $
+ *
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+/* ipl reduced rasterop computations */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ipl.h"
+
+#include "iplmskbits.h"
+
+/* A description:
+ *
+ * There are four possible operations on each bit in the destination word,
+ *
+ *	    1	2   3	4
+ *
+ *    0	    0	0   1	1
+ *    1	    0	1   0	1
+ *
+ * On examination of the reduced rop equation (dst = (dst & and) ^ xor),
+ * these four fall to reduced rops as follows:
+ *
+ *  and	    0	1   1	0
+ *  xor	    0	0   1	1
+ *
+ * or, (if 'and' is expensive) (dst = (dst | or) ^ xor)
+ *
+ *  or	    1	0   0	1
+ *  xor	    1	0   1	0
+ *
+ * The trouble with using this later equation is that trivial
+ * rasterop reduction is more difficult; some common rasterops
+ * use complicated expressions of xor/and instead of the simple
+ * ones while other common rasterops are not made any simpler:
+ *
+ * GXcopy:	*dst = ~xor		instead of  *dst = xor
+ * GXand:	*dst = *dst & ~or	instead of  *dst = *dst & and
+ * GXor:	*dst = *dst | or	instead of  *dst = *dst | xor
+ * GXxor:	*dst = *dst ^ xor	instead of  *dst = *dst ^ xor
+ *
+ * If you're really set on using this second mechanism, the changes
+ * are pretty simple.
+ *
+ * All that remains is to provide a mechanism for computing and/xor values
+ * based on the raster op and foreground value.
+ *
+ * The 16 rops fall as follows, with the associated reduced
+ * rop and/xor and or/xor values.  The values in parenthesis following the
+ * reduced values gives an equation using the source value for
+ * the reduced value, and is one of {0, src, ~src, 1} as appropriate.
+ *
+ *	clear		and		andReverse	copy
+ *     src  0	1	    0   1	    0	1	    0	1
+ *  dst	0   0	0	0   0   0	0   0	1	0   0	1
+ *	1   0	0	1   0   1	1   0	0	1   0	1
+ *
+ *  and	    0	0 (0)	    0   1 (src)	    0	1 (src)	    0	0 (0)
+ *  xor	    0	0 (0)	    0   0 (0)	    0	1 (src)	    0	1 (src)
+ *
+ *  or	    1	1 (1)	    1	0 (~src)    1	0 (~src)    1	1 (1)
+ *  xor	    1	1 (1)	    1	0 (~src)    1	1 (1)	    1	0 (~src)
+ *
+ *	andInverted	noop		xor		or
+ *     src  0	1	    0   1	    0	1	    0	1
+ *  dst	0   0	0	0   0   0	0   0	1	0   0	1
+ *	1   1	0	1   1   1	1   1	0	1   1	1
+ *
+ *  and	    1	0 (~src)    1   1 (1)	    1	1 (1)	    1	0 (~src)
+ *  xor	    0	0 (0)	    0   0 (0)	    0	1 (src)	    0	1 (src)
+ *
+ *  or	    0	1 (src)	    0	0 (0)	    0	0 (0)	    0	1 (src)
+ *  xor	    0	1 (src)	    0	0 (0)	    0	1 (src)	    0	0 (0)
+ *
+ *	nor		equiv		invert		orReverse
+ *     src  0	1	    0   1	    0	1	    0	1
+ *  dst	0   1	0	0   1   0	0   1	1	0   1	1
+ *	1   0	0	1   0   1	1   0	0	1   0	1
+ *
+ *  and	    1	0 (~src)    1   1 (1)	    1	1 (1)	    1	0 (~src)
+ *  xor	    1	0 (~src)    1   0 (~src)    1	1 (1)	    1	1 (1)
+ *
+ *  or	    0	1 (src)	    0	0 (0)	    0	0 (0)	    0	1 (src)
+ *  xor	    1	1 (1)	    1	0 (~src)    1	1 (1)	    1	0 (~src)
+ *
+ *	copyInverted	orInverted	nand		set
+ *     src  0	1	    0   1	    0	1	    0	1
+ *  dst	0   1	0	0   1   0	0   1	1	0   1	1
+ *	1   1	0	1   1   1	1   1	0	1   1	1
+ *
+ *  and	    0	0 (0)	    0   1 (src)	    0	1 (src)	    0	0 (0)
+ *  xor	    1	0 (~src)    1   0 (~src)    1	1 (1)	    1	1 (1)
+ *
+ *  or	    1	1 (1)	    1	0 (~src)    1	0 (~src)    1	1 (1)
+ *  xor	    0	1 (src)	    0	0 (0)	    0	1 (src)	    0	0 (0)
+ */
+
+iplReduceRasterOp (rop, fg, pm, and, xor)
+    int		    rop;
+    unsigned long   fg, pm;
+    unsigned short *and;
+    unsigned short *xor;
+{
+    int rrop;
+    switch (rop)
+    {
+    case GXclear:
+    	INTER_CLR(and);
+    	INTER_CLR(xor);
+	break;
+    case GXand:
+	INTER_PFILL(fg, and);
+	INTER_CLR(xor);
+	break;
+    case GXandReverse:
+	INTER_PFILL(fg, and);
+	INTER_PFILL(fg, xor);
+	break;
+    case GXcopy:
+	INTER_CLR(and);
+	INTER_PFILL(fg, xor);
+	break;
+    case GXandInverted:
+	INTER_PFILL(~fg, xor);
+	INTER_CLR(xor);
+	break;
+    case GXnoop:
+	INTER_SET(and);
+	INTER_CLR(xor);
+	break;
+    case GXxor:
+	INTER_SET(and);
+	INTER_PFILL(fg, xor);
+	break;
+    case GXor:
+	INTER_PFILL(~fg, and);
+	INTER_PFILL(fg, xor);
+	break;
+    case GXnor:
+	INTER_PFILL(~fg, and);
+	INTER_PFILL(~fg, xor);
+	break;
+    case GXequiv:
+	INTER_SET(and);
+	INTER_PFILL(~fg, xor);
+    case GXinvert:
+	INTER_SET(and);
+	INTER_SET(xor);
+	break;
+    case GXorReverse:
+	INTER_PFILL(~fg, and);
+	INTER_SET(xor);
+	break;
+    case GXcopyInverted:
+	INTER_CLR(and);
+	INTER_PFILL(~fg, xor);
+	break;
+    case GXorInverted:
+	INTER_PFILL(fg, and);
+	INTER_PFILL(~fg, xor);
+	break;
+    case GXnand:
+	INTER_PFILL(fg, and);
+	INTER_SET(xor);
+	break;
+    case GXset:
+	INTER_CLR(and);
+	INTER_SET(xor);
+	break;
+    }
+    INTER_ANDXOR_PM(pm, and, xor);
+    if (INTER_IS_CLR(and))
+	rrop = GXcopy;
+    else if (INTER_IS_SET(and))
+	rrop = GXxor;
+    else if (INTER_IS_CLR(xor))
+	rrop = GXand;
+    else if (INTER_IS_XOR_SET(and, xor))
+	rrop = GXor;
+    else
+        rrop = GXset;
+    return rrop;
+}
+
diff --git a/iplan2p4/iplrrop.h b/iplan2p4/iplrrop.h
new file mode 100644
index 000000000..d14d1a54b
--- /dev/null
+++ b/iplan2p4/iplrrop.h
@@ -0,0 +1,76 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplrrop.h,v 3.1 2001/07/25 15:05:09 dawes Exp $ */
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+/* reduced raster ops */
+/* INTER_RROP_DECLARE INTER_RROP_FETCH_GC, 
+   INTER_RROP_SOLID_MASK, INTER_RROP_SPAN INTER_RROP_NAME */
+
+#define INTER_RROP_FETCH_GC(gc) \
+INTER_RROP_FETCH_GCPRIV(((iplPrivGCPtr)(gc)->devPrivates[iplGCPrivateIndex].ptr))
+
+#if RROP == GXcopy
+#define INTER_RROP_DECLARE	register unsigned short *rrop_xor;
+#define INTER_RROP_FETCH_GCPRIV(devPriv)  rrop_xor = (devPriv)->xorg;
+#define INTER_RROP_SOLID(dst)	    	INTER_COPY(rrop_xor, dst)
+#define INTER_RROP_SOLID_MASK(dst,mask) INTER_COPYM(rrop_xor, dst, mask, dst)
+#define INTER_RROP_NAME(prefix) INTER_RROP_NAME_CAT(prefix,Copy)
+#endif /* GXcopy */
+
+#if RROP == GXxor
+#define INTER_RROP_DECLARE	register unsigned short	*rrop_xor;
+#define INTER_RROP_FETCH_GCPRIV(devPriv)  rrop_xor = (devPriv)->xorg;
+#define INTER_RROP_SOLID(dst)		INTER_XOR(rrop_xor, dst, dst)
+#define INTER_RROP_SOLID_MASK(dst,mask) INTER_XORM(rrop_xor, dst, mask, dst)
+#define INTER_RROP_NAME(prefix) INTER_RROP_NAME_CAT(prefix,Xor)
+#endif /* GXxor */
+
+#if RROP == GXand
+#define INTER_RROP_DECLARE	register unsigned short *rrop_and;
+#define INTER_RROP_FETCH_GCPRIV(devPriv)  rrop_and = (devPriv)->andg;
+#define INTER_RROP_SOLID(dst)	    	INTER_AND(rrop_and, dst, dst)
+#define INTER_RROP_SOLID_MASK(dst,mask) INTER_ANDM(rrop_and, dst, mask, dst)
+#define INTER_RROP_NAME(prefix) INTER_RROP_NAME_CAT(prefix,And)
+#endif /* GXand */
+
+#if RROP == GXor
+#define INTER_RROP_DECLARE	register unsigned short *rrop_or;
+#define INTER_RROP_FETCH_GCPRIV(devPriv)  rrop_or = (devPriv)->xorg;
+#define INTER_RROP_SOLID(dst)	    	INTER_OR(rrop_or, dst, dst)
+#define INTER_RROP_SOLID_MASK(dst,mask) INTER_ORM(mask, rrop_or, dst, dst)
+#define INTER_RROP_NAME(prefix) INTER_RROP_NAME_CAT(prefix,Or)
+#endif /* GXor */
+
+#if RROP == GXnoop
+#define INTER_RROP_DECLARE
+#define INTER_RROP_FETCH_GCPRIV(devPriv)
+#define INTER_RROP_SOLID(dst)
+#define INTER_RROP_SOLID_MASK(dst,mask)
+#define INTER_RROP_NAME(prefix) INTER_RROP_NAME_CAT(prefix,Noop)
+#endif /* GXnoop */
+
+#if RROP ==  GXset
+#define INTER_RROP_DECLARE	    register unsigned short	*rrop_and, *rrop_xor;
+#define INTER_RROP_FETCH_GCPRIV(devPriv)  rrop_and = (devPriv)->andg; \
+				    	  rrop_xor = (devPriv)->xorg;
+#define INTER_RROP_SOLID(dst)	INTER_DoRRop(dst, rrop_and, rrop_xor, dst)
+#define INTER_RROP_SOLID_MASK(dst,mask) \
+	INTER_DoMaskRRop(dst, rrop_and, rrop_xor, mask, dst)
+#define INTER_RROP_NAME(prefix) INTER_RROP_NAME_CAT(prefix,General)
+#endif /* GXset */
+
+#ifndef INTER_RROP_SPAN
+#define INTER_RROP_SPAN(pdst,nmiddle) 		\
+    while (--(nmiddle) >= 0) { 			\
+	INTER_RROP_SOLID(pdst); 		\
+	(pdst) = INTER_NEXT(pdst); 		\
+    }
+
+#endif
+
+#if !defined(UNIXCPP) || defined(ANSICPP)
+#define INTER_RROP_NAME_CAT(prefix,suffix)	prefix##suffix
+#else
+#define INTER_RROP_NAME_CAT(prefix,suffix)	prefix/**/suffix
+#endif
+
diff --git a/iplan2p4/iplscrinit.c b/iplan2p4/iplscrinit.c
new file mode 100644
index 000000000..1d7915776
--- /dev/null
+++ b/iplan2p4/iplscrinit.c
@@ -0,0 +1,229 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplscrinit.c,v 3.3 1998/11/22 10:37:41 dawes 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.
+
+********************************************************/
+/* $XConsortium: iplscrinit.c,v 5.32 94/04/17 20:29:00 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "resource.h"
+#include "colormap.h"
+#include "colormapst.h"
+#include "ipl.h"
+#include "mi.h"
+#include "mistruct.h"
+#include "dix.h"
+#include "mibstore.h"
+
+
+BSFuncRec iplBSFuncRec = {
+    iplSaveAreas,
+    iplRestoreAreas,
+    (BackingStoreSetClipmaskRgnProcPtr) 0,
+    (BackingStoreGetImagePixmapProcPtr) 0,
+    (BackingStoreGetSpansPixmapProcPtr) 0,
+};
+
+Bool
+iplCloseScreen (index, pScreen)
+    int		index;
+    ScreenPtr	pScreen;
+{
+    int	    d;
+    DepthPtr	depths = pScreen->allowedDepths;
+
+    for (d = 0; d < pScreen->numDepths; d++)
+	xfree (depths[d].vids);
+    xfree (depths);
+    xfree (pScreen->visuals);
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    xfree (pScreen->devPrivates[iplScreenPrivateIndex].ptr);
+#else
+    xfree (pScreen->devPrivate);
+#endif
+    return TRUE;
+}
+
+Bool
+iplSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
+    register ScreenPtr pScreen;
+    pointer pbits;		/* pointer to screen bitmap */
+    int xsize, ysize;		/* in pixels */
+    int dpix, dpiy;		/* dots per inch */
+    int width;			/* pixel width of frame buffer */
+{
+    int	i;
+    extern RegionPtr	(*iplPuntCopyPlane)();
+
+    if (!iplAllocatePrivates(pScreen, (int *) 0, (int *) 0))
+	return FALSE;
+    pScreen->defColormap = FakeClientID(0);
+    /* let CreateDefColormap do whatever it wants for pixels */ 
+    pScreen->blackPixel = pScreen->whitePixel = (Pixel) 0;
+    pScreen->QueryBestSize = mfbQueryBestSize;
+    /* SaveScreen */
+    pScreen->GetImage = iplGetImage;
+    pScreen->GetSpans = iplGetSpans;
+    pScreen->CreateWindow = iplCreateWindow;
+    pScreen->DestroyWindow = iplDestroyWindow;
+    pScreen->PositionWindow = iplPositionWindow;
+    pScreen->ChangeWindowAttributes = iplChangeWindowAttributes;
+    pScreen->RealizeWindow = iplMapWindow;
+    pScreen->UnrealizeWindow = iplUnmapWindow;
+    pScreen->PaintWindowBackground = iplPaintWindow;
+    pScreen->PaintWindowBorder = iplPaintWindow;
+    pScreen->CopyWindow = iplCopyWindow;
+    pScreen->CreatePixmap = iplCreatePixmap;
+    pScreen->DestroyPixmap = iplDestroyPixmap;
+    pScreen->RealizeFont = mfbRealizeFont;
+    pScreen->UnrealizeFont = mfbUnrealizeFont;
+    pScreen->CreateGC = iplCreateGC;
+    pScreen->CreateColormap = iplInitializeColormap;
+    pScreen->DestroyColormap = (void (*)())NoopDDA;
+    pScreen->InstallColormap = iplInstallColormap;
+    pScreen->UninstallColormap = iplUninstallColormap;
+    pScreen->ListInstalledColormaps = iplListInstalledColormaps;
+    pScreen->StoreColors = (void (*)())NoopDDA;
+    pScreen->ResolveColor = iplResolveColor;
+    pScreen->BitmapToRegion = mfbPixmapToRegion;
+
+    mfbRegisterCopyPlaneProc (pScreen, iplCopyPlane);
+    return TRUE;
+}
+
+#ifdef CFB_NEED_SCREEN_PRIVATE
+Bool
+iplCreateScreenResources(pScreen)
+    ScreenPtr pScreen;
+{
+    Bool retval;
+
+    pointer oldDevPrivate = pScreen->devPrivate;
+    pScreen->devPrivate = pScreen->devPrivates[iplScreenPrivateIndex].ptr;
+    retval = miCreateScreenResources(pScreen);
+    pScreen->devPrivates[iplScreenPrivateIndex].ptr = pScreen->devPrivate;
+    pScreen->devPrivate = oldDevPrivate;
+    return retval;
+}
+#endif
+
+Bool
+iplFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
+    register ScreenPtr pScreen;
+    pointer pbits;		/* pointer to screen bitmap */
+    int xsize, ysize;		/* in pixels */
+    int dpix, dpiy;		/* dots per inch */
+    int width;			/* pixel width of frame buffer */
+{
+    int	i, j;
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    pointer oldDevPrivate;
+#endif
+    VisualPtr	visuals;
+    DepthPtr	depths;
+    int		nvisuals;
+    int		ndepths;
+    int		rootdepth;
+    VisualID	defaultVisual;
+
+    rootdepth = 0;
+    if (!iplInitVisuals (&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
+			 &defaultVisual,((unsigned long)1<<(INTER_PLANES-1)), 8))
+	return FALSE;
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    oldDevPrivate = pScreen->devPrivate;
+#endif
+    if (! miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
+			rootdepth, ndepths, depths,
+			defaultVisual, nvisuals, visuals))
+	return FALSE;
+    /* overwrite miCloseScreen with our own */
+    pScreen->CloseScreen = iplCloseScreen;
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    pScreen->CreateScreenResources = iplCreateScreenResources;
+    pScreen->devPrivates[iplScreenPrivateIndex].ptr = pScreen->devPrivate;
+    pScreen->devPrivate = oldDevPrivate;
+#endif
+    pScreen->BackingStoreFuncs = iplBSFuncRec;
+    pScreen->GetScreenPixmap = iplGetScreenPixmap;
+    pScreen->SetScreenPixmap = iplSetScreenPixmap;
+    return TRUE;
+}
+
+/* dts * (inch/dot) * (25.4 mm / inch) = mm */
+Bool
+iplScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
+    register ScreenPtr pScreen;
+    pointer pbits;		/* pointer to screen bitmap */
+    int xsize, ysize;		/* in pixels */
+    int dpix, dpiy;		/* dots per inch */
+    int width;			/* pixel width of frame buffer */
+{
+    if (!iplSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width))
+	return FALSE;
+    if (!iplFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width))
+	return FALSE;
+#if INTER_PLANES == 2
+/* This shouldn't be necessary */
+    PixmapWidthPaddingInfo[2].padPixelsLog2 = 4;
+    PixmapWidthPaddingInfo[2].padRoundUp = 15;
+    PixmapWidthPaddingInfo[2].padBytesLog2 = 2;
+#endif
+    return TRUE;
+}
+
+PixmapPtr
+iplGetScreenPixmap(pScreen)
+    ScreenPtr pScreen;
+{
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    return (PixmapPtr)(pScreen->devPrivates[iplScreenPrivateIndex].ptr);
+#else
+    return (PixmapPtr)(pScreen->devPrivate.ptr);
+#endif
+}
+
+void
+iplSetScreenPixmap(pPix)
+    PixmapPtr pPix;
+{
+#ifdef CFB_NEED_SCREEN_PRIVATE
+    if (pPix)
+	pPix->drawable.pScreen->devPrivates[iplScreenPrivateIndex].ptr =
+	    (pointer)pPix;
+#else
+    if (pPix)
+	pPix->drawable.pScreen->devPrivate.ptr = (pointer)pPix;
+#endif
+}
diff --git a/iplan2p4/iplsetsp.c b/iplan2p4/iplsetsp.c
new file mode 100644
index 000000000..0533eed71
--- /dev/null
+++ b/iplan2p4/iplsetsp.c
@@ -0,0 +1,300 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplsetsp.c,v 3.0 1996/08/18 01:55:07 dawes Exp $ */
+/* $XConsortium: iplsetsp.c,v 5.10 94/04/17 20:29:01 dpw Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+
+#include "misc.h"
+#include "regionstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ipl.h"
+
+#include "iplmskbits.h"
+#include "iplmergerop.h"
+#include "iplpack.h"
+
+/* iplSetScanline -- copies the bits from psrc to the drawable starting at
+ * (xStart, y) and continuing to (xEnd, y).  xOrigin tells us where psrc 
+ * starts on the scanline. (I.e., if this scanline passes through multiple
+ * boxes, we may not want to start grabbing bits at psrc but at some offset
+ * further on.) 
+ */
+iplSetScanline(y, xOrigin, xStart, xEnd, psrc, alu, pdstBase, widthDst, planemask)
+    int			y;
+    int			xOrigin;	/* where this scanline starts */
+    int			xStart;		/* first bit to use from scanline */
+    int			xEnd;		/* last bit to use from scanline + 1 */
+    register unsigned int *psrc;
+    register int	alu;		/* raster op */
+    INTER_DECLAREG(*pdstBase);		/* start of the drawable */
+    int			widthDst;	/* width of drawable in groups */
+    unsigned long	planemask;
+{
+    int			w;		/* width of scanline in bits */
+    INTER_DECLAREG(*pdst);		/* where to put the bits */
+    INTER_DECLAREGP(tmpSrc);		/* scratch buffer to collect bits in */
+    int			dstBit;		/* offset in bits from beginning of 
+					 * word */
+    register int	nstart; 	/* number of bits from first partial */
+    register int	nend; 		/* " " last partial word */
+    int			offSrc;
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);
+    int nlMiddle, nl, longs;
+    INTER_DECLAREG(*ipsrc);
+    INTER_DECLAREG(*tmppsrc);
+    INTER_DeclareMergeRop()
+
+    INTER_InitializeMergeRop(alu,planemask);
+
+    longs=NUM_LONGS(INTER_PLANES, xOrigin, xEnd);
+
+    tmppsrc = ipsrc = (unsigned short *) 
+	    ALLOCATE_LOCAL(NUM_TEMP_BYTES(INTER_PLANES,longs));
+
+    iplUnpackLine(INTER_PLANES, longs, psrc, ipsrc);
+
+    pdst = pdstBase + (y * widthDst) + (xStart >> INTER_PGSH) * INTER_PLANES; 
+    offSrc = (xStart - xOrigin) & INTER_PIM;
+    w = xEnd - xStart;
+    dstBit = xStart & INTER_PIM;
+
+    ipsrc += ((xStart - xOrigin) >> INTER_PGSH) * INTER_PLANES;
+    if (dstBit + w <= INTER_PPG) 
+    { 
+	INTER_maskpartialbits(dstBit, w, startmask);
+	endmask = 0;
+	nlMiddle = 0;
+    } 
+    else 
+    { 
+	INTER_maskbits(xStart, w, startmask, endmask, nlMiddle);
+    }
+    if (startmask) 
+	nstart = INTER_PPG - dstBit; 
+    else 
+	nstart = 0; 
+    if (endmask) 
+	nend = xEnd & INTER_PIM; 
+    else 
+	nend = 0; 
+    if (startmask) 
+    { 
+	INTER_getbits(ipsrc, offSrc, nstart, tmpSrc);
+	INTER_putbitsmropshort(tmpSrc, dstBit, nstart, pdst);
+	INTER_NEXT_GROUP(pdst); 
+	offSrc += nstart;
+	if (offSrc > INTER_PLST)
+	{
+	    INTER_NEXT_GROUP(ipsrc);
+	    offSrc -= INTER_PPG;
+	}
+    } 
+    nl = nlMiddle; 
+    while (nl--) 
+    { 
+	INTER_getbits(ipsrc, offSrc, INTER_PPG, tmpSrc);
+	INTER_DoMergeRop(tmpSrc, pdst, pdst);
+	INTER_NEXT_GROUP(pdst); 
+	INTER_NEXT_GROUP(ipsrc); 
+    } 
+    if (endmask) 
+    { 
+	INTER_getbits(ipsrc, offSrc, nend, tmpSrc);
+	INTER_putbitsmropshort(tmpSrc, 0, nend, pdst);
+    } 
+    DEALLOCATE_LOCAL(tmppsrc);
+}
+
+
+
+/* SetSpans -- for each span copy pwidth[i] bits from psrc to pDrawable at
+ * ppt[i] using the raster op from the GC.  If fSorted is TRUE, the scanlines
+ * are in increasing Y order.
+ * Source bit lines are server scanline padded so that they always begin
+ * on a word boundary.
+ */ 
+void
+iplSetSpans(pDrawable, pGC, pcharsrc, ppt, pwidth, nspans, fSorted)
+    DrawablePtr		pDrawable;
+    GCPtr		pGC;
+    char		*pcharsrc;
+    register DDXPointPtr ppt;
+    int			*pwidth;
+    int			nspans;
+    int			fSorted;
+{
+    unsigned int	*psrc = (unsigned int *)pcharsrc;
+    INTER_DECLAREG(*pdstBase);		/* start of dst bitmap */
+    int 		widthDst;	/* width of bitmap in words */
+    register BoxPtr 	pbox, pboxLast, pboxTest;
+    register DDXPointPtr pptLast;
+    int 		alu;
+    RegionPtr 		prgnDst;
+    int			xStart, xEnd;
+    int			yMax;
+
+    alu = pGC->alu;
+    prgnDst = iplGetCompositeClip(pGC);
+    pptLast = ppt + nspans;
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pdstBase)
+
+    yMax = (int) pDrawable->y + (int) pDrawable->height;
+
+    pbox = REGION_RECTS(prgnDst);
+    pboxLast = pbox + REGION_NUM_RECTS(prgnDst);
+
+    if(fSorted)
+    {
+    /* scan lines sorted in ascending order. Because they are sorted, we
+     * don't have to check each scanline against each clip box.  We can be
+     * sure that this scanline only has to be clipped to boxes at or after the
+     * beginning of this y-band 
+     */
+	pboxTest = pbox;
+	while(ppt < pptLast)
+	{
+	    pbox = pboxTest;
+	    if(ppt->y >= yMax)
+		break;
+	    while(pbox < pboxLast)
+	    {
+		if(pbox->y1 > ppt->y)
+		{
+		    /* scanline is before clip box */
+		    break;
+		}
+		else if(pbox->y2 <= ppt->y)
+		{
+		    /* clip box is before scanline */
+		    pboxTest = ++pbox;
+		    continue;
+		}
+		else if(pbox->x1 > ppt->x + *pwidth) 
+		{
+		    /* clip box is to right of scanline */
+		    break;
+		}
+		else if(pbox->x2 <= ppt->x)
+		{
+		    /* scanline is to right of clip box */
+		    pbox++;
+		    continue;
+		}
+
+		/* at least some of the scanline is in the current clip box */
+		xStart = max(pbox->x1, ppt->x);
+		xEnd = min(ppt->x + *pwidth, pbox->x2);
+		iplSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
+		    pdstBase, widthDst, pGC->planemask);
+		if(ppt->x + *pwidth <= pbox->x2)
+		{
+		    /* End of the line, as it were */
+		    break;
+		}
+		else
+		    pbox++;
+	    }
+	    /* We've tried this line against every box; it must be outside them
+	     * all.  move on to the next point */
+	    ppt++;
+	    psrc += PixmapWidthInPadUnits(*pwidth, pDrawable->depth);
+	    pwidth++;
+	}
+    }
+    else
+    {
+    /* scan lines not sorted. We must clip each line against all the boxes */
+	while(ppt < pptLast)
+	{
+	    if(ppt->y >= 0 && ppt->y < yMax)
+	    {
+		
+		for(pbox = REGION_RECTS(prgnDst); pbox< pboxLast; pbox++)
+		{
+		    if(pbox->y1 > ppt->y)
+		    {
+			/* rest of clip region is above this scanline,
+			 * skip it */
+			break;
+		    }
+		    if(pbox->y2 <= ppt->y)
+		    {
+			/* clip box is below scanline */
+			pbox++;
+			break;
+		    }
+		    if(pbox->x1 <= ppt->x + *pwidth &&
+		       pbox->x2 > ppt->x)
+		    {
+			xStart = max(pbox->x1, ppt->x);
+			xEnd = min(pbox->x2, ppt->x + *pwidth);
+			iplSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
+			    pdstBase, widthDst, pGC->planemask);
+		    }
+
+		}
+	    }
+	psrc += PixmapWidthInPadUnits(*pwidth, pDrawable->depth);
+	ppt++;
+	pwidth++;
+	}
+    }
+}
+
diff --git a/iplan2p4/iplsolid.c b/iplan2p4/iplsolid.c
new file mode 100644
index 000000000..2f741ed7f
--- /dev/null
+++ b/iplan2p4/iplsolid.c
@@ -0,0 +1,217 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplsolid.c,v 3.1 1998/03/20 21:08:09 hohndel Exp $ */
+/*
+ * $XConsortium: iplsolid.c,v 1.9 94/04/17 20:29:02 dpw Exp $
+ *
+Copyright (c) 1990  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+#include "gcstruct.h"
+#include "window.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+
+#include "ipl.h"
+#include "iplrrop.h"
+
+#include "mi.h"
+#include "mispans.h"
+
+#include "iplmskbits.h"
+
+#  define Expand(left, right, leftAdjust) { \
+    while (h--) { \
+	pdst = pdstRect; \
+	left \
+	m = nmiddle; \
+	INTER_RROP_SPAN(pdst, m); \
+	right \
+	pdstRect += widthDst; \
+    } \
+}
+	
+
+void
+INTER_RROP_NAME(iplFillRectSolid) (pDrawable, pGC, nBox, pBox)
+    DrawablePtr	    pDrawable;
+    GCPtr	    pGC;
+    int		    nBox;
+    BoxPtr	    pBox;
+{
+    register int    m;
+    INTER_DECLAREG(*pdst);
+    INTER_RROP_DECLARE
+    INTER_DECLAREG(leftMask);
+    INTER_DECLAREG(rightMask);
+    INTER_DECLAREG(*pdstBase);
+    INTER_DECLAREG(*pdstRect);
+    int		    nmiddle;
+    int		    h;
+    int		    w;
+    int		    widthDst;
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pdstBase)
+
+    INTER_RROP_FETCH_GC(pGC)
+    
+    for (; nBox; nBox--, pBox++)
+    {
+    	pdstRect = pdstBase + pBox->y1 * widthDst;
+    	h = pBox->y2 - pBox->y1;
+	w = pBox->x2 - pBox->x1;
+	pdstRect += (pBox->x1 >> INTER_PGSH) * INTER_PLANES;
+	if ((pBox->x1 & INTER_PIM) + w <= INTER_PPG)
+	{
+	    INTER_maskpartialbits(pBox->x1, w, leftMask);
+	    pdst = pdstRect;
+	    while (h--) {
+		INTER_RROP_SOLID_MASK (pdst, leftMask);
+		pdst += widthDst;
+	    }
+	}
+	else
+	{
+	    INTER_maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
+	    if (leftMask)
+	    {
+		if (rightMask)	/* left mask and right mask */
+		{
+		    Expand(INTER_RROP_SOLID_MASK (pdst, leftMask); 
+			   INTER_NEXT_GROUP(pdst);,
+			   INTER_RROP_SOLID_MASK (pdst, rightMask);, 1)
+		}
+		else	/* left mask and no right mask */
+		{
+		    Expand(INTER_RROP_SOLID_MASK (pdst, leftMask); 
+			   INTER_NEXT_GROUP(pdst);,
+			   ;, 1)
+		}
+	    }
+	    else
+	    {
+		if (rightMask)	/* no left mask and right mask */
+		{
+		    Expand(;,
+			   INTER_RROP_SOLID_MASK (pdst, rightMask);, 0)
+		}
+		else	/* no left mask and no right mask */
+		{
+		    Expand(;,
+			    ;, 0)
+		}
+	    }
+	}
+    }
+}
+
+void
+INTER_RROP_NAME(iplSolidSpans) (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
+    DrawablePtr pDrawable;
+    GCPtr	pGC;
+    int		nInit;			/* number of spans to fill */
+    DDXPointPtr pptInit;		/* pointer to list of start points */
+    int		*pwidthInit;		/* pointer to list of n widths */
+    int 	fSorted;
+{
+    INTER_DECLAREG(*pdstBase);
+    int		    widthDst;
+
+    INTER_RROP_DECLARE
+    
+    INTER_DECLAREG(*pdst);
+    register int	    ngmiddle;
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);
+    register int	    w;
+    int			    x;
+    
+				/* next three parameters are post-clip */
+    int		    n;		/* number of spans to fill */
+    DDXPointPtr	    ppt;	/* pointer to list of start points */
+    int		    *pwidthFree;/* copies of the pointers to free */
+    DDXPointPtr	    pptFree;
+    int		    *pwidth;
+    iplPrivGCPtr    devPriv;
+
+    devPriv = iplGetGCPrivate(pGC);
+    INTER_RROP_FETCH_GCPRIV(devPriv)
+    n = nInit * miFindMaxBand(pGC->pCompositeClip);
+    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    if(!pptFree || !pwidthFree)
+    {
+	if (pptFree) DEALLOCATE_LOCAL(pptFree);
+	if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+	return;
+    }
+    pwidth = pwidthFree;
+    ppt = pptFree;
+    n = miClipSpans(pGC->pCompositeClip, pptInit, pwidthInit, nInit,
+		     ppt, pwidth, fSorted);
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pdstBase)
+
+    while (n--)
+    {
+	x = ppt->x;
+	pdst = pdstBase + (ppt->y * widthDst);
+	++ppt;
+	w = *pwidth++;
+	if (!w)
+	    continue;
+	if ((x & INTER_PIM) + w <= INTER_PPG)
+	{
+	    pdst += (x >> INTER_PGSH) * INTER_PLANES;
+	    INTER_maskpartialbits (x, w, startmask);
+	    INTER_RROP_SOLID_MASK (pdst, startmask);
+	}
+	else
+	{
+	    pdst += (x >> INTER_PGSH) * INTER_PLANES;
+	    INTER_maskbits (x, w, startmask, endmask, ngmiddle);
+	    if (startmask)
+	    {
+		INTER_RROP_SOLID_MASK (pdst, startmask);
+		INTER_NEXT_GROUP(pdst);
+	    }
+	    
+	    INTER_RROP_SPAN(pdst,ngmiddle);
+
+	    if (endmask)
+	    {
+		INTER_RROP_SOLID_MASK (pdst, endmask);
+	    }
+	}
+    }
+    DEALLOCATE_LOCAL(pptFree);
+    DEALLOCATE_LOCAL(pwidthFree);
+}
diff --git a/iplan2p4/ipltegblt.c b/iplan2p4/ipltegblt.c
new file mode 100644
index 000000000..4d82a655a
--- /dev/null
+++ b/iplan2p4/ipltegblt.c
@@ -0,0 +1,217 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/ipltegblt.c,v 3.0 1996/08/18 01:55:09 dawes Exp $ */
+/* $XConsortium: ipltegblt.c,v 5.9 94/04/17 20:29:03 dpw Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include	"X.h"
+#include	"Xmd.h"
+#include	"Xproto.h"
+#include	"ipl.h"
+#include	"fontstruct.h"
+#include	"dixfontstr.h"
+#include	"gcstruct.h"
+#include	"windowstr.h"
+#include	"scrnintstr.h"
+#include	"pixmapstr.h"
+#include	"regionstr.h"
+#include	"mi.h"
+#define MFB_CONSTS_ONLY
+#include	"maskbits.h"
+
+#include	"iplmskbits.h"
+
+/*
+    this works for fonts with glyphs <= 32 bits wide, on an
+    arbitrarily deep display.  Use iplTEGlyphBlt8 for 8 bit displays.
+
+    This should be called only with a terminal-emulator font;
+this means that the FIXED_METRICS flag is set, and that
+glyphbounds == charbounds.
+
+    in theory, this goes faster; even if it doesn't, it reduces the
+flicker caused by writing a string over itself with image text (since
+the background gets repainted per character instead of per string.)
+this seems to be important for some converted X10 applications.
+
+    Image text looks at the bits in the glyph and the fg and bg in the
+GC.  it paints a rectangle, as defined in the protocol dcoument,
+and the paints the characters.
+
+*/
+
+void
+iplTEGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
+    DrawablePtr pDrawable;
+    GC 		*pGC;
+    int 	x, y;
+    unsigned int nglyph;
+    CharInfoPtr *ppci;		/* array of character info */
+    pointer	pglyphBase;	/* start of array of glyphs */
+{
+    FontPtr	pfont = pGC->font;
+    int widthDst;
+    INTER_DECLAREG(*pdstBase);	/* pointer to group with top row 
+				   of current glyph */
+
+    int w;			/* width of glyph and char */
+    int h;			/* height of glyph and char */
+    register int xpos=x;	/* current x%32  */
+    int ypos=y;			/* current y%32 */
+    register unsigned char *pglyph;
+    int widthGlyph;
+
+    INTER_DECLAREG(*pdst);	/* pointer to current group in dst */
+    int hTmp;			/* counter for height */
+    BoxRec bbox;		/* for clipping */
+
+    register int wtmp,xtemp,width;
+    INTER_DECLAREGP(bgfill);
+    INTER_DECLAREGP(fgfill);
+    unsigned long *ptemp;
+    INTER_DECLAREGP(tmpDst1);
+    INTER_DECLAREGP(tmpDst2);
+    INTER_DECLAREG(*pdtmp);
+    int tmpx;
+
+    xpos += pDrawable->x;
+    ypos += pDrawable->y;
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pdstBase)
+
+    wtmp = FONTMAXBOUNDS(pfont,characterWidth);
+    h = FONTASCENT(pfont) + FONTDESCENT(pfont);
+    widthGlyph = GLYPHWIDTHBYTESPADDED(*ppci);
+
+    xpos += FONTMAXBOUNDS(pfont,leftSideBearing);
+    ypos -= FONTASCENT(pfont);
+
+    bbox.x1 = xpos;
+    bbox.x2 = xpos + (wtmp * nglyph);
+    bbox.y1 = ypos;
+    bbox.y2 = ypos + h;
+
+    INTER_PFILL(pGC->fgPixel, fgfill);
+    INTER_PFILL(pGC->bgPixel, bgfill);
+
+    switch (RECT_IN_REGION(pGC->pScreen,  iplGetCompositeClip(pGC), &bbox))
+    {
+      case rgnOUT:
+	break;
+      case rgnPART:
+	/* this is the WRONG thing to do, but it works.
+	   calling the non-terminal text is easy, but slow, given
+	   what we know about the font.
+
+	   the right thing to do is something like:
+	    for each clip rectangle
+		compute at which row the glyph starts to be in it,
+		   and at which row the glyph ceases to be in it
+		compute which is the first glyph inside the left
+		    edge, and the last one inside the right edge
+		draw a fractional first glyph, using only
+		    the rows we know are in
+		draw all the whole glyphs, using the appropriate rows
+		draw any pieces of the last glyph, using the right rows
+
+	   this way, the code would take advantage of knowing that
+	   all glyphs are the same height and don't overlap.
+
+	   one day...
+	*/
+#if 1
+	miImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
+#endif
+	break;
+      case rgnIN:
+
+        pdtmp = pdstBase + (widthDst * ypos);
+        while(nglyph--)
+        {
+
+	    pglyph = FONTGLYPHBITS(pglyphBase, *ppci++);
+            pdst = pdtmp;
+	    hTmp = h;
+
+	    while (hTmp--)
+	    {
+		x = xpos;
+		width = wtmp;
+ 	        xtemp = 0;
+
+		while (width > 0)
+		{
+		    tmpx = x & INTER_PIM;
+		    w = min(width, INTER_PPG - tmpx);
+		    /* w = min(w, (PGSZ - xtemp)); */
+
+		    ptemp = (unsigned long *)(pglyph + (xtemp >> MFB_PWSH));
+#if 1
+		    INTER_getstipplepixelsb(ptemp,xtemp,w,bgfill,fgfill,tmpDst1);
+#endif
+		    {
+			INTER_DECLAREG(*pdsttmp) =
+				pdst + (x >> INTER_PGSH) * INTER_PLANES;
+#if 1
+			INTER_putbits(tmpDst1,tmpx,w,pdsttmp,pGC->planemask);
+#endif
+		    }
+		    x += w;
+		    xtemp += w;
+		    width -= w;
+		}
+		pglyph += widthGlyph;
+                pdst += widthDst;
+	    }
+	    xpos += wtmp;
+        }     
+	break;
+    }
+}
diff --git a/iplan2p4/ipltile32.c b/iplan2p4/ipltile32.c
new file mode 100644
index 000000000..ea608effb
--- /dev/null
+++ b/iplan2p4/ipltile32.c
@@ -0,0 +1,268 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/ipltile32.c,v 3.1 1998/03/20 21:08:09 hohndel Exp $ */
+/*
+ * Fill 32 bit tiled rectangles.  Used by both PolyFillRect and PaintWindow.
+ * no depth dependencies.
+ */
+
+/*
+
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+*/
+
+/* $XConsortium: ipltile32.c,v 1.8 94/04/17 20:29:05 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+#include "gcstruct.h"
+#include "window.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+
+#include "ipl.h"
+
+#include "mi.h"
+#include "mispans.h"
+
+#include "iplmskbits.h"
+#include "iplmergerop.h"
+
+#define STORE(p)    INTER_MROP_PREBUILT_SOLID(srcpix, p, p)
+
+#define Expand(left,right) {\
+    while (h--)	{ \
+	INTER_COPY(psrc+srcy*INTER_PLANES, srcpix); \
+	INTER_MROP_PREBUILD(srcpix); \
+	++srcy; \
+	if (srcy == tileHeight) \
+	    srcy = 0; \
+	left \
+	ngw = ngwMiddle; \
+	while (ngw--) \
+	{ \
+	    STORE(p); \
+	    INTER_NEXT_GROUP(p); \
+	} \
+	right \
+	p += ngwExtra; \
+    } \
+}
+
+void
+INTER_MROP_NAME(iplFillRectTile32) (pDrawable, pGC, nBox, pBox)
+    DrawablePtr	    pDrawable;
+    GCPtr	    pGC;
+    int		    nBox;	/* number of boxes to fill */
+    BoxPtr 	    pBox;	/* pointer to list of boxes to fill */
+{
+    INTER_DECLAREGP(srcpix);
+    INTER_DECLAREG(*psrc);	/* pointer to bits in tile, if needed */
+    int tileHeight;	/* height of the tile */
+
+    int ngwDst;		/* width in longwords of the dest pixmap */
+    int w;		/* width of current box */
+    register int h;	/* height of current box */
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask); /* masks for reggedy bits at either end of line */
+    int ngwMiddle;	/* number of longwords between sides of boxes */
+    int ngwExtra;	/* to get from right of box to left of next span */
+    register int ngw;	/* loop version of ngwMiddle */
+    INTER_DECLAREG(*p);	/* pointer to bits we're writing */
+    int y;		/* current scan line */
+    int srcy;		/* current tile position */
+
+    INTER_DECLAREG(*pbits); /* pointer to start of pixmap */
+    PixmapPtr	    tile;	/* rotated, expanded tile */
+    INTER_MROP_DECLARE_REG()
+    INTER_MROP_PREBUILT_DECLARE()
+
+    tile = pGC->pRotatedPixmap;
+    tileHeight = tile->drawable.height;
+    psrc = (unsigned short *)tile->devPrivate.ptr;
+
+    INTER_MROP_INITIALIZE(pGC->alu, pGC->planemask);
+
+    iplGetGroupWidthAndPointer (pDrawable, ngwDst, pbits)
+
+    while (nBox--)
+    {
+	w = pBox->x2 - pBox->x1;
+	h = pBox->y2 - pBox->y1;
+	y = pBox->y1;
+	p = pbits + (y * ngwDst) + (pBox->x1 >> INTER_PGSH) * INTER_PLANES;
+	srcy = y % tileHeight;
+
+	if ( ((pBox->x1 & INTER_PIM) + w) <= INTER_PPG)
+	{
+	    INTER_maskpartialbits(pBox->x1, w, startmask);
+	    ngwExtra = ngwDst;
+	    while (h--)
+	    {
+		INTER_COPY(psrc+srcy*INTER_PLANES, srcpix);
+		INTER_MROP_PREBUILD(srcpix);
+		++srcy;
+		if (srcy == tileHeight)
+		    srcy = 0;
+		INTER_MROP_PREBUILT_MASK(srcpix, p, startmask, p);
+		p += ngwExtra;
+	    }
+	}
+	else
+	{
+	    INTER_maskbits(pBox->x1, w, startmask, endmask, ngwMiddle);
+	    ngwExtra = ngwDst - ngwMiddle * INTER_PLANES;
+
+	    if (startmask)
+	    {
+		ngwExtra -= INTER_PLANES;
+		if (endmask)
+		{
+		    Expand(
+		    INTER_MROP_PREBUILT_MASK(srcpix, p, startmask, p);
+		    INTER_NEXT_GROUP(p);,
+		    INTER_MROP_PREBUILT_MASK(srcpix, p, endmask, p));
+		}
+		else
+		{
+		    Expand(
+		    INTER_MROP_PREBUILT_MASK(srcpix, p, startmask, p);
+		    INTER_NEXT_GROUP(p);,
+			   ;)
+		}
+	    }
+	    else
+	    {
+		if (endmask)
+		{
+		    Expand(;,
+		    INTER_MROP_PREBUILT_MASK(srcpix, p, endmask, p));
+		}
+		else
+		{
+		    Expand(;,
+			   ;)
+		}
+	    }
+	}
+        pBox++;
+    }
+}
+
+void
+INTER_MROP_NAME(iplTile32FS)(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
+    DrawablePtr pDrawable;
+    GCPtr	pGC;
+    int		nInit;			/* number of spans to fill */
+    DDXPointPtr pptInit;		/* pointer to list of start points */
+    int		*pwidthInit;		/* pointer to list of n widths */
+    int 	fSorted;
+{
+				/* next three parameters are post-clip */
+    int			n;	/* number of spans to fill */
+    DDXPointPtr		ppt;	/* pointer to list of start points */
+    int			*pwidth;/* pointer to list of n widths */
+    INTER_DECLAREG(*pbits);	/* pointer to start of bitmap */
+    int			ngwDst;	/* width in longwords of bitmap */
+    INTER_DECLAREG(*p);		/* pointer to current longword in bitmap */
+    register int	w;	/* current span width */
+    register int	ngw;
+    register int	x;
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);
+    INTER_DECLAREGP(srcpix);
+    int			y;
+    int			*pwidthFree;/* copies of the pointers to free */
+    DDXPointPtr		pptFree;
+    PixmapPtr		tile;
+    INTER_DECLAREG(*psrc);	/* pointer to bits in tile */
+    int			tileHeight;/* height of the tile */
+    INTER_MROP_DECLARE_REG ()
+    INTER_MROP_PREBUILT_DECLARE()
+
+    n = nInit * miFindMaxBand( iplGetCompositeClip(pGC) );
+    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    if(!pptFree || !pwidthFree)
+    {
+	if (pptFree) DEALLOCATE_LOCAL(pptFree);
+	if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+	return;
+    }
+    pwidth = pwidthFree;
+    ppt = pptFree;
+    n = miClipSpans( iplGetCompositeClip(pGC),
+		     pptInit, pwidthInit, nInit,
+		     ppt, pwidth, fSorted);
+
+    tile = pGC->pRotatedPixmap;
+    tileHeight = tile->drawable.height;
+    psrc = (unsigned short *)tile->devPrivate.ptr;
+
+    INTER_MROP_INITIALIZE(pGC->alu, pGC->planemask);
+
+    iplGetGroupWidthAndPointer (pDrawable, ngwDst, pbits)
+
+    {
+    	while (n--)
+    	{
+	    x = ppt->x;
+	    y = ppt->y;
+	    ++ppt;
+	    w = *pwidth++;
+	    p = pbits + (y * ngwDst) + (x >> INTER_PGSH) * INTER_PLANES;
+	    INTER_COPY(psrc +(y % tileHeight)*INTER_PLANES,srcpix);
+	    INTER_MROP_PREBUILD(srcpix);
+    
+	    if ((x & INTER_PIM) + w < INTER_PPG)
+	    {
+	    	INTER_maskpartialbits(x, w, startmask);
+		INTER_MROP_PREBUILT_MASK(srcpix, p, startmask, p);
+	    }
+	    else
+	    {
+	    	INTER_maskbits(x, w, startmask, endmask, ngw);
+	    	if (startmask)
+	    	{
+		    INTER_MROP_PREBUILT_MASK(srcpix, p, startmask, p);
+		    INTER_NEXT_GROUP(p);
+	    	}
+	    	while (ngw--)
+	    	{
+		    STORE(p);
+		    INTER_NEXT_GROUP(p);
+	    	}
+	    	if (endmask)
+	    	{
+		    INTER_MROP_PREBUILT_MASK(srcpix, p, endmask, p);
+	    	}
+	    }
+    	}
+    }
+    DEALLOCATE_LOCAL(pptFree);
+    DEALLOCATE_LOCAL(pwidthFree);
+}
diff --git a/iplan2p4/ipltileodd.c b/iplan2p4/ipltileodd.c
new file mode 100644
index 000000000..a63ce5da6
--- /dev/null
+++ b/iplan2p4/ipltileodd.c
@@ -0,0 +1,865 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/ipltileodd.c,v 3.0 1996/08/18 01:55:11 dawes Exp $ */
+/*
+ * Fill odd tiled rectangles and spans.
+ * no depth dependencies.
+ */
+
+/*
+
+Copyright (c) 1989  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+*/
+
+/* $XConsortium: ipltileodd.c,v 1.16 94/04/17 20:29:06 dpw Exp $ */
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "servermd.h"
+#include "gcstruct.h"
+#include "window.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+
+#include "ipl.h"
+
+#include "iplmskbits.h"
+#include "iplmergerop.h"
+
+#define LEFTSHIFT_AMT 0
+
+#define LastTileBits {\
+    INTER_COPY(bits, tmp); \
+    if (tileEndPart) \
+	INTER_MSKINSM(tileEndMask, 0, pSrc, 			\
+		         ~0, tileEndLeftShift, pSrcLine, bits) 	\
+    else \
+	INTER_COPY(pSrc, bits); \
+}
+
+#define ResetTileBits {\
+    pSrc = pSrcLine; \
+    nlwSrc = widthSrc;\
+    if (tileEndPart) { \
+	if (INTER_PPG - xoff + tileEndPart <= INTER_PPG) {\
+	    INTER_COPY(pSrc, bits); INTER_NEXT_GROUP(pSrc); \
+	    nlwSrc--; \
+	} else \
+	    INTER_MSKINSM(~0, tileEndLeftShift, tmp, 		\
+			  ~0, tileEndRightShift, bits, bits); 	\
+	xoff = (xoff + xoffStep) & INTER_PIM; \
+	leftShift = xoff << LEFTSHIFT_AMT; \
+	rightShift = INTER_PGSZ - leftShift; \
+    }\
+}
+
+#define NextTileBits {\
+    if (nlwSrc == 1) {\
+	LastTileBits\
+    } else { \
+    	if (nlwSrc == 0) {\
+	    ResetTileBits\
+    	} \
+	if (nlwSrc == 1) {\
+	    LastTileBits\
+	} else {\
+	    INTER_COPY(bits, tmp); \
+	    INTER_COPY(pSrc, bits); INTER_NEXT_GROUP(pSrc); \
+	}\
+    }\
+    nlwSrc--; \
+}
+
+void
+INTER_MROP_NAME(iplFillBoxTileOdd) (pDrawable, nBox, pBox, tile, xrot, yrot, alu, planemask)
+    DrawablePtr	    pDrawable;
+    int		    nBox;	/* number of boxes to fill */
+    register BoxPtr pBox;	/* pointer to list of boxes to fill */
+    PixmapPtr	    tile;	/* tile */
+    int		    xrot, yrot;
+    int		    alu;
+    unsigned long   planemask;
+{
+    int tileWidth;	/* width of tile in pixels */
+    int tileHeight;	/* height of the tile */
+    int widthSrc;
+
+    int widthDst;	/* width in longwords of the dest pixmap */
+    int w;		/* width of current box */
+    int h;		/* height of current box */
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);/* masks for reggedy bits at either end of line */
+    int nlwMiddle;	/* number of longwords between sides of boxes */
+    int nlwSrc;		/* number of whole longwords in source */
+    
+    register int nlw;	/* loop version of nlwMiddle */
+    int srcy;		/* current tile y position */
+    int srcx;		/* current tile x position */
+    int xoffDst, xoffSrc;
+    int leftShift, rightShift;
+
+    INTER_MROP_DECLARE_REG()
+
+    INTER_DECLAREG(*pDstBase);	/* pointer to start of dest */
+    INTER_DECLAREG(*pDstLine);	/* poitner to start of dest box */
+    INTER_DECLAREG(*pSrcBase);	/* pointer to start of source */
+    INTER_DECLAREG(*pSrcLine);	/* pointer to start of source line */
+    INTER_DECLAREG(*pDst);
+    INTER_DECLAREG(*pSrc);
+    INTER_DECLAREGP(bits);
+    INTER_DECLAREGP(tmp);
+    INTER_DECLAREGP(tmp1);
+    register int	   nlwPart;
+    int xoffStart, xoff;
+    int leftShiftStart, rightShiftStart, nlwSrcStart;
+    INTER_DECLAREG(tileEndMask);
+    int tileEndLeftShift, tileEndRightShift;
+    int	xoffStep;
+    int tileEndPart;
+    int needFirst;
+    unsigned short narrow[2 * INTER_PLANES];
+    INTER_DECLAREG(narrowMask);
+    int	    narrowShift;
+    Bool    narrowTile;
+    int     narrowRep;
+
+    INTER_MROP_INITIALIZE (alu, planemask)
+
+    tileHeight = tile->drawable.height;
+    tileWidth = tile->drawable.width;
+    widthSrc = tile->devKind / (INTER_PGSZB * INTER_PLANES);
+    narrowTile = FALSE;
+
+    if (widthSrc == 1)
+    {
+	narrowRep = INTER_PPG / tileWidth;
+	narrowMask = iplendpartial [tileWidth];
+	tileWidth *= narrowRep;
+	narrowShift = tileWidth;
+	tileWidth *= 2;
+	widthSrc = 2;
+	narrowTile = TRUE;
+    }
+    pSrcBase = (unsigned short *)tile->devPrivate.ptr;
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pDstBase)
+
+    tileEndPart = tileWidth & INTER_PIM;
+    tileEndMask = iplendpartial[tileEndPart];
+    tileEndLeftShift = (tileEndPart) << LEFTSHIFT_AMT;
+    tileEndRightShift = INTER_PGSZ - tileEndLeftShift;
+    xoffStep = INTER_PPG - tileEndPart;
+    /*
+     * current assumptions: tile > 32 bits wide.
+     */
+    while (nBox--)
+    {
+	w = pBox->x2 - pBox->x1;
+	h = pBox->y2 - pBox->y1;
+	modulus (pBox->x1 - xrot, tileWidth, srcx);
+	modulus (pBox->y1 - yrot, tileHeight, srcy);
+	xoffDst = pBox->x1 & INTER_PIM;
+	if (xoffDst + w < INTER_PPG)
+	{
+	    INTER_maskpartialbits(pBox->x1, w, startmask);
+	    endmask = 0;
+	    nlwMiddle = 0;
+	}
+	else
+	{
+	    INTER_maskbits (pBox->x1, w, startmask, endmask, nlwMiddle)
+	}
+	pDstLine = pDstBase + (pBox->y1 * widthDst) + 
+		   (pBox->x1 >> INTER_PGSH) * INTER_PLANES;
+	pSrcLine = pSrcBase + (srcy * widthSrc) * INTER_PLANES;
+	xoffSrc = srcx & INTER_PIM;
+	if (xoffSrc >= xoffDst)
+	{
+	    xoffStart = xoffSrc - xoffDst;
+	    needFirst = 1;
+	}
+	else
+	{
+	    xoffStart = INTER_PPG - (xoffDst - xoffSrc);
+	    needFirst = 0;
+	}
+	leftShiftStart = (xoffStart) << LEFTSHIFT_AMT;
+	rightShiftStart = INTER_PGSZ - leftShiftStart;
+	nlwSrcStart = (widthSrc - (srcx >> INTER_PGSH));
+	while (h--)
+	{
+	    /* XXX only works when narrowShift >= INTER_PPG/2 */
+	    if (narrowTile)
+	    {
+		int tmpnarrowRep;
+		int shift=narrowShift/narrowRep;
+		INTER_ANDMSK(pSrcBase + srcy * INTER_PLANES, narrowMask, tmp);
+                tmpnarrowRep=narrowRep;
+		/* copy tile until its nearly a whole group wide */
+	        while (--tmpnarrowRep)
+		    INTER_MSKINSM(~0,0,tmp,~0,shift,tmp,tmp);
+		INTER_MSKINSM(~0, 0, tmp, ~0, narrowShift, tmp, narrow);
+		INTER_MSKINSM(~0, INTER_PPG - narrowShift, tmp,
+			      ~0, 2 * narrowShift - INTER_PPG, tmp, 
+			      narrow + INTER_PLANES); 
+		pSrcLine = narrow;
+	    }
+	    xoff = xoffStart;
+	    leftShift = leftShiftStart;
+	    rightShift = rightShiftStart;
+	    nlwSrc = nlwSrcStart;
+	    pSrc = pSrcLine + (srcx >> INTER_PGSH) * INTER_PLANES;
+	    pDst = pDstLine;
+	    INTER_CLR(bits);
+	    if (needFirst)
+	    {
+		NextTileBits
+	    }
+	    if (startmask)
+	    {
+		NextTileBits
+		INTER_SCRLEFT(leftShift, tmp, tmp);
+ 		if (rightShift != INTER_PGSZ)
+		    INTER_MSKINSM(~0, 0, tmp, ~0, rightShift, bits, tmp)
+		INTER_MROP_MASK (tmp, pDst, startmask, pDst);
+		INTER_NEXT_GROUP(pDst);
+	    }
+	    nlw = nlwMiddle;
+	    while (nlw)
+	    {
+		{
+		    NextTileBits
+		    if (rightShift != INTER_PGSZ)
+		    {
+		        INTER_MSKINSM(~0, leftShift, tmp, ~0, rightShift, bits, 
+				  tmp1);
+		        INTER_MROP_SOLID(tmp1, pDst, pDst);
+		    }
+		    else
+		    {
+			INTER_MROP_SOLID (tmp, pDst, pDst);
+		    }
+		    INTER_NEXT_GROUP(pDst);
+		    nlw--;
+		}
+	    }
+	    if (endmask)
+	    {
+		NextTileBits
+		if (rightShift == INTER_PGSZ)
+		    INTER_CLR(bits);
+	        INTER_MSKINSM(~0, leftShift, tmp, ~0, rightShift, bits, tmp1);
+	        INTER_MROP_MASK(tmp1, pDst, endmask, pDst);
+	    }
+	    pDstLine += widthDst;
+	    pSrcLine += widthSrc * INTER_PLANES;
+	    if (++srcy == tileHeight)
+	    {
+		srcy = 0;
+		pSrcLine = pSrcBase;
+	    }
+	}
+	pBox++;
+    }
+}
+
+void
+INTER_MROP_NAME(iplFillSpanTileOdd) (pDrawable, n, ppt, pwidth, tile, xrot, yrot, alu, planemask)
+    DrawablePtr	pDrawable;
+    int		n;
+    DDXPointPtr	ppt;
+    int		*pwidth;
+    PixmapPtr	tile;
+    int		xrot, yrot;
+    int		alu;
+    unsigned long   planemask;
+{
+    int tileWidth;	/* width of tile in pixels */
+    int tileHeight;	/* height of the tile */
+    int widthSrc;
+
+    int widthDst;		/* width in longwords of the dest pixmap */
+    int w;		/* width of current span */
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG (endmask);	/* masks for reggedy bits at either end of line */
+    int nlwSrc;		/* number of whole longwords in source */
+    
+    register int nlw;	/* loop version of nlwMiddle */
+    int srcy;		/* current tile y position */
+    int srcx;		/* current tile x position */
+    int xoffDst, xoffSrc;
+    int leftShift, rightShift;
+
+    INTER_MROP_DECLARE_REG()
+
+    INTER_DECLAREG(*pDstBase);	/* pointer to start of dest */
+    INTER_DECLAREG(*pDstLine);	/* poitner to start of dest box */
+    INTER_DECLAREG(*pSrcBase);	/* pointer to start of source */
+    INTER_DECLAREG(*pSrcLine);	/* pointer to start of source line */
+    INTER_DECLAREG(*pDst);
+    INTER_DECLAREG(*pSrc);
+    INTER_DECLAREGP(bits);
+    INTER_DECLAREGP(tmp);
+    INTER_DECLAREGP(tmp1);
+    register int	   nlwPart;
+    int xoffStart, xoff;
+    int leftShiftStart, rightShiftStart, nlwSrcStart;
+    INTER_DECLAREG(tileEndMask);
+    int tileEndLeftShift, tileEndRightShift;
+    int	xoffStep;
+    int tileEndPart;
+    int needFirst;
+    unsigned short narrow[2 * INTER_PLANES];
+    INTER_DECLAREG(narrowMask);
+    int	    narrowShift;
+    Bool    narrowTile;
+    int     narrowRep;
+
+    INTER_MROP_INITIALIZE (alu, planemask)
+
+    tileHeight = tile->drawable.height;
+    tileWidth = tile->drawable.width;
+    widthSrc = tile->devKind / (INTER_PGSZB * INTER_PLANES);
+    narrowTile = FALSE;
+    if (widthSrc == 1)
+    {
+	narrowRep = INTER_PPG / tileWidth;
+	narrowMask = iplendpartial [tileWidth];
+	tileWidth *= narrowRep;
+	narrowShift = tileWidth;
+	tileWidth *= 2;
+	widthSrc = 2;
+	narrowTile = TRUE;
+    }
+    pSrcBase = (unsigned short *)tile->devPrivate.ptr;
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pDstBase)
+
+    tileEndPart = tileWidth & INTER_PIM;
+    tileEndMask = iplendpartial[tileEndPart];
+    tileEndLeftShift = (tileEndPart) << LEFTSHIFT_AMT;
+    tileEndRightShift = INTER_PGSZ - tileEndLeftShift;
+    xoffStep = INTER_PPG - tileEndPart;
+    while (n--)
+    {
+	w = *pwidth++;
+	modulus (ppt->x - xrot, tileWidth, srcx);
+	modulus (ppt->y - yrot, tileHeight, srcy);
+	xoffDst = ppt->x & INTER_PIM;
+	if (xoffDst + w < INTER_PPG)
+	{
+	    INTER_maskpartialbits(ppt->x, w, startmask);
+	    endmask = 0;
+	    nlw = 0;
+	}
+	else
+	{
+	    INTER_maskbits (ppt->x, w, startmask, endmask, nlw)
+	}
+	pDstLine = pDstBase + (ppt->y * widthDst) + 
+		   (ppt->x >> INTER_PGSH) * INTER_PLANES;
+	pSrcLine = pSrcBase + (srcy * widthSrc) * INTER_PLANES;
+	xoffSrc = srcx & INTER_PIM;
+	if (xoffSrc >= xoffDst)
+	{
+	    xoffStart = xoffSrc - xoffDst;
+	    needFirst = 1;
+	}
+	else
+	{
+	    xoffStart = INTER_PPG - (xoffDst - xoffSrc);
+	    needFirst = 0;
+	}
+	leftShiftStart = (xoffStart) << LEFTSHIFT_AMT;
+	rightShiftStart = INTER_PGSZ - leftShiftStart;
+	nlwSrcStart = widthSrc - (srcx >> INTER_PGSH);
+	/* XXX only works when narrowShift >= INTER_PPG/2 */
+	if (narrowTile)
+	{
+	    int tmpnarrowRep;
+	    int shift=narrowShift/narrowRep;
+	    INTER_ANDMSK(pSrcBase + srcy * INTER_PLANES, narrowMask, tmp);
+            tmpnarrowRep=narrowRep;
+	    /* copy tile until its nearly a whole group wide */
+	    while (--tmpnarrowRep)
+		INTER_MSKINSM(~0,0,tmp,~0,shift,tmp,tmp);
+	    INTER_MSKINSM(~0, 0, tmp, ~0, narrowShift, tmp, narrow);
+	    INTER_MSKINSM(~0, INTER_PPG - narrowShift, tmp,
+			      ~0, 2 * narrowShift - INTER_PPG, tmp, 
+			      narrow + INTER_PLANES); 
+	    pSrcLine = narrow;
+	}
+	xoff = xoffStart;
+	leftShift = leftShiftStart;
+	rightShift = rightShiftStart;
+	nlwSrc = nlwSrcStart;
+	pSrc = pSrcLine + (srcx >> INTER_PGSH) * INTER_PLANES;
+	pDst = pDstLine;
+	INTER_CLR(bits);
+	if (needFirst)
+	{
+	    NextTileBits
+	}
+	if (startmask)
+	{
+	    NextTileBits
+	    INTER_SCRLEFT(leftShift, tmp, tmp);
+	    if (rightShift != INTER_PGSZ)
+		INTER_MSKINSM(~0, 0, tmp, ~0, rightShift, bits, tmp);
+	    INTER_MROP_MASK (tmp, pDst, startmask, pDst);
+	    INTER_NEXT_GROUP(pDst);
+	}
+	while (nlw)
+	{
+	    {
+		NextTileBits
+		if (rightShift != INTER_PGSZ)
+		{
+		    INTER_MSKINSM(~0, leftShift, tmp, ~0, rightShift, bits, 
+				  tmp1);
+		    INTER_MROP_SOLID(tmp1, pDst, pDst);
+		    INTER_NEXT_GROUP(pDst);
+		}
+		else
+		{
+		    INTER_MROP_SOLID (tmp, pDst, pDst);
+		    INTER_NEXT_GROUP(pDst);
+		}
+		nlw--;
+	    }
+	}
+	if (endmask)
+	{
+	    NextTileBits
+	    if (rightShift == INTER_PGSZ)
+		INTER_CLR(bits);
+	    
+	    INTER_MSKINSM(~0, leftShift, tmp, ~0, rightShift, bits, tmp1);
+	    INTER_MROP_MASK(tmp1, pDst, endmask, pDst);
+	}
+	ppt++;
+    }
+}
+
+# include "fastblt.h"
+
+#define IncSrcPtr   INTER_NEXT_GROUP(psrc); if (!--srcRemaining) { srcRemaining = widthSrc; psrc = psrcStart; }
+
+void
+INTER_MROP_NAME(iplFillBoxTile32s) (pDrawable, nBox, pBox, tile, xrot, yrot, alu, planemask)
+    DrawablePtr	    pDrawable;
+    int		    nBox;	/* number of boxes to fill */
+    register BoxPtr pBox;	/* pointer to list of boxes to fill */
+    PixmapPtr	    tile;	/* tile */
+    int		    xrot, yrot;
+    int		    alu;
+    unsigned long   planemask;
+{
+    int	tileWidth;	/* width of tile */
+    int tileHeight;	/* height of the tile */
+    int	widthSrc;	/* width in longwords of the source tile */
+
+    int widthDst;	/* width in longwords of the dest pixmap */
+    int w;		/* width of current box */
+    int h;		/* height of current box */
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask); /* masks for reggedy bits at either end of line */
+    int nlMiddle;	/* number of longwords between sides of boxes */
+    
+    register int nl;	/* loop version of nlMiddle */
+    int srcy;		/* current tile y position */
+    int srcx;		/* current tile x position */
+    int	srcRemaining;	/* number of longwords remaining in source */
+    int xoffDst, xoffSrc;
+    int	srcStart;	/* number of longwords source offset at left of box */
+    int	leftShift, rightShift;
+
+    INTER_MROP_DECLARE_REG()
+
+    INTER_DECLAREG(*pdstBase);	/* pointer to start of dest */
+    INTER_DECLAREG(*pdstLine);	/* poitner to start of dest box */
+    INTER_DECLAREG(*psrcBase);	/* pointer to start of source */
+    INTER_DECLAREG(*psrcLine);	/* pointer to fetch point of source */
+    INTER_DECLAREG(*psrcStart);	/* pointer to start of source line */
+    INTER_DECLAREG(*pdst);
+    INTER_DECLAREG(*psrc);
+    INTER_DECLAREGP(bits);
+    INTER_DECLAREGP(bits1);
+    register int	    nlTemp;
+
+    INTER_MROP_INITIALIZE (alu, planemask)
+
+    psrcBase = (unsigned short *)tile->devPrivate.ptr;
+    tileHeight = tile->drawable.height;
+    tileWidth = tile->drawable.width;
+    widthSrc = tile->devKind / (INTER_PGSZB * INTER_PLANES);
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pdstBase)
+
+    while (nBox--)
+    {
+	w = pBox->x2 - pBox->x1;
+	h = pBox->y2 - pBox->y1;
+
+	/* set up source */
+	modulus (pBox->x1 - xrot, tileWidth, srcx);
+	modulus (pBox->y1 - yrot, tileHeight, srcy);
+	xoffSrc = srcx & INTER_PIM;
+	srcStart = srcx >> INTER_PGSH;
+	psrcStart = psrcBase + (srcy * widthSrc) * INTER_PLANES;
+	psrcLine = psrcStart + srcStart * INTER_PLANES;
+
+	/* set up dest */
+	xoffDst = pBox->x1 & INTER_PIM;
+	pdstLine = pdstBase + (pBox->y1 * widthDst) + 
+		(pBox->x1 >> INTER_PGSH) * INTER_PLANES;
+	/* set up masks */
+	if (xoffDst + w < INTER_PPG)
+	{
+	    INTER_maskpartialbits(pBox->x1, w, startmask);
+	    endmask = 0;
+	    nlMiddle = 0;
+	}
+	else
+	{
+	    INTER_maskbits (pBox->x1, w, startmask, endmask, nlMiddle)
+	}
+	if (xoffSrc == xoffDst)
+	{
+	    while (h--)
+	    {
+		psrc = psrcLine;
+		pdst = pdstLine;
+		srcRemaining = widthSrc - srcStart;
+		if (startmask)
+		{
+		    INTER_MROP_MASK (psrc, pdst, startmask, pdst);
+		    INTER_NEXT_GROUP(pdst);
+		    IncSrcPtr
+		}
+		nlTemp = nlMiddle;
+		while (nlTemp)
+		{
+		    nl = nlTemp;
+		    if (nl > srcRemaining)
+			nl = srcRemaining;
+
+		    nlTemp -= nl;
+		    srcRemaining -= nl;
+
+		    while (nl--) {
+			    INTER_MROP_SOLID (psrc, pdst, pdst);
+			    INTER_NEXT_GROUP(pdst); INTER_NEXT_GROUP(psrc);
+		    }
+
+		    if (!srcRemaining)
+		    {
+			srcRemaining = widthSrc;
+			psrc = psrcStart;
+		    }
+		}
+		if (endmask)
+		{
+		    INTER_MROP_MASK (psrc, pdst, endmask, pdst);
+		}
+		pdstLine += widthDst;
+		psrcLine += widthSrc * INTER_PLANES;
+		psrcStart += widthSrc * INTER_PLANES;
+		if (++srcy == tileHeight)
+		{
+		    psrcStart = psrcBase;
+		    psrcLine = psrcStart + srcStart * INTER_PLANES;
+		    srcy = 0;
+		}
+	    }
+	}
+	else
+	{
+	    if (xoffSrc > xoffDst)
+	    {
+		leftShift = (xoffSrc - xoffDst) << LEFTSHIFT_AMT;
+		rightShift = INTER_PGSZ - leftShift;
+	    }
+	    else
+	    {
+		rightShift = (xoffDst - xoffSrc) << LEFTSHIFT_AMT;
+		leftShift = INTER_PGSZ - rightShift;
+	    }
+	    while (h--)
+	    {
+		psrc = psrcLine;
+		pdst = pdstLine;
+		INTER_CLR(bits);
+		srcRemaining = widthSrc - srcStart;
+		if (xoffSrc > xoffDst)
+		{
+		    INTER_COPY(psrc, bits);
+		    IncSrcPtr
+		}
+		if (startmask)
+		{
+		    INTER_SCRLEFT(leftShift, bits, bits1);
+		    INTER_COPY(psrc, bits);
+		    IncSrcPtr
+		    INTER_MSKINSM(~0, 0, bits1, ~0, rightShift, bits, bits1);
+		    INTER_MROP_MASK(bits1, pdst, startmask, pdst);
+		    INTER_NEXT_GROUP(pdst);
+		}
+		nlTemp = nlMiddle;
+		while (nlTemp)
+		{
+		    nl = nlTemp;
+		    if (nl > srcRemaining)
+			nl = srcRemaining;
+
+		    nlTemp -= nl;
+		    srcRemaining -= nl;
+    
+		    while (nl--) {
+		    	INTER_SCRLEFT(leftShift, bits, bits1);
+		    	INTER_COPY(psrc, bits); INTER_NEXT_GROUP(psrc);
+		        INTER_MSKINSM(~0, 0, bits1, ~0, rightShift, bits, bits1);
+		    	INTER_MROP_SOLID (bits1, pdst, pdst);
+		    	INTER_NEXT_GROUP(pdst);
+		    }
+
+		    if (!srcRemaining)
+		    {
+			srcRemaining = widthSrc;
+			psrc = psrcStart;
+		    }
+		}
+
+		if (endmask)
+		{
+		    INTER_SCRLEFT(leftShift, bits, bits1);
+		    if (endmask << rightShift)
+		    {
+			INTER_COPY(psrc, bits);
+		        INTER_MSKINSM(~0, 0, bits1, ~0, rightShift, bits, bits1);
+		    }
+		    INTER_MROP_MASK (bits1, pdst, endmask, pdst);
+		}
+		pdstLine += widthDst;
+		psrcLine += widthSrc * INTER_PLANES;
+		psrcStart += widthSrc * INTER_PLANES;
+		if (++srcy == tileHeight)
+		{
+		    psrcStart = psrcBase;
+		    psrcLine = psrcStart + srcStart * INTER_PLANES;
+		    srcy = 0;
+		}
+	    }
+	}
+	pBox++;
+    }
+}
+
+void
+INTER_MROP_NAME(iplFillSpanTile32s) (pDrawable, n, ppt, pwidth, tile, xrot, yrot, alu, planemask)
+    DrawablePtr	pDrawable;
+    int		n;
+    DDXPointPtr	ppt;
+    int		*pwidth;
+    PixmapPtr	tile;
+    int		xrot, yrot;
+    int		alu;
+    unsigned long   planemask;
+{
+    int	tileWidth;	/* width of tile */
+    int tileHeight;	/* height of the tile */
+    int	widthSrc;	/* width in longwords of the source tile */
+
+    int widthDst;	/* width in longwords of the dest pixmap */
+    int w;		/* width of current box */
+    INTER_DECLAREG(startmask);
+    INTER_DECLAREG(endmask);/* masks for reggedy bits at either end of line */
+    int nlMiddle;	/* number of longwords between sides of boxes */
+    
+    register int nl;	/* loop version of nlMiddle */
+    int srcy;		/* current tile y position */
+    int srcx;		/* current tile x position */
+    int	srcRemaining;	/* number of longwords remaining in source */
+    int xoffDst, xoffSrc;
+    int	srcStart;	/* number of longwords source offset at left of box */
+    int	leftShift, rightShift;
+
+    INTER_MROP_DECLARE_REG()
+
+    INTER_DECLAREG(*pdstBase);	/* pointer to start of dest */
+    INTER_DECLAREG(*pdstLine);	/* poitner to start of dest box */
+    INTER_DECLAREG(*psrcBase);	/* pointer to start of source */
+    INTER_DECLAREG(*psrcLine);	/* pointer to fetch point of source */
+    INTER_DECLAREG(*psrcStart);	/* pointer to start of source line */
+    INTER_DECLAREG(*pdst);
+    INTER_DECLAREG(*psrc);
+    INTER_DECLAREGP(bits);
+    INTER_DECLAREGP(bits1);
+    register int	    nlTemp;
+
+    INTER_MROP_INITIALIZE (alu, planemask)
+
+    psrcBase = (unsigned short *)tile->devPrivate.ptr;
+    tileHeight = tile->drawable.height;
+    tileWidth = tile->drawable.width;
+    widthSrc = tile->devKind / (INTER_PGSZB * INTER_PLANES);
+
+    iplGetGroupWidthAndPointer (pDrawable, widthDst, pdstBase)
+
+    while (n--)
+    {
+	w = *pwidth++;
+
+	/* set up source */
+	modulus (ppt->x - xrot, tileWidth, srcx);
+	modulus (ppt->y - yrot, tileHeight, srcy);
+	xoffSrc = srcx & INTER_PIM;
+	srcStart = srcx >> INTER_PGSH;
+	psrcStart = psrcBase + (srcy * widthSrc) * INTER_PLANES;
+	psrcLine = psrcStart + srcStart * INTER_PLANES;
+
+	/* set up dest */
+	xoffDst = ppt->x & INTER_PIM;
+	pdstLine = pdstBase + (ppt->y * widthDst) + 
+		(ppt->x >> INTER_PGSH) * INTER_PLANES;
+	/* set up masks */
+	if (xoffDst + w < INTER_PPG)
+	{
+	    INTER_maskpartialbits(ppt->x, w, startmask);
+	    endmask = 0;
+	    nlMiddle = 0;
+	}
+	else
+	{
+	    INTER_maskbits (ppt->x, w, startmask, endmask, nlMiddle)
+	}
+
+	if (xoffSrc == xoffDst)
+	{
+	    psrc = psrcLine;
+	    pdst = pdstLine;
+	    srcRemaining = widthSrc - srcStart;
+	    if (startmask)
+	    {
+		INTER_MROP_MASK (psrc, pdst, startmask, pdst);
+		INTER_NEXT_GROUP(pdst);
+		IncSrcPtr
+	    }
+	    nlTemp = nlMiddle;
+	    while (nlTemp)
+	    {
+		nl = nlTemp;
+		if (nl > srcRemaining)
+		    nl = srcRemaining;
+
+		nlTemp -= nl;
+		srcRemaining -= nl;
+
+		while (nl--) {
+			INTER_MROP_SOLID (psrc, pdst, pdst);
+			INTER_NEXT_GROUP(pdst); INTER_NEXT_GROUP(psrc);
+		}
+
+		if (!srcRemaining)
+		{
+		    srcRemaining = widthSrc;
+		    psrc = psrcStart;
+		}
+	    }
+	    if (endmask)
+	    {
+		INTER_MROP_MASK (psrc, pdst, endmask, pdst);
+	    }
+	}
+	else
+	{
+	    if (xoffSrc > xoffDst)
+	    {
+		leftShift = (xoffSrc - xoffDst) << LEFTSHIFT_AMT;
+		rightShift = INTER_PGSZ - leftShift;
+	    }
+	    else
+	    {
+		rightShift = (xoffDst - xoffSrc) << LEFTSHIFT_AMT;
+		leftShift = INTER_PGSZ - rightShift;
+	    }
+	    psrc = psrcLine;
+	    pdst = pdstLine;
+	    INTER_CLR(bits);
+	    srcRemaining = widthSrc - srcStart;
+	    if (xoffSrc > xoffDst)
+	    {
+		INTER_COPY(psrc, bits);
+		IncSrcPtr
+	    }
+	    if (startmask)
+	    {
+		INTER_SCRLEFT(leftShift, bits, bits1);
+		INTER_COPY(psrc, bits);
+		IncSrcPtr
+		INTER_MSKINSM(~0, 0, bits1, ~0, rightShift, bits, bits1);
+		INTER_MROP_MASK(bits1, pdst, startmask, pdst);
+		INTER_NEXT_GROUP(pdst);
+	    }
+	    nlTemp = nlMiddle;
+	    while (nlTemp)
+	    {
+		nl = nlTemp;
+		if (nl > srcRemaining)
+		    nl = srcRemaining;
+
+		nlTemp -= nl;
+		srcRemaining -= nl;
+
+		while (nl--) {
+		    INTER_SCRLEFT(leftShift, bits, bits1);
+		    INTER_COPY(psrc, bits); INTER_NEXT_GROUP(psrc);
+		    INTER_MSKINSM(~0, 0, bits1, ~0, rightShift, bits, bits1);
+		    INTER_MROP_SOLID(bits1, pdst, pdst);
+		    INTER_NEXT_GROUP(pdst);
+		}
+
+		if (!srcRemaining)
+		{
+		    srcRemaining = widthSrc;
+		    psrc = psrcStart;
+		}
+	    }
+
+	    if (endmask)
+	    {
+		INTER_SCRLEFT(leftShift, bits, bits1);
+		if (endmask << rightShift)
+		{
+		    INTER_COPY(psrc, bits);
+		    INTER_MSKINSM(~0, 0, bits1, ~0, rightShift, bits, bits1);
+		}
+		INTER_MROP_MASK (bits1, pdst, endmask, pdst);
+	    }
+	}
+	ppt++;
+    }
+}
diff --git a/iplan2p4/iplwindow.c b/iplan2p4/iplwindow.c
new file mode 100644
index 000000000..3446b1904
--- /dev/null
+++ b/iplan2p4/iplwindow.c
@@ -0,0 +1,339 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplwindow.c,v 3.0 1996/08/18 01:55:13 dawes Exp $ */
+/* $XConsortium: iplwindow.c,v 5.22 94/04/17 20:29:07 dpw Exp $ */
+/***********************************************************
+
+Copyright (c) 1987  X Consortium
+
+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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+
+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.
+
+******************************************************************/
+
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+
+#include "X.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+#include "ipl.h"
+#include "mistruct.h"
+#include "regionstr.h"
+#include "iplmskbits.h"
+
+extern WindowPtr *WindowTable;
+
+Bool
+iplCreateWindow(pWin)
+    WindowPtr pWin;
+{
+    iplPrivWin *pPrivWin;
+
+    pPrivWin = iplGetWindowPrivate(pWin);
+    pPrivWin->pRotatedBorder = NullPixmap;
+    pPrivWin->pRotatedBackground = NullPixmap;
+    pPrivWin->fastBackground = FALSE;
+    pPrivWin->fastBorder = FALSE;
+    pPrivWin->oldRotate.x = 0;
+    pPrivWin->oldRotate.y = 0;
+
+#ifdef PIXMAP_PER_WINDOW
+    /* Setup pointer to Screen pixmap */
+    pWin->devPrivates[frameWindowPrivateIndex].ptr =
+	(pointer) iplGetScreenPixmap(pWin->drawable.pScreen);
+#endif
+
+    return TRUE;
+}
+
+Bool
+iplDestroyWindow(pWin)
+    WindowPtr pWin;
+{
+    iplPrivWin *pPrivWin;
+
+    pPrivWin = iplGetWindowPrivate(pWin);
+
+    if (pPrivWin->pRotatedBorder)
+	(*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBorder);
+    if (pPrivWin->pRotatedBackground)
+	(*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBackground);
+    return(TRUE);
+}
+
+/*ARGSUSED*/
+Bool
+iplMapWindow(pWindow)
+    WindowPtr pWindow;
+{
+    return(TRUE);
+}
+
+/* (x, y) is the upper left corner of the window on the screen 
+   do we really need to pass this?  (is it a;ready in pWin->absCorner?)
+   we only do the rotation for pixmaps that are 32 bits wide (padded
+or otherwise.)
+   iplChangeWindowAttributes() has already put a copy of the pixmap
+in pPrivWin->pRotated*
+*/
+/*ARGSUSED*/
+Bool
+iplPositionWindow(pWin, x, y)
+    WindowPtr pWin;
+    int x, y;
+{
+    iplPrivWin *pPrivWin;
+    int setxy = 0;
+
+    pPrivWin = iplGetWindowPrivate(pWin);
+    if (pWin->backgroundState == BackgroundPixmap && pPrivWin->fastBackground)
+    {
+	iplXRotatePixmap(pPrivWin->pRotatedBackground,
+		      pWin->drawable.x - pPrivWin->oldRotate.x);
+	iplYRotatePixmap(pPrivWin->pRotatedBackground,
+		      pWin->drawable.y - pPrivWin->oldRotate.y);
+	setxy = 1;
+    }
+
+    if (!pWin->borderIsPixel &&	pPrivWin->fastBorder)
+    {
+	while (pWin->backgroundState == ParentRelative)
+	    pWin = pWin->parent;
+	iplXRotatePixmap(pPrivWin->pRotatedBorder,
+		      pWin->drawable.x - pPrivWin->oldRotate.x);
+	iplYRotatePixmap(pPrivWin->pRotatedBorder,
+		      pWin->drawable.y - pPrivWin->oldRotate.y);
+	setxy = 1;
+    }
+    if (setxy)
+    {
+	pPrivWin->oldRotate.x = pWin->drawable.x;
+	pPrivWin->oldRotate.y = pWin->drawable.y;
+    }
+    return (TRUE);
+}
+
+/*ARGSUSED*/
+Bool
+iplUnmapWindow(pWindow)
+    WindowPtr pWindow;
+{
+    return (TRUE);
+}
+
+/* UNCLEAN!
+   this code calls the bitblt helper code directly.
+
+   iplCopyWindow copies only the parts of the destination that are
+visible in the source.
+*/
+
+
+void 
+iplCopyWindow(pWin, ptOldOrg, prgnSrc)
+    WindowPtr pWin;
+    DDXPointRec ptOldOrg;
+    RegionPtr prgnSrc;
+{
+    DDXPointPtr pptSrc;
+    register DDXPointPtr ppt;
+    RegionRec rgnDst;
+    register BoxPtr pbox;
+    register int dx, dy;
+    register int i, nbox;
+    WindowPtr pwinRoot;
+
+    pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
+
+    REGION_INIT(pWin->drawable.pScreen, &rgnDst, NullBox, 0);
+
+    dx = ptOldOrg.x - pWin->drawable.x;
+    dy = ptOldOrg.y - pWin->drawable.y;
+    REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
+    REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
+
+    pbox = REGION_RECTS(&rgnDst);
+    nbox = REGION_NUM_RECTS(&rgnDst);
+    if(!nbox || !(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
+    {
+	REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);
+	return;
+    }
+    ppt = pptSrc;
+
+    for (i = nbox; --i >= 0; ppt++, pbox++)
+    {
+	ppt->x = pbox->x1 + dx;
+	ppt->y = pbox->y1 + dy;
+    }
+
+    iplDoBitbltCopy((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
+		GXcopy, &rgnDst, pptSrc, ~0L);
+    DEALLOCATE_LOCAL(pptSrc);
+    REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);
+}
+
+
+
+/* swap in correct PaintWindow* routine.  If we can use a fast output
+routine (i.e. the pixmap is paddable to 32 bits), also pre-rotate a copy
+of it in devPrivates[iplWindowPrivateIndex].ptr.
+*/
+Bool
+iplChangeWindowAttributes(pWin, mask)
+    WindowPtr pWin;
+    unsigned long mask;
+{
+    register unsigned long index;
+    register iplPrivWin *pPrivWin;
+    int width;
+    WindowPtr	pBgWin;
+
+    pPrivWin = iplGetWindowPrivate(pWin);
+
+    /*
+     * When background state changes from ParentRelative and
+     * we had previously rotated the fast border pixmap to match
+     * the parent relative origin, rerotate to match window
+     */
+    if (mask & (CWBackPixmap | CWBackPixel) &&
+	pWin->backgroundState != ParentRelative &&
+	pPrivWin->fastBorder &&
+	(pPrivWin->oldRotate.x != pWin->drawable.x ||
+	 pPrivWin->oldRotate.y != pWin->drawable.y))
+    {
+	iplXRotatePixmap(pPrivWin->pRotatedBorder,
+		      pWin->drawable.x - pPrivWin->oldRotate.x);
+	iplYRotatePixmap(pPrivWin->pRotatedBorder,
+		      pWin->drawable.y - pPrivWin->oldRotate.y);
+	pPrivWin->oldRotate.x = pWin->drawable.x;
+	pPrivWin->oldRotate.y = pWin->drawable.y;
+    }
+    while(mask)
+    {
+	index = lowbit (mask);
+	mask &= ~index;
+	switch(index)
+	{
+	case CWBackPixmap:
+	    if (pWin->backgroundState == None)
+	    {
+		pPrivWin->fastBackground = FALSE;
+	    }
+	    else if (pWin->backgroundState == ParentRelative)
+	    {
+		pPrivWin->fastBackground = FALSE;
+		/* Rotate border to match parent origin */
+		if (pPrivWin->pRotatedBorder) {
+		    for (pBgWin = pWin->parent;
+			 pBgWin->backgroundState == ParentRelative;
+			 pBgWin = pBgWin->parent);
+		    iplXRotatePixmap(pPrivWin->pRotatedBorder,
+				  pBgWin->drawable.x - pPrivWin->oldRotate.x);
+		    iplYRotatePixmap(pPrivWin->pRotatedBorder,
+				  pBgWin->drawable.y - pPrivWin->oldRotate.y);
+		    pPrivWin->oldRotate.x = pBgWin->drawable.x;
+		    pPrivWin->oldRotate.y = pBgWin->drawable.y;
+		}
+	    }
+	    else if (((width = (pWin->background.pixmap->drawable.width))
+		      <= INTER_PGSZ) && !(width & (width - 1)))
+	    {
+		iplCopyRotatePixmap(pWin->background.pixmap,
+				    &pPrivWin->pRotatedBackground,
+				    pWin->drawable.x,
+				    pWin->drawable.y);
+		if (pPrivWin->pRotatedBackground)
+		{
+		    pPrivWin->fastBackground = TRUE;
+		    pPrivWin->oldRotate.x = pWin->drawable.x;
+		    pPrivWin->oldRotate.y = pWin->drawable.y;
+		}
+		else
+		{
+		    pPrivWin->fastBackground = FALSE;
+		}
+	    }
+	    else
+	    {
+		pPrivWin->fastBackground = FALSE;
+	    }
+	    break;
+
+	case CWBackPixel:
+	    pPrivWin->fastBackground = FALSE;
+	    break;
+
+	case CWBorderPixmap:
+	    if (((width = (pWin->border.pixmap->drawable.width)) <= INTER_PGSZ) &&
+		!(width & (width - 1)))
+	    {
+		for (pBgWin = pWin;
+		     pBgWin->backgroundState == ParentRelative;
+		     pBgWin = pBgWin->parent);
+		iplCopyRotatePixmap(pWin->border.pixmap,
+				    &pPrivWin->pRotatedBorder,
+				    pBgWin->drawable.x,
+				    pBgWin->drawable.y);
+		if (pPrivWin->pRotatedBorder)
+		{
+		    pPrivWin->fastBorder = TRUE;
+		    pPrivWin->oldRotate.x = pBgWin->drawable.x;
+		    pPrivWin->oldRotate.y = pBgWin->drawable.y;
+		}
+		else
+		{
+		    pPrivWin->fastBorder = FALSE;
+		}
+	    }
+	    else
+	    {
+		pPrivWin->fastBorder = FALSE;
+	    }
+	    break;
+	 case CWBorderPixel:
+	    pPrivWin->fastBorder = FALSE;
+	    break;
+	}
+    }
+    return (TRUE);
+}
+