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