summaryrefslogtreecommitdiff
path: root/ilbm
diff options
context:
space:
mode:
Diffstat (limited to 'ilbm')
-rw-r--r--ilbm/README17
-rw-r--r--ilbm/ilbm.h1217
-rw-r--r--ilbm/ilbmbitblt.c479
-rw-r--r--ilbm/ilbmblt.c569
-rw-r--r--ilbm/ilbmbres.c324
-rw-r--r--ilbm/ilbmbresd.c215
-rw-r--r--ilbm/ilbmbstore.c155
-rw-r--r--ilbm/ilbmclip.c242
-rw-r--r--ilbm/ilbmcmap.c124
-rw-r--r--ilbm/ilbmfillarc.c373
-rw-r--r--ilbm/ilbmfillrct.c295
-rw-r--r--ilbm/ilbmfillsp.c1145
-rw-r--r--ilbm/ilbmfont.c78
-rw-r--r--ilbm/ilbmgc.c711
-rw-r--r--ilbm/ilbmgetsp.c166
-rw-r--r--ilbm/ilbmhrzvert.c209
-rw-r--r--ilbm/ilbmimage.c437
-rw-r--r--ilbm/ilbmimggblt.c470
-rw-r--r--ilbm/ilbmline.c701
-rw-r--r--ilbm/ilbmmisc.c95
-rw-r--r--ilbm/ilbmpixmap.c289
-rw-r--r--ilbm/ilbmply1rct.c299
-rw-r--r--ilbm/ilbmplygblt.c465
-rw-r--r--ilbm/ilbmpntarea.c652
-rw-r--r--ilbm/ilbmpntwin.c127
-rw-r--r--ilbm/ilbmpolypnt.c148
-rw-r--r--ilbm/ilbmpushpxl.c259
-rw-r--r--ilbm/ilbmscrinit.c247
-rw-r--r--ilbm/ilbmsetsp.c265
-rw-r--r--ilbm/ilbmtegblt.c595
-rw-r--r--ilbm/ilbmtile.c853
-rw-r--r--ilbm/ilbmwindow.c319
-rw-r--r--ilbm/ilbmzerarc.c210
33 files changed, 12750 insertions, 0 deletions
diff --git a/ilbm/README b/ilbm/README
new file mode 100644
index 000000000..650d6b803
--- /dev/null
+++ b/ilbm/README
@@ -0,0 +1,17 @@
+
+ ilbm -- Interleaved bitplanes for Amiga
+ © Copyright 1995 by Geert Uytterhoeven and Others (read the sources)
+
+All stuff in this directory is based on Xdaniver, which is based on mfb (read
+../afb/Xdaniver.doc).
+
+I made changes to support the interleaved mode of the Linux/68k Amiga Color
+Frame Buffer Device, which uses interleaved bitplanes instead of normal
+bitplanes.
+
+Note: there are still some annoying bugs left in ilbmimage.
+
+--
+Geert Uytterhoeven Geert.Uytterhoeven@cs.kuleuven.ac.be
+Wavelets, Linux/m68k on Amiga http://www.cs.kuleuven.ac.be/~geert/
+Department of Computer Science -- Katholieke Universiteit Leuven -- Belgium
diff --git a/ilbm/ilbm.h b/ilbm/ilbm.h
new file mode 100644
index 000000000..1df8eff68
--- /dev/null
+++ b/ilbm/ilbm.h
@@ -0,0 +1,1217 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbm.h,v 3.2 1998/04/05 16:42:23 robin Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbm.h,v 5.31 94/04/17 20:28:15 dpw Exp $ */
+/* Monochrome Frame Buffer definitions
+ written by drewry, september 1986
+*/
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "pixmap.h"
+#include "region.h"
+#include "gc.h"
+#include "colormap.h"
+#include "miscstruct.h"
+#include "mibstore.h"
+
+extern int ilbmInverseAlu[];
+extern int ilbmScreenPrivateIndex;
+/* warning: PixelType definition duplicated in maskbits.h */
+#ifndef PixelType
+#define PixelType unsigned long
+#endif /* PixelType */
+
+#define AFB_MAX_DEPTH 8
+
+/* ilbmbitblt.c */
+
+extern void ilbmDoBitblt(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+#endif
+);
+
+extern RegionPtr ilbmBitBlt(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ GCPtr /*pGC*/,
+ int /*srcx*/,
+ int /*srcy*/,
+ int /*width*/,
+ int /*height*/,
+ int /*dstx*/,
+ int /*dsty*/,
+ void (*doBitBlt)(),
+ unsigned long /*planemask*/
+#endif
+);
+
+extern RegionPtr ilbmCopyArea(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ GCPtr/*pGC*/,
+ int /*srcx*/,
+ int /*srcy*/,
+ int /*width*/,
+ int /*height*/,
+ int /*dstx*/,
+ int /*dsty*/
+#endif
+);
+
+extern RegionPtr ilbmCopyPlane(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrcDrawable*/,
+ DrawablePtr /*pDstDrawable*/,
+ GCPtr/*pGC*/,
+ int /*srcx*/,
+ int /*srcy*/,
+ int /*width*/,
+ int /*height*/,
+ int /*dstx*/,
+ int /*dsty*/,
+ unsigned long /*plane*/
+#endif
+);
+
+extern void ilbmCopy1ToN(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmbltC.c */
+
+extern void ilbmDoBitbltCopy(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmbltCI.c */
+
+extern void ilbmDoBitbltCopyInverted(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmbltG.c */
+
+extern void ilbmDoBitbltGeneral(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmbltO.c */
+
+extern void ilbmDoBitbltOr(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmbltX.c */
+
+extern void ilbmDoBitbltXor(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pSrc*/,
+ DrawablePtr /*pDst*/,
+ int /*alu*/,
+ RegionPtr /*prgnDst*/,
+ DDXPointPtr /*pptSrc*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmbres.c */
+
+extern void ilbmBresS(
+#if NeedFunctionPrototypes
+ PixelType * /*addrl*/,
+ int /*nlwidth*/,
+ int /*sizeDst*/,
+ int /*depthDst*/,
+ int /*signdx*/,
+ int /*signdy*/,
+ int /*axis*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*e*/,
+ int /*e1*/,
+ int /*e2*/,
+ int /*len*/,
+ unsigned char * /*rrops*/
+#endif
+);
+/* ilbmbresd.c */
+
+extern void ilbmBresD(
+#if NeedFunctionPrototypes
+ int * /*pdashIndex*/,
+ unsigned char * /*pDash*/,
+ int /*numInDashList*/,
+ int * /*pdashOffset*/,
+ int /*isDoubleDash*/,
+ PixelType * /*addrl*/,
+ int /*nlwidth*/,
+ int /*sizeDst*/,
+ int /*depthDst*/,
+ int /*signdx*/,
+ int /*signdy*/,
+ int /*axis*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*e*/,
+ int /*e1*/,
+ int /*e2*/,
+ int /*len*/,
+ unsigned char * /*rrops*/,
+ unsigned char * /*bgrrops*/
+#endif
+);
+/* ilbmbstore.c */
+
+extern void ilbmSaveAreas(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pPixmap*/,
+ RegionPtr /*prgnSave*/,
+ int /*xorg*/,
+ int /*yorg*/,
+ WindowPtr /*pWin*/
+#endif
+);
+
+extern void ilbmRestoreAreas(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pPixmap*/,
+ RegionPtr /*prgnRestore*/,
+ int /*xorg*/,
+ int /*yorg*/,
+ WindowPtr /*pWin*/
+#endif
+);
+/* ilbmclip.c */
+
+extern RegionPtr ilbmPixmapToRegion(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pPix*/
+#endif
+);
+
+/* ilbmcmap.c */
+
+extern Bool ilbmInitializeColormap(
+#if NeedFunctionPrototypes
+ ColormapPtr /*pmap*/
+#endif
+);
+
+extern void ilbmResolveColor(
+#if NeedFunctionPrototypes
+ unsigned short * /*pred*/,
+ unsigned short * /*pgreen*/,
+ unsigned short * /*pblue*/,
+ VisualPtr /*pVisual*/
+#endif
+);
+
+extern Bool ilbmSetVisualTypes(
+#if NeedFunctionPrototypes
+ int /*depth*/,
+ int /*visuals*/,
+ int /*bitsPerRGB*/
+#endif
+);
+
+/* ilbmfillarc.c */
+
+extern void ilbmPolyFillArcSolid(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*narcs*/,
+ xArc * /*parcs*/
+#endif
+);
+/* ilbmfillrct.c */
+
+extern void ilbmPolyFillRect(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nrectFill*/,
+ xRectangle * /*prectInit*/
+#endif
+);
+
+/* ilbmply1rct.c */
+extern void ilbmFillPolygonSolid(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*shape*/,
+ int /*count*/,
+ DDXPointPtr /*ptsIn*/
+#endif
+);
+
+/* ilbmfillsp.c */
+
+extern void ilbmSolidFS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+#endif
+);
+
+extern void ilbmStippleFS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+#endif
+);
+
+extern void ilbmTileFS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+#endif
+);
+
+extern void ilbmUnnaturalTileFS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+#endif
+);
+
+extern void ilbmUnnaturalStippleFS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+#endif
+);
+
+extern void ilbmOpaqueStippleFS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+#endif
+);
+
+extern void ilbmUnnaturalOpaqueStippleFS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*nInit*/,
+ DDXPointPtr /*pptInit*/,
+ int * /*pwidthInit*/,
+ int /*fSorted*/
+#endif
+);
+
+/* ilbmfont.c */
+
+extern Bool ilbmRealizeFont(
+#if NeedFunctionPrototypes
+ ScreenPtr /*pscr*/,
+ FontPtr /*pFont*/
+#endif
+);
+
+extern Bool ilbmUnrealizeFont(
+#if NeedFunctionPrototypes
+ ScreenPtr /*pscr*/,
+ FontPtr /*pFont*/
+#endif
+);
+/* ilbmgc.c */
+
+extern Bool ilbmCreateGC(
+#if NeedFunctionPrototypes
+ GCPtr /*pGC*/
+#endif
+);
+
+extern void ilbmValidateGC(
+#if NeedFunctionPrototypes
+ GCPtr /*pGC*/,
+ unsigned long /*changes*/,
+ DrawablePtr /*pDrawable*/
+#endif
+);
+
+extern void ilbmDestroyGC(
+#if NeedFunctionPrototypes
+ GCPtr /*pGC*/
+#endif
+);
+
+extern void ilbmReduceRop(
+#if NeedFunctionPrototypes
+ int /*alu*/,
+ Pixel /*src*/,
+ unsigned long /*planemask*/,
+ int /*depth*/,
+ unsigned char * /*rrops*/
+#endif
+);
+
+extern void ilbmReduceOpaqueStipple (
+#if NeedFunctionPrototypes
+ Pixel /*fg*/,
+ Pixel /*bg*/,
+ unsigned long /*planemask*/,
+ int /*depth*/,
+ unsigned char * /*rrops*/
+#endif
+);
+
+extern void ilbmComputeCompositeClip(
+#if NeedFunctionPrototypes
+ GCPtr /*pGC*/,
+ DrawablePtr /*pDrawable*/
+#endif
+);
+
+/* ilbmgetsp.c */
+
+extern void ilbmGetSpans(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ int /*wMax*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ int /*nspans*/,
+ char * /*pdstStart*/
+#endif
+);
+/* ilbmhrzvert.c */
+
+extern int ilbmHorzS(
+#if NeedFunctionPrototypes
+ PixelType * /*addrl*/,
+ int /*nlwidth*/,
+ int /*sizeDst*/,
+ int /*depthDst*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*len*/,
+ unsigned char * /*rrops*/
+#endif
+);
+
+extern int ilbmVertS(
+#if NeedFunctionPrototypes
+ PixelType * /*addrl*/,
+ int /*nlwidth*/,
+ int /*sizeDst*/,
+ int /*depthDst*/,
+ int /*x1*/,
+ int /*y1*/,
+ int /*len*/,
+ unsigned char * /*rrops*/
+#endif
+);
+/* ilbmigbblak.c */
+
+extern void ilbmImageGlyphBlt (
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*x*/,
+ int /*y*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+#endif
+);
+/* ilbmigbwht.c */
+
+/* ilbmimage.c */
+
+extern void ilbmPutImage(
+#if NeedFunctionPrototypes
+ DrawablePtr /*dst*/,
+ GCPtr /*pGC*/,
+ int /*depth*/,
+ int /*x*/,
+ int /*y*/,
+ int /*w*/,
+ int /*h*/,
+ int /*leftPad*/,
+ int /*format*/,
+ char * /*pImage*/
+#endif
+);
+
+extern void ilbmGetImage(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ int /*sx*/,
+ int /*sy*/,
+ int /*w*/,
+ int /*h*/,
+ unsigned int /*format*/,
+ unsigned long /*planeMask*/,
+ char * /*pdstLine*/
+#endif
+);
+/* ilbmline.c */
+
+extern void ilbmLineSS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/
+#endif
+);
+
+extern void ilbmLineSD(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ DDXPointPtr /*pptInit*/
+#endif
+);
+
+/* ilbmmisc.c */
+
+extern void ilbmQueryBestSize(
+#if NeedFunctionPrototypes
+ int /*class*/,
+ unsigned short * /*pwidth*/,
+ unsigned short * /*pheight*/,
+ ScreenPtr /*pScreen*/
+#endif
+);
+/* ilbmpntarea.c */
+
+extern void ilbmSolidFillArea(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ unsigned char * /*rrops*/
+#endif
+);
+
+extern void ilbmStippleAreaPPW(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ PixmapPtr /*pstipple*/,
+ unsigned char * /*rrops*/
+#endif
+);
+extern void ilbmStippleArea(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ PixmapPtr /*pstipple*/,
+ int /*xOff*/,
+ int /*yOff*/,
+ unsigned char * /*rrops*/
+#endif
+);
+/* ilbmplygblt.c */
+
+extern void ilbmPolyGlyphBlt(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*x*/,
+ int /*y*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+#endif
+);
+
+/* ilbmpixmap.c */
+
+extern PixmapPtr ilbmCreatePixmap(
+#if NeedFunctionPrototypes
+ ScreenPtr /*pScreen*/,
+ int /*width*/,
+ int /*height*/,
+ int /*depth*/
+#endif
+);
+
+extern Bool ilbmDestroyPixmap(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pPixmap*/
+#endif
+);
+
+extern PixmapPtr ilbmCopyPixmap(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pSrc*/
+#endif
+);
+
+extern void ilbmPadPixmap(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pPixmap*/
+#endif
+);
+
+extern void ilbmXRotatePixmap(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pPix*/,
+ int /*rw*/
+#endif
+);
+
+extern void ilbmYRotatePixmap(
+#if NeedFunctionPrototypes
+ PixmapPtr /*pPix*/,
+ int /*rh*/
+#endif
+);
+
+extern void ilbmCopyRotatePixmap(
+#if NeedFunctionPrototypes
+ PixmapPtr /*psrcPix*/,
+ PixmapPtr * /*ppdstPix*/,
+ int /*xrot*/,
+ int /*yrot*/
+#endif
+);
+extern void ilbmPaintWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/,
+ RegionPtr /*pRegion*/,
+ int /*what*/
+#endif
+);
+/* ilbmpolypnt.c */
+
+extern void ilbmPolyPoint(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*mode*/,
+ int /*npt*/,
+ xPoint * /*pptInit*/
+#endif
+);
+/* ilbmpushpxl.c */
+
+extern void ilbmPushPixels(
+#if NeedFunctionPrototypes
+ GCPtr /*pGC*/,
+ PixmapPtr /*pBitMap*/,
+ DrawablePtr /*pDrawable*/,
+ int /*dx*/,
+ int /*dy*/,
+ int /*xOrg*/,
+ int /*yOrg*/
+#endif
+);
+/* ilbmscrclse.c */
+
+extern Bool ilbmCloseScreen(
+#if NeedFunctionPrototypes
+ int /*index*/,
+ ScreenPtr /*pScreen*/
+#endif
+);
+/* ilbmscrinit.c */
+
+extern Bool ilbmAllocatePrivates(
+#if NeedFunctionPrototypes
+ ScreenPtr /*pScreen*/,
+ int * /*pWinIndex*/,
+ int * /*pGCIndex*/
+#endif
+);
+
+extern Bool ilbmScreenInit(
+#if NeedFunctionPrototypes
+ ScreenPtr /*pScreen*/,
+ pointer /*pbits*/,
+ int /*xsize*/,
+ int /*ysize*/,
+ int /*dpix*/,
+ int /*dpiy*/,
+ int /*width*/
+#endif
+);
+
+extern PixmapPtr ilbmGetWindowPixmap(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/
+#endif
+);
+
+extern void ilbmSetWindowPixmap(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/,
+ PixmapPtr /*pPix*/
+#endif
+);
+
+/* ilbmseg.c */
+
+extern void ilbmSegmentSS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSeg*/
+#endif
+);
+
+extern void ilbmSegmentSD(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ int /*nseg*/,
+ xSegment * /*pSeg*/
+#endif
+);
+/* ilbmsetsp.c */
+
+extern int ilbmSetScanline(
+#if NeedFunctionPrototypes
+ int /*y*/,
+ int /*xOrigin*/,
+ int /*xStart*/,
+ int /*xEnd*/,
+ PixelType * /*psrc*/,
+ int /*alu*/,
+ PixelType * /*pdstBase*/,
+ int /*widthDst*/,
+ int /*sizeDst*/,
+ int /*depthDst*/,
+ int /*sizeSrc*/
+#endif
+);
+
+extern void ilbmSetSpans(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr /*pGC*/,
+ char * /*psrc*/,
+ DDXPointPtr /*ppt*/,
+ int * /*pwidth*/,
+ int /*nspans*/,
+ int /*fSorted*/
+#endif
+);
+/* ilbmtegblt.c */
+
+extern void ilbmTEGlyphBlt(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDrawable*/,
+ GCPtr/*pGC*/,
+ int /*x*/,
+ int /*y*/,
+ unsigned int /*nglyph*/,
+ CharInfoPtr * /*ppci*/,
+ pointer /*pglyphBase*/
+#endif
+);
+/* ilbmtileC.c */
+
+extern void ilbmTileAreaPPWCopy(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmtileG.c */
+
+extern void ilbmTileAreaPPWGeneral(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ unsigned long /*planemask*/
+#endif
+);
+
+extern void ilbmTileAreaCopy(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ int /*xOff*/,
+ int /*yOff*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmtileG.c */
+
+extern void ilbmTileAreaGeneral(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ int /*xOff*/,
+ int /*yOff*/,
+ unsigned long /*planemask*/
+#endif
+);
+
+extern void ilbmOpaqueStippleAreaPPWCopy(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ unsigned char */*rropsOS*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmtileG.c */
+
+extern void ilbmOpaqueStippleAreaPPWGeneral(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ unsigned char */*rropsOS*/,
+ unsigned long /*planemask*/
+#endif
+);
+
+extern void ilbmOpaqueStippleAreaCopy(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ int /*xOff*/,
+ int /*yOff*/,
+ unsigned char */*rropsOS*/,
+ unsigned long /*planemask*/
+#endif
+);
+/* ilbmtileG.c */
+
+extern void ilbmOpaqueStippleAreaGeneral(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ int /*nbox*/,
+ BoxPtr /*pbox*/,
+ int /*alu*/,
+ PixmapPtr /*ptile*/,
+ int /*xOff*/,
+ int /*yOff*/,
+ unsigned char */*rropsOS*/,
+ unsigned long /*planemask*/
+#endif
+);
+
+/* ilbmwindow.c */
+
+extern Bool ilbmCreateWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/
+#endif
+);
+
+extern Bool ilbmDestroyWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/
+#endif
+);
+
+extern Bool ilbmMapWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWindow*/
+#endif
+);
+
+extern Bool ilbmPositionWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/,
+ int /*x*/,
+ int /*y*/
+#endif
+);
+
+extern Bool ilbmUnmapWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWindow*/
+#endif
+);
+
+extern void ilbmCopyWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/,
+ DDXPointRec /*ptOldOrg*/,
+ RegionPtr /*prgnSrc*/
+#endif
+);
+
+extern Bool ilbmChangeWindowAttributes(
+#if NeedFunctionPrototypes
+ WindowPtr /*pWin*/,
+ unsigned long /*mask*/
+#endif
+);
+/* ilbmzerarc.c */
+
+extern void ilbmZeroPolyArcSS(
+#if NeedFunctionPrototypes
+ DrawablePtr /*pDraw*/,
+ GCPtr /*pGC*/,
+ int /*narcs*/,
+ xArc * /*parcs*/
+#endif
+);
+
+/*
+ private field of pixmap
+ pixmap.devPrivate = (PixelType *)pointer_to_bits
+ pixmap.devKind = width_of_pixmap_in_bytes
+
+ private field of screen
+ a pixmap, for which we allocate storage. devPrivate is a pointer to
+the bits in the hardware framebuffer. note that devKind can be poked to
+make the code work for framebuffers that are wider than their
+displayable screen (e.g. the early vsII, which displayed 960 pixels
+across, but was 1024 in the hardware.)
+
+ private field of GC
+*/
+
+typedef struct {
+ unsigned char rrops[AFB_MAX_DEPTH]; /* reduction of rasterop to 1 of 3 */
+ unsigned char rropOS[AFB_MAX_DEPTH]; /* rop for opaque stipple */
+} ilbmPrivGC;
+typedef ilbmPrivGC *ilbmPrivGCPtr;
+
+extern int ilbmGCPrivateIndex; /* index into GC private array */
+extern int ilbmWindowPrivateIndex; /* index into Window private array */
+#ifdef PIXMAP_PER_WINDOW
+extern int frameWindowPrivateIndex; /* index into Window private array */
+#endif
+
+#define ilbmGetGCPrivate(pGC) \
+ ((ilbmPrivGC *)((pGC)->devPrivates[ilbmGCPrivateIndex].ptr))
+
+/* private field of window */
+typedef struct {
+ unsigned char fastBorder; /* non-zero if border tile is 32 bits wide */
+ unsigned char fastBackground;
+ unsigned short unused; /* pad for alignment with Sun compiler */
+ DDXPointRec oldRotate;
+ PixmapPtr pRotatedBackground;
+ PixmapPtr pRotatedBorder;
+} ilbmPrivWin;
+
+/* Common macros for extracting drawing information */
+
+#define ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, width, aux, dep, pointer) {\
+ PixmapPtr _pPix; \
+ if ((pDrawable)->type == DRAWABLE_WINDOW) \
+ _pPix = (PixmapPtr)(pDrawable)->pScreen->devPrivates[ilbmScreenPrivateIndex].ptr; \
+ else \
+ _pPix = (PixmapPtr)(pDrawable); \
+ (pointer) = (PixelType *)_pPix->devPrivate.ptr; \
+ (width) = ((int)_pPix->devKind)/sizeof(PixelType); \
+ (dep) = _pPix->drawable.depth; \
+ (aux) = (width)*(dep); \
+}
+
+/* ilbm uses the following macros to calculate addresses in drawables.
+ * To support banked framebuffers, the macros come in four flavors.
+ * All four collapse into the same definition on unbanked devices.
+ *
+ * ilbmScanlineFoo - calculate address and do bank switching
+ * ilbmScanlineFooNoBankSwitch - calculate address, don't bank switch
+ * ilbmScanlineFooSrc - calculate address, switch source bank
+ * ilbmScanlineFooDst - calculate address, switch destination bank
+ */
+
+/* The NoBankSwitch versions are the same for banked and unbanked cases */
+
+#define ilbmScanlineIncNoBankSwitch(_ptr, _off) _ptr += (_off)
+#define ilbmScanlineOffsetNoBankSwitch(_ptr, _off) ((_ptr)+(_off))
+#define ilbmScanlineDeltaNoBankSwitch(_ptr, _y, _w) \
+ ilbmScanlineOffsetNoBankSwitch(_ptr, (_y)*(_w))
+#define ilbmScanlineNoBankSwitch(_ptr, _x, _y, _w) \
+ ilbmScanlineOffsetNoBankSwitch(_ptr, (_y)*(_w)+((_x)>>MFB_PWSH))
+
+#ifdef MFB_LINE_BANK
+
+#include "ilbmlinebank.h" /* get macro definitions from this file */
+
+#else /* !MFB_LINE_BANK - unbanked case */
+
+#define ilbmScanlineInc(_ptr, _off) ilbmScanlineIncNoBankSwitch(_ptr, _off)
+#define ilbmScanlineIncSrc(_ptr, _off) ilbmScanlineInc(_ptr, _off)
+#define ilbmScanlineIncDst(_ptr, _off) ilbmScanlineInc(_ptr, _off)
+
+#define ilbmScanlineOffset(_ptr, _off) ilbmScanlineOffsetNoBankSwitch(_ptr, _off)
+#define ilbmScanlineOffsetSrc(_ptr, _off) ilbmScanlineOffset(_ptr, _off)
+#define ilbmScanlineOffsetDst(_ptr, _off) ilbmScanlineOffset(_ptr, _off)
+
+#define ilbmScanlineSrc(_ptr, _x, _y, _w) ilbmScanline(_ptr, _x, _y, _w)
+#define ilbmScanlineDst(_ptr, _x, _y, _w) ilbmScanline(_ptr, _x, _y, _w)
+
+#define ilbmScanlineDeltaSrc(_ptr, _y, _w) ilbmScanlineDelta(_ptr, _y, _w)
+#define ilbmScanlineDeltaDst(_ptr, _y, _w) ilbmScanlineDelta(_ptr, _y, _w)
+
+#endif /* MFB_LINE_BANK */
+
+#define ilbmScanlineDelta(_ptr, _y, _w) \
+ ilbmScanlineOffset(_ptr, (_y)*(_w))
+
+#define ilbmScanline(_ptr, _x, _y, _w) \
+ ilbmScanlineOffset(_ptr, (_y)*(_w)+((_x)>>MFB_PWSH))
+
+/* precomputed information about each glyph for GlyphBlt code.
+ this saves recalculating the per glyph information for each box.
+*/
+
+typedef struct _ilbmpos{
+ int xpos; /* xposition of glyph's origin */
+ int xchar; /* x position mod 32 */
+ int leftEdge;
+ int rightEdge;
+ int topEdge;
+ int bottomEdge;
+ PixelType *pdstBase; /* longword with character origin */
+ int widthGlyph; /* width in bytes of this glyph */
+} ilbmTEXTPOS;
+
+/* reduced raster ops for ilbm */
+#define RROP_BLACK GXclear
+#define RROP_WHITE GXset
+#define RROP_NOP GXnoop
+#define RROP_INVERT GXinvert
+#define RROP_COPY GXcopy
+
+/* macros for ilbmbitblt.c, ilbmfillsp.c
+ these let the code do one switch on the rop per call, rather
+ than a switch on the rop per item (span or rectangle.)
+*/
+
+#define fnCLEAR(src, dst) (0)
+#define fnAND(src, dst) (src & dst)
+#define fnANDREVERSE(src, dst) (src & ~dst)
+#define fnCOPY(src, dst) (src)
+#define fnANDINVERTED(src, dst) (~src & dst)
+#define fnNOOP(src, dst) (dst)
+#define fnXOR(src, dst) (src ^ dst)
+#define fnOR(src, dst) (src | dst)
+#define fnNOR(src, dst) (~(src | dst))
+#define fnEQUIV(src, dst) (~src ^ dst)
+#define fnINVERT(src, dst) (~dst)
+#define fnORREVERSE(src, dst) (src | ~dst)
+#define fnCOPYINVERTED(src, dst) (~src)
+#define fnORINVERTED(src, dst) (~src | dst)
+#define fnNAND(src, dst) (~(src & dst))
+#define fnSET(src, dst) (~0)
+
+/* Using a "switch" statement is much faster in most cases
+ * since the compiler can do a look-up table or multi-way branch
+ * instruction, depending on the architecture. The result on
+ * A Sun 3/50 is at least 2.5 times faster, assuming a uniform
+ * distribution of RasterOp operation types.
+ *
+ * However, doing some profiling on a running system reveals
+ * GXcopy is the operation over 99.5% of the time and
+ * GXxor is the next most frequent (about .4%), so we make special
+ * checks for those first.
+ *
+ * Note that this requires a change to the "calling sequence"
+ * since we can't engineer a "switch" statement to have an lvalue.
+ */
+#define DoRop(result, alu, src, dst) \
+{ \
+ if (alu == GXcopy) \
+ result = fnCOPY (src, dst); \
+ else if (alu == GXxor) \
+ result = fnXOR (src, dst); \
+ else \
+ switch (alu) { \
+ case GXclear: \
+ result = fnCLEAR (src, dst); \
+ break; \
+ case GXand: \
+ result = fnAND (src, dst); \
+ break; \
+ case GXandReverse: \
+ result = fnANDREVERSE (src, dst); \
+ break; \
+ case GXandInverted: \
+ result = fnANDINVERTED (src, dst); \
+ break; \
+ case GXnoop: \
+ result = fnNOOP (src, dst); \
+ break; \
+ case GXor: \
+ result = fnOR (src, dst); \
+ break; \
+ case GXnor: \
+ result = fnNOR (src, dst); \
+ break; \
+ case GXequiv: \
+ result = fnEQUIV (src, dst); \
+ break; \
+ case GXinvert: \
+ result = fnINVERT (src, dst); \
+ break; \
+ case GXorReverse: \
+ result = fnORREVERSE (src, dst); \
+ break; \
+ case GXcopyInverted: \
+ result = fnCOPYINVERTED (src, dst); \
+ break; \
+ case GXorInverted: \
+ result = fnORINVERTED (src, dst); \
+ break; \
+ case GXnand: \
+ result = fnNAND (src, dst); \
+ break; \
+ case GXset: \
+ result = fnSET (src, dst); \
+ break; \
+ } \
+}
+
+
+/* C expression fragments for various operations. These get passed in
+ * as -D's on the compile command line. See ilbm/Imakefile. This
+ * fixes XBUG 6319.
+ *
+ * This seems like a good place to point out that ilbm's use of the
+ * words black and white is an unfortunate misnomer. In ilbm code, black
+ * means zero, and white means one.
+ */
+#define MFB_OPEQ_WHITE |=
+#define MFB_OPEQ_BLACK &=~
+#define MFB_OPEQ_INVERT ^=
+#define MFB_EQWHOLEWORD_WHITE =~0
+#define MFB_EQWHOLEWORD_BLACK =0
+#define MFB_EQWHOLEWORD_INVERT ^=~0
+#define MFB_OP_WHITE /* nothing */
+#define MFB_OP_BLACK ~
diff --git a/ilbm/ilbmbitblt.c b/ilbm/ilbmbitblt.c
new file mode 100644
index 000000000..6af3108b5
--- /dev/null
+++ b/ilbm/ilbmbitblt.c
@@ -0,0 +1,479 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmbitblt.c,v 3.2 1998/03/20 21:08:00 hohndel Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmbitblt.c,v 5.25 94/04/17 20:28:16 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xprotostr.h"
+
+#include "miscstruct.h"
+#include "regionstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "mi.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+
+static unsigned char ilbmRropsOS[AFB_MAX_DEPTH];
+
+/* CopyArea and CopyPlane for a monchrome frame buffer
+
+
+ clip the source rectangle to the source's available bits. (this
+avoids copying unnecessary pieces that will just get exposed anyway.)
+this becomes the new shape of the destination.
+ clip the destination region to the composite clip in the
+GC. this requires translating the destination region to (dstx, dsty).
+ build a list of source points, one for each rectangle in the
+destination. this is a simple translation.
+ go do the multiple rectangle copies
+ do graphics exposures
+*/
+/** Optimized for drawing pixmaps into windows, especially when drawing into
+ ** unobscured windows. Calls to the general-purpose region code were
+ ** replaced with rectangle-to-rectangle clipping comparisions. This is
+ ** possible, since the pixmap is a single rectangle. In an unobscured
+ ** window, the destination clip is also a single rectangle, and region
+ ** code can be avoided entirely. This is a big savings, since the region
+ ** code uses XAlloc() and makes many function calls.
+ **
+ ** In addition, if source is a pixmap, there is no need to call the
+ ** expensive miHandleExposures() routine. Instead, we simply return NULL.
+ **
+ ** Previously, drawing a pixmap into an unobscured window executed at least
+ ** 8 XAlloc()'s, 30 function calls, and hundreds of lines of code.
+ **
+ ** Now, the same operation requires no XAlloc()'s, no region function calls,
+ ** and much less overhead. Nice for drawing lots of small pixmaps.
+ */
+
+void
+ilbmDoBitblt(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
+ DrawablePtr pSrc, pDst;
+ int alu;
+ RegionPtr prgnDst;
+ DDXPointPtr pptSrc;
+ unsigned long planemask;
+{
+ switch (alu) {
+ case GXcopy:
+ ilbmDoBitbltCopy(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
+ break;
+ case GXxor:
+ ilbmDoBitbltXor(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
+ break;
+ case GXcopyInverted:
+ ilbmDoBitbltCopyInverted(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
+ break;
+ case GXor:
+ ilbmDoBitbltOr(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
+ break;
+ default:
+ ilbmDoBitbltGeneral(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
+ break;
+ }
+}
+
+RegionPtr
+ilbmCopyArea(pSrcDrawable, pDstDrawable, pGC, srcx, srcy, width, height,
+ dstx, dsty)
+ DrawablePtr pSrcDrawable;
+ DrawablePtr pDstDrawable;
+ GC *pGC;
+ int srcx, srcy;
+ int width, height;
+ int dstx, dsty;
+{
+ void (*doBitBlt)();
+
+ switch (pGC->alu) {
+ case GXcopy:
+ doBitBlt = ilbmDoBitbltCopy;
+ break;
+ case GXxor:
+ doBitBlt = ilbmDoBitbltXor;
+ break;
+ case GXcopyInverted:
+ doBitBlt = ilbmDoBitbltCopyInverted;
+ break;
+ case GXor:
+ doBitBlt = ilbmDoBitbltOr;
+ break;
+ default:
+ doBitBlt = ilbmDoBitbltGeneral;
+ break;
+ }
+
+ return(ilbmBitBlt(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
+ width, height, dstx, dsty, doBitBlt, pGC->planemask));
+}
+
+RegionPtr
+ilbmBitBlt(pSrcDrawable, pDstDrawable, pGC, srcx, srcy, width, height,
+ dstx, dsty, doBitBlt, planemask)
+ register DrawablePtr pSrcDrawable;
+ register DrawablePtr pDstDrawable;
+ register GC *pGC;
+ int srcx, srcy;
+ int width, height;
+ int dstx, dsty;
+ void (*doBitBlt)();
+ unsigned long planemask;
+{
+ 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 */
+ void (*localDoBitBlt)();
+
+ 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 = pGC->pCompositeClip;
+ 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 = pGC->pCompositeClip;
+ 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 */
+ cclip = pGC->pCompositeClip;
+ if (REGION_NUM_RECTS(cclip) == 1) {
+ BoxPtr pBox = REGION_RECTS(cclip);
+
+ if (fastBox.x1 < pBox->x1)
+ fastBox.x1 = pBox->x1;
+ if (fastBox.x2 > pBox->x2)
+ fastBox.x2 = pBox->x2;
+ if (fastBox.y1 < pBox->y1)
+ fastBox.y1 = pBox->y1;
+ if (fastBox.y2 > pBox->y2)
+ fastBox.y2 = pBox->y2;
+
+ /* Check to see if the region is empty */
+ if (fastBox.x1 >= fastBox.x2 || fastBox.y1 >= fastBox.y2) {
+ REGION_INIT(pGC->pScreen, &rgnDst, NullBox, 0);
+ } else {
+ REGION_INIT(pGC->pScreen, &rgnDst, &fastBox, 1);
+ }
+ } else {
+ /* We must turn off fastClip now, since we must create
+ a full blown region. It is intersected with the
+ composite clip below. */
+ fastClip = 0;
+ REGION_INIT(pGC->pScreen, &rgnDst, &fastBox,1);
+ }
+ } else
+ REGION_TRANSLATE(pGC->pScreen, &rgnDst, -dx, -dy);
+
+ if (!fastClip) {
+ REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst, pGC->pCompositeClip);
+ }
+
+ /* 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,
+ planemask);
+
+ DEALLOCATE_LOCAL(pptSrc);
+ }
+
+ prgnExposed = NULL;
+ if (pGC->fExpose) {
+ /* 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, (unsigned long)0);
+ }
+ REGION_UNINIT(pGC->pScreen, &rgnDst);
+ if (freeSrcClip)
+ REGION_DESTROY(pGC->pScreen, prgnSrcClip);
+ return prgnExposed;
+}
+
+RegionPtr
+ilbmCopyPlane(pSrcDrawable, pDstDrawable, pGC, srcx, srcy, width, height,
+ dstx, dsty, plane)
+DrawablePtr pSrcDrawable, pDstDrawable;
+register GC *pGC;
+int srcx, srcy;
+int width, height;
+int dstx, dsty;
+unsigned long plane;
+{
+ int alu;
+ RegionPtr prgnExposed = NULL;
+ unsigned long old_planemask;
+ PixmapPtr pPixmap = NULL;
+
+ if (pDstDrawable->depth == 1) {
+ old_planemask = pGC->planemask;
+ pGC->planemask = plane;
+ if ((pGC->fgPixel & 1) == 1 && (pGC->bgPixel & 1) == 0) {
+ prgnExposed = (*pGC->ops->CopyArea)(pSrcDrawable, pDstDrawable,
+ pGC, srcx, srcy, width, height, dstx, dsty);
+ } else if ((pGC->fgPixel & 1) == (pGC->bgPixel & 1)) {
+ unsigned char rop;
+
+ ilbmReduceRop(pGC->alu, pGC->fgPixel, 1, 1, &rop);
+ alu = pGC->alu;
+ pGC->alu = rop;
+ prgnExposed = (*pGC->ops->CopyArea)(pSrcDrawable, pDstDrawable, pGC,
+ srcx, srcy, width, height, dstx,
+ dsty);
+ pGC->alu = alu;
+ } else { /* need to invert the src */
+ alu = pGC->alu;
+ pGC->alu = ilbmInverseAlu[alu];
+ prgnExposed = (*pGC->ops->CopyArea)(pSrcDrawable, pDstDrawable, pGC,
+ srcx, srcy, width, height, dstx,
+ dsty);
+ pGC->alu = alu;
+ }
+ pGC->planemask = old_planemask;
+ } else {
+ int free_pixmap = FALSE;
+ PixmapPtr pBitmap = (PixmapPtr)pSrcDrawable;
+ ScreenPtr pScreen = pSrcDrawable->pScreen;
+ GCPtr pGC1;
+
+ if (pSrcDrawable == pDstDrawable ||
+ pSrcDrawable->type == DRAWABLE_WINDOW || pSrcDrawable->depth != 1) {
+ /* Copy a plane from source drawable to a tmp 1-bit deep pixmap */
+ /* XXX: Range check width and height */
+ pBitmap = (*pScreen->CreatePixmap)(pScreen, width, height, 1);
+
+ if (!pBitmap)
+ return(NULL);
+ pGC1 = GetScratchGC(1, pScreen);
+ if (!pGC1) {
+ (*pScreen->DestroyPixmap)(pBitmap);
+ return(NULL);
+ }
+ ValidateGC((DrawablePtr)pBitmap, pGC1);
+ (void)ilbmBitBlt(pSrcDrawable, (DrawablePtr)pBitmap, pGC1, srcx, srcy,
+ width, height, 0, 0, ilbmDoBitbltCopy, plane);
+ free_pixmap = TRUE;
+ }
+#if 0
+ else {
+ /* XXX: could cope with N-deep pixmap source case without using tmp
+ * src bitmap by setting up a scratch pixmap header and fiddle
+ * around with the pbits pointer.
+ */
+ }
+#endif
+ ilbmReduceOpaqueStipple(pGC->fgPixel, pGC->bgPixel, pGC->planemask,
+ pGC->depth, ilbmRropsOS);
+ (void)ilbmBitBlt((DrawablePtr)pBitmap, pDstDrawable, pGC, 0, 0, width,
+ height, dstx, dsty, ilbmCopy1ToN, pGC->planemask);
+ if (free_pixmap) {
+ (*pScreen->DestroyPixmap)(pBitmap);
+ FreeScratchGC(pGC1);
+ }
+
+ if (pGC->fExpose)
+ prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx,
+ srcy, width, height, dstx, dsty,
+ plane);
+ }
+ return prgnExposed;
+}
+
+void
+ilbmCopy1ToN(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
+ DrawablePtr pSrc, pDst;
+ int alu;
+ RegionPtr prgnDst;
+ DDXPointPtr pptSrc;
+ unsigned long planemask;
+{
+ int numRects = REGION_NUM_RECTS(prgnDst);
+ BoxPtr pbox = REGION_RECTS(prgnDst);
+ int r;
+
+ for (r = 0; r < numRects; r++, pbox++, pptSrc++) {
+ int dx = pptSrc->x;
+ int dy = pptSrc->y;
+
+ if (alu == GXcopy)
+ ilbmOpaqueStippleAreaCopy(pDst, 1, pbox, alu, (PixmapPtr)pSrc, dx, dy,
+ ilbmRropsOS, planemask);
+ else
+ ilbmOpaqueStippleAreaGeneral(pDst, 1, pbox, alu, (PixmapPtr)pSrc, dx,
+ dy, ilbmRropsOS, planemask);
+ }
+}
diff --git a/ilbm/ilbmblt.c b/ilbm/ilbmblt.c
new file mode 100644
index 000000000..455c07cb5
--- /dev/null
+++ b/ilbm/ilbmblt.c
@@ -0,0 +1,569 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmblt.c,v 3.0 1996/08/18 01:53:39 dawes Exp $ */
+/*
+ * ilbm 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: ilbmblt.c,v 1.11 94/04/17 20:28:16 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ilbm.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "maskbits.h"
+#include "fastblt.h"
+#include "mergerop.h"
+
+void
+MROP_NAME(ilbmDoBitblt)(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
+ DrawablePtr pSrc, pDst;
+ int alu;
+ RegionPtr prgnDst;
+ DDXPointPtr pptSrc;
+ unsigned long planemask;
+{
+ PixelType *psrcBase, *pdstBase; /* start of src and dst bitmaps */
+ int widthSrc, widthDst; /* add to get to same position in next line */
+ int heightSrc, heightDst;
+ int auxSrc, auxDst;
+
+ 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 */
+
+ PixelType *psrcLine, *pdstLine;
+ /* pointers to line with current src and dst */
+ register PixelType *psrc; /* pointer to current src longword */
+ register PixelType *pdst; /* pointer to current dst longword */
+
+ MROP_DECLARE_REG()
+
+ /* following used for looping through a line */
+ PixelType startmask, endmask; /* masks for writing ends of dst */
+ int nlMiddle; /* whole longwords in dst */
+ int xoffSrc, xoffDst;
+ register int leftShift, rightShift;
+ register PixelType bits;
+ register PixelType bits1;
+ register int nl; /* temp copy of nlMiddle */
+
+ /* 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;
+ int depthSrc;
+ int depthDst;
+
+ MROP_INITIALIZE(alu,0);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pSrc, widthSrc, auxSrc, depthSrc,
+ psrcBase);
+ ilbmGetPixelWidthAuxDepthAndPointer(pDst, widthDst, auxDst, depthDst,
+ pdstBase);
+
+ /* Special case where depth of dest pixmap is 1 but source pixmap isn't
+ * Used for GetImage to copy a plane from a source pixmap to a particular
+ * dest pixmap plane.
+ * Note: planemask should have only one bit set or several planes from
+ * the source will be copied to the same dest plane.
+ */
+ if (depthDst == 1 && depthDst != depthSrc)
+ widthDst = 0;
+
+ /* 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;
+ auxSrc = -auxSrc;
+ auxDst = -auxDst;
+
+ 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--) {
+ int d;
+ for (d = 0; d < depthSrc; d++) {
+ PixelType *psrcB;
+ PixelType *pdstB;
+
+ if (!(planemask & (1 << d)))
+ continue;
+
+ psrcB = psrcBase + widthSrc * d; /* @@@ NEXT PLANE @@@ */
+ pdstB = pdstBase + widthDst * d; /* @@@ NEXT PLANE @@@ */
+
+ w = pbox->x2 - pbox->x1;
+ h = pbox->y2 - pbox->y1;
+
+ if (ydir == -1) { /* start at last scanline of rectangle */
+ psrcLine = ilbmScanlineDeltaSrc(psrcB, -(pptSrc->y+h-1), auxSrc);
+ pdstLine = ilbmScanlineDeltaDst(pdstB, -(pbox->y2-1), auxDst);
+ } else { /* start at first scanline */
+ psrcLine = ilbmScanlineDeltaSrc(psrcB, pptSrc->y, auxSrc);
+ pdstLine = ilbmScanlineDeltaDst(pdstB, pbox->y1, auxDst);
+ }
+ if ((pbox->x1 & PIM) + w <= PPW) {
+ maskpartialbits (pbox->x1, w, startmask);
+ endmask = 0;
+ nlMiddle = 0;
+ } else {
+ maskbits(pbox->x1, w, startmask, endmask, nlMiddle);
+ }
+ if (xdir == 1) {
+ xoffSrc = pptSrc->x & PIM;
+ xoffDst = pbox->x1 & PIM;
+ pdstLine += (pbox->x1 >> PWSH);
+ psrcLine += (pptSrc->x >> PWSH);
+#ifdef DO_UNALIGNED_BITBLT
+ nl = xoffSrc - xoffDst;
+ psrcLine = (PixelType *)(((unsigned char *) psrcLine) + nl);
+#else
+ if (xoffSrc == xoffDst)
+#endif
+ {
+ while (h--) {
+ psrc = psrcLine;
+ pdst = pdstLine;
+ if (startmask) {
+ *pdst = MROP_MASK(*psrc, *pdst, startmask);
+ psrc++;
+ pdst++;
+ }
+ nl = nlMiddle;
+
+#ifdef LARGE_INSTRUCTION_CACHE
+#ifdef FAST_CONSTANT_OFFSET_MODE
+
+ psrc += nl & (UNROLL-1);
+ pdst += nl & (UNROLL-1);
+
+#define BodyOdd(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
+#define BodyEven(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
+
+#define LoopReset \
+pdst += UNROLL; \
+psrc += UNROLL;
+
+#else
+
+#define BodyOdd(n) *pdst = MROP_SOLID (*psrc, *pdst); pdst++; psrc++;
+#define BodyEven(n) BodyOdd(n)
+
+#define LoopReset ;
+
+#endif
+ PackedLoop
+
+#undef BodyOdd
+#undef BodyEven
+#undef LoopReset
+
+#else
+#ifdef NOTDEF
+ /* you'd think this would be faster --
+ * a single instruction instead of 6
+ * but measurements show it to be ~15% slower
+ */
+ while ((nl -= 6) >= 0) {
+ asm ("moveml %1+,#0x0c0f;moveml#0x0c0f,%0"
+ : "=m" (*(char *)pdst)
+ : "m" (*(char *)psrc)
+ : "d0", "d1", "d2", "d3",
+ "a2", "a3");
+ pdst += 6;
+ }
+ nl += 6;
+ while (nl--)
+ *pdst++ = *psrc++;
+#endif
+ DuffL(nl, label1,
+ *pdst = MROP_SOLID (*psrc, *pdst);
+ pdst++; psrc++;)
+#endif
+
+ if (endmask)
+ *pdst = MROP_MASK(*psrc, *pdst, endmask);
+ ilbmScanlineIncDst(pdstLine, auxDst);
+ ilbmScanlineIncSrc(psrcLine, auxSrc);
+ }
+ }
+#ifndef DO_UNALIGNED_BITBLT
+ else {
+ if (xoffSrc > xoffDst) {
+ leftShift = (xoffSrc - xoffDst);
+ rightShift = PPW - leftShift;
+ } else {
+ rightShift = (xoffDst - xoffSrc);
+ leftShift = PPW - rightShift;
+ }
+ while (h--) {
+ psrc = psrcLine;
+ pdst = pdstLine;
+ bits = 0;
+ if (xoffSrc > xoffDst)
+ bits = *psrc++;
+ if (startmask) {
+ bits1 = BitLeft(bits,leftShift);
+ bits = *psrc++;
+ bits1 |= BitRight(bits,rightShift);
+ *pdst = MROP_MASK(bits1, *pdst, startmask);
+ pdst++;
+ }
+ nl = nlMiddle;
+
+#ifdef LARGE_INSTRUCTION_CACHE
+ bits1 = bits;
+
+#ifdef FAST_CONSTANT_OFFSET_MODE
+
+ psrc += nl & (UNROLL-1);
+ pdst += nl & (UNROLL-1);
+
+#define BodyOdd(n) \
+bits = psrc[-n]; \
+pdst[-n] = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), pdst[-n]);
+
+#define BodyEven(n) \
+bits1 = psrc[-n]; \
+pdst[-n] = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), pdst[-n]);
+
+#define LoopReset \
+pdst += UNROLL; \
+psrc += UNROLL;
+
+#else
+
+#define BodyOdd(n) \
+bits = *psrc++; \
+*pdst = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), *pdst); \
+pdst++;
+
+#define BodyEven(n) \
+bits1 = *psrc++; \
+*pdst = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), *pdst); \
+pdst++;
+
+#define LoopReset ;
+
+#endif /* !FAST_CONSTANT_OFFSET_MODE */
+
+ PackedLoop
+
+#undef BodyOdd
+#undef BodyEven
+#undef LoopReset
+
+#else
+ DuffL(nl,label2,
+ bits1 = BitLeft(bits, leftShift);
+ bits = *psrc++;
+ *pdst = MROP_SOLID (bits1 | BitRight(bits, rightShift), *pdst);
+ pdst++;
+ )
+#endif
+
+ if (endmask) {
+ bits1 = BitLeft(bits, leftShift);
+ if (BitLeft(endmask, rightShift)) {
+ bits = *psrc;
+ bits1 |= BitRight(bits, rightShift);
+ }
+ *pdst = MROP_MASK (bits1, *pdst, endmask);
+ }
+ ilbmScanlineIncDst(pdstLine, auxDst);
+ ilbmScanlineIncSrc(psrcLine, auxSrc);
+ }
+ }
+#endif /* DO_UNALIGNED_BITBLT */
+ } else { /* xdir == -1 */
+ xoffSrc = (pptSrc->x + w - 1) & PIM;
+ xoffDst = (pbox->x2 - 1) & PIM;
+ pdstLine += ((pbox->x2-1) >> PWSH) + 1;
+ psrcLine += ((pptSrc->x+w - 1) >> PWSH) + 1;
+#ifdef DO_UNALIGNED_BITBLT
+ nl = xoffSrc - xoffDst;
+ psrcLine = (PixelType *)
+ (((unsigned char *) psrcLine) + nl);
+#else
+ if (xoffSrc == xoffDst)
+#endif
+ {
+ while (h--) {
+ psrc = psrcLine;
+ pdst = pdstLine;
+ if (endmask) {
+ pdst--;
+ psrc--;
+ *pdst = MROP_MASK (*psrc, *pdst, endmask);
+ }
+ nl = nlMiddle;
+
+#ifdef LARGE_INSTRUCTION_CACHE
+#ifdef FAST_CONSTANT_OFFSET_MODE
+ psrc -= nl & (UNROLL - 1);
+ pdst -= nl & (UNROLL - 1);
+
+#define BodyOdd(n) pdst[n-1] = MROP_SOLID (psrc[n-1], pdst[n-1]);
+
+#define BodyEven(n) BodyOdd(n)
+
+#define LoopReset \
+pdst -= UNROLL;\
+psrc -= UNROLL;
+
+#else
+
+#define BodyOdd(n) --pdst; --psrc; *pdst = MROP_SOLID(*psrc, *pdst);
+#define BodyEven(n) BodyOdd(n)
+#define LoopReset ;
+
+#endif
+ PackedLoop
+
+#undef BodyOdd
+#undef BodyEven
+#undef LoopReset
+
+#else
+ DuffL(nl,label3,
+ --pdst; --psrc; *pdst = MROP_SOLID (*psrc, *pdst);)
+#endif
+
+ if (startmask) {
+ --pdst;
+ --psrc;
+ *pdst = MROP_MASK(*psrc, *pdst, startmask);
+ }
+ ilbmScanlineIncDst(pdstLine, auxDst);
+ ilbmScanlineIncSrc(psrcLine, auxSrc);
+ }
+ }
+#ifndef DO_UNALIGNED_BITBLT
+ else {
+ if (xoffDst > xoffSrc) {
+ rightShift = (xoffDst - xoffSrc);
+ leftShift = PPW - rightShift;
+ } else {
+ leftShift = (xoffSrc - xoffDst);
+ rightShift = PPW - leftShift;
+ }
+ while (h--) {
+ psrc = psrcLine;
+ pdst = pdstLine;
+ bits = 0;
+ if (xoffDst > xoffSrc)
+ bits = *--psrc;
+ if (endmask) {
+ bits1 = BitRight(bits, rightShift);
+ bits = *--psrc;
+ bits1 |= BitLeft(bits, leftShift);
+ pdst--;
+ *pdst = MROP_MASK(bits1, *pdst, endmask);
+ }
+ nl = nlMiddle;
+
+#ifdef LARGE_INSTRUCTION_CACHE
+ bits1 = bits;
+#ifdef FAST_CONSTANT_OFFSET_MODE
+ psrc -= nl & (UNROLL - 1);
+ pdst -= nl & (UNROLL - 1);
+
+#define BodyOdd(n) \
+bits = psrc[n-1]; \
+pdst[n-1] = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),pdst[n-1]);
+
+#define BodyEven(n) \
+bits1 = psrc[n-1]; \
+pdst[n-1] = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),pdst[n-1]);
+
+#define LoopReset \
+pdst -= UNROLL; \
+psrc -= UNROLL;
+
+#else
+
+#define BodyOdd(n) \
+bits = *--psrc; --pdst; \
+*pdst = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),*pdst);
+
+#define BodyEven(n) \
+bits1 = *--psrc; --pdst; \
+*pdst = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),*pdst);
+
+#define LoopReset ;
+
+#endif
+
+ PackedLoop
+
+#undef BodyOdd
+#undef BodyEven
+#undef LoopReset
+
+#else
+ DuffL(nl, label4,
+ bits1 = BitRight(bits, rightShift);
+ bits = *--psrc;
+ --pdst;
+ *pdst = MROP_SOLID(bits1 | BitLeft(bits, leftShift),*pdst);
+ )
+#endif
+
+ if (startmask) {
+ bits1 = BitRight(bits, rightShift);
+ if (BitRight (startmask, leftShift)) {
+ bits = *--psrc;
+ bits1 |= BitLeft(bits, leftShift);
+ }
+ --pdst;
+ *pdst = MROP_MASK(bits1, *pdst, startmask);
+ }
+ ilbmScanlineIncDst(pdstLine, auxDst);
+ ilbmScanlineIncSrc(psrcLine, auxSrc);
+ }
+ }
+#endif
+ }
+ }
+ pbox++;
+ pptSrc++;
+ }
+ if (pboxNew2) {
+ DEALLOCATE_LOCAL(pptNew2);
+ DEALLOCATE_LOCAL(pboxNew2);
+ }
+ if (pboxNew1) {
+ DEALLOCATE_LOCAL(pptNew1);
+ DEALLOCATE_LOCAL(pboxNew1);
+ }
+}
diff --git a/ilbm/ilbmbres.c b/ilbm/ilbmbres.c
new file mode 100644
index 000000000..4204c61b5
--- /dev/null
+++ b/ilbm/ilbmbres.c
@@ -0,0 +1,324 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmbres.c,v 3.0 1996/08/18 01:53:40 dawes Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmbres.c,v 1.22 94/04/17 20:28:17 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "misc.h"
+#include "ilbm.h"
+#include "maskbits.h"
+#include "miline.h"
+
+/* Solid bresenham line */
+/* NOTES
+ e2 is used less often than e1, so it's not in a register
+*/
+
+void
+ilbmBresS(addrlbase, nlwidth, auxDst, depthDst, signdx, signdy, axis, x1, y1,
+ e, e1, e2, len, rrops)
+PixelType *addrlbase; /* pointer to base of bitmap */
+int nlwidth; /* width in longwords of bitmap */
+int auxDst;
+int depthDst;
+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 */
+unsigned char *rrops;
+{
+ register int yinc; /* increment to next scanline, in bytes */
+ register PixelType *addrl; /* bitmask long pointer */
+ register PixelType bit; /* current bit being set/cleared/etc. */
+ PixelType leftbit = mask[0]; /* leftmost bit to process in new word */
+ PixelType rightbit = mask[PPW-1]; /* rightmost bit to process in new word */
+
+ register int e3 = e2-e1;
+ PixelType tmp;
+ int saveE;
+ int saveLen;
+ int d;
+
+ /* point to longword containing first point */
+ yinc = signdy * auxDst;
+ e = e-e1; /* to make looping easier */
+
+ if (!len)
+ return;
+
+ saveLen = len;
+ saveE = e;
+
+ for (d = 0; d < depthDst; d++) {
+ addrl = ilbmScanline(addrlbase, x1, y1, auxDst);
+ addrlbase += nlwidth; /* @@@ NEXT PLANE @@@ */
+ len = saveLen;
+ e = saveE;
+ bit = mask[x1 & PIM];
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ if (axis == X_AXIS) {
+ if (signdx > 0) {
+ tmp = *addrl;
+ for (;;) {
+ tmp &= ~bit;
+ if (!--len)
+ break;
+ bit = SCRRIGHT(bit,1);
+ e += e1;
+ if (e >= 0) {
+ *addrl = tmp;
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ if (!bit) {
+ bit = leftbit;
+ addrl ++;
+ }
+ tmp = *addrl;
+ } else if (!bit) {
+ *addrl = tmp;
+ bit = leftbit;
+ addrl ++;
+ tmp = *addrl;
+ }
+ }
+ *addrl = tmp;
+ } else {
+ tmp = *addrl;
+ for (;;) {
+ tmp &= ~bit;
+ if (!--len)
+ break;
+ e += e1;
+ bit = SCRLEFT(bit,1);
+ if (e >= 0) {
+ *addrl = tmp;
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ if (!bit) {
+ bit = rightbit;
+ addrl --;
+ }
+ tmp = *addrl;
+ } else if (!bit) {
+ *addrl = tmp;
+ bit = rightbit;
+ addrl --;
+ tmp = *addrl;
+ }
+ }
+ *addrl = tmp;
+ }
+ } /* if X_AXIS */ else {
+ if (signdx > 0) {
+ while (len--) {
+ *addrl &= ~bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRRIGHT(bit,1);
+ if (!bit) { bit = leftbit;addrl ++; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ }
+ } else {
+ while (len--) {
+ *addrl &= ~bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRLEFT(bit,1);
+ if (!bit) { bit = rightbit;addrl --; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ }
+ }
+ } /* else Y_AXIS */
+ break;
+
+ case RROP_WHITE:
+ if (axis == X_AXIS) {
+ if (signdx > 0) {
+ tmp = *addrl;
+ for (;;) {
+ tmp |= bit;
+ if (!--len)
+ break;
+ e += e1;
+ bit = SCRRIGHT(bit,1);
+ if (e >= 0) {
+ *addrl = tmp;
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ if (!bit) {
+ bit = leftbit;
+ addrl ++;
+ }
+ tmp = *addrl;
+ } else if (!bit) {
+ *addrl = tmp;
+ bit = leftbit;
+ addrl ++;
+ tmp = *addrl;
+ }
+ }
+ *addrl = tmp;
+ } else {
+ tmp = *addrl;
+ for (;;) {
+ tmp |= bit;
+ if (!--len)
+ break;
+ e += e1;
+ bit = SCRLEFT(bit,1);
+ if (e >= 0) {
+ *addrl = tmp;
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ if (!bit) {
+ bit = rightbit;
+ addrl --;
+ }
+ tmp = *addrl;
+ } else if (!bit) {
+ *addrl = tmp;
+ bit = rightbit;
+ addrl --;
+ tmp = *addrl;
+ }
+ }
+ *addrl = tmp;
+ }
+ } /* if X_AXIS */ else {
+ if (signdx > 0) {
+ while (len--) {
+ *addrl |= bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRRIGHT(bit,1);
+ if (!bit) { bit = leftbit;addrl ++; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ }
+ } else {
+ while (len--) {
+ *addrl |= bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRLEFT(bit,1);
+ if (!bit) { bit = rightbit;addrl --; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ }
+ }
+ } /* else Y_AXIS */
+ break;
+
+ case RROP_INVERT:
+ if (axis == X_AXIS) {
+ if (signdx > 0) {
+ while (len--) {
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ }
+ bit = SCRRIGHT(bit,1);
+ if (!bit) { bit = leftbit;addrl ++; }
+ }
+ } else {
+ while (len--) {
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ }
+ bit = SCRLEFT(bit,1);
+ if (!bit) { bit = rightbit;addrl --; }
+ }
+ }
+ } /* if X_AXIS */ else {
+ if (signdx > 0) {
+ while (len--) {
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRRIGHT(bit,1);
+ if (!bit) { bit = leftbit;addrl ++; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ }
+ } else {
+ while (len--) {
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRLEFT(bit,1);
+ if (!bit) { bit = rightbit; addrl --; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ }
+ }
+ } /* else Y_AXIS */
+ } /* switch */
+ } /* for (d = ... ) */
+}
diff --git a/ilbm/ilbmbresd.c b/ilbm/ilbmbresd.c
new file mode 100644
index 000000000..75391e96b
--- /dev/null
+++ b/ilbm/ilbmbresd.c
@@ -0,0 +1,215 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmbresd.c,v 3.0 1996/08/18 01:53:41 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: ilbmbresd.c,v 1.10 94/04/17 20:28:18 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "misc.h"
+#include "ilbm.h"
+#include "maskbits.h"
+#include "miline.h"
+
+/* Dashed bresenham line */
+
+#define StepDash\
+ if (!--dashRemaining) { \
+ if (++ dashIndex == numInDashList) \
+ dashIndex = 0; \
+ dashRemaining = pDash[dashIndex]; \
+ rop = fgrop; \
+ if (dashIndex & 1) \
+ rop = bgrop; \
+ }
+
+void
+ilbmBresD(pdashIndex, pDash, numInDashList, pdashOffset, isDoubleDash,
+ addrlbase, nlwidth, auxDst, depthDst,
+ signdx, signdy, axis, x1, y1, e, e1, e2, len, rrops, bgrrops)
+int *pdashIndex; /* current dash */
+unsigned char *pDash; /* dash list */
+int numInDashList; /* total length of dash list */
+int *pdashOffset; /* offset into current dash */
+int isDoubleDash;
+PixelType *addrlbase; /* pointer to base of bitmap */
+int nlwidth; /* width in longwords of bitmap */
+int auxDst;
+int depthDst;
+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 */
+unsigned char *rrops;
+unsigned char *bgrrops;
+{
+ register int yinc; /* increment to next scanline, in bytes */
+ register PixelType *addrl;
+ register int e3 = e2-e1;
+ register unsigned long bit;
+ PixelType leftbit = mask[0]; /* leftmost bit to process in new word */
+ PixelType rightbit = mask[PPW-1]; /* rightmost bit to process in new word */
+ int dashIndex;
+ int dashOffset;
+ int dashRemaining;
+ int rop;
+ int fgrop;
+ int bgrop;
+ int saveE;
+ int saveLen;
+ int d;
+
+ dashOffset = *pdashOffset;
+ dashIndex = *pdashIndex;
+ dashRemaining = pDash[dashIndex] - dashOffset;
+ /* point to longword containing first point */
+
+ yinc = signdy * auxDst;
+ e = e-e1; /* to make looping easier */
+
+ saveE = e;
+ saveLen = len;
+
+ for (d = 0; d < depthDst; d++) {
+ addrl = ilbmScanline(addrlbase, x1, y1, auxDst);
+ addrlbase += nlwidth; /* @@@ NEXT PLANE @@@ */
+
+ fgrop = rrops[d];
+ bgrop = bgrrops[d];
+
+ e = saveE;
+ len = saveLen;
+ bit = mask[x1 & PIM];
+
+ rop = fgrop;
+ if (!isDoubleDash)
+ bgrop = -1;
+ if (dashIndex & 1)
+ rop = bgrop;
+
+ if (axis == X_AXIS) {
+ if (signdx > 0) {
+ while (len--) {
+ if (rop == RROP_BLACK)
+ *addrl &= ~bit;
+ else if (rop == RROP_WHITE)
+ *addrl |= bit;
+ else if (rop == RROP_INVERT)
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ }
+ bit = SCRRIGHT(bit,1);
+ if (!bit) { bit = leftbit;addrl ++; }
+ StepDash
+ }
+ } else {
+ while (len--) {
+ if (rop == RROP_BLACK)
+ *addrl &= ~bit;
+ else if (rop == RROP_WHITE)
+ *addrl |= bit;
+ else if (rop == RROP_INVERT)
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ ilbmScanlineInc(addrl, yinc);
+ e += e3;
+ }
+ bit = SCRLEFT(bit,1);
+ if (!bit) { bit = rightbit;addrl --; }
+ StepDash
+ }
+ }
+ } /* if X_AXIS */ else {
+ if (signdx > 0) {
+ while (len--) {
+ if (rop == RROP_BLACK)
+ *addrl &= ~bit;
+ else if (rop == RROP_WHITE)
+ *addrl |= bit;
+ else if (rop == RROP_INVERT)
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRRIGHT(bit,1);
+ if (!bit) { bit = leftbit;addrl ++; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ StepDash
+ }
+ } else {
+ while (len--) {
+ if (rop == RROP_BLACK)
+ *addrl &= ~bit;
+ else if (rop == RROP_WHITE)
+ *addrl |= bit;
+ else if (rop == RROP_INVERT)
+ *addrl ^= bit;
+ e += e1;
+ if (e >= 0) {
+ bit = SCRLEFT(bit,1);
+ if (!bit) { bit = rightbit;addrl --; }
+ e += e3;
+ }
+ ilbmScanlineInc(addrl, yinc);
+ StepDash
+ }
+ }
+ } /* else Y_AXIS */
+ } /* for (d = ...) */
+ *pdashIndex = dashIndex;
+ *pdashOffset = pDash[dashIndex] - dashRemaining;
+}
diff --git a/ilbm/ilbmbstore.c b/ilbm/ilbmbstore.c
new file mode 100644
index 000000000..8309e2600
--- /dev/null
+++ b/ilbm/ilbmbstore.c
@@ -0,0 +1,155 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmbstore.c,v 3.0 1996/08/18 01:53:43 dawes Exp $ */
+/* $XConsortium: ilbmbstore.c,v 5.7 94/04/17 20:28:18 dpw Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/*
+
+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.
+
+*/
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "ilbm.h"
+#include "X.h"
+#include "mibstore.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+
+/*-
+ *-----------------------------------------------------------------------
+ * ilbmSaveAreas --
+ * Function called by miSaveAreas to actually fetch the areas to be
+ * saved into the backing pixmap. This is very simple to do, since
+ * ilbmDoBitblt 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
+ilbmSaveAreas(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 numRects;
+
+ numRects = REGION_NUM_RECTS(prgnSave);
+ pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(numRects * sizeof(DDXPointRec));
+ if (!pPtsInit)
+ return;
+
+ pBox = REGION_RECTS(prgnSave);
+ pPt = pPtsInit;
+ while (numRects--) {
+ pPt->x = pBox->x1 + xorg;
+ pPt->y = pBox->y1 + yorg;
+ pPt++;
+ pBox++;
+ }
+
+ ilbmDoBitblt((DrawablePtr)pPixmap->drawable.pScreen->devPrivates[ilbmScreenPrivateIndex].ptr,
+ (DrawablePtr)pPixmap,
+ GXcopy,
+ prgnSave,
+ pPtsInit, wBackingBitPlanes (pWin));
+
+ DEALLOCATE_LOCAL(pPtsInit);
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * ilbmRestoreAreas --
+ * Function called by miRestoreAreas to actually fetch the areas to be
+ * restored from the backing pixmap. This is very simple to do, since
+ * ilbmDoBitblt 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
+ilbmRestoreAreas(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 numRects;
+
+ numRects = REGION_NUM_RECTS(prgnRestore);
+ pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(numRects*sizeof(DDXPointRec));
+ if (!pPtsInit)
+ return;
+
+ pBox = REGION_RECTS(prgnRestore);
+ pPt = pPtsInit;
+ while (numRects--) {
+ pPt->x = pBox->x1 - xorg;
+ pPt->y = pBox->y1 - yorg;
+ pPt++;
+ pBox++;
+ }
+
+ ilbmDoBitblt((DrawablePtr)pPixmap,
+ (DrawablePtr)pPixmap->drawable.pScreen->devPrivates[ilbmScreenPrivateIndex].ptr,
+ GXcopy,
+ prgnRestore,
+ pPtsInit, wBackingBitPlanes (pWin));
+
+ DEALLOCATE_LOCAL(pPtsInit);
+}
diff --git a/ilbm/ilbmclip.c b/ilbm/ilbmclip.c
new file mode 100644
index 000000000..4628e61d0
--- /dev/null
+++ b/ilbm/ilbmclip.c
@@ -0,0 +1,242 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmclip.c,v 3.0 1996/08/18 01:53:44 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: ilbmclip.c,v 5.6 94/04/17 20:28:19 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "miscstruct.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "regionstr.h"
+#include "gc.h"
+#include "maskbits.h"
+#include "mi.h"
+
+#define ADDRECT(reg,r,fr,rx1,ry1,rx2,ry2) \
+if (((rx1) < (rx2)) && ((ry1) < (ry2)) && \
+ (!((reg)->data->numRects && \
+ ((r-1)->y1 == (ry1)) && \
+ ((r-1)->y2 == (ry2)) && \
+ ((r-1)->x1 <= (rx1)) && \
+ ((r-1)->x2 >= (rx2))))) { \
+ if ((reg)->data->numRects == (reg)->data->size) { \
+ miRectAlloc(reg, 1); \
+ fr = REGION_BOXPTR(reg); \
+ r = fr + (reg)->data->numRects; \
+ } \
+ r->x1 = (rx1); \
+ r->y1 = (ry1); \
+ r->x2 = (rx2); \
+ r->y2 = (ry2); \
+ (reg)->data->numRects++; \
+ if (r->x1 < (reg)->extents.x1) \
+ (reg)->extents.x1 = r->x1; \
+ if (r->x2 > (reg)->extents.x2) \
+ (reg)->extents.x2 = r->x2; \
+ r++; \
+}
+
+/* Convert bitmap clip mask into clipping region.
+ * First, goes through each line and makes boxes by noting the transitions
+ * from 0 to 1 and 1 to 0.
+ * Then it coalesces the current line with the previous if they have boxes
+ * at the same X coordinates.
+ */
+RegionPtr
+ilbmPixmapToRegion(pPix)
+ PixmapPtr pPix;
+{
+ register RegionPtr pReg;
+ register PixelType *pw, w;
+ register int ib;
+ int width, h, base, rx1, crects;
+ PixelType *pwLineEnd;
+ int irectPrevStart, irectLineStart;
+ register BoxPtr prectO, prectN;
+ BoxPtr FirstRect, rects, prectLineStart;
+ Bool fInBox, fSame;
+ register PixelType mask0 = mask[0];
+ PixelType *pwLine;
+ int nWidth;
+
+ pReg = REGION_CREATE(pPix->drawable.pScreen, NULL, 1);
+ if (!pReg)
+ return(NullRegion);
+ FirstRect = REGION_BOXPTR(pReg);
+ rects = FirstRect;
+
+ pwLine = (PixelType *)pPix->devPrivate.ptr;
+ nWidth = pPix->devKind/PGSZB;
+
+ width = pPix->drawable.width;
+ pReg->extents.x1 = width - 1;
+ pReg->extents.x2 = 0;
+ irectPrevStart = -1;
+ for (h = 0; h < pPix->drawable.height; h++) {
+ pw = pwLine;
+ pwLine += nWidth;
+ irectLineStart = rects - FirstRect;
+ /* If the Screen left most bit of the word is set, we're starting in
+ * a box */
+ if (*pw & mask0) {
+ fInBox = TRUE;
+ rx1 = 0;
+ } else
+ fInBox = FALSE;
+ /* Process all words which are fully in the pixmap */
+ pwLineEnd = pw + (width >> PWSH);
+ for (base = 0; pw < pwLineEnd; base += PPW) {
+ w = *pw++;
+ if (fInBox) {
+ if (!~w)
+ continue;
+ } else {
+ if (!w)
+ continue;
+ }
+ for (ib = 0; ib < PPW; ib++) {
+ /* If the Screen left most bit of the word is set, we're
+ * starting a box */
+ if (w & mask0) {
+ if (!fInBox) {
+ rx1 = base + ib;
+ /* start new box */
+ fInBox = TRUE;
+ }
+ } else {
+ if (fInBox) {
+ /* end box */
+ ADDRECT(pReg, rects, FirstRect, rx1, h, base + ib, h + 1);
+ fInBox = FALSE;
+ }
+ }
+ /* Shift the word VISUALLY left one. */
+ w = SCRLEFT(w, 1);
+ }
+ }
+ if (width & PIM) {
+ /* Process final partial word on line */
+ w = *pw++;
+ for (ib = 0; ib < (width & PIM); ib++) {
+ /* If the Screen left most bit of the word is set, we're
+ * starting a box */
+ if (w & mask0) {
+ if (!fInBox) {
+ rx1 = base + ib;
+ /* start new box */
+ fInBox = TRUE;
+ }
+ } else {
+ if (fInBox) {
+ /* end box */
+ ADDRECT(pReg, rects, FirstRect,
+ rx1, h, base + ib, h + 1);
+ fInBox = FALSE;
+ }
+ }
+ /* Shift the word VISUALLY left one. */
+ w = SCRLEFT(w, 1);
+ }
+ }
+ /* If scanline ended with last bit set, end the box */
+ if (fInBox) {
+ ADDRECT(pReg, rects, FirstRect,
+ rx1, h, base + (width & PIM), h + 1);
+ }
+ /* if all rectangles on this line have the same x-coords as
+ * those on the previous line, then add 1 to all the previous y2s and
+ * throw away all the rectangles from this line
+ */
+ fSame = FALSE;
+ if (irectPrevStart != -1) {
+ crects = irectLineStart - irectPrevStart;
+ if (crects == ((rects - FirstRect) - irectLineStart)) {
+ prectO = FirstRect + irectPrevStart;
+ prectN = prectLineStart = FirstRect + irectLineStart;
+ fSame = TRUE;
+ while (prectO < prectLineStart) {
+ if ((prectO->x1 != prectN->x1) || (prectO->x2 != prectN->x2)) {
+ fSame = FALSE;
+ break;
+ }
+ prectO++;
+ prectN++;
+ }
+ if (fSame) {
+ prectO = FirstRect + irectPrevStart;
+ while (prectO < prectLineStart) {
+ prectO->y2 += 1;
+ prectO++;
+ }
+ rects -= crects;
+ pReg->data->numRects -= crects;
+ }
+ }
+ }
+ if (!fSame)
+ irectPrevStart = irectLineStart;
+ }
+ if (!pReg->data->numRects)
+ pReg->extents.x1 = pReg->extents.x2 = 0;
+ else {
+ pReg->extents.y1 = REGION_BOXPTR(pReg)->y1;
+ pReg->extents.y2 = REGION_END(pReg)->y2;
+ if (pReg->data->numRects == 1) {
+ xfree(pReg->data);
+ pReg->data = (RegDataPtr)NULL;
+ }
+ }
+#ifdef DEBUG
+ if (!miValidRegion(pReg))
+ FatalError("Assertion failed file %s, line %d: expr\n", __FILE__, __LINE__);
+#endif
+ return(pReg);
+}
diff --git a/ilbm/ilbmcmap.c b/ilbm/ilbmcmap.c
new file mode 100644
index 000000000..10dadd968
--- /dev/null
+++ b/ilbm/ilbmcmap.c
@@ -0,0 +1,124 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmcmap.c,v 3.1 1998/11/22 10:37:40 dawes Exp $ */
+/* $XConsortium: ilbmcmap.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 jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xproto.h"
+#include "scrnintstr.h"
+#include "colormapst.h"
+#include "resource.h"
+#include "micmap.h"
+
+int
+ilbmListInstalledColormaps(pScreen, pmaps)
+ ScreenPtr pScreen;
+ Colormap *pmaps;
+{
+ return miListInstalledColormaps(pScreen, pmaps);
+}
+
+
+void
+ilbmInstallColormap(pmap)
+ ColormapPtr pmap;
+{
+ miInstallColormap(pmap);
+}
+
+void
+ilbmUninstallColormap(pmap)
+ ColormapPtr pmap;
+{
+ miUninstallColormap(pmap);
+}
+
+void
+ilbmResolveColor(pred, pgreen, pblue, pVisual)
+ unsigned short *pred, *pgreen, *pblue;
+ register VisualPtr pVisual;
+{
+ miResolveColor(pred, pgreen, pblue, pVisual);
+}
+
+Bool
+ilbmInitializeColormap(pmap)
+ register ColormapPtr pmap;
+{
+ return miInitializeColormap(pmap);
+}
+
+int
+ilbmExpandDirectColors(pmap, ndef, indefs, outdefs)
+ ColormapPtr pmap;
+ int ndef;
+ xColorItem *indefs, *outdefs;
+{
+ return miExpandDirectColors(pmap, ndef, indefs, outdefs);
+}
+
+Bool
+ilbmCreateDefColormap(pScreen)
+ ScreenPtr pScreen;
+{
+ return miCreateDefColormap(pScreen);
+}
+
+Bool
+ilbmSetVisualTypes(depth, visuals, bitsPerRGB)
+ int depth;
+ int visuals;
+ int bitsPerRGB;
+{
+ 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 correspond to
+ * the set which can be used with this version of ilbm.
+ */
+
+Bool
+ilbmInitVisuals(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/ilbm/ilbmfillarc.c b/ilbm/ilbmfillarc.c
new file mode 100644
index 000000000..f107e4692
--- /dev/null
+++ b/ilbm/ilbmfillarc.c
@@ -0,0 +1,373 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmfillarc.c,v 3.1 1998/03/20 21:08:01 hohndel Exp $ */
+/************************************************************
+
+Copyright (c) 1989 X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+********************************************************/
+
+/* $XConsortium: ilbmfillarc.c,v 5.14 94/04/17 20:28:20 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xprotostr.h"
+#include "miscstruct.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "ilbm.h"
+#include "maskbits.h"
+#include "mifillarc.h"
+#include "mi.h"
+
+static void
+ilbmFillEllipseSolid(pDraw, arc, rrops)
+ DrawablePtr pDraw;
+ xArc *arc;
+ register unsigned char *rrops;
+{
+ int x, y, e;
+ int yk, xk, ym, xm, dx, dy, xorg, yorg;
+ register int slw;
+ miFillArcRec info;
+ PixelType *addrlt, *addrlb;
+ register PixelType *pdst;
+ PixelType *addrl;
+ register int n;
+ register int d;
+ int nlwidth;
+ register int xpos;
+ PixelType startmask, endmask;
+ int nlmiddle;
+ int depthDst;
+ int auxDst;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst,
+ addrlt);
+ miFillArcSetup(arc, &info);
+ MIFILLARCSETUP();
+ xorg += pDraw->x;
+ yorg += pDraw->y;
+ addrlb = addrlt;
+ addrlt += auxDst * (yorg - y);
+ addrlb += auxDst * (yorg + y + dy);
+ while (y) {
+ addrlt += auxDst;
+ addrlb -= auxDst;
+ MIFILLARCSTEP(slw);
+ if (!slw)
+ continue;
+ xpos = xorg - x;
+ pdst = addrl = ilbmScanlineOffset(addrlt, (xpos >> PWSH));
+ if (((xpos & PIM) + slw) < PPW) {
+ maskpartialbits(xpos, slw, startmask);
+ for (d = 0; d < depthDst; d++, pdst += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ *pdst &= ~startmask;
+ break;
+ case RROP_WHITE:
+ *pdst |= startmask;
+ break;
+ case RROP_INVERT:
+ *pdst ^= startmask;
+ break;
+ case RROP_NOP:
+ break;
+ }
+ }
+ if (miFillArcLower(slw)) {
+ pdst = ilbmScanlineOffset(addrlb, (xpos >> PWSH));
+
+ for (d = 0; d < depthDst; d++, pdst += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ *pdst &= ~startmask;
+ break;
+ case RROP_WHITE:
+ *pdst |= startmask;
+ break;
+ case RROP_INVERT:
+ *pdst ^= startmask;
+ break;
+ case RROP_NOP:
+ break;
+ }
+ }
+ }
+ continue;
+ }
+ maskbits(xpos, slw, startmask, endmask, nlmiddle);
+ for (d = 0; d < depthDst; d++, addrl += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ n = nlmiddle;
+ pdst = addrl;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ if (startmask)
+ *pdst++ &= ~startmask;
+ while (n--)
+ *pdst++ = 0;
+ if (endmask)
+ *pdst &= ~endmask;
+ break;
+
+ case RROP_WHITE:
+ if (startmask)
+ *pdst++ |= startmask;
+ while (n--)
+ *pdst++ = ~0;
+ if (endmask)
+ *pdst |= endmask;
+ break;
+
+ case RROP_INVERT:
+ if (startmask)
+ *pdst++ ^= startmask;
+ while (n--)
+ *pdst++ ^= ~0;
+ if (endmask)
+ *pdst ^= endmask;
+ break;
+
+ case RROP_NOP:
+ break;
+ }
+ }
+ if (!miFillArcLower(slw))
+ continue;
+ addrl = ilbmScanlineOffset(addrlb, (xpos >> PWSH));
+ for (d = 0; d < depthDst; d++, addrl += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ n = nlmiddle;
+ pdst = addrl;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ if (startmask)
+ *pdst++ &= ~startmask;
+ while (n--)
+ *pdst++ = 0;
+ if (endmask)
+ *pdst &= ~endmask;
+ break;
+
+ case RROP_WHITE:
+ if (startmask)
+ *pdst++ |= startmask;
+ while (n--)
+ *pdst++ = ~0;
+ if (endmask)
+ *pdst |= endmask;
+ break;
+
+ case RROP_INVERT:
+ if (startmask)
+ *pdst++ ^= startmask;
+ while (n--)
+ *pdst++ ^= ~0;
+ if (endmask)
+ *pdst ^= endmask;
+ break;
+
+ case RROP_NOP:
+ break;
+ }
+ }
+ }
+}
+
+#define FILLSPAN(xl,xr,addr) \
+ if (xr >= xl) { \
+ width = xr - xl + 1; \
+ addrl = ilbmScanlineOffset(addr, (xl >> PWSH)); \
+ if (((xl & PIM) + width) < PPW) { \
+ maskpartialbits(xl, width, startmask); \
+ for (pdst = addrl, d = 0; d < depthDst; d++, pdst += nlwidth) { /* @@@ NEXT PLANE @@@ */ \
+ switch (rrops[d]) { \
+ case RROP_BLACK: \
+ *pdst &= ~startmask; \
+ break; \
+ case RROP_WHITE: \
+ *pdst |= startmask; \
+ break; \
+ case RROP_INVERT: \
+ *pdst ^= startmask; \
+ break; \
+ case RROP_NOP: \
+ break; \
+ } \
+ } \
+ } else { \
+ maskbits(xl, width, startmask, endmask, nlmiddle); \
+ for (d = 0; d < depthDst; d++, addrl += nlwidth) { /* @@@ NEXT PLANE @@@ */ \
+ n = nlmiddle; \
+ pdst = addrl; \
+ switch (rrops[d]) { \
+ case RROP_BLACK: \
+ if (startmask) \
+ *pdst++ &= ~startmask; \
+ while (n--) \
+ *pdst++ = 0; \
+ if (endmask) \
+ *pdst &= ~endmask; \
+ break; \
+ case RROP_WHITE: \
+ if (startmask) \
+ *pdst++ |= startmask; \
+ while (n--) \
+ *pdst++ = ~0; \
+ if (endmask) \
+ *pdst |= endmask; \
+ break; \
+ case RROP_INVERT: \
+ if (startmask) \
+ *pdst++ ^= startmask; \
+ while (n--) \
+ *pdst++ ^= ~0; \
+ if (endmask) \
+ *pdst ^= endmask; \
+ break; \
+ case RROP_NOP: \
+ break; \
+ } \
+ } \
+ } \
+ }
+
+#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
+ilbmFillArcSliceSolidCopy(pDraw, pGC, arc, rrops)
+ DrawablePtr pDraw;
+ GCPtr pGC;
+ xArc *arc;
+ register unsigned char *rrops;
+{
+ PixelType *addrl;
+ register PixelType *pdst;
+ register int n;
+ register int d;
+ int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
+ register int x, y, e;
+ miFillArcRec info;
+ miArcSliceRec slice;
+ int xl, xr, xc;
+ PixelType *addrlt, *addrlb;
+ int nlwidth;
+ int width;
+ PixelType startmask, endmask;
+ int nlmiddle;
+ int auxDst;
+ int depthDst;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst,
+ addrlt);
+ miFillArcSetup(arc, &info);
+ miFillArcSliceSetup(arc, &slice, pGC);
+ MIFILLARCSETUP();
+ xorg += pDraw->x;
+ yorg += pDraw->y;
+ addrlb = addrlt;
+ addrlt = ilbmScanlineDeltaNoBankSwitch(addrlt, yorg - y, auxDst);
+ addrlb = ilbmScanlineDeltaNoBankSwitch(addrlb, yorg + y + dy, auxDst);
+ slice.edge1.x += pDraw->x;
+ slice.edge2.x += pDraw->x;
+ while (y > 0) {
+ ilbmScanlineIncNoBankSwitch(addrlt, auxDst);
+ ilbmScanlineIncNoBankSwitch(addrlb, -auxDst);
+ MIFILLARCSTEP(slw);
+ MIARCSLICESTEP(slice.edge1);
+ MIARCSLICESTEP(slice.edge2);
+ if (miFillSliceUpper(slice)) {
+ MIARCSLICEUPPER(xl, xr, slice, slw);
+ FILLSLICESPANS(slice.flip_top, addrlt);
+ }
+ if (miFillSliceLower(slice)) {
+ MIARCSLICELOWER(xl, xr, slice, slw);
+ FILLSLICESPANS(slice.flip_bot, addrlb);
+ }
+ }
+}
+
+void
+ilbmPolyFillArcSolid(pDraw, pGC, narcs, parcs)
+ register DrawablePtr pDraw;
+ GCPtr pGC;
+ int narcs;
+ xArc *parcs;
+{
+ ilbmPrivGC *priv;
+ register xArc *arc;
+ register int i;
+ int x2, y2;
+ BoxRec box;
+ RegionPtr cclip;
+ unsigned char *rrops;
+
+ priv = (ilbmPrivGC *) pGC->devPrivates[ilbmGCPrivateIndex].ptr;
+ rrops = priv->rrops;
+ cclip = pGC->pCompositeClip;
+ 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))
+ ilbmFillEllipseSolid(pDraw, arc, rrops);
+ else
+ ilbmFillArcSliceSolidCopy(pDraw, pGC, arc, rrops);
+ continue;
+ }
+ }
+ miPolyFillArc(pDraw, pGC, 1, arc);
+ }
+}
diff --git a/ilbm/ilbmfillrct.c b/ilbm/ilbmfillrct.c
new file mode 100644
index 000000000..642a95f40
--- /dev/null
+++ b/ilbm/ilbmfillrct.c
@@ -0,0 +1,295 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmfillrct.c,v 3.1 1998/03/20 21:08:01 hohndel Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmfillrct.c,v 5.10 94/04/17 20:28:21 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xprotostr.h"
+#include "pixmapstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "miscstruct.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+#define MODEQ(a, b) ((a) %= (b))
+void ilbmPaintOddSize();
+
+/*
+ filled rectangles.
+ translate the rectangles, clip them, and call the
+helper function in the GC.
+*/
+
+#define NUM_STACK_RECTS 1024
+
+void
+ilbmPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
+ DrawablePtr pDrawable;
+ 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];
+ int numRects;
+ int n;
+ int xorg, yorg;
+ ilbmPrivGC *priv;
+ PixmapPtr ppix;
+ unsigned char *rrops;
+ unsigned char *rropsOS;
+
+ priv = (ilbmPrivGC *)pGC->devPrivates[ilbmGCPrivateIndex].ptr;
+ ppix = pGC->pRotatedPixmap;
+ prgnClip = pGC->pCompositeClip;
+ rrops = priv->rrops;
+ rropsOS = priv->rropOS;
+
+ prect = prectInit;
+ xorg = pDrawable->x;
+ yorg = pDrawable->y;
+ if (xorg || yorg) {
+ prect = prectInit;
+ n = nrectFill;
+ Duff(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) {
+ switch (pGC->fillStyle) {
+ case FillSolid:
+ ilbmSolidFillArea(pDrawable, pboxClipped-pboxClippedBase,
+ pboxClippedBase, rrops);
+ break;
+ case FillTiled:
+ switch (pGC->alu) {
+ case GXcopy:
+ if (pGC->pRotatedPixmap)
+ ilbmTileAreaPPWCopy(pDrawable, pboxClipped-pboxClippedBase,
+ pboxClippedBase, GXcopy,
+ pGC->pRotatedPixmap, pGC->planemask);
+ else
+ ilbmTileAreaCopy(pDrawable, pboxClipped-pboxClippedBase,
+ pboxClippedBase, GXcopy, pGC->tile.pixmap,
+ pGC->patOrg.x, pGC->patOrg.y,
+ pGC->planemask);
+ break;
+
+ default:
+ if (pGC->pRotatedPixmap)
+ ilbmTileAreaPPWGeneral(pDrawable, pboxClipped-pboxClippedBase,
+ pboxClippedBase, pGC->alu,
+ pGC->pRotatedPixmap,
+ pGC->planemask);
+ else
+ ilbmTileAreaGeneral(pDrawable, pboxClipped-pboxClippedBase,
+ pboxClippedBase, pGC->alu,
+ pGC->tile.pixmap, pGC->patOrg.x,
+ pGC->patOrg.y, pGC->planemask);
+ break;
+ } /* switch (alu) */
+ break;
+
+ case FillStippled:
+ if (pGC->pRotatedPixmap)
+ ilbmStippleAreaPPW(pDrawable, pboxClipped-pboxClippedBase,
+ pboxClippedBase, pGC->pRotatedPixmap, rrops);
+ else
+ ilbmStippleArea(pDrawable, pboxClipped-pboxClippedBase,
+ pboxClippedBase, pGC->stipple, pGC->patOrg.x,
+ pGC->patOrg.y, rrops);
+ break;
+
+ case FillOpaqueStippled:
+ switch (pGC->alu) {
+ case GXcopy:
+ if (pGC->pRotatedPixmap)
+ ilbmOpaqueStippleAreaPPWCopy(pDrawable,
+ pboxClipped-pboxClippedBase,
+ pboxClippedBase, GXcopy,
+ pGC->pRotatedPixmap, rropsOS,
+ pGC->planemask);
+ else
+ ilbmOpaqueStippleAreaCopy(pDrawable,
+ pboxClipped-pboxClippedBase,
+ pboxClippedBase, GXcopy,
+ pGC->stipple, pGC->patOrg.x,
+ pGC->patOrg.y, rropsOS,
+ pGC->planemask);
+ break;
+
+ default:
+ if (pGC->pRotatedPixmap)
+ ilbmOpaqueStippleAreaPPWGeneral(pDrawable,
+ pboxClipped-pboxClippedBase,
+ pboxClippedBase, pGC->alu,
+ pGC->pRotatedPixmap,
+ rropsOS, pGC->planemask);
+ else
+ ilbmOpaqueStippleAreaGeneral(pDrawable,
+ pboxClipped-pboxClippedBase,
+ pboxClippedBase, pGC->alu,
+ pGC->stipple, pGC->patOrg.x,
+ pGC->patOrg.y, rropsOS,
+ pGC->planemask);
+ break;
+ } /* switch (alu) */
+ break;
+ }
+ }
+ if (pboxClippedBase != stackRects)
+ DEALLOCATE_LOCAL(pboxClippedBase);
+}
diff --git a/ilbm/ilbmfillsp.c b/ilbm/ilbmfillsp.c
new file mode 100644
index 000000000..5564e5142
--- /dev/null
+++ b/ilbm/ilbmfillsp.c
@@ -0,0 +1,1145 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmfillsp.c,v 3.1 1998/03/20 21:08:01 hohndel Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmfillsp.c,v 5.13 94/04/17 20:28:21 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "gcstruct.h"
+#include "window.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+#include "ilbm.h"
+#include "maskbits.h"
+
+#include "mergerop.h"
+
+#include "servermd.h"
+#include "mi.h"
+#include "mispans.h"
+
+/* scanline filling for monochrome frame buffer
+ written by drewry, oct 1986
+
+ 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 ilbmCreateGC().)
+
+ the number of new scnalines created by clipping ==
+MaxRectsPerBand * nSpans.
+
+*/
+
+
+void
+ilbmSolidFS(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 */
+ register DDXPointPtr ppt; /* pointer to list of start points */
+ register int *pwidth; /* pointer to list of n widths */
+ PixelType *addrlBase; /* pointer to start of bitmap */
+ PixelType *pBase;
+ int nlwidth; /* width in longwords of bitmap */
+ register PixelType *addrl;/* pointer to current longword in bitmap */
+ register int nlmiddle;
+ register PixelType startmask;
+ register PixelType endmask;
+ int *pwidthFree; /* copies of the pointers to free */
+ DDXPointPtr pptFree;
+ int depthDst;
+ int auxDst;
+ int d;
+ unsigned char *rrops;
+
+ 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);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBase);
+ rrops = ((ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr))->rrops;
+ while (n--) {
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (*pwidth) {
+ addrl = addrlBase;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ /* all bits inside same longword */
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl &= ~startmask;
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask)
+ *addrl++ &= ~startmask;
+ Duff (nlmiddle, *addrl++ = 0x0);
+ if (endmask)
+ *addrl &= ~endmask;
+ }
+ break;
+
+ case RROP_WHITE:
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ /* all bits inside same longword */
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl |= startmask;
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask)
+ *addrl++ |= startmask;
+ Duff (nlmiddle, *addrl++ = ~0);
+ if (endmask)
+ *addrl |= endmask;
+ }
+ break;
+ case RROP_INVERT:
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ /* all bits inside same longword */
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl ^= startmask;
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask)
+ *addrl++ ^= startmask;
+ Duff (nlmiddle, *addrl++ ^= ~0);
+ if (endmask)
+ *addrl ^= endmask;
+ }
+ break;
+ case RROP_NOP:
+ break;
+ }
+ }
+ }
+ pwidth++;
+ ppt++;
+ }
+ DEALLOCATE_LOCAL(pptFree);
+ DEALLOCATE_LOCAL(pwidthFree);
+}
+
+void
+ilbmStippleFS(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 */
+ PixelType *addrlBase; /* pointer to start of bitmap */
+ PixelType *pBase;
+ int nlwidth; /* width in longwords of bitmap */
+ register PixelType *addrl;/* pointer to current longword in bitmap */
+ register PixelType src;
+ register int nlmiddle;
+ register PixelType startmask;
+ register PixelType endmask;
+ PixmapPtr pStipple;
+ PixelType *psrc;
+ int tileHeight;
+ int *pwidthFree; /* copies of the pointers to free */
+ DDXPointPtr pptFree;
+ int d;
+ int depthDst;
+ int auxDst;
+ unsigned char *rrops;
+
+ 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);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBase);
+
+ pStipple = pGC->pRotatedPixmap;
+ tileHeight = pStipple->drawable.height;
+ psrc = (PixelType *)(pStipple->devPrivate.ptr);
+
+ rrops = ((ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr))->rrops;
+
+ while (n--) {
+ src = psrc[ppt->y % tileHeight];
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ addrl = addrlBase;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ /* all bits inside same longword */
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl &= ~(src & startmask);
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask)
+ *addrl++ &= ~(src & startmask);
+ Duff (nlmiddle, *addrl++ &= ~src);
+ if (endmask)
+ *addrl &= ~(src & endmask);
+ }
+ break;
+ case RROP_WHITE:
+ /* all bits inside same longword */
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl |= (src & startmask);
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask)
+ *addrl++ |= (src & startmask);
+ Duff (nlmiddle, *addrl++ |= src);
+ if (endmask)
+ *addrl |= (src & endmask);
+ }
+ break;
+ case RROP_INVERT:
+ /* all bits inside same longword */
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl ^= (src & startmask);
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask)
+ *addrl++ ^= (src & startmask);
+ Duff (nlmiddle, *addrl++ ^= src);
+ if (endmask)
+ *addrl ^= (src & endmask);
+ }
+ break;
+
+ case RROP_NOP:
+ break;
+ }
+ }
+ pwidth++;
+ ppt++;
+ }
+ DEALLOCATE_LOCAL(pptFree);
+ DEALLOCATE_LOCAL(pwidthFree);
+}
+
+void
+ilbmTileFS(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 */
+ PixelType *addrlBase; /* pointer to start of bitmap */
+ PixelType *pBase;
+ int nlwidth; /* width in longwords of bitmap */
+ register PixelType *addrl; /* pointer to current longword in bitmap */
+ register PixelType src;
+ register int nlmiddle;
+ register PixelType startmask;
+ register PixelType endmask;
+ PixmapPtr pTile;
+ PixelType *psrc;
+ int tileHeight;
+ int rop;
+ int *pwidthFree; /* copies of the pointers to free */
+ DDXPointPtr pptFree;
+ int auxDst;
+ int depthDst;
+ int d;
+
+ 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);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBase);
+
+ pTile = pGC->pRotatedPixmap;
+ tileHeight = pTile->drawable.height;
+ psrc = (PixelType *)(pTile->devPrivate.ptr);
+ rop = pGC->alu;
+
+ switch (rop) {
+ case GXcopy:
+#define DoMaskCopyRop(src,dst,mask) ((dst) & ~(mask) | (src) & (mask))
+ while (n--) {
+ if (*pwidth) {
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(pGC->planemask & (1 << d)))
+ continue;
+
+ addrl = addrlBase;
+ src = psrc[ppt->y % tileHeight + tileHeight * d];
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl = DoMaskCopyRop (src, *addrl, startmask);
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask) {
+ *addrl = DoMaskCopyRop (src, *addrl, startmask);
+ addrl++;
+ }
+ while (nlmiddle--) {
+ *addrl = src;
+ addrl++;
+ }
+ if (endmask)
+ *addrl = DoMaskCopyRop (src, *addrl, endmask);
+ }
+ }
+ }
+ pwidth++;
+ ppt++;
+ }
+ break;
+
+ default:
+ {
+ register DeclareMergeRop ();
+
+ InitializeMergeRop(rop,~0);
+ while (n--) {
+ if (*pwidth) {
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(pGC->planemask & (1 << d)))
+ continue;
+
+ addrl = addrlBase;
+
+ src = psrc[ppt->y % tileHeight + tileHeight * d];
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl = DoMaskMergeRop (src, *addrl, startmask);
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask) {
+ *addrl = DoMaskMergeRop (src, *addrl, startmask);
+ addrl++;
+ }
+ while (nlmiddle--) {
+ *addrl = DoMergeRop (src, *addrl);
+ addrl++;
+ }
+ if (endmask)
+ *addrl = DoMaskMergeRop (src, *addrl, endmask);
+ }
+ }
+ }
+ pwidth++;
+ ppt++;
+ }
+ break;
+ }
+ }
+ DEALLOCATE_LOCAL(pptFree);
+ DEALLOCATE_LOCAL(pwidthFree);
+}
+
+void
+ilbmOpaqueStippleFS(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 */
+ PixelType *addrlBase; /* pointer to start of bitmap */
+ PixelType *pBase;
+ int nlwidth; /* width in longwords of bitmap */
+ register PixelType *addrl; /* pointer to current longword in bitmap */
+ register PixelType src;
+ register int nlmiddle;
+ register PixelType startmask;
+ register PixelType endmask;
+ PixmapPtr pTile;
+ PixelType *psrc;
+ int tileHeight;
+ int rop;
+ unsigned char *rropsOS;
+ int *pwidthFree; /* copies of the pointers to free */
+ DDXPointPtr pptFree;
+ int auxDst;
+ int depthDst;
+ int d;
+
+ 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);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBase);
+
+ pTile = pGC->pRotatedPixmap;
+ tileHeight = pTile->drawable.height;
+ psrc = (PixelType *)(pTile->devPrivate.ptr);
+ rop = pGC->alu;
+ rropsOS = ((ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr))->rropOS;
+
+ switch (rop) {
+ case GXcopy:
+#define DoMaskCopyRop(src,dst,mask) ((dst) & ~(mask) | (src) & (mask))
+ while (n--) {
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+ if (*pwidth) {
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ src = 0;
+ break;
+ case RROP_WHITE:
+ src = ~0;
+ break;
+ case RROP_INVERT:
+ src = ~psrc[ppt->y % tileHeight];
+ break;
+ case RROP_COPY:
+ src = psrc[ppt->y % tileHeight];
+ break;
+ case RROP_NOP:
+ continue;
+ }
+
+ addrl = addrlBase;
+
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl = DoMaskCopyRop (src, *addrl, startmask);
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask) {
+ *addrl = DoMaskCopyRop (src, *addrl, startmask);
+ addrl++;
+ }
+ while (nlmiddle--) {
+ *addrl = src;
+ addrl++;
+ }
+ if (endmask)
+ *addrl = DoMaskCopyRop (src, *addrl, endmask);
+ }
+ } /* for (d = ...) */
+ }
+
+ pwidth++;
+ ppt++;
+ }
+ break;
+
+ default:
+ {
+ register DeclareMergeRop ();
+
+ InitializeMergeRop(rop,~0);
+ while (n--) {
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+ if (*pwidth) {
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ src = 0;
+ break;
+ case RROP_WHITE:
+ src = ~0;
+ break;
+ case RROP_INVERT:
+ src = ~psrc[ppt->y % tileHeight];
+ break;
+ case RROP_COPY:
+ src = psrc[ppt->y % tileHeight];
+ break;
+ case RROP_NOP:
+ continue;
+ }
+
+ addrl = addrlBase;
+
+ if ( ((ppt->x & PIM) + *pwidth) < PPW) {
+ maskpartialbits(ppt->x, *pwidth, startmask);
+ *addrl = DoMaskMergeRop (src, *addrl, startmask);
+ } else {
+ maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
+ if (startmask) {
+ *addrl = DoMaskMergeRop (src, *addrl, startmask);
+ addrl++;
+ }
+ while (nlmiddle--) {
+ *addrl = DoMergeRop (src, *addrl);
+ addrl++;
+ }
+ if (endmask)
+ *addrl = DoMaskMergeRop (src, *addrl, endmask);
+ }
+ } /* for (d = ...) */
+ }
+ pwidth++;
+ ppt++;
+ } /* while (n) */
+ break;
+ }
+ } /* switch (rop) */
+ DEALLOCATE_LOCAL(pptFree);
+ DEALLOCATE_LOCAL(pwidthFree);
+}
+
+/* Fill spans with tiles that aren't PPW bits wide */
+void
+ilbmUnnaturalTileFS(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 iline; /* first line of tile to use */
+ /* 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 */
+ PixelType *addrlBase; /* pointer to start of bitmap */
+ PixelType *pBase;
+ int nlwidth; /* width in longwords of bitmap */
+ register PixelType *pdst;/* pointer to current word in bitmap */
+ register PixelType *psrc;/* pointer to current word in tile */
+ register int nlMiddle;
+ register int rop, nstart;
+ PixelType startmask;
+ PixmapPtr pTile; /* pointer to tile we want to fill with */
+ int w, width, x, xSrc, ySrc, srcStartOver, nend;
+ int tlwidth, rem, tileWidth, tileHeight, endinc;
+ PixelType endmask, *psrcT;
+ int *pwidthFree; /* copies of the pointers to free */
+ DDXPointPtr pptFree;
+ int auxDst;
+ int sizeTile;
+ int depthDst;
+ register int d;
+
+ 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);
+
+ pTile = pGC->tile.pixmap;
+ tlwidth = pTile->devKind/PGSZB;
+ rop = pGC->alu;
+
+ xSrc = pDrawable->x;
+ ySrc = pDrawable->y;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBase);
+
+ tileWidth = pTile->drawable.width;
+ tileHeight = pTile->drawable.height;
+ sizeTile = tlwidth * tileHeight;
+
+ /* this replaces rotating the tile. Instead we just adjust the offset
+ * at which we start grabbing bits from the tile.
+ * Ensure that ppt->x - xSrc >= 0 and ppt->y - ySrc >= 0,
+ * so that iline and rem always stay within the tile bounds.
+ */
+ xSrc += (pGC->patOrg.x % tileWidth) - tileWidth;
+ ySrc += (pGC->patOrg.y % tileHeight) - tileHeight;
+
+ while (n--) {
+ iline = (ppt->y - ySrc) % tileHeight;
+ psrcT = (PixelType *) pTile->devPrivate.ptr + (iline * tlwidth);
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+
+ for (d = 0; d < depthDst; d++, psrcT += sizeTile, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(pGC->planemask & (1 << d)))
+ continue;
+
+ if (*pwidth) {
+ x = ppt->x;
+ pdst = addrlBase;
+ width = *pwidth;
+ while (width > 0) {
+ psrc = psrcT;
+ w = min(tileWidth, width);
+ if ((rem = (x - xSrc) % tileWidth) != 0) {
+ /* if we're in the middle of the tile, get
+ as many bits as will finish the span, or
+ as many as will get to the left edge of the tile,
+ or a longword worth, starting at the appropriate
+ offset in the tile.
+ */
+ w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
+ endinc = rem / BITMAP_SCANLINE_PAD;
+ getandputrop((psrc+endinc), (rem&PIM), (x & PIM), w, pdst, rop);
+ if ((x & PIM) + w >= PPW)
+ pdst++;
+ } else if (((x & PIM) + w) < PPW) {
+ /* doing < PPW bits is easy, and worth special-casing */
+ putbitsrop(*psrc, x & PIM, w, pdst, rop);
+ } else {
+ /* start at the left edge of the tile,
+ and put down as much as we can
+ */
+ maskbits(x, w, startmask, endmask, nlMiddle);
+
+ if (startmask)
+ nstart = PPW - (x & PIM);
+ else
+ nstart = 0;
+ if (endmask)
+ nend = (x + w) & PIM;
+ else
+ nend = 0;
+
+ srcStartOver = nstart > PLST;
+
+ if (startmask) {
+ putbitsrop(*psrc, (x & PIM), nstart, pdst, rop);
+ pdst++;
+ if (srcStartOver)
+ psrc++;
+ }
+
+ while (nlMiddle--) {
+ getandputrop0(psrc, nstart, PPW, pdst, rop);
+ pdst++;
+ psrc++;
+ }
+ if (endmask) {
+ getandputrop0(psrc, nstart, nend, pdst, rop);
+ }
+ }
+ x += w;
+ width -= w;
+ }
+ }
+ }
+ ppt++;
+ pwidth++;
+ }
+ DEALLOCATE_LOCAL(pptFree);
+ DEALLOCATE_LOCAL(pwidthFree);
+}
+
+/* Fill spans with stipples that aren't PPW bits wide */
+void
+ilbmUnnaturalStippleFS(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 */
+ PixelType *addrlBase; /* pointer to start of bitmap */
+ PixelType *pBase;
+ int nlwidth; /* width in longwords of bitmap */
+ register PixelType *pdst; /* pointer to current word in bitmap */
+ register PixelType *psrc; /* pointer to current word in tile */
+ register int nlMiddle;
+ register int rop, nstart;
+ PixelType startmask;
+ PixmapPtr pTile; /* pointer to tile we want to fill with */
+ int w, width, x, xSrc, ySrc, srcStartOver, nend;
+ PixelType endmask, *psrcT;
+ int tlwidth, rem, tileWidth, endinc;
+ int tileHeight;
+ int *pwidthFree; /* copies of the pointers to free */
+ DDXPointPtr pptFree;
+ unsigned char *rrops;
+ register int d;
+ int auxDst;
+ int depthDst;
+
+ 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);
+
+ pTile = pGC->stipple;
+ tlwidth = pTile->devKind/PGSZB;
+ xSrc = pDrawable->x;
+ ySrc = pDrawable->y;
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBase);
+
+ tileWidth = pTile->drawable.width;
+ tileHeight = pTile->drawable.height;
+ rrops = ((ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr))->rrops;
+
+ /* 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 rem always stay within the tile bounds.
+ */
+ xSrc += (pGC->patOrg.x % tileWidth) - tileWidth;
+ ySrc += (pGC->patOrg.y % tileHeight) - tileHeight;
+ while (n--) {
+ iline = (ppt->y - ySrc) % tileHeight;
+ psrcT = (PixelType *) pTile->devPrivate.ptr + (iline * tlwidth);
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ rop = rrops[d];
+ if (rop == RROP_NOP)
+ continue;
+
+ pdst = addrlBase;
+ x = ppt->x;
+
+ if (*pwidth) {
+ width = *pwidth;
+ while (width > 0) {
+ psrc = psrcT;
+ w = min(tileWidth, width);
+ if ((rem = (x - xSrc) % tileWidth) != 0) {
+ /* if we're in the middle of the tile, get
+ as many bits as will finish the span, or
+ as many as will get to the left edge of the tile,
+ or a longword worth, starting at the appropriate
+ offset in the tile.
+ */
+ w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
+ endinc = rem / BITMAP_SCANLINE_PAD;
+ getandputrrop((psrc + endinc), (rem & PIM), (x & PIM),
+ w, pdst, rop)
+ if ((x & PIM) + w >= PPW)
+ pdst++;
+ } else if (((x & PIM) + w) < PPW) {
+ /* doing < PPW bits is easy, and worth special-casing */
+ putbitsrrop(*psrc, x & PIM, w, pdst, rop);
+ } else {
+ /* start at the left edge of the tile,
+ and put down as much as we can
+ */
+ maskbits(x, w, startmask, endmask, nlMiddle);
+
+ if (startmask)
+ nstart = PPW - (x & PIM);
+ else
+ nstart = 0;
+ if (endmask)
+ nend = (x + w) & PIM;
+ else
+ nend = 0;
+
+ srcStartOver = nstart > PLST;
+
+ if (startmask) {
+ putbitsrrop(*psrc, (x & PIM), nstart, pdst, rop);
+ pdst++;
+ if (srcStartOver)
+ psrc++;
+ }
+
+ while (nlMiddle--) {
+ getandputrrop0(psrc, nstart, PPW, pdst, rop);
+ pdst++;
+ psrc++;
+ }
+ if (endmask) {
+ getandputrrop0(psrc, nstart, nend, pdst, rop);
+ }
+ }
+ x += w;
+ width -= w;
+ }
+ }
+ }
+ ppt++;
+ pwidth++;
+ }
+ DEALLOCATE_LOCAL(pptFree);
+ DEALLOCATE_LOCAL(pwidthFree);
+}
+
+/* Fill spans with OpaqueStipples that aren't PPW bits wide */
+void
+ilbmUnnaturalOpaqueStippleFS(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 iline; /* first line of tile to use */
+ /* 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 */
+ PixelType *addrlBase; /* pointer to start of bitmap */
+ PixelType *pBase;
+ int nlwidth; /* width in longwords of bitmap */
+ register PixelType *pdst;/* pointer to current word in bitmap */
+ register PixelType *psrc;/* pointer to current word in tile */
+ register int nlMiddle;
+ register int d;
+ register PixelType tmpsrc;
+ register PixelType tmpdst;
+ register int alu, nstart;
+ register unsigned char *rropsOS;
+ PixelType startmask;
+ PixmapPtr pTile; /* pointer to tile we want to fill with */
+ int w, width, x, xSrc, ySrc, srcStartOver, nend;
+ int tlwidth, rem, tileWidth, tileHeight, endinc;
+ PixelType endmask, *psrcT;
+ int *pwidthFree; /* copies of the pointers to free */
+ DDXPointPtr pptFree;
+ int auxDst;
+ int sizeTile;
+ int depthDst;
+
+ 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);
+
+ pTile = pGC->stipple;
+ tlwidth = pTile->devKind/PGSZB;
+ alu = pGC->alu;
+
+ xSrc = pDrawable->x;
+ ySrc = pDrawable->y;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBase);
+
+ tileWidth = pTile->drawable.width;
+ tileHeight = pTile->drawable.height;
+ rropsOS = ilbmGetGCPrivate(pGC)->rropOS;
+
+ /* this replaces rotating the tile. Instead we just adjust the offset
+ * at which we start grabbing bits from the tile.
+ * Ensure that ppt->x - xSrc >= 0 and ppt->y - ySrc >= 0,
+ * so that iline and rem always stay within the tile bounds.
+ */
+ xSrc += (pGC->patOrg.x % tileWidth) - tileWidth;
+ ySrc += (pGC->patOrg.y % tileHeight) - tileHeight;
+
+ while (n--) {
+ iline = (ppt->y - ySrc) % tileHeight;
+ psrcT = (PixelType *) pTile->devPrivate.ptr + (iline * tlwidth);
+ addrlBase = ilbmScanline(pBase, ppt->x, ppt->y, auxDst);
+
+ for (d = 0; d < depthDst; d++, addrlBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(pGC->planemask & (1 << d)))
+ continue;
+
+ if (*pwidth) {
+ x = ppt->x;
+ pdst = addrlBase;
+ width = *pwidth;
+ while (width > 0) {
+ psrc = psrcT;
+ w = min(tileWidth, width);
+ if ((rem = (x - xSrc) % tileWidth) != 0) {
+ /* if we're in the middle of the tile, get
+ as many bits as will finish the span, or
+ as many as will get to the left edge of the tile,
+ or a longword worth, starting at the appropriate
+ offset in the tile.
+ */
+ w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
+ endinc = rem / BITMAP_SCANLINE_PAD;
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+
+ case RROP_COPY:
+ getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
+ break;
+
+ case RROP_INVERT:
+ getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
+ tmpsrc = ~tmpsrc;
+ break;
+ }
+
+ if (alu != GXcopy) {
+ getbits (pdst, (x & PIM), w, tmpdst);
+ DoRop (tmpsrc, alu, tmpsrc, tmpdst);
+ }
+
+ putbits (tmpsrc, (x & PIM), w, pdst);
+ if ((x & PIM) + w >= PPW)
+ pdst++;
+ } else if (((x & PIM) + w) < PPW) {
+ /* doing < PPW bits is easy, and worth special-casing */
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+ case RROP_COPY:
+ tmpsrc = *psrc;
+ break;
+ case RROP_INVERT:
+ tmpsrc = ~*psrc;
+ break;
+ }
+ if (alu != GXcopy) {
+ getbits (pdst, (x & PIM), w, tmpdst);
+ DoRop (tmpsrc, alu, tmpsrc, tmpdst);
+ }
+ putbits (tmpsrc, (x & PIM), w, pdst);
+ } else {
+ /* start at the left edge of the tile,
+ and put down as much as we can
+ */
+ maskbits(x, w, startmask, endmask, nlMiddle);
+
+ if (startmask)
+ nstart = PPW - (x & PIM);
+ else
+ nstart = 0;
+ if (endmask)
+ nend = (x + w) & PIM;
+ else
+ nend = 0;
+
+ srcStartOver = nstart > PLST;
+
+ if (startmask) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+ case RROP_COPY:
+ tmpsrc = *psrc;
+ break;
+ case RROP_INVERT:
+ tmpsrc = ~*psrc;
+ break;
+ }
+ if (alu != GXcopy) {
+ getbits (pdst, (x & PIM), nstart, tmpdst);
+ DoRop (tmpsrc, alu, tmpsrc, tmpdst);
+ }
+ putbits (tmpsrc, (x & PIM), nstart, pdst);
+ pdst++;
+ if (srcStartOver)
+ psrc++;
+ }
+
+ while (nlMiddle--) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+ case RROP_COPY:
+ getbits (psrc, nstart, PPW, tmpsrc);
+ break;
+ case RROP_INVERT:
+ getbits (psrc, nstart, PPW, tmpsrc);
+ tmpsrc = ~tmpsrc;
+ break;
+ }
+ if (alu != GXcopy) {
+ tmpdst = *pdst;
+ DoRop (tmpsrc, alu, tmpsrc, tmpdst);
+ }
+ *pdst++ = tmpsrc;
+ /*putbits (tmpsrc, 0, PPW, pdst);
+ pdst++;*/
+ psrc++;
+ }
+ if (endmask) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+
+ case RROP_COPY:
+ getbits (psrc, nstart, nend, tmpsrc);
+ break;
+
+ case RROP_INVERT:
+ getbits (psrc, nstart, nend, tmpsrc);
+ tmpsrc = ~tmpsrc;
+ break;
+ }
+ if (alu != GXcopy) {
+ tmpdst = *pdst;
+ DoRop (tmpsrc, alu, tmpsrc, tmpdst);
+ }
+ putbits (tmpsrc, 0, nend, pdst);
+ }
+ }
+ x += w;
+ width -= w;
+ }
+ }
+ }
+ ppt++;
+ pwidth++;
+ }
+ DEALLOCATE_LOCAL(pptFree);
+ DEALLOCATE_LOCAL(pwidthFree);
+}
diff --git a/ilbm/ilbmfont.c b/ilbm/ilbmfont.c
new file mode 100644
index 000000000..50cf56773
--- /dev/null
+++ b/ilbm/ilbmfont.c
@@ -0,0 +1,78 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmfont.c,v 3.0 1996/08/18 01:53:51 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: ilbmfont.c,v 1.18 94/04/17 20:28:22 keith Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ilbm.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "scrnintstr.h"
+
+/*ARGSUSED*/
+Bool
+ilbmRealizeFont( pscr, pFont)
+ ScreenPtr pscr;
+ FontPtr pFont;
+{
+ return (TRUE);
+}
+
+/*ARGSUSED*/
+Bool
+ilbmUnrealizeFont( pscr, pFont)
+ ScreenPtr pscr;
+ FontPtr pFont;
+{
+ return (TRUE);
+}
diff --git a/ilbm/ilbmgc.c b/ilbm/ilbmgc.c
new file mode 100644
index 000000000..8253d9cd4
--- /dev/null
+++ b/ilbm/ilbmgc.c
@@ -0,0 +1,711 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmgc.c,v 3.1 1998/03/20 21:08:02 hohndel Exp $ */
+/***********************************************************
+
+Copyright (c) 1987 X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XConsortium: ilbmgc.c,v 5.35 94/04/17 20:28:23 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ilbm.h"
+#include "dixfontstr.h"
+#include "fontstruct.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "region.h"
+
+#include "mistruct.h"
+#include "migc.h"
+
+#include "maskbits.h"
+
+static GCFuncs ilbmFuncs = {
+ ilbmValidateGC,
+ miChangeGC,
+ miCopyGC,
+ ilbmDestroyGC,
+ miChangeClip,
+ miDestroyClip,
+ miCopyClip
+};
+
+static GCOps ilbmGCOps = {
+ ilbmSolidFS,
+ ilbmSetSpans,
+ ilbmPutImage,
+ ilbmCopyArea,
+ miCopyPlane,
+ ilbmPolyPoint,
+ ilbmLineSS,
+ ilbmSegmentSS,
+ miPolyRectangle,
+ ilbmZeroPolyArcSS,
+ ilbmFillPolygonSolid,
+ ilbmPolyFillRect,
+ ilbmPolyFillArcSolid,
+ miPolyText8,
+ miPolyText16,
+ miImageText8,
+ miImageText16,
+ ilbmTEGlyphBlt,
+ ilbmPolyGlyphBlt,
+ ilbmPushPixels
+#ifdef NEED_LINEHELPER
+ ,NULL
+#endif
+};
+
+
+Bool
+ilbmCreateGC(pGC)
+ register GCPtr pGC;
+{
+ ilbmPrivGC *pPriv;
+
+ 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 monochrome frame buffer, they don't change
+ */
+
+ pGC->ops = &ilbmGCOps;
+ pGC->funcs = &ilbmFuncs;
+
+ /* ilbm wants to translate before scan convesion */
+ pGC->miTranslate = 1;
+
+ pPriv = (ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr);
+ ilbmReduceRop(pGC->alu, pGC->fgPixel, pGC->planemask, pGC->depth,
+ pPriv->rrops);
+ ilbmReduceOpaqueStipple(pGC->fgPixel, pGC->bgPixel, pGC->planemask,
+ pGC->depth, pPriv->rropOS);
+
+ pGC->fExpose = TRUE;
+ pGC->pRotatedPixmap = NullPixmap;
+ pGC->freeCompClip = FALSE;
+ 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
+*/
+
+/*ARGSUSED*/
+void
+ilbmValidateGC(pGC, changes, pDrawable)
+ register GCPtr pGC;
+ unsigned long changes;
+ DrawablePtr pDrawable;
+{
+ register ilbmPrivGCPtr devPriv;
+ int mask; /* stateChanges */
+ int index; /* used for stepping through bitfields */
+ int xrot, yrot; /* rotations for tile and stipple pattern */
+ int rrop; /* reduced rasterop */
+ /* flags for changing the proc vector
+ and updating things in devPriv
+ */
+ int new_rotate, new_rrop, new_line, new_text, new_fill;
+ DDXPointRec oldOrg; /* origin of thing GC was last used with */
+
+ oldOrg = pGC->lastWinOrg;
+
+ pGC->lastWinOrg.x = pDrawable->x;
+ pGC->lastWinOrg.y = pDrawable->y;
+
+ /* we need to re-rotate the tile if the previous window/pixmap
+ origin (oldOrg) differs from the new window/pixmap origin
+ (pGC->lastWinOrg)
+ */
+ new_rotate = (oldOrg.x != pGC->lastWinOrg.x) ||
+ (oldOrg.y != pGC->lastWinOrg.y);
+
+
+ devPriv = ((ilbmPrivGCPtr)(pGC->devPrivates[ilbmGCPrivateIndex].ptr));
+
+
+ /*
+ 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)))
+ ilbmComputeCompositeClip(pGC, pDrawable);
+
+ new_rrop = FALSE;
+ new_line = FALSE;
+ new_text = FALSE;
+ new_fill = FALSE;
+
+ 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 GCPlaneMask:
+ case GCFunction:
+ case GCForeground:
+ new_rrop = TRUE;
+ break;
+ case GCBackground:
+ new_rrop = TRUE; /* for opaque stipples */
+ break;
+ case GCLineStyle:
+ case GCLineWidth:
+ case GCJoinStyle:
+ new_line = TRUE;
+ break;
+ case GCCapStyle:
+ break;
+ case GCFillStyle:
+ new_fill = TRUE;
+ break;
+ case GCFillRule:
+ break;
+ case GCTile:
+ if (pGC->tileIsPixel)
+ break;
+ new_rotate = TRUE;
+ new_fill = TRUE;
+ break;
+
+ case GCStipple:
+ if (pGC->stipple == (PixmapPtr)NULL)
+ break;
+ new_rotate = TRUE;
+ new_fill = 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;
+ }
+ }
+
+ /* deal with the changes we've collected .
+ new_rrop must be done first because subsequent things
+ depend on it.
+ */
+
+ if (new_rotate || new_fill) {
+ Bool new_pix = FALSE;
+
+ /* figure out how much to rotate */
+ xrot = pGC->patOrg.x;
+ yrot = pGC->patOrg.y;
+ xrot += pDrawable->x;
+ yrot += pDrawable->y;
+
+ switch (pGC->fillStyle) {
+ case FillTiled:
+ /* copy current tile and stipple */
+ if (!pGC->tileIsPixel &&
+ (pGC->tile.pixmap->drawable.width <= PPW) &&
+ !(pGC->tile.pixmap->drawable.width &
+ (pGC->tile.pixmap->drawable.width - 1))) {
+ ilbmCopyRotatePixmap(pGC->tile.pixmap, &pGC->pRotatedPixmap,
+ xrot, yrot);
+ new_pix = TRUE;
+ }
+ break;
+ case FillStippled:
+ case FillOpaqueStippled:
+ if (pGC->stipple && (pGC->stipple->drawable.width <= PPW) &&
+ !(pGC->stipple->drawable.width &
+ (pGC->stipple->drawable.width - 1))) {
+ ilbmCopyRotatePixmap(pGC->stipple, &pGC->pRotatedPixmap,
+ xrot, yrot);
+ new_pix = TRUE;
+ }
+ }
+ /* destroy any previously rotated tile or stipple */
+ if (!new_pix && pGC->pRotatedPixmap) {
+ (*pDrawable->pScreen->DestroyPixmap)(pGC->pRotatedPixmap);
+ pGC->pRotatedPixmap = (PixmapPtr)NULL;
+ }
+ }
+
+ /*
+ * duck out here when the GC is unchanged
+ */
+
+ if (!changes)
+ return;
+
+ if (new_rrop || new_fill) {
+ ilbmReduceRop(pGC->alu, pGC->fgPixel, pGC->planemask, pDrawable->depth,
+ devPriv->rrops);
+ ilbmReduceOpaqueStipple(pGC->fgPixel, pGC->bgPixel, pGC->planemask,
+ pGC->depth, devPriv->rropOS);
+ new_fill = TRUE;
+ }
+
+ if (new_line || new_fill || new_text) {
+ if (!pGC->ops->devPrivate.val) {
+ pGC->ops = miCreateGCOps(pGC->ops);
+ pGC->ops->devPrivate.val = 1;
+ }
+ }
+
+ if (new_line || new_fill) {
+ if (pGC->lineWidth == 0) {
+ if (pGC->lineStyle == LineSolid && pGC->fillStyle == FillSolid)
+ pGC->ops->PolyArc = ilbmZeroPolyArcSS;
+ else
+ pGC->ops->PolyArc = miZeroPolyArc;
+ } else
+ pGC->ops->PolyArc = miPolyArc;
+ if (pGC->lineStyle == LineSolid) {
+ if (pGC->lineWidth == 0) {
+ if (pGC->fillStyle == FillSolid) {
+ pGC->ops->PolySegment = ilbmSegmentSS;
+ pGC->ops->Polylines = ilbmLineSS;
+ } else {
+ pGC->ops->PolySegment = miPolySegment;
+ pGC->ops->Polylines = miZeroLine;
+ }
+ } else {
+ pGC->ops->PolySegment = miPolySegment;
+ pGC->ops->Polylines = miWideLine;
+ }
+ } else {
+ if (pGC->lineWidth == 0 && pGC->fillStyle == FillSolid) {
+ pGC->ops->PolySegment = ilbmSegmentSD;
+ pGC->ops->Polylines = ilbmLineSD;
+ } else {
+ pGC->ops->PolySegment = miPolySegment;
+ pGC->ops->Polylines = miWideDash;
+ }
+ }
+ }
+
+ if (new_text || new_fill) {
+ if ((pGC->font) &&
+ (FONTMAXBOUNDS(pGC->font,rightSideBearing) -
+ FONTMINBOUNDS(pGC->font,leftSideBearing) > 32 ||
+ FONTMINBOUNDS(pGC->font,characterWidth) < 0)) {
+ pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
+ pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
+ } else {
+ /* special case ImageGlyphBlt for terminal emulator fonts */
+ if ((pGC->font) &&
+ TERMINALFONT(pGC->font)) {
+ pGC->ops->ImageGlyphBlt = ilbmTEGlyphBlt;
+ } else {
+ pGC->ops->ImageGlyphBlt = ilbmImageGlyphBlt;
+ }
+
+ /* now do PolyGlyphBlt */
+ if (pGC->fillStyle == FillSolid) {
+ pGC->ops->PolyGlyphBlt = ilbmPolyGlyphBlt;
+ } else {
+ pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
+ }
+ }
+ }
+
+ if (new_fill) {
+ /* install a suitable fillspans and pushpixels */
+ pGC->ops->PushPixels = ilbmPushPixels;
+ pGC->ops->FillPolygon = miFillPolygon;
+ pGC->ops->PolyFillArc = miPolyFillArc;
+
+ switch (pGC->fillStyle) {
+ case FillSolid:
+ pGC->ops->FillSpans = ilbmSolidFS;
+ pGC->ops->FillPolygon = ilbmFillPolygonSolid;
+ pGC->ops->PolyFillArc = ilbmPolyFillArcSolid;
+ break;
+ case FillTiled:
+ if (pGC->pRotatedPixmap)
+ pGC->ops->FillSpans = ilbmTileFS;
+ else
+ pGC->ops->FillSpans = ilbmUnnaturalTileFS;
+ break;
+ case FillOpaqueStippled:
+ if (pGC->pRotatedPixmap)
+ pGC->ops->FillSpans = ilbmOpaqueStippleFS;
+ else
+ pGC->ops->FillSpans = ilbmUnnaturalOpaqueStippleFS;
+ break;
+
+ case FillStippled:
+ if (pGC->pRotatedPixmap)
+ pGC->ops->FillSpans = ilbmStippleFS;
+ else
+ pGC->ops->FillSpans = ilbmUnnaturalStippleFS;
+ break;
+ }
+ } /* end of new_fill */
+}
+
+void
+ilbmDestroyGC(pGC)
+ GCPtr pGC;
+{
+ if (pGC->pRotatedPixmap)
+ (*pGC->pScreen->DestroyPixmap)(pGC->pRotatedPixmap);
+ if (pGC->freeCompClip)
+ REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
+ miDestroyGCOps(pGC->ops);
+}
+
+/* table to map alu(src, dst) to alu(~src, dst) */
+int ilbmInverseAlu[16] = {
+ GXclear,
+ GXandInverted,
+ GXnor,
+ GXcopyInverted,
+ GXand,
+ GXnoop,
+ GXequiv,
+ GXorInverted,
+ GXandReverse,
+ GXxor,
+ GXinvert,
+ GXnand,
+ GXcopy,
+ GXor,
+ GXorReverse,
+ GXset
+};
+
+void
+ilbmReduceOpaqueStipple(fg, bg, planemask, depth, rop)
+register PixelType fg;
+register PixelType bg;
+register unsigned long planemask;
+int depth;
+register unsigned char *rop;
+{
+ register int d;
+ register Pixel mask = 1;
+
+ bg ^= fg;
+
+ for (d = 0; d < depth; d++, mask <<= 1) {
+ if (!(planemask & mask))
+ rop[d] = RROP_NOP;
+ else if (!(bg & mask)) {
+ /* Both fg and bg have a 0 or 1 in this plane */
+ if (fg & mask)
+ rop[d] = RROP_WHITE;
+ else
+ rop[d] = RROP_BLACK;
+ } else {
+ /* Both fg and bg have different bits on this plane */
+ if (fg & mask)
+ rop[d] = RROP_COPY;
+ else
+ rop[d] = RROP_INVERT;
+ }
+ }
+}
+
+void
+ilbmReduceRop(alu, src, planemask, depth, rop)
+ register int alu;
+ register Pixel src;
+ register unsigned long planemask;
+ int depth;
+ register unsigned char *rop;
+{
+ register int d;
+ register Pixel mask = 1;
+
+ for (d = 0; d < depth; d++, mask <<= 1) {
+ if (!(planemask & mask))
+ rop[d] = RROP_NOP;
+ else if ((src & mask) == 0) /* src is black */
+ switch (alu) {
+ case GXclear:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXand:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXandReverse:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXcopy:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXandInverted:
+ rop[d] = RROP_NOP;
+ break;
+ case GXnoop:
+ rop[d] = RROP_NOP;
+ break;
+ case GXxor:
+ rop[d] = RROP_NOP;
+ break;
+ case GXor:
+ rop[d] = RROP_NOP;
+ break;
+ case GXnor:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXequiv:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXinvert:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXorReverse:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXcopyInverted:
+ rop[d] = RROP_WHITE;
+ break;
+ case GXorInverted:
+ rop[d] = RROP_WHITE;
+ break;
+ case GXnand:
+ rop[d] = RROP_WHITE;
+ break;
+ case GXset:
+ rop[d] = RROP_WHITE;
+ break;
+ }
+ else /* src is white */
+ switch (alu) {
+ case GXclear:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXand:
+ rop[d] = RROP_NOP;
+ break;
+ case GXandReverse:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXcopy:
+ rop[d] = RROP_WHITE;
+ break;
+ case GXandInverted:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXnoop:
+ rop[d] = RROP_NOP;
+ break;
+ case GXxor:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXor:
+ rop[d] = RROP_WHITE;
+ break;
+ case GXnor:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXequiv:
+ rop[d] = RROP_NOP;
+ break;
+ case GXinvert:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXorReverse:
+ rop[d] = RROP_WHITE;
+ break;
+ case GXcopyInverted:
+ rop[d] = RROP_BLACK;
+ break;
+ case GXorInverted:
+ rop[d] = RROP_NOP;
+ break;
+ case GXnand:
+ rop[d] = RROP_INVERT;
+ break;
+ case GXset:
+ rop[d] = RROP_WHITE;
+ break;
+ }
+ }
+}
+
+void
+ilbmComputeCompositeClip(pGC, pDrawable)
+ GCPtr pGC;
+ DrawablePtr pDrawable;
+{
+ ScreenPtr pScreen = pGC->pScreen;
+
+ if (pDrawable->type == DRAWABLE_WINDOW) {
+ WindowPtr pWin = (WindowPtr) pDrawable;
+ RegionPtr pregWin;
+ Bool freeTmpClip, freeCompClip;
+
+ if (pGC->subWindowMode == IncludeInferiors) {
+ pregWin = NotClippedByChildren(pWin);
+ freeTmpClip = TRUE;
+ } else {
+ pregWin = &pWin->clipList;
+ freeTmpClip = FALSE;
+ }
+ freeCompClip = pGC->freeCompClip;
+
+ /*
+ * if there is no client clip, we can get by with just keeping the
+ * pointer we got, and remembering whether or not should destroy (or
+ * maybe re-use) it later. this way, we avoid unnecessary copying of
+ * regions. (this wins especially if many clients clip by children
+ * and have no client clip.)
+ */
+ if (pGC->clientClipType == CT_NONE) {
+ if (freeCompClip)
+ REGION_DESTROY(pScreen, pGC->pCompositeClip);
+ pGC->pCompositeClip = pregWin;
+ pGC->freeCompClip = freeTmpClip;
+ } else {
+ /*
+ * we need one 'real' region to put into the composite clip. if
+ * pregWin the current composite clip are real, we can get rid of
+ * one. if pregWin is real and the current composite clip isn't,
+ * use pregWin for the composite clip. if the current composite
+ * clip is real and pregWin isn't, use the current composite
+ * clip. if neither is real, create a new region.
+ */
+
+ REGION_TRANSLATE(pScreen, pGC->clientClip,
+ pDrawable->x + pGC->clipOrg.x,
+ pDrawable->y + pGC->clipOrg.y);
+
+ if (freeCompClip) {
+ REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip, pregWin,
+ pGC->clientClip);
+ if (freeTmpClip)
+ REGION_DESTROY(pScreen, pregWin);
+ } else if (freeTmpClip) {
+ REGION_INTERSECT(pScreen, pregWin, pregWin, pGC->clientClip);
+ pGC->pCompositeClip = pregWin;
+ } else {
+ pGC->pCompositeClip = REGION_CREATE(pScreen, NullBox, 0);
+ REGION_INTERSECT(pScreen, pGC->pCompositeClip,
+ pregWin, pGC->clientClip);
+ }
+ pGC->freeCompClip = TRUE;
+ REGION_TRANSLATE(pScreen, pGC->clientClip,
+ -(pDrawable->x + pGC->clipOrg.x),
+ -(pDrawable->y + pGC->clipOrg.y));
+ }
+ } /* end of composite clip for a window */
+ else {
+ BoxRec pixbounds;
+
+ /* XXX should we translate by drawable.x/y here ? */
+ pixbounds.x1 = 0;
+ pixbounds.y1 = 0;
+ pixbounds.x2 = pDrawable->width;
+ pixbounds.y2 = pDrawable->height;
+
+ if (pGC->freeCompClip) {
+ REGION_RESET(pScreen, pGC->pCompositeClip, &pixbounds);
+ } else {
+ pGC->freeCompClip = TRUE;
+ pGC->pCompositeClip = REGION_CREATE(pScreen, &pixbounds, 1);
+ }
+
+ if (pGC->clientClipType == CT_REGION) {
+ REGION_TRANSLATE(pScreen, pGC->pCompositeClip, -pGC->clipOrg.x,
+ -pGC->clipOrg.y);
+ REGION_INTERSECT(pScreen, pGC->pCompositeClip,
+ pGC->pCompositeClip, pGC->clientClip);
+ REGION_TRANSLATE(pScreen, pGC->pCompositeClip, pGC->clipOrg.x,
+ pGC->clipOrg.y);
+ }
+ } /* end of composite clip for pixmap */
+} /* end ilbmComputeCompositeClip */
diff --git a/ilbm/ilbmgetsp.c b/ilbm/ilbmgetsp.c
new file mode 100644
index 000000000..727bafd39
--- /dev/null
+++ b/ilbm/ilbmgetsp.c
@@ -0,0 +1,166 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmgetsp.c,v 3.0 1996/08/18 01:53:54 dawes Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmgetsp.c,v 5.10 94/04/17 20:28:24 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+
+#include "misc.h"
+#include "region.h"
+#include "gc.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+#include "servermd.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.
+ */
+/*ARGSUSED*/
+void
+ilbmGetSpans(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 */
+{
+ PixelType *pdstStart = (PixelType *)pchardstStart;
+ register PixelType *pdst; /* where to put the bits */
+ register PixelType *psrc; /* where to get the bits */
+ register PixelType tmpSrc; /* scratch buffer for bits */
+ PixelType *psrcBase; /* start of src bitmap */
+ int widthSrc; /* width of pixmap in bytes */
+ int auxSrc;
+ int depthSrc;
+ register DDXPointPtr pptLast; /* one past last point to get */
+ int xEnd; /* last pixel to copy from */
+ register int nstart;
+ register int d;
+ int nend;
+ int srcStartOver;
+ PixelType startmask, endmask;
+ unsigned int srcBit;
+ int nlMiddle, nl;
+ int w;
+
+ pptLast = ppt + nspans;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, widthSrc, auxSrc, depthSrc,
+ psrcBase);
+ pdst = pdstStart;
+
+ while (ppt < pptLast) {
+ /* XXX should this really be << PWSH, or * 8, or * PGSZB? */
+ xEnd = min(ppt->x + *pwidth, widthSrc << PWSH);
+ pwidth++;
+ for (d = 0; d < depthSrc; d++) {
+ psrc = ilbmScanline(psrcBase, ppt->x, ppt->y, auxSrc);
+ psrcBase += widthSrc; /* @@@ NEXT PLANE @@@ */
+ w = xEnd - ppt->x;
+ srcBit = ppt->x & PIM;
+
+ if (srcBit + w <= PPW)
+ {
+ getandputbits0(psrc, srcBit, w, pdst);
+ pdst++;
+ }
+ else
+ {
+
+ maskbits(ppt->x, w, startmask, endmask, nlMiddle);
+ if (startmask)
+ nstart = PPW - srcBit;
+ else
+ nstart = 0;
+ if (endmask)
+ nend = xEnd & PIM;
+ srcStartOver = srcBit + nstart > PLST;
+ if (startmask)
+ {
+ getandputbits0(psrc, srcBit, nstart, pdst);
+ if (srcStartOver)
+ psrc++;
+ }
+ nl = nlMiddle;
+#ifdef FASTPUTBITS
+ Duff(nl, putbits(*psrc, nstart, PPW, pdst); psrc++; pdst++;);
+#else
+ while (nl--)
+ {
+ tmpSrc = *psrc;
+ putbits(tmpSrc, nstart, PPW, pdst);
+ psrc++;
+ pdst++;
+ }
+#endif
+ if (endmask)
+ {
+ putbits(*psrc, nstart, nend, pdst);
+ if (nstart + nend > PPW)
+ pdst++;
+ }
+ if (startmask || endmask)
+ pdst++;
+ }
+ }
+ ppt++;
+ }
+}
diff --git a/ilbm/ilbmhrzvert.c b/ilbm/ilbmhrzvert.c
new file mode 100644
index 000000000..fe2638167
--- /dev/null
+++ b/ilbm/ilbmhrzvert.c
@@ -0,0 +1,209 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmhrzvert.c,v 3.0 1996/08/18 01:53:55 dawes Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmhrzvert.c,v 1.15 94/04/17 20:28:24 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+
+#include "gc.h"
+#include "window.h"
+#include "pixmap.h"
+#include "region.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+/* horizontal solid line
+ abs(len) > 1
+*/
+ilbmHorzS(pbase, nlwidth, auxDst, depthDst, x1, y1, len, rrops)
+PixelType *pbase; /* pointer to base of bitmap */
+register int nlwidth; /* width in longwords of bitmap */
+int auxDst;
+int depthDst;
+int x1; /* initial point */
+int y1;
+int len; /* length of line */
+register unsigned char *rrops;
+{
+ register PixelType *addrl;
+ register PixelType startmask;
+ register PixelType endmask;
+ register int nlmiddle;
+ register int d;
+ int saveNLmiddle;
+
+ /* force the line to go left to right
+ but don't draw the last point
+ */
+ if (len < 0) {
+ x1 += len;
+ x1 += 1;
+ len = -len;
+ }
+
+ /* all bits inside same longword */
+ if ( ((x1 & PIM) + len) < PPW) {
+ maskpartialbits(x1, len, startmask);
+
+ for (d = 0; d < depthDst; d++) {
+ addrl = ilbmScanline(pbase, x1, y1, auxDst);
+ pbase += nlwidth; /* @@@ NEXT PLANE @@@ */
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ *addrl &= ~startmask;
+ break;
+ case RROP_WHITE:
+ *addrl |= startmask;
+ break;
+ case RROP_INVERT:
+ *addrl ^= startmask;
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ...) */
+ } else {
+ maskbits(x1, len, startmask, endmask, nlmiddle);
+ saveNLmiddle = nlmiddle;
+
+ for (d = 0; d < depthDst; d++) {
+ addrl = ilbmScanline(pbase, x1, y1, auxDst);
+ pbase += nlwidth; /* @@@ NEXT PLANE @@@ */
+ nlmiddle = saveNLmiddle;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ if (startmask)
+ *addrl++ &= ~startmask;
+ Duff (nlmiddle, *addrl++ = 0x0);
+ if (endmask)
+ *addrl &= ~endmask;
+ break;
+
+ case RROP_WHITE:
+ if (startmask)
+ *addrl++ |= startmask;
+ Duff (nlmiddle, *addrl++ = ~0);
+ if (endmask)
+ *addrl |= endmask;
+ break;
+
+ case RROP_INVERT:
+ if (startmask)
+ *addrl++ ^= startmask;
+ Duff (nlmiddle, *addrl++ ^= ~0);
+ if (endmask)
+ *addrl ^= endmask;
+ break;
+
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ... ) */
+ }
+}
+
+/* vertical solid line
+ this uses do loops because pcc (Ultrix 1.2, bsd 4.2) generates
+ better code. sigh. we know that len will never be 0 or 1, so
+ it's OK to use it.
+*/
+
+ilbmVertS(pbase, nlwidth, auxDst, depthDst, x1, y1, len, rrops)
+PixelType *pbase; /* pointer to base of bitmap */
+register int nlwidth; /* width in longwords of bitmap */
+int auxDst;
+int depthDst;
+int x1, y1; /* initial point */
+register int len; /* length of line */
+unsigned char *rrops;
+{
+ register PixelType *addrl;
+ register PixelType bitmask;
+ int saveLen;
+ int d;
+
+ if (len < 0) {
+ auxDst = -auxDst;
+ len = -len;
+ }
+
+ saveLen = len;
+
+ for (d = 0; d < depthDst; d++) {
+ addrl = ilbmScanline(pbase, x1, y1, auxDst);
+ pbase += nlwidth; /* @@@ NEXT PLANE @@@ */
+ len = saveLen;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ bitmask = rmask[x1 & PIM];
+ Duff(len, *addrl &= bitmask; ilbmScanlineInc(addrl, auxDst) );
+ break;
+
+ case RROP_WHITE:
+ bitmask = mask[x1 & PIM];
+ Duff(len, *addrl |= bitmask; ilbmScanlineInc(addrl, auxDst) );
+ break;
+
+ case RROP_INVERT:
+ bitmask = mask[x1 & PIM];
+ Duff(len, *addrl ^= bitmask; ilbmScanlineInc(addrl, auxDst) );
+ break;
+
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ...) */
+}
diff --git a/ilbm/ilbmimage.c b/ilbm/ilbmimage.c
new file mode 100644
index 000000000..d2f7a4df9
--- /dev/null
+++ b/ilbm/ilbmimage.c
@@ -0,0 +1,437 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmimage.c,v 3.1 1998/03/20 21:08:02 hohndel Exp $ */
+#include <stdio.h>
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "gcstruct.h"
+#include "ilbm.h"
+#include "maskbits.h"
+#include "servermd.h"
+
+void
+ilbmPutImage(pDraw, pGC, depth, x, y, width, height, leftPad, format, pImage)
+ DrawablePtr pDraw;
+ GCPtr pGC;
+ int depth, x, y, width, height;
+ int leftPad;
+ int format;
+ char *pImage;
+{
+ PixmapPtr pPixmap;
+
+#if 1
+ fprintf(stderr, "ilbmPutImage()\n");
+ fprintf(stderr, "\tdepth = %d, x = %d, y = %d, width = %d, height = %d, "
+ "leftPad = %d\n", depth, x, y, width, height, leftPad);
+ switch (format) {
+ case XYBitmap:
+ fprintf(stderr, "\tformat = XYBitmap\n");
+ break;
+ case XYPixmap:
+ fprintf(stderr, "\tformat = XYPixmap\n");
+ break;
+ case ZPixmap:
+ fprintf(stderr, "\tformat = ZPixmap\n");
+ break;
+ default:
+ fprintf(stderr, "\tformat = %d\n");
+ break;
+ }
+#endif
+
+ if ((width == 0) || (height == 0))
+ return;
+
+ if (format != ZPixmap || depth == 1 || pDraw->depth == 1) {
+ if (format == XYBitmap) {
+ char *ptmp;
+ int realwidth;
+ int size;
+ int aux;
+ int d, yy, xx;
+ char *ss, *dd;
+
+ realwidth = BitmapBytePad(width+leftPad);
+ aux = depth*realwidth;
+ size = height*aux;
+
+#if 1
+ fprintf(stderr, "\trealwidth = %d, aux = %d, size = %d\n", realwidth,
+ aux, size);
+#endif
+
+ if (!(ptmp = (char *)ALLOCATE_LOCAL(size)))
+ return;
+
+ /*
+ * Convert from bitplanes to interleaved bitplanes
+ */
+
+ ss = (char *)pImage;
+ for (d = 0; d < depth; d++) {
+ dd = ptmp+d*realwidth;
+ for (yy = 0; yy < height; yy++) {
+ for (xx = 0; xx < realwidth; xx++)
+#if 1
+ {
+ fprintf(stderr, "*(%d) = *(%d)\n", (&dd[xx])-ptmp,
+ ss-(char *)pImage);
+#endif
+ dd[xx] = *(ss++);
+#if 1
+ }
+#endif
+ dd += aux;
+ }
+ }
+
+ pPixmap = GetScratchPixmapHeader(pDraw->pScreen, width+leftPad, height,
+ depth, depth,
+ BitmapBytePad(width+leftPad),
+ (pointer)ptmp);
+ if (!pPixmap) {
+ DEALLOCATE_LOCAL(ptmp);
+ return;
+ }
+ pGC->fExpose = FALSE;
+ (void)(*pGC->ops->CopyPlane)((DrawablePtr)pPixmap, pDraw, pGC, leftPad,
+ 0, width, height, x, y, 1);
+ DEALLOCATE_LOCAL(ptmp);
+ } else {
+#if 0
+ /* XXX: bit plane order wronge ! */
+ pPixmap->drawable.depth = 1;
+ pPixmap->drawable.bitsPerPixel = 1;
+
+ switch (pGC->alu) {
+ case GXcopy:
+ doBitBlt = ilbmDoBitbltCopy;
+ break;
+ case GXxor:
+ doBitBlt = ilbmDoBitbltXor;
+ break;
+ case GXcopyInverted:
+ doBitBlt = ilbmDoBitbltCopyInverted;
+ break;
+ case GXor:
+ doBitBlt = ilbmDoBitbltOr;
+ break;
+ default:
+ doBitBlt = ilbmDoBitbltGeneral;
+ break;
+ }
+
+ for (plane = (1L << (pPixmap->drawable.depth - 1)); plane;
+ plane >>= 1) {
+ (void)ilbmBitBlt((DrawablePtr)pPixmap, pDraw, pGC, leftPad, 0,
+ width, height, x, y, doBitBlt, plane);
+ /* pDraw->devKind += sizeDst; */
+ }
+#else
+ char *ptmp;
+ int realwidth;
+ int size;
+ int aux;
+ int d, yy, xx;
+ char *ss, *dd;
+
+ realwidth = BitmapBytePad(width+leftPad);
+ aux = depth*realwidth;
+ size = height*aux;
+
+#if 1
+ fprintf(stderr, "\trealwidth = %d, aux = %d, size = %d\n", realwidth,
+ aux, size);
+#endif
+
+ if (!(ptmp = (char *)ALLOCATE_LOCAL(size)))
+ return;
+
+ /*
+ * Convert from bitplanes to interleaved bitplanes
+ */
+
+ ss = (char *)pImage;
+ for (d = 0; d < depth; d++) {
+ dd = ptmp+d*realwidth;
+ for (yy = 0; yy < height; yy++) {
+ for (xx = 0; xx < realwidth; xx++)
+#if 1
+ {
+ fprintf(stderr, "*(%d) = *(%d)\n", (&dd[xx])-ptmp,
+ ss-(char *)pImage);
+#endif
+ dd[xx] = *(ss++);
+#if 1
+ }
+#endif
+ dd += aux;
+ }
+ }
+
+ pPixmap = GetScratchPixmapHeader(pDraw->pScreen, width+leftPad, height,
+ depth, depth,
+ BitmapBytePad(width+leftPad),
+ (pointer)ptmp);
+ if (!pPixmap) {
+ DEALLOCATE_LOCAL(ptmp);
+ return;
+ }
+
+ pGC->fExpose = FALSE;
+ (void)(*pGC->ops->CopyArea)((DrawablePtr)pPixmap, pDraw, pGC, leftPad,
+ 0, width, height, x, y);
+ DEALLOCATE_LOCAL(ptmp);
+#endif
+ }
+
+ pGC->fExpose = TRUE;
+ FreeScratchPixmapHeader(pPixmap);
+ } else {
+ /* Chunky to planar conversion required */
+
+ PixmapPtr pPixmap;
+ ScreenPtr pScreen = pDraw->pScreen;
+ int widthSrc;
+ int start_srcshift;
+ register int b;
+ register int dstshift;
+ register int shift_step;
+ register PixelType dst;
+ register PixelType srcbits;
+ register PixelType *pdst;
+ register PixelType *psrc;
+ int start_bit;
+ register int nl;
+ register int h;
+ register int d;
+ int auxDst;
+ PixelType *pdstBase;
+ int widthDst;
+ int depthDst;
+
+ /* Create a tmp pixmap */
+ pPixmap = (pScreen->CreatePixmap)(pScreen, width, height, depth);
+ if (!pPixmap)
+ return;
+
+ ilbmGetPixelWidthAuxDepthAndPointer((DrawablePtr)pPixmap, widthDst,
+ auxDst, depthDst, pdstBase);
+
+ widthSrc = PixmapWidthInPadUnits(width, depth);
+ /* XXX: if depth == 8, use fast chunky to planar assembly function.*/
+ if (depth > 4) {
+ start_srcshift = 24;
+ shift_step = 8;
+ } else {
+ start_srcshift = 28;
+ shift_step = 4;
+ }
+
+ for (d = 0; d < depth; d++, pdstBase += widthDst) { /* @@@ NEXT PLANE @@@ */
+ register PixelType *pdstLine = pdstBase;
+ start_bit = start_srcshift + d;
+ psrc = (PixelType *)pImage;
+ h = height;
+
+ while (h--) {
+ pdst = pdstLine;
+ pdstLine += auxDst;
+ dstshift = PPW - 1;
+ dst = 0;
+ nl = widthSrc;
+ while (nl--) {
+ srcbits = *psrc++;
+ for (b = start_bit; b >= 0; b -= shift_step) {
+ dst |= ((srcbits >> b) & 1) << dstshift;
+ if (--dstshift < 0) {
+ dstshift = PPW - 1;
+ *pdst++ = dst;
+ dst = 0;
+ }
+ }
+ }
+ if (dstshift != PPW - 1)
+ *pdst++ = dst;
+ }
+ } /* for (d = ...) */
+
+ pGC->fExpose = FALSE;
+ (void)(*pGC->ops->CopyArea)((DrawablePtr)pPixmap, pDraw, pGC, leftPad, 0,
+ width, height, x, y);
+ pGC->fExpose = TRUE;
+ (*pScreen->DestroyPixmap)(pPixmap);
+ }
+}
+
+void
+ilbmGetImage(pDrawable, sx, sy, width, height, format, planemask, pdstLine)
+ DrawablePtr pDrawable;
+ int sx, sy, width, height;
+ unsigned int format;
+ unsigned long planemask;
+ char *pdstLine;
+{
+ BoxRec box;
+ DDXPointRec ptSrc;
+ RegionRec rgnDst;
+ ScreenPtr pScreen;
+ PixmapPtr pPixmap;
+
+#if 1
+ fprintf(stderr, "ilbmGetImage()\n");
+ fprintf(stderr, "\tsx = %d, sy = %d, width = %d, height = %d, "
+ "planemask = 0x%08x\n", sx, sy, width, height, planemask);
+ switch (format) {
+ case XYBitmap:
+ fprintf(stderr, "\tformat = XYBitmap\n");
+ break;
+ case XYPixmap:
+ fprintf(stderr, "\tformat = XYPixmap\n");
+ break;
+ case ZPixmap:
+ fprintf(stderr, "\tformat = ZPixmap\n");
+ break;
+ default:
+ fprintf(stderr, "\tformat = %d\n");
+ break;
+ }
+#endif
+
+ if ((width == 0) || (height == 0))
+ return;
+
+ pScreen = pDrawable->pScreen;
+ sx += pDrawable->x;
+ sy += pDrawable->y;
+
+ if (format == XYPixmap || pDrawable->depth == 1) {
+ pPixmap = GetScratchPixmapHeader(pScreen, width, height, 1, 1,
+ BitmapBytePad(width), (pointer)pdstLine);
+ if (!pPixmap)
+ return;
+
+ ptSrc.x = sx;
+ ptSrc.y = sy;
+ box.x1 = 0;
+ box.y1 = 0;
+ box.x2 = width;
+ box.y2 = height;
+ REGION_INIT(pScreen, &rgnDst, &box, 1);
+
+ pPixmap->drawable.depth = 1;
+ pPixmap->drawable.bitsPerPixel = 1;
+ /* dix layer only ever calls GetImage with 1 bit set in planemask
+ * when format is XYPixmap.
+ */
+ ilbmDoBitblt(pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst, &ptSrc,
+ planemask);
+
+ FreeScratchPixmapHeader(pPixmap);
+ REGION_UNINIT(pScreen, &rgnDst);
+ } else {
+ /* Planar to chunky conversion required */
+
+ PixelType *psrcBits;
+ PixelType *psrcLine;
+ PixelType startmask, endmask;
+ int depthSrc;
+ int widthSrc;
+ int auxSrc;
+ int sizeDst;
+ int widthDst;
+ register PixelType *psrc;
+ register PixelType *pdst;
+ register PixelType dst;
+ register PixelType srcbits;
+ register int d;
+ register int b;
+ register int dstshift;
+ register int shift_step;
+ register int start_endbit;
+ int start_startbit;
+ register int end_endbit;
+ register int start_dstshift;
+ register int nl;
+ register int h;
+ int nlmiddle;
+
+ widthDst = PixmapWidthInPadUnits(width, pDrawable->depth);
+ sizeDst = widthDst * height;
+
+ /* Clear the dest image */
+ bzero(pdstLine, sizeDst << 2);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, widthSrc, auxSrc,
+ depthSrc, psrcBits);
+
+ psrcBits = ilbmScanline(psrcBits, sx, sy, auxSrc);
+
+ start_startbit = PPW - 1 - (sx & PIM);
+ if ((sx & PIM) + width < PPW) {
+ maskpartialbits(sx, width, startmask);
+ nlmiddle = 0;
+ endmask = 0;
+ start_endbit = PPW - ((sx + width) & PIM);
+ } else {
+ maskbits(sx, width, startmask, endmask, nlmiddle);
+ start_endbit = 0;
+ end_endbit = PPW - ((sx + width) & PIM);
+ }
+ /* ZPixmap images have either 4 or 8 bits per pixel dependent on
+ * depth.
+ */
+ if (depthSrc > 4) {
+ start_dstshift = 24;
+ shift_step = 8;
+ } else {
+ start_dstshift = 28;
+ shift_step = 4;
+ }
+#define SHIFT_BITS(start_bit,end_bit) \
+for (b = (start_bit); b >= (end_bit); b--) { \
+ dst |= ((srcbits >> b) & 1) << dstshift; \
+ if ((dstshift -= shift_step) < 0) { \
+ dstshift = start_dstshift + d; \
+ *pdst++ = dst; \
+ dst = *pdst; \
+ } \
+} \
+
+ for (d = 0; d < depthSrc; d++, psrcBits += widthSrc) { /* @@@ NEXT PLANE @@@ */
+ psrcLine = psrcBits;
+ pdst = (PixelType *)pdstLine;
+ h = height;
+
+ while (h--) {
+ psrc = psrcLine;
+ psrcLine += auxSrc;
+ dst = *pdst;
+ dstshift = start_dstshift + d;
+
+ if (startmask) {
+ srcbits = *psrc++ & startmask;
+ SHIFT_BITS(start_startbit, start_endbit);
+ }
+
+ nl = nlmiddle;
+ while (nl--) {
+ srcbits = *psrc++;
+ SHIFT_BITS(PPW - 1, 0);
+ }
+ if (endmask) {
+ srcbits = *psrc & endmask;
+ SHIFT_BITS(PPW - 1, end_endbit);
+ }
+
+ if (dstshift != start_dstshift + d)
+ *pdst++ = dst;
+ } /* while (h--) */
+ } /* for (d = ...) */
+ }
+}
diff --git a/ilbm/ilbmimggblt.c b/ilbm/ilbmimggblt.c
new file mode 100644
index 000000000..1bd6f02f9
--- /dev/null
+++ b/ilbm/ilbmimggblt.c
@@ -0,0 +1,470 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmimggblt.c,v 3.1 1998/03/20 21:08:02 hohndel Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmimggblt.c,v 5.17 94/04/17 20:28:25 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ilbm.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "maskbits.h"
+
+/*
+ we should eventually special-case fixed-width fonts for ImageText.
+
+ this works for fonts with glyphs <= 32 bits wide.
+
+ the clipping calculations are done for worst-case fonts.
+we make no assumptions about the heights, widths, or bearings
+of the glyphs. if we knew that the glyphs are all the same height,
+we could clip the tops and bottoms per clipping box, rather
+than per character per clipping box. if we knew that the glyphs'
+left and right bearings were wlle-behaved, we could clip a single
+character at the start, output until the last unclipped
+character, and then clip the last one. this is all straightforward
+to determine based on max-bounds and min-bounds from the font.
+ there is some inefficiency introduced in the per-character
+clipping to make what's going on clearer.
+
+ (it is possible, for example, for a font to be defined in which the
+next-to-last character in a font would be clipped out, but the last
+one wouldn't. the code below deals with this.)
+
+ 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.
+
+ the register allocations for startmask and endmask may not
+be the right thing. are there two other deserving candidates?
+xoff, pdst, pglyph, and tmpSrc seem like the right things, though.
+*/
+
+void
+ilbmImageGlyphBlt(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 */
+{
+ ExtentInfoRec info; /* used by QueryGlyphExtents() */
+ BoxRec bbox; /* string's bounding box */
+ xRectangle backrect;/* backing rectangle to paint.
+ in the general case, NOT necessarily
+ the same as the string's bounding box
+ */
+
+ CharInfoPtr pci;
+ int xorg, yorg; /* origin of drawable in bitmap */
+ int widthDst; /* width of dst in longwords */
+
+ /* these keep track of the character origin */
+ PixelType *pdstBase;
+ /* points to longword with character origin */
+ int xchar; /* xorigin of char (mod 32) */
+
+ /* these are used for placing the glyph */
+ register int xoff; /* x offset of left edge of glyph (mod 32) */
+ register PixelType *pdst;
+ /* pointer to current longword in dst */
+
+ register int d;
+ int depthDst;
+ int auxDst;
+ int hSave;
+ int w; /* width of glyph in bits */
+ int h; /* height of glyph */
+ int widthGlyph; /* width of glyph, in bytes */
+ unsigned char rrops[AFB_MAX_DEPTH];
+ register unsigned char *pglyph;
+ /* pointer to current row of glyph */
+ unsigned char *pglyphSave;
+
+ /* used for putting down glyph */
+ register PixelType tmpSrc;
+ /* for getting bits from glyph */
+ register PixelType startmask;
+ register PixelType endmask;
+
+ register int nFirst;/* bits of glyph in current longword */
+ PixelType *pdstSave;
+ int oldFill;
+ ilbmPrivGC *pPriv = (ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr);
+
+ xorg = pDrawable->x;
+ yorg = pDrawable->y;
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, widthDst, auxDst, depthDst,
+ pdstBase);
+
+ QueryGlyphExtents(pGC->font, ppci, (unsigned long)nglyph, &info);
+
+ backrect.x = x;
+ backrect.y = y - FONTASCENT(pGC->font);
+ backrect.width = info.overallWidth;
+ backrect.height = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font);
+
+ x += xorg;
+ y += yorg;
+
+ bbox.x1 = x + info.overallLeft;
+ bbox.x2 = x + info.overallRight;
+ bbox.y1 = y - info.overallAscent;
+ bbox.y2 = y + info.overallDescent;
+
+ oldFill = pGC->fillStyle;
+ pGC->fillStyle = FillSolid;
+ ilbmReduceRop (pGC->alu, pGC->bgPixel, pGC->planemask, pGC->depth,
+ pPriv->rrops);
+ ilbmPolyFillRect(pDrawable, pGC, 1, &backrect);
+ pGC->fillStyle = oldFill;
+ ilbmReduceRop (pGC->alu, pGC->fgPixel, pGC->planemask, pGC->depth,
+ pPriv->rrops);
+ ilbmReduceRop (GXcopy, pGC->fgPixel, pGC->planemask, pGC->depth, rrops);
+
+ /* the faint-hearted can open their eyes now */
+
+ switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox)) {
+ case rgnOUT:
+ break;
+ case rgnIN:
+ pdstBase = ilbmScanlineNoBankSwitch(pdstBase, x, y, auxDst);
+ xchar = x & PIM;
+
+ while (nglyph--) {
+ pci = *ppci;
+ pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
+ w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
+ hSave = pci->metrics.ascent + pci->metrics.descent;
+ widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
+ /* start at top scanline of glyph */
+ pdstSave = ilbmScanlineDelta(pdstBase, -pci->metrics.ascent,
+ auxDst);
+
+ /* find correct word in scanline and x offset within it
+ for left edge of glyph
+ */
+ xoff = xchar + pci->metrics.leftSideBearing;
+ if (xoff > PLST) {
+ pdstSave++;
+ xoff &= PIM;
+ } else if (xoff < 0) {
+ xoff += PPW;
+ pdstSave--;
+ }
+
+ for (d = 0; d < depthDst; d++) {
+ h = hSave;
+ pdst = pdstSave;
+ pdstSave += widthDst; /* @@@ NEXT PLANE @@@ */
+ pglyph = pglyphSave;
+
+ if ((xoff + w) <= PPW) {
+ /* glyph all in one longword */
+ maskpartialbits(xoff, w, startmask);
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ }
+ } else {
+ /* glyph crosses longword boundary */
+ maskPPWbits(xoff, w, startmask, endmask);
+ nFirst = PPW - xoff;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
+ *(pdst+1) |= SCRLEFT(tmpSrc, nFirst) & endmask;
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ }
+ } /* glyph crosses longwords boundary */
+ } /* depth loop */
+ /* update character origin */
+ x += pci->metrics.characterWidth;
+ xchar += pci->metrics.characterWidth;
+ if (xchar > PLST) {
+ xchar -= PPW;
+ pdstBase++;
+ } else if (xchar < 0) {
+ xchar += PPW;
+ pdstBase--;
+ }
+ ppci++;
+ } /* while nglyph-- */
+ break;
+ case rgnPART:
+ {
+ ilbmTEXTPOS *ppos;
+ int nbox;
+ BoxPtr pbox;
+ RegionPtr cclip;
+ int xpos; /* x position of char origin */
+ int i;
+ BoxRec clip;
+ int leftEdge, rightEdge;
+ int topEdge, bottomEdge;
+ int glyphRow; /* first row of glyph not wholly
+ clipped out */
+ int glyphCol; /* leftmost visible column of glyph */
+ int getWidth; /* bits to get from glyph */
+
+ if (!(ppos = (ilbmTEXTPOS *)ALLOCATE_LOCAL(nglyph *
+ sizeof(ilbmTEXTPOS))))
+ return;
+
+ pdstBase = ilbmScanlineNoBankSwitch(pdstBase, x, y, auxDst);
+ xpos = x;
+ xchar = xpos & PIM;
+
+ for (i = 0; i < nglyph; i++) {
+ pci = ppci[i];
+
+ ppos[i].xpos = xpos;
+ ppos[i].xchar = xchar;
+ ppos[i].leftEdge = xpos + pci->metrics.leftSideBearing;
+ ppos[i].rightEdge = xpos + pci->metrics.rightSideBearing;
+ ppos[i].topEdge = y - pci->metrics.ascent;
+ ppos[i].bottomEdge = y + pci->metrics.descent;
+ ppos[i].pdstBase = pdstBase;
+ ppos[i].widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
+
+ xpos += pci->metrics.characterWidth;
+ xchar += pci->metrics.characterWidth;
+ if (xchar > PLST) {
+ xchar &= PIM;
+ pdstBase++;
+ } else if (xchar < 0) {
+ xchar += PPW;
+ pdstBase--;
+ }
+ }
+
+ cclip = pGC->pCompositeClip;
+ pbox = REGION_RECTS(cclip);
+ nbox = REGION_NUM_RECTS(cclip);
+
+ /* HACK ALERT
+ since we continue out of the loop below so often, it
+ is easier to increment pbox at the top than at the end.
+ don't try this at home.
+ */
+ pbox--;
+ while (nbox--) {
+ pbox++;
+ clip.x1 = max(bbox.x1, pbox->x1);
+ clip.y1 = max(bbox.y1, pbox->y1);
+ clip.x2 = min(bbox.x2, pbox->x2);
+ clip.y2 = min(bbox.y2, pbox->y2);
+ if ((clip.x2<=clip.x1) || (clip.y2<=clip.y1))
+ continue;
+
+ for (i = 0; i < nglyph; i++) {
+ pci = ppci[i];
+ xchar = ppos[i].xchar;
+
+ /* clip the left and right edges */
+ if (ppos[i].leftEdge < clip.x1)
+ leftEdge = clip.x1;
+ else
+ leftEdge = ppos[i].leftEdge;
+
+ if (ppos[i].rightEdge > clip.x2)
+ rightEdge = clip.x2;
+ else
+ rightEdge = ppos[i].rightEdge;
+
+ w = rightEdge - leftEdge;
+ if (w <= 0)
+ continue;
+
+ /* clip the top and bottom edges */
+ if (ppos[i].topEdge < clip.y1)
+ topEdge = clip.y1;
+ else
+ topEdge = ppos[i].topEdge;
+
+ if (ppos[i].bottomEdge > clip.y2)
+ bottomEdge = clip.y2;
+ else
+ bottomEdge = ppos[i].bottomEdge;
+
+ hSave = bottomEdge - topEdge;
+ if (hSave <= 0)
+ continue;
+
+ glyphRow = (topEdge - y) + pci->metrics.ascent;
+ widthGlyph = ppos[i].widthGlyph;
+ pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
+ pglyphSave += (glyphRow * widthGlyph);
+
+ glyphCol = (leftEdge - ppos[i].xpos) -
+ (pci->metrics.leftSideBearing);
+ getWidth = w + glyphCol;
+
+ pdstSave = ilbmScanlineDelta(ppos[i].pdstBase, -(y-topEdge),
+ auxDst);
+ xoff = xchar + (leftEdge - ppos[i].xpos);
+ if (xoff > PLST) {
+ xoff &= PIM;
+ pdstSave++;
+ } else if (xoff < 0) {
+ xoff += PPW;
+ pdstSave--;
+ }
+
+ for (d = 0; d < depthDst; d++) {
+ h = hSave;
+ pdst = pdstSave;
+ pdstSave += widthDst; /* @@@ NEXT PLANE @@@ */
+ pglyph = pglyphSave;
+
+ if ((xoff + w) <= PPW) {
+ maskpartialbits(xoff, w, startmask);
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ }
+ } else {
+ maskPPWbits(xoff, w, startmask, endmask);
+ nFirst = PPW - xoff;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
+ *(pdst+1) |= SCRLEFT(tmpSrc, nFirst) & endmask;
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ }
+ }
+ } /* depth */
+ } /* for each glyph */
+ } /* while nbox-- */
+ DEALLOCATE_LOCAL(ppos);
+ break;
+ }
+
+ default:
+ break;
+ }
+}
diff --git a/ilbm/ilbmline.c b/ilbm/ilbmline.c
new file mode 100644
index 000000000..d831489c5
--- /dev/null
+++ b/ilbm/ilbmline.c
@@ -0,0 +1,701 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmline.c,v 3.1 1998/03/20 21:08:02 hohndel Exp $ */
+/***********************************************************
+
+Copyright (c) 1987 X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XConsortium: ilbmline.c,v 5.18 94/04/17 20:28:26 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+#include "mistruct.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+#include "miline.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
+ilbmSegmentSS(pDrawable, pGC, nseg, pSeg)
+ DrawablePtr pDrawable;
+ GCPtr pGC;
+ int nseg;
+ register xSegment *pSeg;
+#else
+ilbmLineSS(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 */
+
+ PixelType *addrlBase; /* pointer to start of drawable */
+ PixelType *addrl; /* address of destination pixmap */
+ int nlwidth; /* width in longwords 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 depthDst;
+ int d;
+ int auxDst;
+ unsigned char *rrops;
+
+ /* a bunch of temporaries */
+ register int y1, y2;
+ register int x1, x2;
+ RegionPtr cclip;
+
+ cclip = pGC->pCompositeClip;
+ rrops = ((ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr))->rrops;
+ pboxInit = REGION_RECTS(cclip);
+ nboxInit = REGION_NUM_RECTS(cclip);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ addrlBase);
+
+ 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)
+ ilbmVertS(addrlBase, nlwidth, auxDst, depthDst, x1, y1t,
+ y2t-y1t, rrops); /* @@@ NEXT PLANE PASSED @@@ */
+ }
+ 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)) {
+ int tmp;
+
+ /* 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)
+ ilbmHorzS(addrlBase, nlwidth, auxDst, depthDst, x1t, y1,
+ x2t-x1t, rrops); /* @@@ NEXT PLANE PASSED @@@ */
+ 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
+ ilbmBresS(addrlBase, nlwidth, auxDst, depthDst, signdx, signdy,
+ axis, x1, y1, e, e1, e2, len, rrops); /* @@@ NEXT PLANE PASSED @@@ */
+ 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;
+ ilbmBresS(addrlBase, nlwidth, auxDst, depthDst, signdx,
+ signdy, axis, new_x1, new_y1, err, e1, e2, len,
+ rrops); /* @@@ NEXT PLANE PASSED @@@ */
+ }
+ 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)) {
+ for (d = 0; d < depthDst; d++) {
+ addrl = ilbmScanline(addrlBase, x2, y2, auxDst);
+ addrlBase += nlwidth; /* @@@ NEXT PLANE @@@ */
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ *addrl &= rmask[x2 & PIM];
+ break;
+ case RROP_WHITE:
+ *addrl |= mask[x2 & PIM];
+ break;
+ case RROP_INVERT:
+ *addrl ^= mask[x2 & PIM];
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ...) */
+ break;
+ } else
+ pbox++;
+ }
+ }
+#endif
+}
+
+/*
+ * Draw dashed 1-pixel lines.
+ */
+
+void
+#ifdef POLYSEGMENT
+ilbmSegmentSD(pDrawable, pGC, nseg, pSeg)
+ DrawablePtr pDrawable;
+ register GCPtr pGC;
+ int nseg;
+ register xSegment *pSeg;
+#else
+ilbmLineSD(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 */
+
+ PixelType *addrlBase; /* address of destination pixmap */
+ PixelType *addrl;
+ int nlwidth; /* width in longwords of destination pixmap */
+ int auxDst;
+ int depthDst;
+ 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;
+ unsigned char *rrops;
+ unsigned char bgrrops[AFB_MAX_DEPTH];
+ unsigned char *pDash;
+ int dashOffset;
+ int numInDashList;
+ int dashIndex;
+ int isDoubleDash;
+ int dashIndexTmp, dashOffsetTmp;
+ int unclippedlen;
+ int d;
+
+ cclip = pGC->pCompositeClip;
+ rrops = ((ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr))->rrops;
+ pboxInit = REGION_RECTS(cclip);
+ nboxInit = REGION_NUM_RECTS(cclip);
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ addrlBase);
+
+ /* 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);
+
+ if (isDoubleDash)
+ ilbmReduceRop (pGC->alu, pGC->bgPixel, pGC->planemask, pGC->depth,
+ bgrrops);
+
+ 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;
+ ilbmBresD(&dashIndexTmp, pDash, numInDashList, &dashOffsetTmp,
+ isDoubleDash, addrlBase, nlwidth, auxDst, depthDst,
+ signdx, signdy, axis, x1, y1, e, e1, e2, unclippedlen,
+ rrops, bgrrops); /* @@@ NEXT PLANE PASSED @@@ */
+ break;
+#else
+ ilbmBresD(&dashIndex, pDash, numInDashList, &dashOffset,
+ isDoubleDash, addrlBase, nlwidth, auxDst, depthDst,
+ signdx, signdy, axis, x1, y1, e, e1, e2, unclippedlen,
+ rrops, bgrrops); /* @@@ NEXT PLANE PASSED @@@ */
+ 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;
+
+ 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;
+ ilbmBresD(&dashIndexTmp, pDash, numInDashList, &dashOffsetTmp,
+ isDoubleDash, addrlBase, nlwidth, auxDst, depthDst,
+ signdx, signdy, axis, new_x1, new_y1, err, e1, e2,
+ len, rrops, bgrrops); /* @@@ NEXT PLANE PASSED @@@ */
+ }
+ 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)) {
+ int rop;
+
+ for (d = 0; d < depthDst; d++) {
+ addrl = ilbmScanline(addrlBase, x2, y2, auxDst);
+ addrlBase += nlwidth; /* @@@ NEXT PLANE @@@ */
+
+ rop = rrops[d];
+ if (dashIndex & 1)
+ rop = bgrrops[d];
+
+ switch (rop) {
+ case RROP_BLACK:
+ *addrl &= rmask[x2 & PIM];
+ break;
+ case RROP_WHITE:
+ *addrl |= mask[x2 & PIM];
+ break;
+
+ case RROP_INVERT:
+ *addrl ^= mask[x2 & PIM];
+ break;
+
+ case RROP_NOP:
+ break;
+ }
+ } /* for (d = ...) */
+ break;
+ } else
+ pbox++;
+ }
+ }
+#endif
+}
diff --git a/ilbm/ilbmmisc.c b/ilbm/ilbmmisc.c
new file mode 100644
index 000000000..d85346aca
--- /dev/null
+++ b/ilbm/ilbmmisc.c
@@ -0,0 +1,95 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmmisc.c,v 3.0 1996/08/18 01:53:59 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: ilbmmisc.c,v 5.4 94/04/17 20:28:27 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "misc.h"
+#include "cursor.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+
+/*ARGSUSED*/
+void
+ilbmQueryBestSize(class, pwidth, pheight, pScreen)
+int class;
+unsigned short *pwidth;
+unsigned short *pheight;
+ScreenPtr pScreen;
+{
+ unsigned width, test;
+
+ switch (class) {
+ case CursorShape:
+ if (*pwidth > pScreen->width)
+ *pwidth = pScreen->width;
+ if (*pheight > pScreen->height)
+ *pheight = pScreen->height;
+ break;
+ case TileShape:
+ case StippleShape:
+ width = *pwidth;
+ if (!width) break;
+ /* Return the closes power of two not less than what they gave me */
+ test = 0x80000000;
+ /* Find the highest 1 bit in the width given */
+ while (!(test & width))
+ test >>= 1;
+ /* If their number is greater than that, bump up to the next
+ * power of two */
+ if ((test - 1) & width)
+ test <<= 1;
+ *pwidth = test;
+ /* We don't care what height they use */
+ break;
+ }
+}
diff --git a/ilbm/ilbmpixmap.c b/ilbm/ilbmpixmap.c
new file mode 100644
index 000000000..ab5a33f2a
--- /dev/null
+++ b/ilbm/ilbmpixmap.c
@@ -0,0 +1,289 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmpixmap.c,v 3.0 1996/08/18 01:54:01 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: ilbmpixmap.c,v 5.13 94/04/17 20:28:28 dpw Exp $ */
+
+/* pixmap management
+ written by drewry, september 1986
+
+ on a monchrome device, a pixmap is a bitmap.
+*/
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "Xmd.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "maskbits.h"
+
+#include "ilbm.h"
+#include "mi.h"
+
+#include "servermd.h"
+
+PixmapPtr
+ilbmCreatePixmap(pScreen, width, height, depth)
+ ScreenPtr pScreen;
+ int width;
+ int height;
+ int depth;
+{
+ PixmapPtr pPixmap;
+ int datasize;
+ int paddedWidth;
+
+ paddedWidth = BitmapBytePad(width);
+ datasize = height * paddedWidth * depth;
+ 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 = 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)(pPixmap + 1);
+#endif
+ return(pPixmap);
+}
+
+Bool
+ilbmDestroyPixmap(pPixmap)
+ PixmapPtr pPixmap;
+{
+ if (--pPixmap->refcnt)
+ return(TRUE);
+ xfree(pPixmap);
+ return(TRUE);
+}
+
+
+PixmapPtr
+ilbmCopyPixmap(pSrc)
+ register PixmapPtr pSrc;
+{
+ register PixmapPtr pDst;
+ int size;
+ ScreenPtr pScreen;
+
+ size = pSrc->drawable.height * pSrc->devKind * pSrc->drawable.depth;
+ 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
+ XRotatePixmap 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
+ilbmPadPixmap(pPixmap)
+ PixmapPtr pPixmap;
+{
+ register int width = pPixmap->drawable.width;
+ register int h;
+ register PixelType mask;
+ register PixelType *p;
+ register PixelType bits; /* real pattern bits */
+ register int i;
+ int d;
+ int rep; /* repeat count for pattern */
+
+ if (width >= PPW)
+ return;
+
+ rep = PPW/width;
+ if (rep*width != PPW)
+ return;
+
+ mask = endtab[width];
+
+ p = (PixelType *)(pPixmap->devPrivate.ptr);
+
+ for (d = 0; d < pPixmap->drawable.depth; d++) {
+ for (h = 0; h < pPixmap->drawable.height; h++) {
+ *p &= mask;
+ bits = *p;
+ for (i = 1; i < rep; i++) {
+ bits = SCRRIGHT(bits, width);
+ *p |= bits;
+ }
+ p++;
+ }
+ }
+ pPixmap->drawable.width = PPW;
+}
+
+/* Rotates pixmap pPix by w pixels to the right on the screen. Assumes that
+ * words are PPW bits wide, and that the least significant bit appears on the
+ * left.
+ */
+void
+ilbmXRotatePixmap(pPix, rw)
+ PixmapPtr pPix;
+ register int rw;
+{
+ register PixelType *pw, *pwFinal;
+ register PixelType t;
+
+ if (pPix == NullPixmap)
+ return;
+
+ pw = (PixelType *)pPix->devPrivate.ptr;
+ rw %= (int)pPix->drawable.width;
+ if (rw < 0)
+ rw += (int)pPix->drawable.width;
+ if (pPix->drawable.width == PPW) {
+ pwFinal = pw + pPix->drawable.height * pPix->drawable.depth;
+ while (pw < pwFinal) {
+ t = *pw;
+ *pw++ = SCRRIGHT(t, rw) | (SCRLEFT(t, (PPW-rw)) & endtab[rw]);
+ }
+ } else {
+ /* We no longer do this. Validate doesn't try to rotate odd-size
+ * tiles or stipples. ilbmUnnatural<tile/stipple>FS works directly off
+ * the unrotate tile/stipple in the GC
+ */
+ ErrorF("X internal error: trying to rotate odd-sized pixmap.\n");
+ }
+
+}
+
+/* Rotates pixmap pPix by h lines. Assumes that h is always less than
+ pPix->height
+ works on any width.
+ */
+void
+ilbmYRotatePixmap(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 height;
+ int aux;
+
+ if (pPix == NullPixmap)
+ return;
+ height = (int) pPix->drawable.height;
+ rh %= height;
+ if (rh < 0)
+ rh += height;
+
+ aux = pPix->devKind*pPix->drawable.depth;
+ nbyDown = rh*aux;
+ nbyUp = height*aux-nbyDown;
+
+ if (!(ptmp = (char *)ALLOCATE_LOCAL(nbyUp)))
+ return;
+
+ pbase = (char *)pPix->devPrivate.ptr;
+ 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 rh */
+ DEALLOCATE_LOCAL(ptmp);
+}
+
+void
+ilbmCopyRotatePixmap(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) &&
+ (pdstPix->drawable.depth == psrcPix->drawable.depth)) {
+ memmove((char *)pdstPix->devPrivate.ptr, (char *)psrcPix->devPrivate.ptr,
+ psrcPix->drawable.height * psrcPix->devKind *
+ psrcPix->drawable.depth);
+ pdstPix->drawable.width = psrcPix->drawable.width;
+ pdstPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+ } else {
+ if (pdstPix)
+ /* FIX XBUG 6168 */
+ (*pdstPix->drawable.pScreen->DestroyPixmap)(pdstPix);
+ *ppdstPix = pdstPix = ilbmCopyPixmap(psrcPix);
+ if (!pdstPix)
+ return;
+ }
+ ilbmPadPixmap(pdstPix);
+ if (xrot)
+ ilbmXRotatePixmap(pdstPix, xrot);
+ if (yrot)
+ ilbmYRotatePixmap(pdstPix, yrot);
+}
diff --git a/ilbm/ilbmply1rct.c b/ilbm/ilbmply1rct.c
new file mode 100644
index 000000000..b76a29892
--- /dev/null
+++ b/ilbm/ilbmply1rct.c
@@ -0,0 +1,299 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmply1rct.c,v 3.1 1998/03/20 21:08:03 hohndel Exp $ */
+/*
+ * $XConsortium: ilbmply1rct.c,v 1.9 94/04/17 20:28:28 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 jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+#include "mistruct.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+#if defined(mips) || defined(sparc)
+#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
+
+void
+ilbmFillPolygonSolid (pDrawable, pGC, shape, mode, count, ptsIn)
+ DrawablePtr pDrawable;
+ GCPtr pGC;
+ int shape;
+ int mode;
+ int count;
+ DDXPointPtr ptsIn;
+{
+ ilbmPrivGCPtr devPriv;
+ int nlwidth;
+ PixelType *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;
+ PixelType mask, bits = ~((PixelType)0);
+ int nmiddle;
+ register unsigned char *rrops;
+ register int n;
+ register int d;
+ int auxDst;
+ int depthDst;
+ register PixelType *pdst;
+
+ devPriv = (ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr);
+
+ if (mode == CoordModePrevious || shape != Convex ||
+ REGION_NUM_RECTS(pGC->pCompositeClip) != 1) {
+ miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
+ return;
+ }
+ origin = *((int *) &pDrawable->x);
+ origin -= (origin & 0x8000) << 1;
+ extents = &pGC->pCompositeClip->extents;
+ vertex1 = *((int *) &extents->x1) - origin;
+ vertex2 = *((int *) &extents->x2) - origin - 0x00010001;
+ clip = 0;
+ y = 32767;
+ maxy = 0;
+ vertex2p = (int *) ptsIn;
+ endp = vertex2p + count;
+ 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 (y == maxy)
+ return;
+
+ if (clip & 0x80008000) {
+ miFillPolygon (pDrawable, pGC, shape, mode, vertex2p - (int *) ptsIn, ptsIn);
+ return;
+ }
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ addrl);
+ rrops = devPriv->rrops;
+ addrl = ilbmScanlineDelta(addrl, y + pDrawable->y, auxDst);
+ 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 & PIM;
+ l -= c;
+ l = l >> PWSH;
+ addr = addrl + l;
+ if (c + nmiddle < PPW) {
+ mask = SCRRIGHT (bits,c) ^ SCRRIGHT (bits,c+nmiddle);
+ for (pdst = addr, d = 0; d < depthDst; d++, pdst += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ *pdst &= ~mask;
+ break;
+ case RROP_WHITE:
+ *pdst |= mask;
+ break;
+ case RROP_INVERT:
+ *pdst ^= mask;
+ break;
+ case RROP_NOP:
+ break;
+ }
+ }
+ } else {
+ if (c) {
+ mask = SCRRIGHT(bits, c);
+ for (pdst = addr, d = 0; d < depthDst; d++, pdst += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ *pdst &= ~mask;
+ break;
+ case RROP_WHITE:
+ *pdst |= mask;
+ break;
+ case RROP_INVERT:
+ *pdst ^= mask;
+ break;
+ case RROP_NOP:
+ break;
+ }
+ }
+ nmiddle += c - PPW;
+ addr++;
+ }
+ nmiddle >>= PWSH;
+ mask = ~SCRRIGHT(bits, r & PIM);
+
+ for (d = 0; d < depthDst; d++, addr += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ n = nmiddle;
+ pdst = addr;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ Duff (n, *pdst++ = 0;)
+ if (mask)
+ *pdst &= ~mask;
+ break;
+ case RROP_WHITE:
+ Duff (n, *pdst++ = ~0;);
+ if (mask)
+ *pdst |= mask;
+ break;
+ case RROP_INVERT:
+ Duff (n, *pdst++ ^= ~0;);
+ if (mask)
+ *pdst ^= mask;
+ break;
+ case RROP_NOP:
+ break;
+ }
+ }
+ }
+ if (!--h)
+ break;
+ ilbmScanlineInc(addrl, auxDst);
+ Step(x1,dx1,dy1,e1,sign1,step1)
+ Step(x2,dx2,dy2,e2,sign2,step2)
+ }
+ if (y == maxy)
+ break;
+ ilbmScanlineInc(addrl, auxDst);
+ }
+}
diff --git a/ilbm/ilbmplygblt.c b/ilbm/ilbmplygblt.c
new file mode 100644
index 000000000..a7dca5756
--- /dev/null
+++ b/ilbm/ilbmplygblt.c
@@ -0,0 +1,465 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmplygblt.c,v 3.1 1998/03/20 21:08:03 hohndel Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmimggblt.c,v 5.17 94/04/17 20:28:25 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ilbm.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "maskbits.h"
+
+/*
+ this works for fonts with glyphs <= 32 bits wide.
+
+ the clipping calculations are done for worst-case fonts.
+we make no assumptions about the heights, widths, or bearings
+of the glyphs. if we knew that the glyphs are all the same height,
+we could clip the tops and bottoms per clipping box, rather
+than per character per clipping box. if we knew that the glyphs'
+left and right bearings were wlle-behaved, we could clip a single
+character at the start, output until the last unclipped
+character, and then clip the last one. this is all straightforward
+to determine based on max-bounds and min-bounds from the font.
+ there is some inefficiency introduced in the per-character
+clipping to make what's going on clearer.
+
+ (it is possible, for example, for a font to be defined in which the
+next-to-last character in a font would be clipped out, but the last
+one wouldn't. the code below deals with this.)
+
+*/
+
+void
+ilbmPolyGlyphBlt (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 */
+{
+ ExtentInfoRec info; /* used by QueryGlyphExtents() */
+ BoxRec bbox; /* string's bounding box */
+ xRectangle backrect; /* backing rectangle to paint.
+ in the general case, NOT necessarily
+ the same as the string's bounding box
+ */
+
+ CharInfoPtr pci;
+ int xorg, yorg; /* origin of drawable in bitmap */
+ int widthDst; /* width of dst in longwords */
+
+ /* these keep track of the character origin */
+ PixelType *pdstBase;
+ /* points to longword with character origin */
+ int xchar; /* xorigin of char (mod 32) */
+
+ /* these are used for placing the glyph */
+ register int xoff; /* x offset of left edge of glyph (mod 32) */
+ register PixelType *pdst; /* pointer to current longword in dst */
+
+ register int d;
+ int depthDst;
+ int auxDst;
+ int hSave;
+ int w; /* width of glyph in bits */
+ int h; /* height of glyph */
+ int widthGlyph; /* width of glyph, in bytes */
+ unsigned char *rrops;
+ register unsigned char *pglyph;
+ /* pointer to current row of glyph */
+ unsigned char *pglyphSave;
+
+ /* used for putting down glyph */
+ register PixelType tmpSrc;
+ /* for getting bits from glyph */
+ register PixelType startmask;
+ register PixelType endmask;
+
+ register int nFirst; /* bits of glyph in current longword */
+ PixelType *pdstSave;
+
+ xorg = pDrawable->x;
+ yorg = pDrawable->y;
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, widthDst, auxDst, depthDst,
+ pdstBase);
+
+ QueryGlyphExtents(pGC->font, ppci, (unsigned long)nglyph, &info);
+
+ x += xorg;
+ y += yorg;
+
+ bbox.x1 = x + info.overallLeft;
+ bbox.x2 = x + info.overallRight;
+ bbox.y1 = y - info.overallAscent;
+ bbox.y2 = y + info.overallDescent;
+
+ rrops = ((ilbmPrivGCPtr) pGC->devPrivates[ilbmGCPrivateIndex].ptr)->rrops;
+
+ switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox)) {
+ case rgnOUT:
+ break;
+ case rgnIN:
+ pdstBase = ilbmScanlineNoBankSwitch(pdstBase, x, y, auxDst);
+ xchar = x & PIM;
+
+ while (nglyph--) {
+ pci = *ppci;
+ pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
+ w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
+ hSave = pci->metrics.ascent + pci->metrics.descent;
+ widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
+ /* start at top scanline of glyph */
+ pdstSave = ilbmScanlineDelta(pdstBase, -pci->metrics.ascent,
+ auxDst);
+
+ /* find correct word in scanline and x offset within it
+ for left edge of glyph
+ */
+ xoff = xchar + pci->metrics.leftSideBearing;
+ if (xoff > PLST) {
+ pdstSave++;
+ xoff &= PIM;
+ } else if (xoff < 0) {
+ xoff += PPW;
+ pdstSave--;
+ }
+
+ for (d = 0; d < depthDst; d++) {
+ h = hSave;
+ pdst = pdstSave;
+ pdstSave += widthDst; /* @@@ NEXT PLANE @@@ */
+ pglyph = pglyphSave;
+
+ if ((xoff + w) <= PPW) {
+ /* glyph all in one longword */
+ maskpartialbits(xoff, w, startmask);
+ switch (rrops[d]) {
+ case RROP_WHITE:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_BLACK:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ }
+ } else {
+ /* glyph crosses longword boundary */
+ maskPPWbits(xoff, w, startmask, endmask);
+ nFirst = PPW - xoff;
+ switch (rrops[d]) {
+ case RROP_WHITE:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) |= (SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_BLACK:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ getleftbits(pglyph, w, tmpSrc);
+ *pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) ^= (SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ }
+ } /* glyph crosses longwords boundary */
+ } /* depth loop */
+ /* update character origin */
+ x += pci->metrics.characterWidth;
+ xchar += pci->metrics.characterWidth;
+ if (xchar > PLST) {
+ xchar -= PPW;
+ pdstBase++;
+ } else if (xchar < 0) {
+ xchar += PPW;
+ pdstBase--;
+ }
+ ppci++;
+ } /* while nglyph-- */
+ break;
+ case rgnPART:
+ {
+ ilbmTEXTPOS *ppos;
+ int nbox;
+ BoxPtr pbox;
+ RegionPtr cclip;
+ int xpos; /* x position of char origin */
+ int i;
+ BoxRec clip;
+ int leftEdge, rightEdge;
+ int topEdge, bottomEdge;
+ int glyphRow; /* first row of glyph not wholly
+ clipped out */
+ int glyphCol; /* leftmost visible column of glyph */
+ int getWidth; /* bits to get from glyph */
+
+ if (!(ppos = (ilbmTEXTPOS *)ALLOCATE_LOCAL(nglyph *
+ sizeof(ilbmTEXTPOS))))
+ return;
+
+ pdstBase = ilbmScanlineNoBankSwitch(pdstBase, x, y, auxDst);
+ xpos = x;
+ xchar = xpos & PIM;
+
+ for (i = 0; i < nglyph; i++) {
+ pci = ppci[i];
+
+ ppos[i].xpos = xpos;
+ ppos[i].xchar = xchar;
+ ppos[i].leftEdge = xpos + pci->metrics.leftSideBearing;
+ ppos[i].rightEdge = xpos + pci->metrics.rightSideBearing;
+ ppos[i].topEdge = y - pci->metrics.ascent;
+ ppos[i].bottomEdge = y + pci->metrics.descent;
+ ppos[i].pdstBase = pdstBase;
+ ppos[i].widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
+
+ xpos += pci->metrics.characterWidth;
+ xchar += pci->metrics.characterWidth;
+ if (xchar > PLST) {
+ xchar &= PIM;
+ pdstBase++;
+ } else if (xchar < 0) {
+ xchar += PPW;
+ pdstBase--;
+ }
+ }
+
+ cclip = pGC->pCompositeClip;
+ pbox = REGION_RECTS(cclip);
+ nbox = REGION_NUM_RECTS(cclip);
+
+ /* HACK ALERT
+ since we continue out of the loop below so often, it
+ is easier to increment pbox at the top than at the end.
+ don't try this at home.
+ */
+ pbox--;
+ while (nbox--) {
+ pbox++;
+ clip.x1 = max(bbox.x1, pbox->x1);
+ clip.y1 = max(bbox.y1, pbox->y1);
+ clip.x2 = min(bbox.x2, pbox->x2);
+ clip.y2 = min(bbox.y2, pbox->y2);
+ if ((clip.x2<=clip.x1) || (clip.y2<=clip.y1))
+ continue;
+
+ for (i = 0; i<nglyph; i++) {
+ pci = ppci[i];
+ xchar = ppos[i].xchar;
+
+ /* clip the left and right edges */
+ if (ppos[i].leftEdge < clip.x1)
+ leftEdge = clip.x1;
+ else
+ leftEdge = ppos[i].leftEdge;
+
+ if (ppos[i].rightEdge > clip.x2)
+ rightEdge = clip.x2;
+ else
+ rightEdge = ppos[i].rightEdge;
+
+ w = rightEdge - leftEdge;
+ if (w <= 0)
+ continue;
+
+ /* clip the top and bottom edges */
+ if (ppos[i].topEdge < clip.y1)
+ topEdge = clip.y1;
+ else
+ topEdge = ppos[i].topEdge;
+
+ if (ppos[i].bottomEdge > clip.y2)
+ bottomEdge = clip.y2;
+ else
+ bottomEdge = ppos[i].bottomEdge;
+
+ hSave = bottomEdge - topEdge;
+ if (hSave <= 0)
+ continue;
+
+ glyphRow = (topEdge - y) + pci->metrics.ascent;
+ widthGlyph = ppos[i].widthGlyph;
+ pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
+ pglyphSave += (glyphRow * widthGlyph);
+
+ glyphCol = (leftEdge - ppos[i].xpos) -
+ (pci->metrics.leftSideBearing);
+ getWidth = w + glyphCol;
+
+ pdstSave = ilbmScanlineDelta(ppos[i].pdstBase, -(y-topEdge),
+ auxDst);
+ xoff = xchar + (leftEdge - ppos[i].xpos);
+ if (xoff > PLST) {
+ xoff &= PIM;
+ pdstSave++;
+ } else if (xoff < 0) {
+ xoff += PPW;
+ pdstSave--;
+ }
+
+ for (d = 0; d < depthDst; d++) {
+ h = hSave;
+ pdst = pdstSave;
+ pdstSave += widthDst; /* @@@ NEXT PLANE @@@ */
+ pglyph = pglyphSave;
+
+ if ((xoff + w) <= PPW) {
+ maskpartialbits(xoff, w, startmask);
+ switch (rrops[d]) {
+ case RROP_WHITE:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_BLACK:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ }
+ } else {
+ maskPPWbits(xoff, w, startmask, endmask);
+ nFirst = PPW - xoff;
+ switch (rrops[d]) {
+ case RROP_WHITE:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) |= (SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_BLACK:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
+ *pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
+ *(pdst+1) ^= (SCRLEFT(tmpSrc, nFirst) & endmask);
+ pglyph += widthGlyph;
+ ilbmScanlineInc(pdst, auxDst);
+ }
+ break;
+ }
+ }
+ } /* depth */
+ } /* for each glyph */
+ } /* while nbox-- */
+ DEALLOCATE_LOCAL(ppos);
+ break;
+ }
+
+ default:
+ break;
+ }
+}
diff --git a/ilbm/ilbmpntarea.c b/ilbm/ilbmpntarea.c
new file mode 100644
index 000000000..0199b0bc6
--- /dev/null
+++ b/ilbm/ilbmpntarea.c
@@ -0,0 +1,652 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmpntarea.c,v 3.0 1996/08/18 01:54:04 dawes Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmpntarea.c,v 5.7 94/04/17 20:28:29 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+
+#include "windowstr.h"
+#include "regionstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+/*
+ the solid fillers are called for rectangles and window backgrounds.
+ the boxes are already translated.
+ maybe this should always take a pixmap instead of a drawable?
+
+ NOTE:
+ iy = ++iy < tileHeight ? iy : 0
+is equivalent to iy%= tileheight, and saves a division.
+*/
+
+/*ARGSUSED*/
+void
+ilbmSolidFillArea(pDraw, nbox, pbox, rrops)
+ DrawablePtr pDraw;
+ int nbox;
+ BoxPtr pbox;
+ register unsigned char *rrops;
+{
+ int nlwidth; /* width in longwords of the drawable */
+ int w; /* width of current box */
+ register int h; /* height of current box */
+ register PixelType *p; /* pointer to bits we're writing */
+ register int nlw; /* loop version of nlwMiddle */
+ register PixelType startmask;
+ register PixelType endmask;
+ /* masks for reggedy bits at either end of line */
+ register int nlwExtra; /* to get from right of box to left of next span */
+ int nlwMiddle; /* number of longwords between sides of boxes */
+ PixelType *pbits; /* pointer to start of drawable */
+ PixelType *saveP;
+ int saveH;
+ int depthDst;
+ int auxDst;
+ register int d;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst, pbits);
+
+ while (nbox--) {
+ w = pbox->x2 - pbox->x1;
+ saveH = pbox->y2 - pbox->y1;
+
+ saveP = ilbmScanline(pbits, pbox->x1, pbox->y1, auxDst);
+
+ if ( ((pbox->x1 & PIM) + w) < PPW) {
+ for (d = 0; d < depthDst; d++) {
+ h = saveH;
+ p = saveP;
+ saveP += nlwidth; /* @@@ NEXT PLANE @@@ */
+ maskpartialbits(pbox->x1, w, startmask);
+ nlwExtra = auxDst;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ Duff(h, *p &= ~startmask; ilbmScanlineInc(p, nlwExtra));
+ break;
+ case RROP_WHITE:
+ Duff(h, *p |= startmask; ilbmScanlineInc(p, nlwExtra));
+ break;
+ case RROP_INVERT:
+ Duff(h, *p ^= startmask; ilbmScanlineInc(p, nlwExtra));
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ..) */
+ } else {
+ maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
+
+ for (d = 0; d < depthDst; d++) {
+ h = saveH;
+ p = saveP;
+ saveP += nlwidth; /* @@@ NEXT PLANE @@@ */
+ nlwExtra = auxDst - nlwMiddle;
+
+ if (startmask && endmask) {
+ nlwExtra -= 1;
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ nlw = nlwMiddle;
+ *p &= ~startmask;
+ p++;
+ Duff(nlw, *p++ = 0);
+ *p &= ~endmask;
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ nlw = nlwMiddle;
+ *p |= startmask;
+ p++;
+ Duff(nlw, *p++ = ~0);
+ *p |= endmask;
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ nlw = nlwMiddle;
+ *p ^= startmask;
+ p++;
+ Duff(nlw, *p++ ^= ~0);
+ *p ^= endmask;
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ }
+ } else if (startmask && !endmask) {
+ nlwExtra -= 1;
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ nlw = nlwMiddle;
+ *p &= ~startmask;
+ p++;
+ Duff(nlw, *p++ = 0);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ nlw = nlwMiddle;
+ *p |= startmask;
+ p++;
+ Duff(nlw, *p++ = ~0);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ nlw = nlwMiddle;
+ *p ^= startmask;
+ p++;
+ Duff(nlw, *p++ ^= ~0);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ }
+ } else if (!startmask && endmask) {
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ = 0);
+ *p &= ~endmask;
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ = ~0);
+ *p |= endmask;
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ ^= ~0);
+ *p ^= endmask;
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ case RROP_NOP:
+ break;
+ }
+ } else { /* no ragged bits at either end */
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ = 0);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ = ~0);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ ^= ~0);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ }
+ } /* for (d = 0 ... ) */
+ }
+ pbox++;
+ }
+}
+
+/* stipple a list of boxes -
+
+you can use the reduced rasterop for stipples. if rrop is
+black, AND the destination with (not stipple pattern). if rrop is
+white OR the destination with the stipple pattern. if rrop is invert,
+XOR the destination with the stipple pattern.
+*/
+
+/*ARGSUSED*/
+void
+ilbmStippleAreaPPW(pDraw, nbox, pbox, pstipple, rrops)
+ DrawablePtr pDraw;
+ int nbox;
+ BoxPtr pbox;
+ PixmapPtr pstipple;
+ unsigned char *rrops;
+{
+ register PixelType *psrc; /* pointer to bits in tile, if needed */
+ int tileHeight; /* height of the tile */
+ register PixelType srcpix;
+
+ int nlwidth; /* width in longwords of the drawable */
+ int w; /* width of current box */
+ register int nlw; /* loop version of nlwMiddle */
+ register PixelType *p; /* pointer to bits we're writing */
+ register int h; /* height of current box */
+ PixelType startmask;
+ PixelType endmask; /* masks for reggedy bits at either end of line */
+ int nlwMiddle; /* number of longwords between sides of boxes */
+ int nlwExtra; /* to get from right of box to left of next span */
+ int auxDst;
+ int depthDst;
+ int d;
+ int saveIy;
+ register int iy; /* index of current scanline in tile */
+ PixelType *pbits; /* pointer to start of drawable */
+ PixelType *pBase;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst, pBase);
+
+ tileHeight = pstipple->drawable.height;
+ psrc = (PixelType *)(pstipple->devPrivate.ptr);
+
+ while (nbox--) {
+ w = pbox->x2 - pbox->x1;
+ saveIy = pbox->y1 % tileHeight;
+ pbits = pBase;
+
+ if ( ((pbox->x1 & PIM) + w) < PPW) {
+ maskpartialbits(pbox->x1, w, startmask);
+ nlwExtra = auxDst;
+ for (d = 0; d < depthDst; d++) {
+ p = ilbmScanline(pbits, pbox->x1, pbox->y1, auxDst);
+ pbits += nlwidth; /* @@@ NEXT PLANE @@@ */
+ iy = saveIy;
+ h = pbox->y2 - pbox->y1;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ *p &= ~(srcpix & startmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ *p |= (srcpix & startmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ *p ^= (srcpix & startmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ...) */
+
+ } else {
+ maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
+
+ for (d = 0; d < depthDst; d++) {
+ nlwExtra = auxDst - nlwMiddle;
+ p = ilbmScanline(pbits, pbox->x1, pbox->y1, auxDst);
+ pbits += nlwidth; /* @@@ NEXT PLANE @@@ */
+ iy = saveIy;
+ h = pbox->y2 - pbox->y1;
+
+ if (startmask && endmask) {
+ nlwExtra -= 1;
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ *p &= ~(srcpix & startmask);
+ p++;
+ Duff (nlw, *p++ &= ~srcpix);
+ *p &= ~(srcpix & endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ *p |= (srcpix & startmask);
+ p++;
+ Duff (nlw, *p++ |= srcpix);
+ *p |= (srcpix & endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ *p ^= (srcpix & startmask);
+ p++;
+ Duff (nlw, *p++ ^= srcpix);
+ *p ^= (srcpix & endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } else if (startmask && !endmask) {
+ nlwExtra -= 1;
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ *p &= ~(srcpix & startmask);
+ p++;
+ Duff(nlw, *p++ &= ~srcpix);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ *p |= (srcpix & startmask);
+ p++;
+ Duff(nlw, *p++ |= srcpix);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ *p ^= (srcpix & startmask);
+ p++;
+ Duff(nlw, *p++ ^= srcpix);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } else if (!startmask && endmask) {
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ &= ~srcpix);
+ *p &= ~(srcpix & endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ |= srcpix);
+ *p |= (srcpix & endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ ^= srcpix);
+ *p ^= (srcpix & endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } else { /* no ragged bits at either end */
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ &= ~srcpix);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_WHITE:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ |= srcpix);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ case RROP_INVERT:
+ while (h--) {
+ srcpix = psrc[iy];
+ iy = ++iy < tileHeight ? iy : 0;
+ nlw = nlwMiddle;
+ Duff(nlw, *p++ ^= srcpix);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ break;
+ } /* switch */
+ }
+ } /* for (d = ...) */
+ }
+ pbox++;
+ }
+}
+
+void
+ilbmStippleArea(pDraw, nbox, pbox, pTile, xOff, yOff, rrops)
+ DrawablePtr pDraw;
+ int nbox;
+ BoxPtr pbox;
+ PixmapPtr pTile;
+ int xOff;
+ int yOff;
+ unsigned char *rrops;
+{
+ register PixelType *psrc; /* pointer to bits in tile, if needed */
+ int nlwidth; /* width in longwords of the drawable */
+ register int h; /* height of current box */
+ register PixelType *pdst; /* pointer to bits we're writing */
+ int auxDst;
+ int depthDst;
+ int sizeTile;
+ int tileLine;
+ int iline;
+ int w, width, x, xSrc, ySrc, srcStartOver, nend;
+ int tlwidth, rem, tileWidth, tileHeight, endinc;
+ int saveW;
+ register int rop;
+ PixelType *psrcT;
+ int d;
+ int nstart;
+ PixelType startmask;
+ PixelType endmask; /* masks for reggedy bits at either end of line */
+ int nlMiddle; /* number of longwords between sides of boxes */
+ int iy;
+ PixelType *pBase; /* pointer to start of drawable */
+ PixelType *saveP;
+ PixelType *pStartDst;
+ PixelType *pStartTile;
+ int saveH;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst, pBase);
+
+ tileHeight = pTile->drawable.height;
+ tileWidth = pTile->drawable.width;
+ tlwidth = pTile->devKind/sizeof(PixelType);
+
+ xSrc = pDraw->x + ((xOff % tileWidth) - tileWidth);
+ ySrc = pDraw->y + ((yOff % tileHeight) - tileHeight);
+
+ while (nbox--) {
+ saveW = pbox->x2 - pbox->x1;
+ iline = (pbox->y1 - ySrc) % tileHeight;
+ psrcT = (PixelType *)pTile->devPrivate.ptr;
+ tileLine = iline * tlwidth;
+ saveH = pbox->y2 - pbox->y1;
+ saveP = ilbmScanline(pBase, pbox->x1, pbox->y1, auxDst);
+
+ for (d = 0; d < depthDst; d++, saveP += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ h = saveH;
+ pStartDst = saveP;
+ pStartTile = psrcT + tileLine;
+ iy = iline;
+
+ while (h--) {
+ x = pbox->x1;
+ width = saveW;
+ pdst = pStartDst;
+ rop = rrops[d];
+
+ while (width > 0) {
+ psrc = pStartTile;
+ w = min(tileWidth, width);
+ if ((rem = (x - xSrc) % tileWidth) != 0) {
+ /* if we're in the middle of the tile, get
+ as many bits as will finish the span, or
+ as many as will get to the left edge of the tile,
+ or a longword worth, starting at the appropriate
+ offset in the tile.
+ */
+ w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
+ endinc = rem / BITMAP_SCANLINE_PAD;
+ getandputrrop((psrc + endinc), (rem & PIM), (x & PIM), w,
+ pdst, rop)
+ if ((x & PIM) + w >= PPW)
+ pdst++;
+ } else if (((x & PIM) + w) < PPW) {
+ /* doing < PPW bits is easy, and worth special-casing */
+ putbitsrrop(*psrc, x & PIM, w, pdst, rop);
+ } else {
+ /* start at the left edge of the tile,
+ and put down as much as we can
+ */
+ maskbits(x, w, startmask, endmask, nlMiddle);
+
+ if (startmask)
+ nstart = PPW - (x & PIM);
+ else
+ nstart = 0;
+ if (endmask)
+ nend = (x + w) & PIM;
+ else
+ nend = 0;
+
+ srcStartOver = nstart > PLST;
+
+ if (startmask) {
+ putbitsrrop(*psrc, (x & PIM), nstart, pdst, rop);
+ pdst++;
+ if (srcStartOver)
+ psrc++;
+ }
+
+ while (nlMiddle--) {
+ getandputrrop0(psrc, nstart, PPW, pdst, rop);
+ pdst++;
+ psrc++;
+ }
+
+ if (endmask) {
+ getandputrrop0(psrc, nstart, nend, pdst, rop);
+ }
+ }
+ x += w;
+ width -= w;
+ } /* while (width > 0) */
+
+ pStartDst += auxDst;
+ if (++iy >= tileHeight) {
+ iy = 0;
+ pStartTile = psrcT;
+ } else
+ pStartTile += tlwidth;
+
+ } /* while (h) */
+ } /* for (d = ... ) */
+ pbox++;
+ } /* for each box */
+}
diff --git a/ilbm/ilbmpntwin.c b/ilbm/ilbmpntwin.c
new file mode 100644
index 000000000..5cc29e331
--- /dev/null
+++ b/ilbm/ilbmpntwin.c
@@ -0,0 +1,127 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmpntwin.c,v 3.0 1996/08/18 01:54:05 dawes Exp $ */
+/* $XConsortium: ilbmpntwin.c,v 5.12 94/04/17 20:28:30 dpw Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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 jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+
+#include "windowstr.h"
+#include "regionstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+#include "mi.h"
+
+void
+ilbmPaintWindow(pWin, pRegion, what)
+ WindowPtr pWin;
+ RegionPtr pRegion;
+ int what;
+{
+ register ilbmPrivWin *pPrivWin;
+ unsigned char rrops[AFB_MAX_DEPTH];
+
+ pPrivWin = (ilbmPrivWin *)(pWin->devPrivates[ilbmWindowPrivateIndex].ptr);
+
+ switch (what) {
+ case PW_BACKGROUND:
+ switch (pWin->backgroundState) {
+ case None:
+ return;
+ case ParentRelative:
+ do {
+ pWin = pWin->parent;
+ } while (pWin->backgroundState == ParentRelative);
+ (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
+ what);
+ return;
+ case BackgroundPixmap:
+ if (pPrivWin->fastBackground) {
+ ilbmTileAreaPPWCopy((DrawablePtr)pWin,
+ REGION_NUM_RECTS(pRegion),
+ REGION_RECTS(pRegion), GXcopy,
+ pPrivWin->pRotatedBackground, ~0);
+ return;
+ } else {
+ ilbmTileAreaCopy((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
+ REGION_RECTS(pRegion), GXcopy,
+ pWin->background.pixmap, 0, 0, ~0);
+ return;
+ }
+ break;
+ case BackgroundPixel:
+ ilbmReduceRop(GXcopy, pWin->background.pixel, ~0,
+ pWin->drawable.depth, rrops);
+ ilbmSolidFillArea((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
+ REGION_RECTS(pRegion), rrops);
+ return;
+ }
+ break;
+ case PW_BORDER:
+ if (pWin->borderIsPixel) {
+ ilbmReduceRop(GXcopy, pWin->border.pixel, ~0, pWin->drawable.depth,
+ rrops);
+ ilbmSolidFillArea((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
+ REGION_RECTS(pRegion), rrops);
+ return;
+ } else if (pPrivWin->fastBorder) {
+ ilbmTileAreaPPWCopy((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
+ REGION_RECTS(pRegion), GXcopy,
+ pPrivWin->pRotatedBorder, ~0);
+ return;
+ }
+ break;
+ }
+ miPaintWindow(pWin, pRegion, what);
+}
diff --git a/ilbm/ilbmpolypnt.c b/ilbm/ilbmpolypnt.c
new file mode 100644
index 000000000..f313dc8d1
--- /dev/null
+++ b/ilbm/ilbmpolypnt.c
@@ -0,0 +1,148 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmpolypnt.c,v 3.1 1998/03/20 21:08:03 hohndel Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmpolypnt.c,v 5.6 94/04/17 20:28:30 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xprotostr.h"
+#include "pixmapstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "miscstruct.h"
+#include "regionstr.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+void
+ilbmPolyPoint(pDrawable, pGC, mode, npt, pptInit)
+ register DrawablePtr pDrawable;
+ GCPtr pGC;
+ int mode; /* Origin or Previous */
+ int npt;
+ xPoint *pptInit;
+{
+
+ register BoxPtr pbox;
+ register int nbox;
+ register int d;
+
+ register PixelType *addrl;
+ PixelType *pBase;
+ PixelType *pBaseSave;
+ int nlwidth;
+ int auxDst;
+ int depthDst;
+
+ int nptTmp;
+ register xPoint *ppt;
+
+ register int x;
+ register int y;
+ register unsigned char *rrops;
+ ilbmPrivGC *pGCPriv;
+
+ pGCPriv = (ilbmPrivGC *) pGC->devPrivates[ilbmGCPrivateIndex].ptr;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, nlwidth, auxDst, depthDst,
+ pBaseSave);
+
+ rrops = pGCPriv->rrops;
+ if ((mode == CoordModePrevious) && (npt > 1))
+ for (ppt = pptInit + 1, nptTmp = npt - 1; --nptTmp >= 0; ppt++) {
+ ppt->x += (ppt-1)->x;
+ ppt->y += (ppt-1)->y;
+ }
+
+ nbox = REGION_NUM_RECTS(pGC->pCompositeClip);
+ pbox = REGION_RECTS(pGC->pCompositeClip);
+ for (; --nbox >= 0; pbox++)
+ for (d = 0, pBase = pBaseSave; d < depthDst; d++, pBase += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ addrl = pBase;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ for (ppt = pptInit, nptTmp = npt; --nptTmp >= 0; ppt++) {
+ x = ppt->x + pDrawable->x;
+ y = ppt->y + pDrawable->y;
+ if ((x >= pbox->x1) && (x < pbox->x2) &&
+ (y >= pbox->y1) && (y < pbox->y2))
+ *ilbmScanline(addrl, x, y, auxDst) &= rmask[x & PIM];
+ }
+ break;
+
+ case RROP_WHITE:
+ for (ppt = pptInit, nptTmp = npt; --nptTmp >= 0; ppt++) {
+ x = ppt->x + pDrawable->x;
+ y = ppt->y + pDrawable->y;
+ if ((x >= pbox->x1) && (x < pbox->x2) &&
+ (y >= pbox->y1) && (y < pbox->y2))
+ *ilbmScanline(addrl, x, y, auxDst) |= mask[x & PIM];
+ }
+ break;
+
+ case RROP_INVERT:
+ for (ppt = pptInit, nptTmp = npt; --nptTmp >= 0; ppt++) {
+ x = ppt->x + pDrawable->x;
+ y = ppt->y + pDrawable->y;
+ if ((x >= pbox->x1) && (x < pbox->x2) &&
+ (y >= pbox->y1) && (y < pbox->y2))
+ *ilbmScanline(addrl, x, y, auxDst) ^= mask[x & PIM];
+ }
+ break;
+
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ...) */
+}
diff --git a/ilbm/ilbmpushpxl.c b/ilbm/ilbmpushpxl.c
new file mode 100644
index 000000000..6a045d242
--- /dev/null
+++ b/ilbm/ilbmpushpxl.c
@@ -0,0 +1,259 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmpushpxl.c,v 3.1 1998/03/20 21:08:03 hohndel Exp $ */
+/***********************************************************
+
+Copyright (c) 1987 X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XConsortium: ilbmpushpxl.c,v 5.6 94/04/17 20:28:31 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "gcstruct.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "miscstruct.h"
+#include "maskbits.h"
+#include "regionstr.h"
+#include "ilbm.h"
+
+/* ilbmSolidPP is courtesy of xhacks@csri.toronto.edu
+
+ For fillStyle==FillSolid, a monochrome PushPixels can be reduced to
+ a ROP in the following way: (Note that the ROP is the same as the
+ result of ROP(src=0x3,dst=0x5))
+
+ src=0011 0000 0011
+ dst=0101 0101 0101
+ rop fg=0 fg=1
+ GXclear 0x0 0000 0100 0100 0
+ GXand 0x1 0001 0100 0101 s&d
+ GXandReverse 0x2 0010 0100 0110 s&~d
+ GXcopy 0x3 0011 0100 0111 s
+ GXandInverted 0x4 0100 0101 0100 ~s&d
+ GXnoop 0x5 0101 0101 0101 d
+ GXxor 0x6 0110 0101 0110 s^d
+ GXor 0x7 0111 0101 0111 s|d
+ GXnor 0x8 1000 0110 0100 ~s&~d
+ GXequiv 0x9 1001 0110 0101 ~s^d
+ GXinvert 0xa 1010 0110 0110 ~d
+ GXorReverse 0xb 1011 0110 0111 s|~d
+ GXcopyInverted 0xc 1100 0111 0100 ~s
+ GXorInverted 0xd 1101 0111 0101 ~s|d
+ GXnand 0xe 1110 0111 0110 ~s|~d
+ GXset 0xf 1111 0111 0111 1
+
+For src=0: newRop = 0x4|(rop>>2)
+For src=1: newRop = 0x4|(rop&3)
+*/
+
+/* ilbmSolidPP -- squeegees the forground color of pGC through pBitMap
+ * into pDrawable. pBitMap is a stencil (dx by dy of it is used, it may
+ * be bigger) which is placed on the drawable at xOrg, yOrg. Where a 1 bit
+ * is set in the bitmap, the fill style is put onto the drawable using
+ * the GC's logical function. The drawable is not changed where the bitmap
+ * has a zero bit or outside the area covered by the stencil.
+ */
+void
+ilbmSolidPP(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
+ GCPtr pGC;
+ PixmapPtr pBitMap;
+ DrawablePtr pDrawable;
+ int dx, dy, xOrg, yOrg;
+{
+ unsigned char alu;
+ RegionRec rgnDst;
+ DDXPointPtr pptSrc;
+ BoxRec srcBox;
+ register DDXPointPtr ppt;
+ register BoxPtr pbox;
+ int i;
+
+ if (!pGC->planemask & 1) return;
+
+ /* compute the reduced rop function */
+ alu = pGC->alu;
+ if (!(pGC->fgPixel&1)) alu >>= 2;
+ alu = (alu & 0x3) | 0x4;
+ if (alu == GXnoop) return;
+
+ srcBox.x1 = xOrg;
+ srcBox.y1 = yOrg;
+ srcBox.x2 = xOrg + dx;
+ srcBox.y2 = yOrg + dy;
+ REGION_INIT(pGC->pScreen, &rgnDst, &srcBox, 1);
+
+ /* clip the shape of the dst to the destination composite clip */
+ REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst, pGC->pCompositeClip);
+
+ if (!REGION_NIL(&rgnDst)) {
+ i = REGION_NUM_RECTS(&rgnDst);
+ pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(i * sizeof(DDXPointRec));
+ if (pptSrc) {
+ for (pbox = REGION_RECTS(&rgnDst), ppt = pptSrc; --i >= 0;
+ pbox++, ppt++) {
+ ppt->x = pbox->x1 - xOrg;
+ ppt->y = pbox->y1 - yOrg;
+ }
+ ilbmDoBitblt((DrawablePtr)pBitMap, pDrawable, alu, &rgnDst, pptSrc,
+ pGC->planemask);
+ DEALLOCATE_LOCAL(pptSrc);
+ }
+ }
+ REGION_UNINIT(pGC->pScreen, &rgnDst);
+}
+
+#define NPT 128
+
+/* ilbmPushPixels -- squeegees the forground color of pGC through pBitMap
+ * into pDrawable. pBitMap is a stencil (dx by dy of it is used, it may
+ * be bigger) which is placed on the drawable at xOrg, yOrg. Where a 1 bit
+ * is set in the bitmap, the fill style is put onto the drawable using
+ * the GC's logical function. The drawable is not changed where the bitmap
+ * has a zero bit or outside the area covered by the stencil.
+ */
+void
+ilbmPushPixels(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
+ GCPtr pGC;
+ PixmapPtr pBitMap;
+ DrawablePtr pDrawable;
+ int dx, dy, xOrg, yOrg;
+{
+ int h, dxDivPPW, ibEnd;
+ PixelType *pwLineStart;
+ register PixelType *pw, *pwEnd;
+ register PixelType mask;
+ register int ib;
+ register PixelType w;
+ register int ipt; /* index into above arrays */
+ Bool fInBox;
+ DDXPointRec pt[NPT];
+ int width[NPT];
+
+ /* Now scan convert the pixmap and use the result to call fillspans in
+ * in the drawable with the original GC */
+ ipt = 0;
+ dxDivPPW = dx/PPW;
+ for (h = 0; h < dy; h++) {
+
+ pw = (PixelType *)
+ (((char *)(pBitMap->devPrivate.ptr))+(h * pBitMap->devKind));
+ pwLineStart = pw;
+ /* Process all words which are fully in the pixmap */
+
+ fInBox = FALSE;
+ pwEnd = pwLineStart + dxDivPPW;
+ while (pw < pwEnd) {
+ w = *pw;
+ mask = endtab[1];
+ for (ib = 0; ib < PPW; ib++) {
+ if (w & mask) {
+ if (!fInBox) {
+ pt[ipt].x = ((pw - pwLineStart) << PWSH) + ib + xOrg;
+ pt[ipt].y = h + yOrg;
+ /* start new box */
+ fInBox = TRUE;
+ }
+ } else {
+ if (fInBox) {
+ width[ipt] = ((pw - pwLineStart) << PWSH) +
+ ib + xOrg - pt[ipt].x;
+ if (++ipt >= NPT) {
+ (*pGC->ops->FillSpans)(pDrawable, pGC, NPT, pt,
+ width, TRUE);
+ ipt = 0;
+ }
+ /* end box */
+ fInBox = FALSE;
+ }
+ }
+ mask = SCRRIGHT(mask, 1);
+ }
+ pw++;
+ }
+ ibEnd = dx & PIM;
+ if (ibEnd) {
+ /* Process final partial word on line */
+ w = *pw;
+ mask = endtab[1];
+ for (ib = 0; ib < ibEnd; ib++) {
+ if (w & mask) {
+ if (!fInBox) {
+ /* start new box */
+ pt[ipt].x = ((pw - pwLineStart) << PWSH) + ib + xOrg;
+ pt[ipt].y = h + yOrg;
+ fInBox = TRUE;
+ }
+ } else {
+ if (fInBox) {
+ /* end box */
+ width[ipt] = ((pw - pwLineStart) << PWSH) +
+ ib + xOrg - pt[ipt].x;
+ if (++ipt >= NPT) {
+ (*pGC->ops->FillSpans)(pDrawable, pGC, NPT, pt,
+ width, TRUE);
+ ipt = 0;
+ }
+ fInBox = FALSE;
+ }
+ }
+ mask = SCRRIGHT(mask, 1);
+ }
+ }
+ /* If scanline ended with last bit set, end the box */
+ if (fInBox) {
+ width[ipt] = dx + xOrg - pt[ipt].x;
+ if (++ipt >= NPT) {
+ (*pGC->ops->FillSpans)(pDrawable, pGC, NPT, pt, width, TRUE);
+ ipt = 0;
+ }
+ }
+ }
+ /* Flush any remaining spans */
+ if (ipt) {
+ (*pGC->ops->FillSpans)(pDrawable, pGC, ipt, pt, width, TRUE);
+ }
+}
diff --git a/ilbm/ilbmscrinit.c b/ilbm/ilbmscrinit.c
new file mode 100644
index 000000000..5a6fa71a0
--- /dev/null
+++ b/ilbm/ilbmscrinit.c
@@ -0,0 +1,247 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmscrinit.c,v 3.5 1998/11/22 10:37:40 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: ilbmscrinit.c,v 5.17 94/04/17 20:28:34 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xproto.h" /* for xColorItem */
+#include "Xmd.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "resource.h"
+#include "colormap.h"
+#include "ilbm.h"
+#include "mistruct.h"
+#include "dix.h"
+#include "mi.h"
+#include "mibstore.h"
+#include "migc.h"
+#include "servermd.h"
+
+#ifdef PIXMAP_PER_WINDOW
+int frameWindowPrivateIndex;
+#endif
+int ilbmWindowPrivateIndex;
+int ilbmGCPrivateIndex;
+int ilbmScreenPrivateIndex;
+
+static unsigned long ilbmGeneration = 0;
+
+BSFuncRec ilbmBSFuncRec = {
+ ilbmSaveAreas,
+ ilbmRestoreAreas,
+ (BackingStoreSetClipmaskRgnProcPtr) 0,
+ (BackingStoreGetImagePixmapProcPtr) 0,
+ (BackingStoreGetSpansPixmapProcPtr) 0,
+};
+
+Bool
+ilbmCloseScreen(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);
+ xfree(pScreen->devPrivates[ilbmScreenPrivateIndex].ptr);
+ return(TRUE);
+}
+
+Bool
+ilbmCreateScreenResources(pScreen)
+ ScreenPtr pScreen;
+{
+ Bool retval;
+
+ pointer oldDevPrivate = pScreen->devPrivate;
+
+ pScreen->devPrivate = pScreen->devPrivates[ilbmScreenPrivateIndex].ptr;
+ retval = miCreateScreenResources(pScreen);
+
+ /* Modify screen's pixmap devKind value stored off devPrivate to
+ * be the width of a single plane in longs rather than the width
+ * of a chunky screen in longs as incorrectly setup by the mi routine.
+ */
+ ((PixmapPtr)pScreen->devPrivate)->devKind = BitmapBytePad(pScreen->width);
+ pScreen->devPrivates[ilbmScreenPrivateIndex].ptr = pScreen->devPrivate;
+ pScreen->devPrivate = oldDevPrivate;
+ return(retval);
+}
+
+Bool
+ilbmAllocatePrivates(pScreen, pWinIndex, pGCIndex)
+ ScreenPtr pScreen;
+ int *pWinIndex, *pGCIndex;
+{
+ if (ilbmGeneration != serverGeneration) {
+#ifdef PIXMAP_PER_WINDOW
+ frameWindowPrivateIndex = AllocateWindowPrivateIndex();
+#endif
+ ilbmWindowPrivateIndex = AllocateWindowPrivateIndex();
+ ilbmGCPrivateIndex = AllocateGCPrivateIndex();
+ ilbmGeneration = serverGeneration;
+ }
+ if (pWinIndex)
+ *pWinIndex = ilbmWindowPrivateIndex;
+ if (pGCIndex)
+ *pGCIndex = ilbmGCPrivateIndex;
+
+ ilbmScreenPrivateIndex = AllocateScreenPrivateIndex();
+ pScreen->GetWindowPixmap = ilbmGetWindowPixmap;
+ pScreen->SetWindowPixmap = ilbmSetWindowPixmap;
+ return(AllocateWindowPrivate(pScreen, ilbmWindowPrivateIndex, sizeof(ilbmPrivWin)) &&
+ AllocateGCPrivate(pScreen, ilbmGCPrivateIndex, sizeof(ilbmPrivGC)));
+}
+
+/* dts * (inch/dot) * (25.4 mm / inch) = mm */
+Bool
+ilbmScreenInit(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 */
+{
+ VisualPtr visuals;
+ DepthPtr depths;
+ int nvisuals;
+ int ndepths;
+ int rootdepth;
+ VisualID defaultVisual;
+ pointer oldDevPrivate;
+
+ rootdepth = 0;
+ if (!ilbmInitVisuals(&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
+ &defaultVisual, 256, 8)) {
+ ErrorF("ilbmInitVisuals: FALSE\n");
+ return FALSE;
+ }
+ if (!ilbmAllocatePrivates(pScreen,(int *)NULL, (int *)NULL)) {
+ ErrorF("ilbmAllocatePrivates: FALSE\n");
+ return FALSE;
+ }
+
+ pScreen->defColormap = (Colormap)FakeClientID(0);
+ /* whitePixel, blackPixel */
+ pScreen->blackPixel = 0;
+ pScreen->whitePixel = 0;
+ pScreen->QueryBestSize = ilbmQueryBestSize;
+ /* SaveScreen */
+ pScreen->GetImage = ilbmGetImage;
+ pScreen->GetSpans = ilbmGetSpans;
+ pScreen->CreateWindow = ilbmCreateWindow;
+ pScreen->DestroyWindow = ilbmDestroyWindow;
+ pScreen->PositionWindow = ilbmPositionWindow;
+ pScreen->ChangeWindowAttributes = ilbmChangeWindowAttributes;
+ pScreen->RealizeWindow = ilbmMapWindow;
+ pScreen->UnrealizeWindow = ilbmUnmapWindow;
+ pScreen->PaintWindowBackground = ilbmPaintWindow;
+ pScreen->PaintWindowBorder = ilbmPaintWindow;
+ pScreen->CopyWindow = ilbmCopyWindow;
+ pScreen->CreatePixmap = ilbmCreatePixmap;
+ pScreen->DestroyPixmap = ilbmDestroyPixmap;
+ pScreen->RealizeFont = ilbmRealizeFont;
+ pScreen->UnrealizeFont = ilbmUnrealizeFont;
+ pScreen->CreateGC = ilbmCreateGC;
+ pScreen->CreateColormap = ilbmInitializeColormap;
+ pScreen->DestroyColormap = (void (*)())NoopDDA;
+ pScreen->InstallColormap = ilbmInstallColormap;
+ pScreen->UninstallColormap = ilbmUninstallColormap;
+ pScreen->ListInstalledColormaps = ilbmListInstalledColormaps;
+ pScreen->StoreColors = (void (*)())NoopDDA;
+ pScreen->ResolveColor = ilbmResolveColor;
+ pScreen->BitmapToRegion = ilbmPixmapToRegion;
+ oldDevPrivate = pScreen->devPrivate;
+ if (!miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width, rootdepth,
+ ndepths, depths, defaultVisual, nvisuals, visuals)) {
+ ErrorF("miScreenInit: FALSE\n");
+ return FALSE;
+ }
+
+ pScreen->CloseScreen = ilbmCloseScreen;
+ pScreen->CreateScreenResources = ilbmCreateScreenResources;
+ pScreen->BackingStoreFuncs = ilbmBSFuncRec;
+
+ pScreen->devPrivates[ilbmScreenPrivateIndex].ptr = pScreen->devPrivate;
+ pScreen->devPrivate = oldDevPrivate;
+
+ return TRUE;
+}
+
+PixmapPtr
+ilbmGetWindowPixmap(pWin)
+ WindowPtr pWin;
+{
+#ifdef PIXMAP_PER_WINDOW
+ return (PixmapPtr)(pWin->devPrivates[frameWindowPrivateIndex].ptr);
+#else
+ ScreenPtr pScreen = pWin->drawable.pScreen;
+
+ return (* pScreen->GetScreenPixmap)(pScreen);
+#endif
+}
+
+void
+ilbmSetWindowPixmap(pWin, pPix)
+ WindowPtr pWin;
+ PixmapPtr pPix;
+{
+#ifdef PIXMAP_PER_WINDOW
+ pWin->devPrivates[frameWindowPrivateIndex].ptr = (pointer)pPix;
+#else
+ (* pWin->drawable.pScreen->SetScreenPixmap)(pPix);
+#endif
+}
diff --git a/ilbm/ilbmsetsp.c b/ilbm/ilbmsetsp.c
new file mode 100644
index 000000000..a18cf53f8
--- /dev/null
+++ b/ilbm/ilbmsetsp.c
@@ -0,0 +1,265 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmsetsp.c,v 3.1 1998/03/20 21:08:04 hohndel Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmsetsp.c,v 5.8 94/04/17 20:28:34 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+
+#include "misc.h"
+#include "regionstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+#include "servermd.h"
+
+
+/* ilbmSetScanline -- 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.)
+ */
+ilbmSetScanline(y, xOrigin, xStart, xEnd, psrc, alu, pdstBase, widthDst, auxDst,
+ depthDst, widthSrc)
+ 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 PixelType *psrc;
+ register int alu; /* raster op */
+ PixelType *pdstBase; /* start of the drawable */
+ int widthDst; /* width of drawable in words */
+ int auxDst;
+ int depthDst;
+ int widthSrc; /* width of drawable in words */
+{
+ int w; /* width of scanline in bits */
+ register PixelType *pdst; /* where to put the bits */
+ register PixelType 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;
+ PixelType startmask, endmask;
+ PixelType *savePsrc = psrc + ((xStart - xOrigin) >> PWSH);
+ int nlMiddle, nl;
+ int d;
+
+ for (d = 0; d < depthDst; d++) {
+ pdst = ilbmScanline(pdstBase, xStart, y, auxDst) + widthDst * d; /* @@@ NEXT PLANE @@@ */
+ psrc = savePsrc + widthSrc * d; /* @@@ NEXT PLANE @@@ */
+ offSrc = (xStart - xOrigin) & PIM;
+ w = xEnd - xStart;
+ dstBit = xStart & PIM;
+
+ if (dstBit + w <= PPW) {
+ getandputrop(psrc, offSrc, dstBit, w, pdst, alu)
+ } else {
+ maskbits(xStart, w, startmask, endmask, nlMiddle);
+ if (startmask)
+ nstart = PPW - dstBit;
+ else
+ nstart = 0;
+ if (endmask)
+ nend = xEnd & PIM;
+ else
+ nend = 0;
+ if (startmask) {
+ getandputrop(psrc, offSrc, dstBit, nstart, pdst, alu)
+ pdst++;
+ offSrc += nstart;
+ if (offSrc > PLST) {
+ psrc++;
+ offSrc -= PPW;
+ }
+ }
+ nl = nlMiddle;
+ while (nl--) {
+ getbits(psrc, offSrc, PPW, tmpSrc);
+ DoRop(*pdst, alu, tmpSrc, *pdst);
+ pdst++;
+ psrc++;
+ }
+ if (endmask) {
+ getandputrop0(psrc, offSrc, nend, pdst, alu);
+ }
+ }
+ }
+}
+
+/* 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
+ilbmSetSpans(pDrawable, pGC, pcharsrc, ppt, pwidth, nspans, fSorted)
+ DrawablePtr pDrawable;
+ GCPtr pGC;
+ char *pcharsrc;
+ register DDXPointPtr ppt;
+ int *pwidth;
+ int nspans;
+ int fSorted;
+{
+ PixelType *psrc = (PixelType *)pcharsrc;
+ PixelType *pdstBase; /* start of dst bitmap */
+ int widthDst; /* width of bitmap in words */
+ int auxDst;
+ int depthDst;
+ int widthSrc;
+ register BoxPtr pbox, pboxLast, pboxTest;
+ register DDXPointPtr pptLast;
+ int alu;
+ RegionPtr prgnDst;
+ int xStart, xEnd;
+ int yMax;
+
+ alu = pGC->alu;
+ prgnDst = pGC->pCompositeClip;
+
+ pptLast = ppt + nspans;
+
+ yMax = pDrawable->y + (int) pDrawable->height;
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, widthDst, auxDst, depthDst,
+ pdstBase);
+
+ 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);
+ widthSrc = PixmapWidthInPadUnits(*pwidth, 1);
+ ilbmSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu, pdstBase,
+ widthDst, auxDst, depthDst, widthSrc);
+ 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 += widthSrc * depthDst;
+ 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);
+ widthSrc = PixmapWidthInPadUnits(*pwidth, 1);
+ ilbmSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
+ pdstBase, widthDst, auxDst, depthDst,
+ widthSrc);
+ }
+
+ }
+ }
+ psrc += widthSrc * depthDst;
+ ppt++;
+ pwidth++;
+ }
+ }
+}
diff --git a/ilbm/ilbmtegblt.c b/ilbm/ilbmtegblt.c
new file mode 100644
index 000000000..dc42baee9
--- /dev/null
+++ b/ilbm/ilbmtegblt.c
@@ -0,0 +1,595 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmtegblt.c,v 3.1 1998/03/20 21:08:04 hohndel Exp $ */
+/* $XConsortium: ilbmtegblt.c,v 5.14 94/04/17 20:28:35 dpw Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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 jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xmd.h"
+#include "Xproto.h"
+#include "ilbm.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "regionstr.h"
+#include "maskbits.h"
+
+/*
+ this works for fonts with glyphs <= PPW bits wide.
+
+ 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.
+
+*/
+
+#if defined(NO_3_60_CG4) && defined(FASTPUTBITS) && defined(FASTGETBITS)
+#define FASTCHARS
+#endif
+
+/*
+ * this macro "knows" that only characters <= 8 bits wide will
+ * fit this case (which is why it is independent of GLYPHPADBYTES)
+ */
+
+#if (BITMAP_BIT_ORDER == MSBFirst) && (GLYPHPADBYTES != 4)
+#if GLYPHPADBYTES == 1
+#define ShiftAmnt 24
+#else
+#define ShiftAmnt 16
+#endif
+
+/*
+ * Note: for BITMAP_BIT_ORDER != IMAGE_BYTE_ORDER, SCRRIGHT() evaluates its
+ * first argument more than once. Thus the imbedded char++ have to be moved.
+ * (DHD)
+ */
+#if BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER
+#if PPW == 32
+#define GetBits4 c = (*char1++ << ShiftAmnt) | \
+ SCRRIGHT (*char2++ << ShiftAmnt, xoff2) | \
+ SCRRIGHT (*char3++ << ShiftAmnt, xoff3) | \
+ SCRRIGHT (*char4++ << ShiftAmnt, xoff4);
+#else /* PPW */
+#define GetBits4 c = ((unsigned long)(*char1++ << ShiftAmnt) << 32 ) | \
+ (SCRRIGHT (*char2++ << ShiftAmnt, xoff2) << 32 ) | \
+ (SCRRIGHT (*char3++ << ShiftAmnt, xoff3) << 32 ) | \
+ (SCRRIGHT (*char4++ << ShiftAmnt, xoff4) << 32 ) | \
+ (*char5++ << ShiftAmnt) | \
+ SCRRIGHT (*char6++ << ShiftAmnt, xoff6) | \
+ SCRRIGHT (*char7++ << ShiftAmnt, xoff7) | \
+ SCRRIGHT (*char8++ << ShiftAmnt, xoff8);
+#endif /* PPW */
+#else /* BITMAP_BIT_ORDER != IMAGE_BYTE_ORDER */
+#if PPW == 32
+#define GetBits4 c = (*char1++ << ShiftAmnt) | \
+ SCRRIGHT (*char2 << ShiftAmnt, xoff2) | \
+ SCRRIGHT (*char3 << ShiftAmnt, xoff3) | \
+ SCRRIGHT (*char4 << ShiftAmnt, xoff4); \
+ char2++; char3++; char4++;
+#else /* PPW == 64 */
+#define GetBits4 c = ((unsigned long)(*char1++ << ShiftAmnt) << 32 ) | \
+ (SCRRIGHT (*char2 << ShiftAmnt, xoff2) << 32 ) | \
+ (SCRRIGHT (*char3 << ShiftAmnt, xoff3) << 32 ) | \
+ (SCRRIGHT (*char4 << ShiftAmnt, xoff4) << 32 ) | \
+ (*char5++ << ShiftAmnt) | \
+ SCRRIGHT (*char6 << ShiftAmnt, xoff6) | \
+ SCRRIGHT (*char7 << ShiftAmnt, xoff7) | \
+ SCRRIGHT (*char8 << ShiftAmnt, xoff8); \
+ char2++; char3++; char4++; char6++; char7++; char8++;
+#endif /* PPW */
+#endif /* BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER */
+
+#else /* (BITMAP_BIT_ORDER != MSBFirst) || (GLYPHPADBYTES == 4) */
+
+#if BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER
+#if PPW == 32
+#define GetBits4 c = *char1++ | \
+ SCRRIGHT (*char2++, xoff2) | \
+ SCRRIGHT (*char3++, xoff3) | \
+ SCRRIGHT (*char4++, xoff4);
+#else /* PPW == 64 */
+#define GetBits4 c = (unsigned long)(((*char1++) << 64 ) | \
+ (SCRRIGHT (*char2++, xoff2) << 64 ) | \
+ (SCRRIGHT (*char3++, xoff3) << 64 ) | \
+ (SCRRIGHT (*char4++, xoff4) << 64 ) | \
+ SCRRIGHT (*char5++, xoff5) | \
+ SCRRIGHT (*char6++, xoff6) | \
+ SCRRIGHT (*char7++, xoff7) | \
+ SCRRIGHT (*char8++, xoff8));
+#endif /* PPW */
+#else /* BITMAP_BIT_ORDER != IMAGE_BYTE_ORDER */
+#if PPW == 32
+#define GetBits4 c = *char1++ | \
+ SCRRIGHT (*char2, xoff2) | \
+ SCRRIGHT (*char3, xoff3) | \
+ SCRRIGHT (*char4, xoff4); \
+ char2++; char3++; char4++;
+#else /* PPW == 64 */
+#define GetBits4 c = (unsigned long)(((*char1++) << 64 ) | \
+ (SCRRIGHT (*char2, xoff2) << 64 ) | \
+ (SCRRIGHT (*char3, xoff3) << 64 ) | \
+ (SCRRIGHT (*char4, xoff4) << 64 ) | \
+ SCRRIGHT (*char5, xoff5) | \
+ SCRRIGHT (*char6, xoff6) | \
+ SCRRIGHT (*char7, xoff7) | \
+ SCRRIGHT (*char8, xoff8)); \
+ char2++; char3++; char4++; \
+ char5++; char6++; char7++; char8++;
+#endif /* PPW */
+#endif /* BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER */
+
+#endif /* BITMAP_BIT_ORDER && GLYPHPADBYTES */
+
+
+#if GLYPHPADBYTES == 1
+typedef unsigned char *glyphPointer;
+#define USE_LEFTBITS
+#endif
+
+#if GLYPHPADBYTES == 2
+typedef unsigned short *glyphPointer;
+#define USE_LEFTBITS
+#endif
+
+#if GLYPHPADBYTES == 4
+typedef unsigned int *glyphPointer;
+#endif
+
+#ifdef USE_LEFTBITS
+#define GetBits1 getleftbits (char1, widthGlyph, c); \
+ c &= glyphMask; \
+ char1 = (glyphPointer) (((char *) char1) + glyphBytes);
+#else
+#define GetBits1 c = *char1++;
+#endif
+
+void
+ilbmTEGlyphBlt (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;
+ PixelType *pdstBase; /* pointer to longword with top row
+ of current glyph */
+
+ int h; /* height of glyph and char */
+ register int xpos; /* current x */
+ int ypos; /* current y */
+ int widthGlyph;
+
+ int hTmp; /* counter for height */
+ register PixelType startmask, endmask;
+ int nfirst; /* used if glyphs spans a longword boundary */
+ BoxRec bbox; /* for clipping */
+ int widthGlyphs;
+ int auxDst;
+ int depthDst;
+ PixelType *saveDst;
+ register PixelType *dst;
+ register PixelType c;
+ register int d;
+ register int xoff1, xoff2, xoff3, xoff4;
+ register glyphPointer char1, char2, char3, char4;
+ glyphPointer schar1, schar2, schar3, schar4;
+#if PPW == 64
+ register int xoff5, xoff6, xoff7, xoff8;
+ register glyphPointer char5, char6, char7, char8;
+ glyphPointer schar5, schar6, schar7, schar8;
+#endif /* PPW */
+
+ unsigned char *rrops;
+#ifdef USE_LEFTBITS
+ register PixelType glyphMask;
+ register PixelType tmpSrc;
+ register int glyphBytes;
+#endif
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDrawable, widthDst, auxDst, depthDst,
+ pdstBase);
+
+ xpos = x + pDrawable->x;
+ ypos = y + pDrawable->y;
+
+ widthGlyph = FONTMAXBOUNDS(pfont,characterWidth);
+ h = FONTASCENT(pfont) + FONTDESCENT(pfont);
+
+ xpos += FONTMAXBOUNDS(pfont,leftSideBearing);
+ ypos -= FONTASCENT(pfont);
+
+ rrops = ((ilbmPrivGCPtr) pGC->devPrivates[ilbmGCPrivateIndex].ptr)->rropOS;
+
+ bbox.x1 = xpos;
+ bbox.x2 = xpos + (widthGlyph * nglyph);
+ bbox.y1 = ypos;
+ bbox.y2 = ypos + h;
+
+ switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox)) {
+ 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...
+ */
+ ilbmImageGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
+ case rgnOUT:
+ return;
+ }
+ pdstBase = ilbmScanlineDeltaNoBankSwitch(pdstBase, ypos, auxDst);
+ widthGlyphs = widthGlyph * PGSZB;
+
+#ifdef USE_LEFTBITS
+ glyphMask = endtab[widthGlyph];
+ glyphBytes = GLYPHWIDTHBYTESPADDED(*ppci);
+#endif
+
+ if (nglyph >= PGSZB && widthGlyphs <= PPW) {
+ while (nglyph >= PGSZB) {
+ nglyph -= PGSZB;
+ xoff1 = xpos & PIM;
+ xoff2 = widthGlyph;
+ xoff3 = xoff2 + widthGlyph;
+ xoff4 = xoff3 + widthGlyph;
+#if PPW == 64
+ xoff5 = xoff4 + widthGlyph;
+ xoff6 = xoff5 + widthGlyph;
+ xoff7 = xoff6 + widthGlyph;
+ xoff8 = xoff7 + widthGlyph;
+#endif /* PPW */
+ schar1 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+ schar2 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+ schar3 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+ schar4 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+#if PPW == 64
+ schar5 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+ schar6 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+ schar7 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+ schar8 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
+#endif /* PPW */
+
+ hTmp = h;
+ saveDst = ilbmScanlineOffset(pdstBase, (xpos >> PWSH)); /* switch now */
+
+#ifndef FASTCHARS
+ if (xoff1 + widthGlyphs <= PPW) {
+ maskpartialbits (xoff1, widthGlyphs, startmask);
+#endif
+ for (d = 0; d < depthDst; d++) {
+ hTmp = h;
+ dst = saveDst;
+ saveDst += widthDst; /* @@@ NEXT PLANE @@@ */
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (hTmp--) {
+#ifdef FASTCHARS
+ FASTPUTBITS(0, xoff1, widthGlyphs, dst);
+#else
+ *(dst) &= ~startmask;
+#endif
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (hTmp--) {
+#ifdef FASTCHARS
+ FASTPUTBITS(~0, xoff1, widthGlyphs, dst);
+#else
+ *(dst) |= startmask;
+#endif
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ char1 = schar1;
+ char2 = schar2;
+ char3 = schar3;
+ char4 = schar4;
+ /* XXX */
+ while (hTmp--) {
+ GetBits4
+#ifdef FASTCHARS
+# if BITMAP_BIT_ORDER == MSBFirst
+ c >>= PPW - widthGlyphs;
+# endif
+ FASTPUTBITS(~c, xoff1, widthGlyphs, dst);
+#else
+ *(dst) = (*dst) & ~startmask | ~SCRRIGHT(c, xoff1) & startmask;
+#endif
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_COPY:
+ char1 = schar1;
+ char2 = schar2;
+ char3 = schar3;
+ char4 = schar4;
+
+ while (hTmp--) {
+ GetBits4
+#ifdef FASTCHARS
+# if BITMAP_BIT_ORDER == MSBFirst
+ c >>= PPW - widthGlyphs;
+#endif
+ FASTPUTBITS(c, xoff1, widthGlyphs, dst);
+#else
+ *(dst) = (*dst) & ~startmask | SCRRIGHT(c, xoff1) & startmask;
+#endif
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch (rrops[d]) */
+ } /* for (d = ... ) */
+#ifndef FASTCHARS
+ } else {
+ maskPPWbits (xoff1, widthGlyphs, startmask, endmask);
+ nfirst = PPW - xoff1;
+ for (d = 0; d < depthDst; d++) {
+ hTmp = h;
+ dst = saveDst;
+ saveDst += widthDst; /* @@@ NEXT PLANE @@@ */
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (hTmp--) {
+ dst[0] &= ~startmask;
+ dst[1] &= ~endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (hTmp--) {
+ dst[0] |= startmask;
+ dst[1] |= endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ char1 = schar1;
+ char2 = schar2;
+ char3 = schar3;
+ char4 = schar4;
+
+ while (hTmp--) {
+ GetBits4
+ dst[0] = dst[0] & ~startmask |
+ ~SCRRIGHT(c,xoff1) & startmask;
+ dst[1] = dst[1] & ~endmask |
+ ~SCRLEFT(c,nfirst) & endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_COPY:
+ char1 = schar1;
+ char2 = schar2;
+ char3 = schar3;
+ char4 = schar4;
+
+ while (hTmp--) {
+ GetBits4
+ dst[0] = dst[0] & ~startmask |
+ SCRRIGHT(c,xoff1) & startmask;
+ dst[1] = dst[1] & ~endmask |
+ SCRLEFT(c,nfirst) & endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ... ) */
+ }
+#endif
+ xpos += widthGlyphs;
+ }
+ }
+
+ while (nglyph--) {
+ xoff1 = xpos & PIM;
+ schar1 = (glyphPointer) FONTGLYPHBITS(pglyphBase,(*ppci++));
+ hTmp = h;
+ saveDst = ilbmScanlineOffset(pdstBase, (xpos >> PWSH));
+
+ if (xoff1 + widthGlyph <= PPW) {
+ maskpartialbits (xoff1, widthGlyph, startmask);
+
+ for (d = 0; d < depthDst; d++) {
+ hTmp = h;
+ dst = saveDst;
+ saveDst += widthDst; /* @@@ NEXT PLANE @@@ */
+ char1 = schar1;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (hTmp--) {
+ (*dst) &= ~startmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (hTmp--) {
+ (*dst) |= startmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ while (hTmp--) {
+#ifdef FASTCHARS
+#ifdef USE_LEFTBITS
+ FASTGETBITS (char1,0,widthGlyph,c);
+ char1 = (glyphPointer) (((char *) char1) + glyphBytes);
+#else
+ c = *char1++;
+#if BITMAP_BIT_ORDER == MSBFirst
+ c >>= PPW - widthGlyph;
+#endif
+#endif
+ FASTPUTBITS (~c,xoff1,widthGlyph,dst);
+#else
+ GetBits1
+ (*dst) = (*dst) & ~startmask | ~SCRRIGHT(c, xoff1) & startmask;
+#endif
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_COPY:
+ while (hTmp--) {
+#ifdef FASTCHARS
+#ifdef USE_LEFTBITS
+ FASTGETBITS (char1,0,widthGlyph,c);
+ char1 = (glyphPointer) (((char *) char1) + glyphBytes);
+#else
+ c = *char1++;
+#if BITMAP_BIT_ORDER == MSBFirst
+ c >>= PPW - widthGlyph;
+#endif
+#endif
+ FASTPUTBITS (c,xoff1,widthGlyph,dst);
+#else
+ GetBits1
+ (*dst) = (*dst) & ~startmask | SCRRIGHT(c, xoff1) & startmask;
+#endif
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ...) */
+ } else {
+ maskPPWbits (xoff1, widthGlyph, startmask, endmask);
+ nfirst = PPW - xoff1;
+
+ for (d = 0; d < depthDst; d++) {
+ hTmp = h;
+ dst = saveDst;
+ saveDst += widthDst; /* @@@ NEXT PLANE @@@ */
+ char1 = schar1;
+
+ switch (rrops[d]) {
+ case RROP_BLACK:
+ while (hTmp--) {
+ dst[0] &= ~startmask;
+ dst[1] &= ~endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_WHITE:
+ while (hTmp--) {
+ dst[0] |= startmask;
+ dst[1] |= endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_INVERT:
+ while (hTmp--) {
+ GetBits1
+ dst[0] = dst[0] & ~startmask |
+ ~SCRRIGHT(c,xoff1) & startmask;
+ dst[1] = dst[1] & ~endmask |
+ ~SCRLEFT(c,nfirst) & endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_COPY:
+ while (hTmp--) {
+ GetBits1
+ dst[0] = dst[0] & ~startmask |
+ SCRRIGHT(c,xoff1) & startmask;
+ dst[1] = dst[1] & ~endmask |
+ SCRLEFT(c,nfirst) & endmask;
+ ilbmScanlineInc(dst, auxDst);
+ }
+ break;
+ case RROP_NOP:
+ break;
+ } /* switch */
+ } /* for (d = ...) */
+ }
+
+ xpos += widthGlyph;
+ }
+}
diff --git a/ilbm/ilbmtile.c b/ilbm/ilbmtile.c
new file mode 100644
index 000000000..e289144ef
--- /dev/null
+++ b/ilbm/ilbmtile.c
@@ -0,0 +1,853 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmtile.c,v 3.0 1996/08/18 01:54:12 dawes Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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: ilbmtile.c,v 5.8 94/04/17 20:28:36 dpw Exp $ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+
+#include "windowstr.h"
+#include "regionstr.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+
+#include "ilbm.h"
+#include "maskbits.h"
+
+#include "mergerop.h"
+/*
+
+ the boxes are already translated.
+
+ NOTE:
+ iy = ++iy < tileHeight ? iy : 0
+is equivalent to iy%= tileheight, and saves a division.
+*/
+
+/*
+ tile area with a PPW bit wide pixmap
+*/
+void
+MROP_NAME(ilbmTileAreaPPW)(pDraw, nbox, pbox, alu, ptile, planemask)
+ DrawablePtr pDraw;
+ int nbox;
+ BoxPtr pbox;
+ int alu;
+ PixmapPtr ptile;
+ unsigned long planemask;
+{
+ register PixelType *psrc;
+ /* pointer to bits in tile, if needed */
+ int tileHeight; /* height of the tile */
+ register PixelType srcpix;
+ int nlwidth; /* width in longwords of the drawable */
+ int w; /* width of current box */
+ MROP_DECLARE_REG ()
+ register int h; /* height of current box */
+ register int nlw; /* loop version of nlwMiddle */
+ register PixelType *p; /* pointer to bits we're writing */
+ int auxDst;
+ int depthDst;
+ int tlwidth;
+ register int d;
+ PixelType startmask;
+ PixelType endmask; /* masks for reggedy bits at either end of line */
+ int nlwMiddle; /* number of longwords between sides of boxes */
+ int nlwExtra; /* to get from right of box to left of next span */
+ register int iy; /* index of current scanline in tile */
+ PixelType *pbits; /* pointer to start of drawable */
+ PixelType *saveP;
+ PixelType *pSaveSrc;
+ int saveH;
+ int saveIY;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst,
+ pbits);
+
+ MROP_INITIALIZE(alu,~0)
+
+ tileHeight = ptile->drawable.height;
+ tlwidth = ptile->devKind/sizeof(PixelType);
+ pSaveSrc = (PixelType *)(ptile->devPrivate.ptr);
+
+ while (nbox--) {
+ w = pbox->x2 - pbox->x1;
+ saveH = pbox->y2 - pbox->y1;
+ saveIY = pbox->y1 % tileHeight;
+ saveP = ilbmScanline(pbits, pbox->x1, pbox->y1, auxDst);
+ psrc = pSaveSrc;
+
+ if (((pbox->x1 & PIM) + w) < PPW) {
+ maskpartialbits(pbox->x1, w, startmask);
+ nlwExtra = auxDst;
+ for (d = 0; d < depthDst; d++, saveP += nlwidth, psrc += tileHeight) { /* @@@ NEXT PLANE @@@ */
+ if (!(planemask & (1 << d)))
+ continue;
+
+ p = saveP;
+ h = saveH;
+ iy = saveIY;
+
+ while (h--) {
+ srcpix = psrc[iy];
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ *p = MROP_MASK(srcpix,*p,startmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ }
+ } else {
+ maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
+
+ for (d = 0; d < depthDst; d++, saveP += nlwidth, psrc += tileHeight) { /* @@@ NEXT PLANE @@@ */
+ if (!(planemask & (1 << d)))
+ continue;
+
+ p = saveP;
+ h = saveH;
+ iy = saveIY;
+ nlwExtra = auxDst - nlwMiddle;
+
+ if (startmask && endmask) {
+ nlwExtra -= 1;
+ while (h--) {
+ srcpix = psrc[iy];
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ *p = MROP_MASK (srcpix,*p,startmask);
+ p++;
+ while (nlw--) {
+ *p = MROP_SOLID(srcpix,*p);
+ p++;
+ }
+
+ *p = MROP_MASK(srcpix,*p,endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ } else if (startmask && !endmask) {
+ nlwExtra -= 1;
+ while (h--) {
+ srcpix = psrc[iy];
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ *p = MROP_MASK(srcpix,*p,startmask);
+ p++;
+ while (nlw--) {
+ *p = MROP_SOLID(srcpix,*p);
+ p++;
+ }
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ } else if (!startmask && endmask) {
+ while (h--) {
+ srcpix = psrc[iy];
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ while (nlw--) {
+ *p = MROP_SOLID(srcpix,*p);
+ p++;
+ }
+
+ *p = MROP_MASK(srcpix,*p,endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ } else { /* no ragged bits at either end */
+ while (h--) {
+ srcpix = psrc[iy];
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ while (nlw--) {
+ *p = MROP_SOLID (srcpix,*p);
+ p++;
+ }
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ }
+ } /* for (d = ...) */
+ }
+ pbox++;
+ }
+}
+
+void
+MROP_NAME(ilbmTileArea)(pDraw, nbox, pbox, alu, pTile, xOff, yOff, planemask)
+ DrawablePtr pDraw;
+ int nbox;
+ BoxPtr pbox;
+ int alu;
+ PixmapPtr pTile;
+ int xOff;
+ int yOff;
+ unsigned long planemask;
+{
+ register PixelType *psrc;
+ /* pointer to bits in tile, if needed */
+ int nlwidth; /* width in longwords of the drawable */
+ MROP_DECLARE_REG ()
+ register int h; /* height of current box */
+ register PixelType *pdst; /* pointer to bits we're writing */
+ register PixelType tmpsrc, tmpdst;
+ int auxDst;
+ int depthDst;
+ int sizeTile;
+ int tileLine;
+ int iline;
+ int w, width, x, xSrc, ySrc, srcStartOver, nend;
+ int tlwidth, rem, tileWidth, tileHeight, endinc;
+ int saveW;
+ PixelType *psrcT;
+ int d;
+ int nstart;
+ PixelType startmask;
+ PixelType endmask; /* masks for reggedy bits at either end of line */
+ int nlMiddle; /* number of longwords between sides of boxes */
+ int iy;
+ PixelType *pBase; /* pointer to start of drawable */
+ PixelType *saveP;
+ PixelType *pStartDst;
+ PixelType *pStartTile;
+ int saveH;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst,
+ pBase);
+
+ MROP_INITIALIZE(alu,~0)
+
+ tileHeight = pTile->drawable.height;
+ tileWidth = pTile->drawable.width;
+ tlwidth = pTile->devKind/sizeof(PixelType);
+ sizeTile = tlwidth * tileHeight;
+
+ xSrc = pDraw->x + ((xOff % tileWidth) - tileWidth);
+ ySrc = pDraw->y + ((yOff % tileHeight) - tileHeight);
+
+ while (nbox--) {
+ saveW = pbox->x2 - pbox->x1;
+ iline = (pbox->y1 - ySrc) % tileHeight;
+ psrcT = (PixelType *) pTile->devPrivate.ptr;
+ tileLine = iline * tlwidth;
+ saveH = pbox->y2 - pbox->y1;
+ saveP = ilbmScanline(pBase, pbox->x1, pbox->y1, auxDst);
+
+ for (d = 0; d < depthDst; d++, psrcT += sizeTile, saveP += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(planemask & (1 << d)))
+ continue;
+
+ h = saveH;
+ pStartDst = saveP;
+ pStartTile = psrcT + tileLine;
+ iy = iline;
+
+ while (h--) {
+ x = pbox->x1;
+ width = saveW;
+ pdst = pStartDst;
+ while (width > 0) {
+ psrc = pStartTile;
+ w = min(tileWidth, width);
+ if ((rem = (x - xSrc) % tileWidth) != 0) {
+ /* if we're in the middle of the tile, get
+ as many bits as will finish the span, or
+ as many as will get to the left edge of the tile,
+ or a longword worth, starting at the appropriate
+ offset in the tile.
+ */
+ w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
+ endinc = rem / BITMAP_SCANLINE_PAD;
+
+ getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
+#if (MROP) != Mcopy
+ getbits (pdst, (x & PIM), w, tmpdst);
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, (x & PIM), w, pdst);
+
+ if ((x & PIM) + w >= PPW)
+ pdst++;
+ } else if (((x & PIM) + w) < PPW) {
+ /* doing < PPW bits is easy, and worth special-casing */
+ tmpsrc = *psrc;
+#if (MROP) != Mcopy
+ getbits (pdst, (x & PIM), w, tmpdst);
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, (x & PIM), w, pdst);
+ } else {
+ /* start at the left edge of the tile,
+ and put down as much as we can
+ */
+ maskbits(x, w, startmask, endmask, nlMiddle);
+
+ if (startmask)
+ nstart = PPW - (x & PIM);
+ else
+ nstart = 0;
+ if (endmask)
+ nend = (x + w) & PIM;
+ else
+ nend = 0;
+
+ srcStartOver = nstart > PLST;
+
+ if (startmask) {
+ tmpsrc = *psrc;
+#if (MROP) != Mcopy
+ getbits (pdst, (x & PIM), nstart, tmpdst);
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, (x & PIM), nstart, pdst);
+ pdst++;
+ if (srcStartOver)
+ psrc++;
+ }
+
+ while (nlMiddle--) {
+ getbits (psrc, nstart, PPW, tmpsrc);
+#if (MROP) != Mcopy
+ tmpdst = *pdst;
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ *pdst++ = tmpsrc;
+ /*putbits (tmpsrc, 0, PPW, pdst);
+ pdst++;*/
+ psrc++;
+ }
+
+ if (endmask) {
+ getbits (psrc, nstart, nend, tmpsrc);
+#if (MROP) != Mcopy
+ tmpdst = *pdst;
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, 0, nend, pdst);
+ }
+ }
+ x += w;
+ width -= w;
+ } /* while (width > 0) */
+
+ pStartDst += auxDst;
+ if (++iy >= tileHeight) {
+ iy = 0;
+ pStartTile = psrcT;
+ } else
+ pStartTile += tlwidth;
+
+ } /* while (h) */
+ } /* for (d = ... ) */
+ pbox++;
+ } /* for each box */
+}
+
+void
+MROP_NAME(ilbmOpaqueStippleAreaPPW)(pDraw, nbox, pbox, alu, ptile,
+ rropsOS, planemask)
+ DrawablePtr pDraw;
+ int nbox;
+ BoxPtr pbox;
+ int alu;
+ PixmapPtr ptile;
+ register unsigned char *rropsOS;
+ unsigned long planemask;
+{
+ register PixelType *psrc;
+ /* pointer to bits in tile, if needed */
+ int tileHeight; /* height of the tile */
+ register PixelType srcpix;
+ int nlwidth; /* width in longwords of the drawable */
+ int w; /* width of current box */
+ MROP_DECLARE_REG ()
+ register int h; /* height of current box */
+ register int nlw; /* loop version of nlwMiddle */
+ register PixelType *p; /* pointer to bits we're writing */
+ int auxDst;
+ int depthDst;
+ register int d;
+ PixelType startmask;
+ PixelType endmask; /* masks for reggedy bits at either end of line */
+ int nlwMiddle; /* number of longwords between sides of boxes */
+ int nlwExtra; /* to get from right of box to left of next span */
+ register int iy; /* index of current scanline in tile */
+ PixelType *pbits; /* pointer to start of drawable */
+ PixelType *saveP;
+ int saveH;
+ int saveIY;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst,
+ pbits);
+
+ MROP_INITIALIZE(alu,~0)
+
+ tileHeight = ptile->drawable.height;
+ psrc = (PixelType *)(ptile->devPrivate.ptr);
+
+ while (nbox--) {
+ w = pbox->x2 - pbox->x1;
+ saveH = pbox->y2 - pbox->y1;
+ saveIY = pbox->y1 % tileHeight;
+ saveP = ilbmScanline(pbits, pbox->x1, pbox->y1, auxDst);
+
+ if ( ((pbox->x1 & PIM) + w) < PPW) {
+ maskpartialbits(pbox->x1, w, startmask);
+ nlwExtra = auxDst;
+ for (d = 0; d < depthDst; d++, saveP += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(planemask & (1 << d)))
+ continue;
+
+ p = saveP;
+ h = saveH;
+ iy = saveIY;
+
+ while (h--) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ srcpix = 0;
+ break;
+ case RROP_WHITE:
+ srcpix = ~0;
+ break;
+ case RROP_COPY:
+ srcpix = psrc[iy];
+ break;
+ case RROP_INVERT:
+ srcpix = ~psrc[iy];
+ break;
+ }
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ *p = MROP_MASK(srcpix,*p,startmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ }
+ } else {
+ maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
+
+ for (d = 0; d < depthDst; d++, saveP += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(planemask & (1 << d)))
+ continue;
+
+ p = saveP;
+ h = saveH;
+ iy = saveIY;
+ nlwExtra = auxDst - nlwMiddle;
+
+ if (startmask && endmask) {
+ nlwExtra -= 1;
+ while (h--) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ srcpix = 0;
+ break;
+ case RROP_WHITE:
+ srcpix = ~0;
+ break;
+ case RROP_COPY:
+ srcpix = psrc[iy];
+ break;
+ case RROP_INVERT:
+ srcpix = ~psrc[iy];
+ break;
+ }
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ *p = MROP_MASK (srcpix,*p,startmask);
+ p++;
+ while (nlw--) {
+ *p = MROP_SOLID(srcpix,*p);
+ p++;
+ }
+
+ *p = MROP_MASK(srcpix,*p,endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ } else if (startmask && !endmask) {
+ nlwExtra -= 1;
+ while (h--) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ srcpix = 0;
+ break;
+ case RROP_WHITE:
+ srcpix = ~0;
+ break;
+ case RROP_COPY:
+ srcpix = psrc[iy];
+ break;
+ case RROP_INVERT:
+ srcpix = ~psrc[iy];
+ break;
+ }
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ *p = MROP_MASK(srcpix,*p,startmask);
+ p++;
+ while (nlw--) {
+ *p = MROP_SOLID(srcpix,*p);
+ p++;
+ }
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ } else if (!startmask && endmask) {
+ while (h--) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ srcpix = 0;
+ break;
+ case RROP_WHITE:
+ srcpix = ~0;
+ break;
+ case RROP_COPY:
+ srcpix = psrc[iy];
+ break;
+ case RROP_INVERT:
+ srcpix = ~psrc[iy];
+ break;
+ }
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ while (nlw--) {
+ *p = MROP_SOLID(srcpix,*p);
+ p++;
+ }
+
+ *p = MROP_MASK(srcpix,*p,endmask);
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ } else { /* no ragged bits at either end */
+ while (h--) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ srcpix = 0;
+ break;
+ case RROP_WHITE:
+ srcpix = ~0;
+ break;
+ case RROP_COPY:
+ srcpix = psrc[iy];
+ break;
+ case RROP_INVERT:
+ srcpix = ~psrc[iy];
+ break;
+ }
+ iy++;
+ if (iy == tileHeight)
+ iy = 0;
+ nlw = nlwMiddle;
+ while (nlw--) {
+ *p = MROP_SOLID (srcpix,*p);
+ p++;
+ }
+ ilbmScanlineInc(p, nlwExtra);
+ }
+ }
+ } /* for (d = ...) */
+ }
+ pbox++;
+ }
+}
+
+void
+MROP_NAME(ilbmOpaqueStippleArea)(pDraw, nbox, pbox, alu, pTile, xOff, yOff,
+ rropsOS, planemask)
+ DrawablePtr pDraw;
+ int nbox;
+ BoxPtr pbox;
+ int alu;
+ PixmapPtr pTile;
+ int xOff;
+ int yOff;
+ register unsigned char *rropsOS;
+ unsigned long planemask;
+{
+ register PixelType *psrc;
+ /* pointer to bits in tile, if needed */
+ int nlwidth; /* width in longwords of the drawable */
+ MROP_DECLARE_REG ()
+ register int h; /* height of current box */
+ register PixelType *pdst; /* pointer to bits we're writing */
+ register PixelType tmpsrc, tmpdst;
+ int auxDst;
+ int depthDst;
+ int tileLine;
+ int iline;
+ int w, width, x, xSrc, ySrc, srcStartOver, nend;
+ int tlwidth, rem, tileWidth, tileHeight, endinc;
+ int saveW;
+ PixelType *psrcT;
+ int d;
+ int nstart;
+ PixelType startmask;
+ PixelType endmask; /* masks for reggedy bits at either end of line */
+ int nlMiddle; /* number of longwords between sides of boxes */
+ int iy;
+ PixelType *pBase; /* pointer to start of drawable */
+ PixelType *saveP;
+ PixelType *pStartDst;
+ PixelType *pStartTile;
+ int saveH;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst,
+ pBase);
+
+ MROP_INITIALIZE(alu,~0)
+
+ tileHeight = pTile->drawable.height;
+ tileWidth = pTile->drawable.width;
+ tlwidth = pTile->devKind/sizeof(PixelType);
+
+ xSrc = pDraw->x + ((xOff % tileWidth) - tileWidth);
+ ySrc = pDraw->y + ((yOff % tileHeight) - tileHeight);
+
+ while (nbox--) {
+ saveW = pbox->x2 - pbox->x1;
+ iline = (pbox->y1 - ySrc) % tileHeight;
+ psrcT = (PixelType *) pTile->devPrivate.ptr;
+ tileLine = iline * tlwidth;
+ saveH = pbox->y2 - pbox->y1;
+ saveP = ilbmScanline(pBase, pbox->x1, pbox->y1, auxDst);
+
+ for (d = 0; d < depthDst; d++, saveP += nlwidth) { /* @@@ NEXT PLANE @@@ */
+ if (!(planemask & (1 << d)))
+ continue;
+
+ h = saveH;
+ pStartDst = saveP;
+ pStartTile = psrcT + tileLine;
+ iy = iline;
+
+ while (h--) {
+ x = pbox->x1;
+ width = saveW;
+ pdst = pStartDst;
+ while (width > 0) {
+ psrc = pStartTile;
+ w = min(tileWidth, width);
+ if ((rem = (x - xSrc) % tileWidth) != 0) {
+ /* if we're in the middle of the tile, get
+ as many bits as will finish the span, or
+ as many as will get to the left edge of the tile,
+ or a longword worth, starting at the appropriate
+ offset in the tile.
+ */
+ w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
+ endinc = rem / BITMAP_SCANLINE_PAD;
+
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+
+ case RROP_COPY:
+ getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
+ break;
+
+ case RROP_INVERT:
+ getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
+ tmpsrc = ~tmpsrc;
+ break;
+ }
+#if (MROP) != Mcopy
+ getbits (pdst, (x & PIM), w, tmpdst);
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, (x & PIM), w, pdst);
+
+ if ((x & PIM) + w >= PPW)
+ pdst++;
+ } else if (((x & PIM) + w) < PPW) {
+ /* doing < PPW bits is easy, and worth special-casing */
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+ case RROP_COPY:
+ tmpsrc = *psrc;
+ break;
+ case RROP_INVERT:
+ tmpsrc = ~*psrc;
+ break;
+ }
+#if (MROP) != Mcopy
+ getbits (pdst, (x & PIM), w, tmpdst);
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, (x & PIM), w, pdst);
+ } else {
+ /* start at the left edge of the tile,
+ and put down as much as we can
+ */
+ maskbits(x, w, startmask, endmask, nlMiddle);
+
+ if (startmask)
+ nstart = PPW - (x & PIM);
+ else
+ nstart = 0;
+ if (endmask)
+ nend = (x + w) & PIM;
+ else
+ nend = 0;
+
+ srcStartOver = nstart > PLST;
+
+ if (startmask) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+ case RROP_COPY:
+ tmpsrc = *psrc;
+ break;
+ case RROP_INVERT:
+ tmpsrc = ~*psrc;
+ break;
+ }
+#if (MROP) != Mcopy
+ getbits (pdst, (x & PIM), nstart, tmpdst);
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, (x & PIM), nstart, pdst);
+ pdst++;
+ if (srcStartOver)
+ psrc++;
+ }
+
+ while (nlMiddle--) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+ case RROP_COPY:
+ getbits (psrc, nstart, PPW, tmpsrc);
+ break;
+ case RROP_INVERT:
+ getbits (psrc, nstart, PPW, tmpsrc);
+ tmpsrc = ~tmpsrc;
+ break;
+ }
+#if (MROP) != Mcopy
+ tmpdst = *pdst;
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ *pdst++ = tmpsrc;
+ /*putbits (tmpsrc, 0, PPW, pdst);
+ pdst++; */
+ psrc++;
+ }
+
+ if (endmask) {
+ switch (rropsOS[d]) {
+ case RROP_BLACK:
+ tmpsrc = 0;
+ break;
+ case RROP_WHITE:
+ tmpsrc = ~0;
+ break;
+
+ case RROP_COPY:
+ getbits (psrc, nstart, nend, tmpsrc);
+ break;
+
+ case RROP_INVERT:
+ getbits (psrc, nstart, nend, tmpsrc);
+ tmpsrc = ~tmpsrc;
+ break;
+ }
+#if (MROP) != Mcopy
+ tmpdst = *pdst;
+ tmpsrc = DoMergeRop (tmpsrc, tmpdst);
+#endif
+ putbits (tmpsrc, 0, nend, pdst);
+ }
+ }
+ x += w;
+ width -= w;
+ } /* while (width > 0) */
+
+ pStartDst += auxDst;
+ if (++iy >= tileHeight) {
+ iy = 0;
+ pStartTile = psrcT;
+ } else
+ pStartTile += tlwidth;
+
+ } /* while (h) */
+ } /* for (d = ... ) */
+ pbox++;
+ } /* for each box */
+}
diff --git a/ilbm/ilbmwindow.c b/ilbm/ilbmwindow.c
new file mode 100644
index 000000000..524972944
--- /dev/null
+++ b/ilbm/ilbmwindow.c
@@ -0,0 +1,319 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmwindow.c,v 3.0 1996/08/18 01:54:14 dawes Exp $ */
+/* $XConsortium: ilbmwindow.c,v 5.14 94/04/17 20:28:36 dpw Exp $ */
+/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
+/***********************************************************
+
+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 jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+#include "ilbm.h"
+#include "mistruct.h"
+#include "regionstr.h"
+#include "maskbits.h"
+
+extern WindowPtr *WindowTable;
+
+Bool
+ilbmCreateWindow(pWin)
+ register WindowPtr pWin;
+{
+ register ilbmPrivWin *pPrivWin;
+
+ pPrivWin = (ilbmPrivWin *)(pWin->devPrivates[ilbmWindowPrivateIndex].ptr);
+ pPrivWin->pRotatedBorder = NullPixmap;
+ pPrivWin->pRotatedBackground = NullPixmap;
+ pPrivWin->fastBackground = FALSE;
+ pPrivWin->fastBorder = FALSE;
+#ifdef PIXMAP_PER_WINDOW
+ pWin->devPrivates[frameWindowPrivateIndex].ptr =
+ pWin->pDrawable.pScreen->devPrivates[ilbmScreenPrivateIndex].ptr;
+#endif
+
+ return (TRUE);
+}
+
+/* This always returns true, because Xfree can't fail. It might be possible
+ * on some devices for Destroy to fail */
+Bool
+ilbmDestroyWindow(pWin)
+ WindowPtr pWin;
+{
+ register ilbmPrivWin *pPrivWin;
+
+ pPrivWin = (ilbmPrivWin *)(pWin->devPrivates[ilbmWindowPrivateIndex].ptr);
+
+ if (pPrivWin->pRotatedBorder)
+ (*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBorder);
+ if (pPrivWin->pRotatedBackground)
+ (*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBackground);
+
+ return (TRUE);
+}
+
+/*ARGSUSED*/
+Bool
+ilbmMapWindow(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.)
+ ilbmChangeWindowAttributes() has already put a copy of the pixmap
+in pPrivWin->pRotated*
+*/
+
+/*ARGSUSED*/
+Bool
+ilbmPositionWindow(pWin, x, y)
+ WindowPtr pWin;
+ int x, y;
+{
+ register ilbmPrivWin *pPrivWin;
+ int reset = 0;
+
+ pPrivWin = (ilbmPrivWin *)(pWin->devPrivates[ilbmWindowPrivateIndex].ptr);
+ if (pWin->backgroundState == BackgroundPixmap && pPrivWin->fastBackground) {
+ ilbmXRotatePixmap(pPrivWin->pRotatedBackground,
+ pWin->drawable.x - pPrivWin->oldRotate.x);
+ ilbmYRotatePixmap(pPrivWin->pRotatedBackground,
+ pWin->drawable.y - pPrivWin->oldRotate.y);
+ reset = 1;
+ }
+
+ if (!pWin->borderIsPixel && pPrivWin->fastBorder) {
+ while (pWin->backgroundState == ParentRelative)
+ pWin = pWin->parent;
+ ilbmXRotatePixmap(pPrivWin->pRotatedBorder,
+ pWin->drawable.x - pPrivWin->oldRotate.x);
+ ilbmYRotatePixmap(pPrivWin->pRotatedBorder,
+ pWin->drawable.y - pPrivWin->oldRotate.y);
+ reset = 1;
+ }
+ if (reset) {
+ pPrivWin->oldRotate.x = pWin->drawable.x;
+ pPrivWin->oldRotate.y = pWin->drawable.y;
+ }
+
+ /* This is the "wrong" fix to the right problem, but it doesn't really
+ * cost very much. When the window is moved, we need to invalidate any
+ * RotatedPixmap that exists in any GC currently validated against this
+ * window.
+ */
+ pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+
+ /* Again, we have no failure modes indicated by any of the routines
+ * we've called, so we have to assume it worked */
+ return (TRUE);
+}
+
+/*ARGSUSED*/
+Bool
+ilbmUnmapWindow(pWindow)
+ WindowPtr pWindow;
+{
+ return (TRUE);
+}
+
+/* UNCLEAN!
+ this code calls the bitblt helper code directly.
+
+ ilbmCopyWindow copies only the parts of the destination that are
+visible in the source.
+*/
+
+
+void
+ilbmCopyWindow(pWin, ptOldOrg, prgnSrc)
+ WindowPtr pWin;
+ DDXPointRec ptOldOrg;
+ RegionPtr prgnSrc;
+{
+ DDXPointPtr pptSrc;
+ register DDXPointPtr ppt;
+ RegionPtr prgnDst;
+ register BoxPtr pbox;
+ register int dx, dy;
+ register int i, nbox;
+ WindowPtr pwinRoot;
+
+ pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
+
+ prgnDst = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
+
+ 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, prgnDst, &pWin->borderClip,
+ prgnSrc);
+
+ pbox = REGION_RECTS(prgnDst);
+ nbox = REGION_NUM_RECTS(prgnDst);
+ if (!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
+ return;
+ ppt = pptSrc;
+
+ for (i=nbox; --i >= 0; ppt++, pbox++) {
+ ppt->x = pbox->x1 + dx;
+ ppt->y = pbox->y1 + dy;
+ }
+
+ ilbmDoBitblt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot, GXcopy, prgnDst,
+ pptSrc, ~0);
+ DEALLOCATE_LOCAL(pptSrc);
+ REGION_DESTROY(pWin->drawable.pScreen, prgnDst);
+}
+
+
+
+/* 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 devPrivate.
+*/
+Bool
+ilbmChangeWindowAttributes(pWin, mask)
+ register WindowPtr pWin;
+ register unsigned long mask;
+{
+ register unsigned long index;
+ register ilbmPrivWin *pPrivWin;
+ WindowPtr pBgWin;
+
+ pPrivWin = (ilbmPrivWin *)(pWin->devPrivates[ilbmWindowPrivateIndex].ptr);
+ /*
+ * 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)) {
+ ilbmXRotatePixmap(pPrivWin->pRotatedBorder,
+ pWin->drawable.x - pPrivWin->oldRotate.x);
+ ilbmYRotatePixmap(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);
+ ilbmXRotatePixmap(pPrivWin->pRotatedBorder,
+ pBgWin->drawable.x - pPrivWin->oldRotate.x);
+ ilbmYRotatePixmap(pPrivWin->pRotatedBorder,
+ pBgWin->drawable.y - pPrivWin->oldRotate.y);
+ pPrivWin->oldRotate.x = pBgWin->drawable.x;
+ pPrivWin->oldRotate.y = pBgWin->drawable.y;
+ }
+ } else if ((pWin->background.pixmap->drawable.width <= PPW) &&
+ !(pWin->background.pixmap->drawable.width &
+ (pWin->background.pixmap->drawable.width - 1))) {
+ ilbmCopyRotatePixmap(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 ((pWin->border.pixmap->drawable.width <= PPW) &&
+ !(pWin->border.pixmap->drawable.width &
+ (pWin->border.pixmap->drawable.width - 1))) {
+ for (pBgWin = pWin;
+ pBgWin->backgroundState == ParentRelative;
+ pBgWin = pBgWin->parent);
+ ilbmCopyRotatePixmap(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;
+ }
+ }
+ /* Again, we have no failure modes indicated by any of the routines
+ * we've called, so we have to assume it worked */
+ return (TRUE);
+}
diff --git a/ilbm/ilbmzerarc.c b/ilbm/ilbmzerarc.c
new file mode 100644
index 000000000..9bdf22155
--- /dev/null
+++ b/ilbm/ilbmzerarc.c
@@ -0,0 +1,210 @@
+/* $XFree86: xc/programs/Xserver/ilbm/ilbmzerarc.c,v 3.1 1998/03/20 21:08:04 hohndel Exp $ */
+/************************************************************
+
+Copyright (c) 1989 X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+********************************************************/
+
+/* $XConsortium: ilbmzerarc.c,v 5.19 94/04/17 20:28:37 dpw Exp $ */
+
+/* Derived from:
+ * "Algorithm for drawing ellipses or hyperbolae with a digital plotter"
+ * by M. L. V. Pitteway
+ * The Computer Journal, November 1967, Volume 10, Number 3, pp. 282-289
+ */
+
+/* Modified jun 95 by Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
+ to use interleaved bitplanes instead of normal bitplanes */
+
+#include "X.h"
+#include "Xprotostr.h"
+#include "miscstruct.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "scrnintstr.h"
+#include "ilbm.h"
+#include "maskbits.h"
+#include "mizerarc.h"
+#include "mi.h"
+
+/*
+ * Note: LEFTMOST must be the bit leftmost in the actual screen
+ * representation. This depends also on the IMAGE_BYTE_ORDER.
+ * LONG2CHARS() takes care of the re-ordering as required. (DHD)
+ */
+#if (BITMAP_BIT_ORDER == MSBFirst)
+#define LEFTMOST ((PixelType) LONG2CHARS((1 << PLST)))
+#else
+#define LEFTMOST ((PixelType) LONG2CHARS(1))
+#endif
+
+#define Pixelate(base,yoff,xoff) \
+{ \
+ paddr = ilbmScanlineOffset(base, (yoff) + ((xoff)>>PWSH)); \
+ pmask = SCRRIGHT(LEFTMOST, (xoff) & PIM); \
+ for (de = 0; de < depthDst; de++, paddr += nlwidth) /* @@@ NEXT PLANE @@@ */ \
+ switch (rrops[de]) { \
+ case RROP_BLACK: \
+ *paddr &= ~pmask; \
+ break; \
+ case RROP_WHITE: \
+ *paddr |= pmask; \
+ break; \
+ case RROP_INVERT: \
+ *paddr ^= pmask; \
+ break; \
+ case RROP_NOP: \
+ break; \
+ } \
+}
+
+#define DoPix(bit,base,yoff,xoff) if (mask & bit) Pixelate(base,yoff,xoff);
+
+static void
+ilbmZeroArcSS(pDraw, pGC, arc)
+ DrawablePtr pDraw;
+ GCPtr pGC;
+ xArc *arc;
+{
+ miZeroArcRec info;
+ Bool do360;
+ register int de;
+ register int x, y, a, b, d, mask;
+ register int k1, k3, dx, dy;
+ PixelType *addrl;
+ PixelType *yorgl, *yorgol;
+ PixelType pixel;
+ int nlwidth, yoffset, dyoffset;
+ int auxDst, depthDst;
+ PixelType pmask;
+ register PixelType *paddr;
+ register unsigned char *rrops;
+
+ rrops = ((ilbmPrivGC *)(pGC->devPrivates[ilbmGCPrivateIndex].ptr))->rrops;
+
+ ilbmGetPixelWidthAuxDepthAndPointer(pDraw, nlwidth, auxDst, depthDst,
+ addrl);
+ do360 = miZeroArcSetup(arc, &info, TRUE);
+ yorgl = addrl + ((info.yorg + pDraw->y) * auxDst);
+ yorgol = addrl + ((info.yorgo + pDraw->y) * auxDst);
+ info.xorg += pDraw->x;
+ info.xorgo += pDraw->x;
+ MIARCSETUP();
+ yoffset = y ? auxDst : 0;
+ dyoffset = 0;
+ mask = info.initialMask;
+ if (!(arc->width & 1)) {
+ DoPix(2, yorgl, 0, info.xorgo);
+ DoPix(8, yorgol, 0, info.xorgo);
+ }
+ if (!info.end.x || !info.end.y) {
+ mask = info.end.mask;
+ info.end = info.altend;
+ }
+ if (do360 && (arc->width == arc->height) && !(arc->width & 1)) {
+ int xoffset = auxDst;
+ PixelType *yorghl = ilbmScanlineDeltaNoBankSwitch(yorgl, info.h, auxDst);
+ int xorghp = info.xorg + info.h;
+ int xorghn = info.xorg - info.h;
+
+ while (1) {
+ Pixelate(yorgl, yoffset, info.xorg + x);
+ Pixelate(yorgl, yoffset, info.xorg - x);
+ Pixelate(yorgol, -yoffset, info.xorg - x);
+ Pixelate(yorgol, -yoffset, info.xorg + x);
+ if (a < 0)
+ break;
+ Pixelate(yorghl, -xoffset, xorghp - y);
+ Pixelate(yorghl, -xoffset, xorghn + y);
+ Pixelate(yorghl, xoffset, xorghn + y);
+ Pixelate(yorghl, xoffset, xorghp - y);
+ xoffset += auxDst;
+ MIARCCIRCLESTEP(yoffset += auxDst;);
+ }
+ x = info.w;
+ yoffset = info.h * auxDst;
+ } else if (do360) {
+ while (y < info.h || x < info.w) {
+ MIARCOCTANTSHIFT(dyoffset = auxDst;);
+ Pixelate(yorgl, yoffset, info.xorg + x);
+ Pixelate(yorgl, yoffset, info.xorgo - x);
+ Pixelate(yorgol, -yoffset, info.xorgo - x);
+ Pixelate(yorgol, -yoffset, info.xorg + x);
+ MIARCSTEP(yoffset += dyoffset;, yoffset += auxDst;);
+ }
+ } else {
+ while (y < info.h || x < info.w) {
+ MIARCOCTANTSHIFT(dyoffset = auxDst;);
+ if ((x == info.start.x) || (y == info.start.y)) {
+ mask = info.start.mask;
+ info.start = info.altstart;
+ }
+ DoPix(1, yorgl, yoffset, info.xorg + x);
+ DoPix(2, yorgl, yoffset, info.xorgo - x);
+ DoPix(4, yorgol, -yoffset, info.xorgo - x);
+ DoPix(8, yorgol, -yoffset, info.xorg + x);
+ if ((x == info.end.x) || (y == info.end.y)) {
+ mask = info.end.mask;
+ info.end = info.altend;
+ }
+ MIARCSTEP(yoffset += dyoffset;, yoffset += auxDst;);
+ }
+ }
+ if ((x == info.start.x) || (y == info.start.y))
+ mask = info.start.mask;
+ DoPix(1, yorgl, yoffset, info.xorg + x);
+ DoPix(4, yorgol, -yoffset, info.xorgo - x);
+ if (arc->height & 1) {
+ DoPix(2, yorgl, yoffset, info.xorgo - x);
+ DoPix(8, yorgol, -yoffset, info.xorg + x);
+ }
+}
+
+void
+ilbmZeroPolyArcSS(pDraw, pGC, narcs, parcs)
+ DrawablePtr pDraw;
+ GCPtr pGC;
+ int narcs;
+ xArc *parcs;
+{
+ register xArc *arc;
+ register int i;
+ BoxRec box;
+ RegionPtr cclip;
+
+ cclip = pGC->pCompositeClip;
+ for (arc = parcs, i = narcs; --i >= 0; arc++) {
+ if (miCanZeroArc(arc)) {
+ box.x1 = arc->x + pDraw->x;
+ box.y1 = arc->y + pDraw->y;
+ box.x2 = box.x1 + (int)arc->width + 1;
+ box.y2 = box.y1 + (int)arc->height + 1;
+ if (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN)
+ ilbmZeroArcSS(pDraw, pGC, arc);
+ else
+ miZeroPolyArc(pDraw, pGC, 1, arc);
+ } else
+ miPolyArc(pDraw, pGC, 1, arc);
+ }
+}