aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/iplan2p4
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/programs/Xserver/iplan2p4')
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/Imakefile119
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/ipl.h1254
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplallpriv.c93
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplbitblt.c388
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplblt.c431
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplbres.c186
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplbresd.c212
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplbstore.c159
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplcmap.c126
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplfillarc.c271
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplfillrct.c281
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplfillsp.c384
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplgc.c786
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplgetsp.c166
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplhrzvert.c128
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplimage.c87
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplline.c758
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplmap.h176
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplmergerop.h146
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplmskbits.c108
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplmskbits.h500
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplpack.c316
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplpack.h10
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplpixmap.c386
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplply1rct.c310
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplpntwin.c341
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplpolypnt.c123
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplrrop.c219
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplrrop.h80
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplscrinit.c233
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplsetsp.c304
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplsolid.c221
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/ipltegblt.c221
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/ipltile32.c272
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/ipltileodd.c869
-rw-r--r--nx-X11/programs/Xserver/iplan2p4/iplwindow.c343
36 files changed, 11007 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/iplan2p4/Imakefile b/nx-X11/programs/Xserver/iplan2p4/Imakefile
new file mode 100644
index 000000000..3a3526156
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/Imakefile
@@ -0,0 +1,119 @@
+XCOMM $XFree86: xc/programs/Xserver/iplan2p4/Imakefile,v 3.4 1999/04/17 09:08:48 dawes Exp $
+XCOMM $XConsortium: Imakefile,v 5.41 93/09/06 18:37:23 rws Exp $
+#include <Server.tmpl>
+
+#ifndef IPlanes
+#define IPlanes 4
+#endif
+
+SRCS = iplgc.c iplrrop.c iplwindow.c \
+ iplpntwin.c iplmskbits.c iplpixmap.c iplbitblt.c \
+ iplfillsp.c iplsetsp.c iplscrinit.c iplallpriv.c \
+ iplgetsp.c iplfillrct.c \
+ iplsolidC.c iplsolidX.c iplsolidG.c \
+ ipltileoddC.c ipltileoddG.c ipltile32C.c ipltile32G.c \
+ iplcmap.c \
+ iplfillarcC.c iplfillarcG.c \
+ ipltegblt.c iplbstore.c \
+ iplpolypnt.c \
+ iplbres.c iplline.c iplhrzvert.c iplbresd.c iplimage.c iplseg.c \
+ iplbitblt.c iplbltC.c iplbltX.c iplbltO.c iplbltG.c \
+ iplply1rctC.c iplply1rctG.c iplpack.c
+
+OBJS = iplgc.o iplrrop.o iplwindow.o \
+ iplgetsp.o iplfillrct.o \
+ iplsolidC.o iplsolidX.o iplsolidG.o \
+ ipltileoddC.o ipltileoddG.o ipltile32C.o ipltile32G.o \
+ iplfillsp.o iplsetsp.o iplscrinit.o iplallpriv.o \
+ iplpntwin.o iplmskbits.o iplpixmap.o \
+ iplcmap.o \
+ iplfillarcC.o iplfillarcG.o \
+ ipltegblt.o iplbstore.o \
+ iplpolypnt.o \
+ iplbres.o iplline.o iplhrzvert.o iplbresd.o iplimage.o iplseg.o \
+ iplbitblt.o iplbltC.o iplbltX.o iplbltO.o iplbltG.o \
+ iplply1rctC.o iplply1rctG.o iplpack.o
+
+ INCLUDES = -I. -I../cfb -I../mfb -I../mi -I../include -I$(XINCLUDESRC) \
+ -I$(FONTINCSRC) $(EXTRAINCLUDES)
+ LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln \
+ ../mfb/llib-lmfb.ln ../mi/llib-lmi.ln
+ DEFINES = -DINTER_PLANES=IPlanes
+
+NormalLibraryObjectRule()
+#if IPlanes == 2
+NormalLibraryTarget(ipl2p2,$(OBJS))
+LintLibraryTarget(ipl2p2,$(SRCS))
+#elif IPlanes == 4
+NormalLibraryTarget(ipl2p4,$(OBJS))
+LintLibraryTarget(ipl2p4,$(SRCS))
+#elif IPlanes == 8
+NormalLibraryTarget(ipl2p8,$(OBJS))
+LintLibraryTarget(ipl2p8,$(SRCS))
+#endif
+
+NormalLintTarget($(SRCS))
+
+#ifdef LinkDirectory
+
+LinkSourceFile(ipl.h,LinkDirectory)
+LinkSourceFile(iplallpriv.c,LinkDirectory)
+LinkSourceFile(iplbitblt.c,LinkDirectory)
+LinkSourceFile(iplblt.c,LinkDirectory)
+LinkSourceFile(iplbres.c,LinkDirectory)
+LinkSourceFile(iplbresd.c,LinkDirectory)
+LinkSourceFile(iplbstore.c,LinkDirectory)
+LinkSourceFile(iplcmap.c,LinkDirectory)
+LinkSourceFile(iplfillarc.c,LinkDirectory)
+LinkSourceFile(iplfillrct.c,LinkDirectory)
+LinkSourceFile(iplfillsp.c,LinkDirectory)
+LinkSourceFile(iplgc.c,LinkDirectory)
+LinkSourceFile(iplgetsp.c,LinkDirectory)
+LinkSourceFile(iplhrzvert.c,LinkDirectory)
+LinkSourceFile(iplimage.c,LinkDirectory)
+LinkSourceFile(iplline.c,LinkDirectory)
+LinkSourceFile(iplmap.h,LinkDirectory)
+LinkSourceFile(iplmergerop.h,LinkDirectory)
+LinkSourceFile(iplmskbits.c,LinkDirectory)
+LinkSourceFile(iplmskbits.h,LinkDirectory)
+LinkSourceFile(iplpack.c,LinkDirectory)
+LinkSourceFile(iplpack.h,LinkDirectory)
+LinkSourceFile(iplpixmap.c,LinkDirectory)
+LinkSourceFile(iplply1rct.c,LinkDirectory)
+LinkSourceFile(iplpntwin.c,LinkDirectory)
+LinkSourceFile(iplpolypnt.c,LinkDirectory)
+LinkSourceFile(iplrrop.c,LinkDirectory)
+LinkSourceFile(iplrrop.h,LinkDirectory)
+LinkSourceFile(iplscrinit.c,LinkDirectory)
+LinkSourceFile(iplsetsp.c,LinkDirectory)
+LinkSourceFile(iplsolid.c,LinkDirectory)
+LinkSourceFile(ipltegblt.c,LinkDirectory)
+LinkSourceFile(ipltile32.c,LinkDirectory)
+LinkSourceFile(ipltileodd.c,LinkDirectory)
+LinkSourceFile(iplwindow.c,LinkDirectory)
+#endif
+
+ObjectFromSpecialSource(iplseg,iplline,-DPOLYSEGMENT)
+
+ObjectFromSpecialSource(iplfillarcC,iplfillarc,-DRROP=GXcopy)
+ObjectFromSpecialSource(iplfillarcG,iplfillarc,-DRROP=GXset)
+
+ObjectFromSpecialSource(iplbltC,iplblt,-DMROP=Mcopy)
+ObjectFromSpecialSource(iplbltX,iplblt,-DMROP=Mxor)
+ObjectFromSpecialSource(iplbltO,iplblt,-DMROP=Mor)
+ObjectFromSpecialSource(iplbltG,iplblt,-DMROP=0)
+
+ObjectFromSpecialSource(iplsolidC,iplsolid,-DRROP=GXcopy)
+ObjectFromSpecialSource(iplsolidX,iplsolid,-DRROP=GXxor)
+ObjectFromSpecialSource(iplsolidG,iplsolid,-DRROP=GXset)
+
+ObjectFromSpecialSource(ipltileoddC,ipltileodd,-DMROP=Mcopy)
+ObjectFromSpecialSource(ipltileoddG,ipltileodd,-DMROP=0)
+
+ObjectFromSpecialSource(ipltile32C,ipltile32,-DMROP=Mcopy)
+ObjectFromSpecialSource(ipltile32G,ipltile32,-DMROP=0)
+
+ObjectFromSpecialSource(iplply1rctC,iplply1rct,-DRROP=GXcopy)
+ObjectFromSpecialSource(iplply1rctG,iplply1rct,-DRROP=GXset)
+
+DependTarget()
diff --git a/nx-X11/programs/Xserver/iplan2p4/ipl.h b/nx-X11/programs/Xserver/iplan2p4/ipl.h
new file mode 100644
index 000000000..356e43367
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/ipl.h
@@ -0,0 +1,1254 @@
+/* $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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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(
+ int /*alu*/,
+ unsigned long /*fg*/,
+ unsigned long /*planemask*/
+);
+
+extern int iplSetOpaqueStipple(
+ int /*alu*/,
+ unsigned long /*fg*/,
+ unsigned long /*bg*/,
+ unsigned long /*planemask*/
+);
+
+extern int iplComputeClipMasks32(
+ BoxPtr /*pBox*/,
+ int /*numRects*/,
+ int /*x*/,
+ int /*y*/,
+ int /*w*/,
+ int /*h*/,
+ CARD32 * /*clips*/
+);
+/* ipl8cppl.c */
+
+extern void iplCopyImagePlane(
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ int /*rop*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplCopyPlane8to1(
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ int /*rop*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/,
+ unsigned long /*bitPlane*/
+);
+/* ipl8lineCO.c */
+
+extern int ipl8LineSS1RectCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/,
+ DDXPointPtr /*pptInitOrig*/,
+ int * /*x1p*/,
+ int * /*y1p*/,
+ int * /*x2p*/,
+ int * /*y2p*/
+);
+
+extern void ipl8LineSS1Rect(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/
+);
+
+extern void ipl8ClippedLineCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*x2*/,
+ int /*y2*/,
+ BoxPtr /*boxp*/,
+ Bool /*shorten*/
+);
+/* ipl8lineCP.c */
+
+extern int ipl8LineSS1RectPreviousCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/,
+ DDXPointPtr /*pptInitOrig*/,
+ int * /*x1p*/,
+ int * /*y1p*/,
+ int * /*x2p*/,
+ int * /*y2p*/
+);
+/* ipl8lineG.c */
+
+extern int ipl8LineSS1RectGeneral(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/,
+ DDXPointPtr /*pptInitOrig*/,
+ int * /*x1p*/,
+ int * /*y1p*/,
+ int * /*x2p*/,
+ int * /*y2p*/
+);
+
+extern void ipl8ClippedLineGeneral(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*x2*/,
+ int /*y2*/,
+ BoxPtr /*boxp*/,
+ Bool /*shorten*/
+);
+/* ipl8lineX.c */
+
+extern int ipl8LineSS1RectXor(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/,
+ DDXPointPtr /*pptInitOrig*/,
+ int * /*x1p*/,
+ int * /*y1p*/,
+ int * /*x2p*/,
+ int * /*y2p*/
+);
+
+extern void ipl8ClippedLineXor(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*x2*/,
+ int /*y2*/,
+ BoxPtr /*boxp*/,
+ Bool /*shorten*/
+);
+/* ipl8segC.c */
+
+extern int ipl8SegmentSS1RectCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSegInit*/
+);
+/* ipl8segCS.c */
+
+extern int ipl8SegmentSS1RectShiftCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSegInit*/
+);
+
+extern void ipl8SegmentSS1Rect(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSegInit*/
+);
+/* ipl8segG.c */
+
+extern int ipl8SegmentSS1RectGeneral(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSegInit*/
+);
+/* iplsegX.c */
+
+extern int ipl8SegmentSS1RectXor(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSegInit*/
+);
+/* iplallpriv.c */
+
+extern Bool iplAllocatePrivates(
+ ScreenPtr /*pScreen*/,
+ int * /*window_index*/,
+ int * /*gc_index*/
+);
+/* iplbitblt.c */
+
+extern RegionPtr iplBitBlt(
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ GCPtr/*pGC*/,
+ int /*srcx*/,
+ int /*srcy*/,
+ int /*width*/,
+ int /*height*/,
+ int /*dstx*/,
+ int /*dsty*/,
+ void (* /*doBitBlt*/)(),
+ unsigned long /*bitPlane*/
+);
+
+extern void iplDoBitblt(
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+);
+
+extern RegionPtr iplCopyArea(
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ GCPtr/*pGC*/,
+ int /*srcx*/,
+ int /*srcy*/,
+ int /*width*/,
+ int /*height*/,
+ int /*dstx*/,
+ int /*dsty*/
+);
+
+extern void iplCopyPlane1to8(
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ int /*rop*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/,
+ unsigned long /*bitPlane*/
+);
+
+extern RegionPtr iplCopyPlane(
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ GCPtr /*pGC*/,
+ int /*srcx*/,
+ int /*srcy*/,
+ int /*width*/,
+ int /*height*/,
+ int /*dstx*/,
+ int /*dsty*/,
+ unsigned long /*bitPlane*/
+);
+/* iplbltC.c */
+
+extern void iplDoBitbltCopy(
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+);
+/* iplbltG.c */
+
+extern void iplDoBitbltGeneral(
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+);
+/* iplbltO.c */
+
+extern void iplDoBitbltOr(
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+);
+/* iplbltX.c */
+
+extern void iplDoBitbltXor(
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+);
+/* iplbres.c */
+
+extern void iplBresS(
+ 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*/
+);
+/* iplbresd.c */
+
+extern void iplBresD(
+ 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*/
+);
+/* iplbstore.c */
+
+extern void iplSaveAreas(
+ PixmapPtr /*pPixmap*/,
+ RegionPtr /*prgnSave*/,
+ int /*xorg*/,
+ int /*yorg*/,
+ WindowPtr /*pWin*/
+);
+
+extern void iplRestoreAreas(
+ PixmapPtr /*pPixmap*/,
+ RegionPtr /*prgnRestore*/,
+ int /*xorg*/,
+ int /*yorg*/,
+ WindowPtr /*pWin*/
+);
+/* iplcmap.c */
+
+extern int iplListInstalledColormaps(
+ ScreenPtr /*pScreen*/,
+ Colormap * /*pmaps*/
+);
+
+extern void iplInstallColormap(
+ ColormapPtr /*pmap*/
+);
+
+extern void iplUninstallColormap(
+ ColormapPtr /*pmap*/
+);
+
+extern void iplResolveColor(
+ unsigned short * /*pred*/,
+ unsigned short * /*pgreen*/,
+ unsigned short * /*pblue*/,
+ VisualPtr /*pVisual*/
+);
+
+extern Bool iplInitializeColormap(
+ ColormapPtr /*pmap*/
+);
+
+extern int iplExpandDirectColors(
+ ColormapPtr /*pmap*/,
+ int /*ndef*/,
+ xColorItem * /*indefs*/,
+ xColorItem * /*outdefs*/
+);
+
+extern Bool iplCreateDefColormap(
+ ScreenPtr /*pScreen*/
+);
+
+extern Bool iplSetVisualTypes(
+ int /*depth*/,
+ int /*visuals*/,
+ int /*bitsPerRGB*/
+);
+
+extern Bool iplInitVisuals(
+ VisualPtr * /*visualp*/,
+ DepthPtr * /*depthp*/,
+ int * /*nvisualp*/,
+ int * /*ndepthp*/,
+ int * /*rootDepthp*/,
+ VisualID * /*defaultVisp*/,
+ unsigned long /*sizes*/,
+ int /*bitsPerRGB*/
+);
+/* iplfillarcC.c */
+
+extern void iplPolyFillArcSolidCopy(
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*narcs*/,
+ xArc * /*parcs*/
+);
+/* iplfillarcG.c */
+
+extern void iplPolyFillArcSolidGeneral(
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*narcs*/,
+ xArc * /*parcs*/
+);
+/* iplfillrct.c */
+
+extern void iplFillBoxTileOdd(
+ DrawablePtr /*pDrawable*/,
+ int /*n*/,
+ BoxPtr /*rects*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/
+);
+
+extern void iplFillRectTileOdd(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void iplPolyFillRect(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nrectFill*/,
+ xRectangle * /*prectInit*/
+);
+/* iplfillsp.c */
+
+extern void iplUnnaturalTileFS(
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+
+extern void iplUnnaturalStippleFS(
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+
+extern void ipl8Stipple32FS(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+
+extern void ipl8OpaqueStipple32FS(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+/* iplgc.c */
+
+extern GCOpsPtr iplMatchCommon(
+ GCPtr /*pGC*/,
+ iplPrivGCPtr /*devPriv*/
+);
+
+extern Bool iplCreateGC(
+ GCPtr /*pGC*/
+);
+
+extern void iplValidateGC(
+ GCPtr /*pGC*/,
+ unsigned long /*changes*/,
+ DrawablePtr /*pDrawable*/
+);
+
+/* iplgetsp.c */
+
+extern void iplGetSpans(
+ DrawablePtr /*pDrawable*/,
+ int /*wMax*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ int /*nspans*/,
+ char * /*pdstStart*/
+);
+/* iplglblt8.c */
+
+extern void iplPolyGlyphBlt8(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*x*/,
+ int /*y*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+);
+/* iplglrop8.c */
+
+extern void iplPolyGlyphRop8(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*x*/,
+ int /*y*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+);
+/* iplhrzvert.c */
+
+extern int iplHorzS(
+ int /*rop*/,
+ unsigned short * /*and*/,
+ unsigned short * /*xor*/,
+ unsigned short * /*addrg*/,
+ int /*nlwidth*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*len*/
+);
+
+extern int iplVertS(
+ int /*rop*/,
+ unsigned short * /*and*/,
+ unsigned short * /*xor*/,
+ unsigned short * /*addrg*/,
+ int /*nlwidth*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*len*/
+);
+/* ipligblt8.c */
+
+extern void iplImageGlyphBlt8(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*x*/,
+ int /*y*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+);
+/* iplimage.c */
+
+extern void iplPutImage(
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*depth*/,
+ int /*x*/,
+ int /*y*/,
+ int /*w*/,
+ int /*h*/,
+ int /*leftPad*/,
+ int /*format*/,
+ char * /*pImage*/
+);
+
+extern void iplGetImage(
+ DrawablePtr /*pDrawable*/,
+ int /*sx*/,
+ int /*sy*/,
+ int /*w*/,
+ int /*h*/,
+ unsigned int /*format*/,
+ unsigned long /*planeMask*/,
+ char * /*pdstLine*/
+);
+/* iplline.c */
+
+extern void iplLineSS(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/
+);
+
+extern void iplLineSD(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/
+);
+/* iplmskbits.c */
+/* iplpixmap.c */
+
+extern PixmapPtr iplCreatePixmap(
+ ScreenPtr /*pScreen*/,
+ int /*width*/,
+ int /*height*/,
+ int /*depth*/
+);
+
+extern Bool iplDestroyPixmap(
+ PixmapPtr /*pPixmap*/
+);
+
+extern PixmapPtr iplCopyPixmap(
+ PixmapPtr /*pSrc*/
+);
+
+extern void iplPadPixmap(
+ PixmapPtr /*pPixmap*/
+);
+
+extern void iplXRotatePixmap(
+ PixmapPtr /*pPix*/,
+ int /*rw*/
+);
+
+extern void iplYRotatePixmap(
+ PixmapPtr /*pPix*/,
+ int /*rh*/
+);
+
+extern void iplCopyRotatePixmap(
+ PixmapPtr /*psrcPix*/,
+ PixmapPtr * /*ppdstPix*/,
+ int /*xrot*/,
+ int /*yrot*/
+);
+/* iplply1rctC.c */
+
+extern void iplFillPoly1RectCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*shape*/,
+ int /*mode*/,
+ int /*count*/,
+ DDXPointPtr /*ptsIn*/
+);
+/* iplply1rctG.c */
+
+extern void iplFillPoly1RectGeneral(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*shape*/,
+ int /*mode*/,
+ int /*count*/,
+ DDXPointPtr /*ptsIn*/
+);
+/* iplpntwin.c */
+
+extern void iplPaintWindow(
+ WindowPtr /*pWin*/,
+ RegionPtr /*pRegion*/,
+ int /*what*/
+);
+
+extern void iplFillBoxSolid(
+ DrawablePtr /*pDrawable*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/,
+ unsigned long /*pixel*/
+);
+
+extern void iplFillBoxTile32(
+ DrawablePtr /*pDrawable*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/,
+ PixmapPtr /*tile*/
+);
+/* iplpolypnt.c */
+
+extern void iplPolyPoint(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ xPoint * /*pptInit*/
+);
+/* iplpush8.c */
+
+extern void iplPushPixels8(
+ GCPtr /*pGC*/,
+ PixmapPtr /*pBitmap*/,
+ DrawablePtr /*pDrawable*/,
+ int /*dx*/,
+ int /*dy*/,
+ int /*xOrg*/,
+ int /*yOrg*/
+);
+/* iplrctstp8.c */
+
+extern void ipl8FillRectOpaqueStippled32(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void ipl8FillRectTransparentStippled32(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void ipl8FillRectStippledUnnatural(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+/* iplrrop.c */
+
+extern int iplReduceRasterOp(
+ int /*rop*/,
+ unsigned long /*fg*/,
+ unsigned long /*pm*/,
+ unsigned short * /*andp*/,
+ unsigned short * /*xorp*/
+);
+/* iplscrinit.c */
+
+extern Bool iplCloseScreen(
+ int /*index*/,
+ ScreenPtr /*pScreen*/
+);
+
+extern Bool iplSetupScreen(
+ ScreenPtr /*pScreen*/,
+ pointer /*pbits*/,
+ int /*xsize*/,
+ int /*ysize*/,
+ int /*dpix*/,
+ int /*dpiy*/,
+ int /*width*/
+);
+
+extern int iplFinishScreenInit(
+ ScreenPtr /*pScreen*/,
+ pointer /*pbits*/,
+ int /*xsize*/,
+ int /*ysize*/,
+ int /*dpix*/,
+ int /*dpiy*/,
+ int /*width*/
+);
+
+extern Bool iplScreenInit(
+ ScreenPtr /*pScreen*/,
+ pointer /*pbits*/,
+ int /*xsize*/,
+ int /*ysize*/,
+ int /*dpix*/,
+ int /*dpiy*/,
+ int /*width*/
+);
+
+extern PixmapPtr iplGetScreenPixmap(
+ ScreenPtr /*pScreen*/
+);
+
+extern void iplSetScreenPixmap(
+ PixmapPtr /*pPix*/
+);
+
+/* iplseg.c */
+
+extern void iplSegmentSS(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSeg*/
+);
+
+extern void iplSegmentSD(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSeg*/
+);
+/* iplsetsp.c */
+
+extern int iplSetScanline(
+ int /*y*/,
+ int /*xOrigin*/,
+ int /*xStart*/,
+ int /*xEnd*/,
+ unsigned int * /*psrc*/,
+ int /*alu*/,
+ unsigned short * /*pdstBase*/,
+ int /*widthDst*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplSetSpans(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ char * /*psrc*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ int /*nspans*/,
+ int /*fSorted*/
+);
+/* iplsolidC.c */
+
+extern void iplFillRectSolidCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void iplSolidSpansCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+/* iplsolidG.c */
+
+extern void iplFillRectSolidGeneral(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void iplSolidSpansGeneral(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+/* iplsolidX.c */
+
+extern void iplFillRectSolidXor(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void iplSolidSpansXor(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+/* iplteblt8.c */
+
+extern void iplTEGlyphBlt8(
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*xInit*/,
+ int /*yInit*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+);
+/* ipltegblt.c */
+
+extern void iplTEGlyphBlt(
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*x*/,
+ int /*y*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+);
+/* ipltile32C.c */
+
+extern void iplFillRectTile32Copy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void iplTile32FSCopy(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+/* ipltile32G.c */
+
+extern void iplFillRectTile32General(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/
+);
+
+extern void iplTile32FSGeneral(
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+);
+/* ipltileoddC.c */
+
+extern void iplFillBoxTileOddCopy(
+ DrawablePtr /*pDrawable*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplFillSpanTileOddCopy(
+ DrawablePtr /*pDrawable*/,
+ int /*n*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplFillBoxTile32sCopy(
+ DrawablePtr /*pDrawable*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplFillSpanTile32sCopy(
+ DrawablePtr /*pDrawable*/,
+ int /*n*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+/* ipltileoddG.c */
+
+extern void iplFillBoxTileOddGeneral(
+ DrawablePtr /*pDrawable*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplFillSpanTileOddGeneral(
+ DrawablePtr /*pDrawable*/,
+ int /*n*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplFillBoxTile32sGeneral(
+ DrawablePtr /*pDrawable*/,
+ int /*nBox*/,
+ BoxPtr /*pBox*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+
+extern void iplFillSpanTile32sGeneral(
+ DrawablePtr /*pDrawable*/,
+ int /*n*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ PixmapPtr /*tile*/,
+ int /*xrot*/,
+ int /*yrot*/,
+ int /*alu*/,
+ unsigned long /*planemask*/
+);
+/* iplwindow.c */
+
+extern Bool iplCreateWindow(
+ WindowPtr /*pWin*/
+);
+
+extern Bool iplDestroyWindow(
+ WindowPtr /*pWin*/
+);
+
+extern Bool iplMapWindow(
+ WindowPtr /*pWindow*/
+);
+
+extern Bool iplPositionWindow(
+ WindowPtr /*pWin*/,
+ int /*x*/,
+ int /*y*/
+);
+
+extern Bool iplUnmapWindow(
+ WindowPtr /*pWindow*/
+);
+
+extern void iplCopyWindow(
+ WindowPtr /*pWin*/,
+ DDXPointRec /*ptOldOrg*/,
+ RegionPtr /*prgnSrc*/
+);
+
+extern Bool iplChangeWindowAttributes(
+ WindowPtr /*pWin*/,
+ unsigned long /*mask*/
+);
+/* iplzerarcC.c */
+
+extern void iplZeroPolyArcSS8Copy(
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*narcs*/,
+ xArc * /*parcs*/
+);
+/* iplzerarcG.c */
+
+extern void iplZeroPolyArcSS8General(
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*narcs*/,
+ xArc * /*parcs*/
+);
+/* iplzerarcX.c */
+
+extern void iplZeroPolyArcSS8Xor(
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*narcs*/,
+ xArc * /*parcs*/
+);
+
+/* 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/nx-X11/programs/Xserver/iplan2p4/iplallpriv.c b/nx-X11/programs/Xserver/iplan2p4/iplallpriv.c
new file mode 100644
index 000000000..23a13dbd1
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplallpriv.c
@@ -0,0 +1,93 @@
+/* $XFree86$ */
+/*
+ * $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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplbitblt.c b/nx-X11/programs/Xserver/iplan2p4/iplbitblt.c
new file mode 100644
index 000000000..4bf64437e
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplbitblt.c
@@ -0,0 +1,388 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplbitblt.c,v 3.1tsi 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/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_NULL(pGC->pScreen, &rgnDst);
+ }
+ 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/nx-X11/programs/Xserver/iplan2p4/iplblt.c b/nx-X11/programs/Xserver/iplan2p4/iplblt.c
new file mode 100644
index 000000000..85bcece13
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplblt.c
@@ -0,0 +1,431 @@
+/* $XFree86$ */
+/*
+ * 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplbres.c b/nx-X11/programs/Xserver/iplan2p4/iplbres.c
new file mode 100644
index 000000000..4fa9a3256
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplbres.c
@@ -0,0 +1,186 @@
+/* $XFree86$ */
+/***********************************************************
+
+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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplbresd.c b/nx-X11/programs/Xserver/iplan2p4/iplbresd.c
new file mode 100644
index 000000000..61b154135
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplbresd.c
@@ -0,0 +1,212 @@
+/* $XFree86$ */
+/***********************************************************
+
+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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplbstore.c b/nx-X11/programs/Xserver/iplan2p4/iplbstore.c
new file mode 100644
index 000000000..d2fc23513
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplbstore.c
@@ -0,0 +1,159 @@
+/* $XFree86$ */
+
+/*-
+ * 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.
+ *
+ *
+ */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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 <X11/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/nx-X11/programs/Xserver/iplan2p4/iplcmap.c b/nx-X11/programs/Xserver/iplan2p4/iplcmap.c
new file mode 100644
index 000000000..0f3cdca14
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplcmap.c
@@ -0,0 +1,126 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplcmap.c,v 3.0 1996/08/18 01:54:40 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplfillarc.c b/nx-X11/programs/Xserver/iplan2p4/iplfillarc.c
new file mode 100644
index 000000000..f62ff9f9e
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplfillarc.c
@@ -0,0 +1,271 @@
+/* $XFree86$ */
+/************************************************************
+
+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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplfillrct.c b/nx-X11/programs/Xserver/iplan2p4/iplfillrct.c
new file mode 100644
index 000000000..a3301457b
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplfillrct.c
@@ -0,0 +1,281 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplfillrct.c,v 3.0 1996/08/18 01:54:42 dawes 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplfillsp.c b/nx-X11/programs/Xserver/iplan2p4/iplfillsp.c
new file mode 100644
index 000000000..863d369af
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplfillsp.c
@@ -0,0 +1,384 @@
+/* $XFree86$ */
+/************************************************************
+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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplgc.c b/nx-X11/programs/Xserver/iplan2p4/iplgc.c
new file mode 100644
index 000000000..1cbcb7522
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplgc.c
@@ -0,0 +1,786 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplgc.c,v 3.0 1996/08/18 01:54:45 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: 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xproto.h>
+#include "ipl.h"
+#include <X11/fonts/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/nx-X11/programs/Xserver/iplan2p4/iplgetsp.c b/nx-X11/programs/Xserver/iplan2p4/iplgetsp.c
new file mode 100644
index 000000000..c325ad1fe
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplgetsp.c
@@ -0,0 +1,166 @@
+/* $XFree86$ */
+/* $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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplhrzvert.c b/nx-X11/programs/Xserver/iplan2p4/iplhrzvert.c
new file mode 100644
index 000000000..45faaa1cb
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplhrzvert.c
@@ -0,0 +1,128 @@
+/* $XFree86$ */
+/***********************************************************
+
+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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplimage.c b/nx-X11/programs/Xserver/iplan2p4/iplimage.c
new file mode 100644
index 000000000..5b72b885f
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplimage.c
@@ -0,0 +1,87 @@
+/* $XFree86$ */
+/***********************************************************
+
+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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplline.c b/nx-X11/programs/Xserver/iplan2p4/iplline.c
new file mode 100644
index 000000000..19d078cb2
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplline.c
@@ -0,0 +1,758 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplline.c,v 3.0 1996/08/18 01:54:50 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: 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplmap.h b/nx-X11/programs/Xserver/iplan2p4/iplmap.h
new file mode 100644
index 000000000..cc065aa82
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplmap.h
@@ -0,0 +1,176 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplmap.h,v 3.1 1998/04/05 16:42:26 robin 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/iplan2p4/iplmergerop.h b/nx-X11/programs/Xserver/iplan2p4/iplmergerop.h
new file mode 100644
index 000000000..09141c983
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplmergerop.h
@@ -0,0 +1,146 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplmergerop.h,v 3.0 1996/08/18 01:54:53 dawes Exp $ */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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 <X11/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/nx-X11/programs/Xserver/iplan2p4/iplmskbits.c b/nx-X11/programs/Xserver/iplan2p4/iplmskbits.c
new file mode 100644
index 000000000..e611bd293
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplmskbits.c
@@ -0,0 +1,108 @@
+/* $XFree86$ */
+/* Modified nov 94 by Martin Schaller (Martin_Schaller@maus.r.de) for use with
+interleaved planes */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/iplan2p4/iplmskbits.h b/nx-X11/programs/Xserver/iplan2p4/iplmskbits.h
new file mode 100644
index 000000000..1efc47d44
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplmskbits.h
@@ -0,0 +1,500 @@
+/* $XFree86$ */
+/* 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; \
+ })
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/iplan2p4/iplpack.c b/nx-X11/programs/Xserver/iplan2p4/iplpack.c
new file mode 100644
index 000000000..a6ca6f12b
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplpack.c
@@ -0,0 +1,316 @@
+/* $XFree86$ */
+/* 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/nx-X11/programs/Xserver/iplan2p4/iplpack.h b/nx-X11/programs/Xserver/iplan2p4/iplpack.h
new file mode 100644
index 000000000..53c2c988f
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplpack.h
@@ -0,0 +1,10 @@
+/* $XFree86$ */
+/* 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/nx-X11/programs/Xserver/iplan2p4/iplpixmap.c b/nx-X11/programs/Xserver/iplan2p4/iplpixmap.c
new file mode 100644
index 000000000..7bfb49551
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplpixmap.c
@@ -0,0 +1,386 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplpixmap.c,v 3.0 1996/08/18 01:54:59 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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;
+ size_t datasize;
+ size_t paddedWidth;
+ int ipad=INTER_PLANES*2 - 1;
+
+ paddedWidth = PixmapBytePad(width, depth);
+ paddedWidth = (paddedWidth + ipad) & ~ipad;
+ if (paddedWidth / 4 > 32767 || height > 32767)
+ return NullPixmap;
+ 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/nx-X11/programs/Xserver/iplan2p4/iplply1rct.c b/nx-X11/programs/Xserver/iplan2p4/iplply1rct.c
new file mode 100644
index 000000000..bac2be4ed
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplply1rct.c
@@ -0,0 +1,310 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplply1rct.c,v 3.0 1996/08/18 01:55:00 dawes 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplpntwin.c b/nx-X11/programs/Xserver/iplan2p4/iplpntwin.c
new file mode 100644
index 000000000..8421ba377
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplpntwin.c
@@ -0,0 +1,341 @@
+/* $XFree86$ */
+/* $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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplpolypnt.c b/nx-X11/programs/Xserver/iplan2p4/iplpolypnt.c
new file mode 100644
index 000000000..61aea7ffd
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplpolypnt.c
@@ -0,0 +1,123 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplpolypnt.c,v 3.0 1996/08/18 01:55:02 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: 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplrrop.c b/nx-X11/programs/Xserver/iplan2p4/iplrrop.c
new file mode 100644
index 000000000..1b65fa9dc
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplrrop.c
@@ -0,0 +1,219 @@
+/* $XFree86$ */
+/*
+ * $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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplrrop.h b/nx-X11/programs/Xserver/iplan2p4/iplrrop.h
new file mode 100644
index 000000000..05a88fea4
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplrrop.h
@@ -0,0 +1,80 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplrrop.h,v 3.0 1996/08/18 01:55:04 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))
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#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/nx-X11/programs/Xserver/iplan2p4/iplscrinit.c b/nx-X11/programs/Xserver/iplan2p4/iplscrinit.c
new file mode 100644
index 000000000..073e7b9a4
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplscrinit.c
@@ -0,0 +1,233 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplscrinit.c,v 3.2 1998/06/27 12:55:03 hohndel 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplsetsp.c b/nx-X11/programs/Xserver/iplan2p4/iplsetsp.c
new file mode 100644
index 000000000..9a6c8128d
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplsetsp.c
@@ -0,0 +1,304 @@
+/* $XFree86$ */
+/* $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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplsolid.c b/nx-X11/programs/Xserver/iplan2p4/iplsolid.c
new file mode 100644
index 000000000..768bf0ace
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplsolid.c
@@ -0,0 +1,221 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplsolid.c,v 3.0 1996/08/18 01:55:08 dawes 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/ipltegblt.c b/nx-X11/programs/Xserver/iplan2p4/ipltegblt.c
new file mode 100644
index 000000000..9a46e31c6
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/ipltegblt.c
@@ -0,0 +1,221 @@
+/* $XFree86$ */
+/* $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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xproto.h>
+#include "ipl.h"
+#include <X11/fonts/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/nx-X11/programs/Xserver/iplan2p4/ipltile32.c b/nx-X11/programs/Xserver/iplan2p4/ipltile32.c
new file mode 100644
index 000000000..06be5a2e8
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/ipltile32.c
@@ -0,0 +1,272 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/ipltile32.c,v 3.0 1996/08/18 01:55:10 dawes 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/ipltileodd.c b/nx-X11/programs/Xserver/iplan2p4/ipltileodd.c
new file mode 100644
index 000000000..7230a5621
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/ipltileodd.c
@@ -0,0 +1,869 @@
+/* $XFree86$ */
+/*
+ * 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/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/nx-X11/programs/Xserver/iplan2p4/iplwindow.c b/nx-X11/programs/Xserver/iplan2p4/iplwindow.c
new file mode 100644
index 000000000..511e753b3
--- /dev/null
+++ b/nx-X11/programs/Xserver/iplan2p4/iplwindow.c
@@ -0,0 +1,343 @@
+/* $XFree86: xc/programs/Xserver/iplan2p4/iplwindow.c,v 3.0tsi 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 */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/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_NULL(pWin->drawable.pScreen, &rgnDst);
+
+ 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);
+}
+