#include "X.h"
#include "Xmd.h"
#include "gcstruct.h"
#include "window.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "windowstr.h"
#include "mfb.h"
#include "maskbits.h"
#include "mergerop.h"
#include "servermd.h"
#include "mi.h"
#include "mispans.h"
void
mfbBlackSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GCPtr pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *addrl;
register int nlmiddle;
register PixelType startmask;
register PixelType endmask;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
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);
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
while (n--)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
if (*pwidth)
{
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl &= ~startmask;
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
*addrl++ &= ~startmask;
Duff (nlmiddle, *addrl++ = 0x0);
if (endmask)
*addrl &= ~endmask;
}
}
pwidth++;
ppt++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
void
mfbWhiteSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GCPtr pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *addrl;
register int nlmiddle;
register PixelType startmask;
register PixelType endmask;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
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);
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
while (n--)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
if (*pwidth)
{
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl |= startmask;
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
*addrl++ |= startmask;
Duff (nlmiddle, *addrl++ = ~0);
if (endmask)
*addrl |= endmask;
}
}
pwidth++;
ppt++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
void
mfbInvertSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GCPtr pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *addrl;
register int nlmiddle;
register PixelType startmask;
register PixelType endmask;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
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);
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
while (n--)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
if (*pwidth)
{
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl ^= startmask;
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
*addrl++ ^= startmask;
Duff (nlmiddle, *addrl++ ^= ~0);
if (endmask)
*addrl ^= endmask;
}
}
pwidth++;
ppt++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
void
mfbWhiteStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GC *pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *addrl;
register PixelType src;
register int nlmiddle;
register PixelType startmask;
register PixelType endmask;
PixmapPtr pStipple;
PixelType *psrc;
int tileHeight;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
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);
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
pStipple = pGC->pRotatedPixmap;
tileHeight = pStipple->drawable.height;
psrc = (PixelType *)(pStipple->devPrivate.ptr);
while (n--)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
src = psrc[ppt->y % tileHeight];
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl |= (src & startmask);
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
*addrl++ |= (src & startmask);
Duff (nlmiddle, *addrl++ |= src);
if (endmask)
*addrl |= (src & endmask);
}
pwidth++;
ppt++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
void
mfbBlackStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GC *pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *addrl;
register PixelType src;
register int nlmiddle;
register PixelType startmask;
register PixelType endmask;
PixmapPtr pStipple;
PixelType *psrc;
int tileHeight;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
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);
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
pStipple = pGC->pRotatedPixmap;
tileHeight = pStipple->drawable.height;
psrc = (PixelType *)(pStipple->devPrivate.ptr);
while (n--)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
src = psrc[ppt->y % tileHeight];
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl &= ~(src & startmask);
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
*addrl++ &= ~(src & startmask);
Duff (nlmiddle, *addrl++ &= ~src);
if (endmask)
*addrl &= ~(src & endmask);
}
pwidth++;
ppt++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
void
mfbInvertStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GC *pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *addrl;
register PixelType src;
register int nlmiddle;
register PixelType startmask;
register PixelType endmask;
PixmapPtr pStipple;
PixelType *psrc;
int tileHeight;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
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);
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
pStipple = pGC->pRotatedPixmap;
tileHeight = pStipple->drawable.height;
psrc = (PixelType *)(pStipple->devPrivate.ptr);
while (n--)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
src = psrc[ppt->y % tileHeight];
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl ^= (src & startmask);
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
*addrl++ ^= (src & startmask);
Duff(nlmiddle, *addrl++ ^= src);
if (endmask)
*addrl ^= (src & endmask);
}
pwidth++;
ppt++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
#define FILLSPANPPW(ROP) \
while (n--) \
{ \
if (*pwidth) \
{ \
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth); \
src = psrc[ppt->y % tileHeight]; \
if ( ((ppt->x & PIM) + *pwidth) < PPW) \
{ \
maskpartialbits(ppt->x, *pwidth, startmask); \
*addrl = (*addrl & ~startmask) | \
(ROP(src, *addrl) & startmask); \
} \
else \
{ \
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); \
if (startmask) \
{ \
*addrl = (*addrl & ~startmask) | \
(ROP(src, *addrl) & startmask); \
addrl++; \
} \
while (nlmiddle--) \
{ \
*addrl = ROP(src, *addrl); \
addrl++; \
} \
if (endmask) \
*addrl = (*addrl & ~endmask) | \
(ROP(src, *addrl) & endmask); \
} \
} \
pwidth++; \
ppt++; \
}
void
mfbTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GC *pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *addrl;
register PixelType src;
register int nlmiddle;
register PixelType startmask;
register PixelType endmask;
PixmapPtr pTile;
PixelType *psrc;
int tileHeight;
int rop;
int *pwidthFree;
DDXPointPtr pptFree;
MfbBits flip;
if (!(pGC->planemask & 1))
return;
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);
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
pTile = pGC->pRotatedPixmap;
tileHeight = pTile->drawable.height;
psrc = (PixelType *)(pTile->devPrivate.ptr);
if (pGC->fillStyle == FillTiled)
rop = pGC->alu;
else
rop = ((mfbPrivGC *)(pGC->devPrivates[mfbGCPrivateIndex].ptr))->ropOpStip;
flip = 0;
switch(rop)
{
case GXcopyInverted:
flip = ~0;
case GXcopy:
{
#define DoMaskCopyRop(src,dst,mask) (((dst) & ~(mask)) | ((src) & (mask)))
while (n--)
{
if (*pwidth)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
src = psrc[ppt->y % tileHeight] ^ flip;
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl = DoMaskCopyRop (src, *addrl, startmask);
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
{
*addrl = DoMaskCopyRop (src, *addrl, startmask);
addrl++;
}
while (nlmiddle--)
{
*addrl = src;
addrl++;
}
if (endmask)
*addrl = DoMaskCopyRop (src, *addrl, endmask);
}
}
pwidth++;
ppt++;
}
}
break;
default:
{
register DeclareMergeRop ();
InitializeMergeRop(rop,~0);
while (n--)
{
if (*pwidth)
{
addrl = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
src = psrc[ppt->y % tileHeight];
if ( ((ppt->x & PIM) + *pwidth) < PPW)
{
maskpartialbits(ppt->x, *pwidth, startmask);
*addrl = DoMaskMergeRop (src, *addrl, startmask);
}
else
{
maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle);
if (startmask)
{
*addrl = DoMaskMergeRop (src, *addrl, startmask);
addrl++;
}
while (nlmiddle--)
{
*addrl = DoMergeRop (src, *addrl);
addrl++;
}
if (endmask)
*addrl = DoMaskMergeRop (src, *addrl, endmask);
}
}
pwidth++;
ppt++;
}
}
break;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
void
mfbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GC *pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int iline;
int n;
register DDXPointPtr ppt;
register int *pwidth;
PixelType *addrlBase;
int nlwidth;
register PixelType *pdst;
register PixelType *psrc;
register int nlMiddle;
register int rop, nstart;
PixelType startmask;
PixmapPtr pTile;
int w, width, x, xSrc, ySrc, srcStartOver, nend;
int tlwidth, rem, tileWidth, tileHeight, endinc;
PixelType endmask, *psrcT;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
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);
if (pGC->fillStyle == FillTiled)
{
pTile = pGC->tile.pixmap;
tlwidth = pTile->devKind / PGSZB;
rop = pGC->alu;
}
else
{
pTile = pGC->stipple;
tlwidth = pTile->devKind / PGSZB;
rop = ((mfbPrivGC *)(pGC->devPrivates[mfbGCPrivateIndex].ptr))->ropOpStip;
}
xSrc = pDrawable->x;
ySrc = pDrawable->y;
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
tileWidth = pTile->drawable.width;
tileHeight = pTile->drawable.height;
xSrc += (pGC->patOrg.x % tileWidth) - tileWidth;
ySrc += (pGC->patOrg.y % tileHeight) - tileHeight;
while (n--)
{
iline = (ppt->y - ySrc) % tileHeight;
pdst = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
psrcT = (PixelType *) pTile->devPrivate.ptr + (iline * tlwidth);
x = ppt->x;
if (*pwidth)
{
width = *pwidth;
while(width > 0)
{
psrc = psrcT;
w = min(tileWidth, width);
if((rem = (x - xSrc) % tileWidth) != 0)
{
w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
endinc = rem / BITMAP_SCANLINE_PAD;
getandputrop((psrc+endinc), (rem&PIM), (x & PIM), w, pdst, rop);
if((x & PIM) + w >= PPW)
pdst++;
}
else if(((x & PIM) + w) < PPW)
{
putbitsrop(*psrc, x & PIM, w, pdst, rop);
}
else
{
maskbits(x, w, startmask, endmask, nlMiddle);
if (startmask)
nstart = PPW - (x & PIM);
else
nstart = 0;
if (endmask)
nend = (x + w) & PIM;
else
nend = 0;
srcStartOver = nstart > PLST;
if(startmask)
{
putbitsrop(*psrc, (x & PIM), nstart, pdst, rop);
pdst++;
#if defined(__alpha__) || defined(__alpha)
psrc += srcStartOver;
#else
if(srcStartOver)
psrc++;
#endif
}
while(nlMiddle--)
{
getandputrop0(psrc, nstart, PPW, pdst, rop);
pdst++;
psrc++;
}
if(endmask)
{
getandputrop0(psrc, nstart, nend, pdst, rop);
}
}
x += w;
width -= w;
}
}
ppt++;
pwidth++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}
void
mfbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
DrawablePtr pDrawable;
GC *pGC;
int nInit;
DDXPointPtr pptInit;
int *pwidthInit;
int fSorted;
{
int n;
register DDXPointPtr ppt;
register int *pwidth;
int iline;
PixelType *addrlBase;
int nlwidth;
register PixelType *pdst;
register PixelType *psrc;
register int nlMiddle;
register int rop, nstart;
PixelType startmask;
PixmapPtr pTile;
int w, width, x, xSrc, ySrc, srcStartOver, nend;
PixelType endmask, *psrcT;
int tlwidth, rem, tileWidth, endinc;
int tileHeight;
int *pwidthFree;
DDXPointPtr pptFree;
if (!(pGC->planemask & 1))
return;
n = nInit * miFindMaxBand(pGC->pCompositeClip);
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
if(!pptFree || !pwidthFree)
{
if (pptFree) DEALLOCATE_LOCAL(pptFree);
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
return;
}
pwidth = pwidthFree;
ppt = pptFree;
n = miClipSpans(pGC->pCompositeClip, pptInit, pwidthInit, nInit,
ppt, pwidth, fSorted);
pTile = pGC->stipple;
rop = ((mfbPrivGC *)(pGC->devPrivates[mfbGCPrivateIndex].ptr))->rop;
tlwidth = pTile->devKind / PGSZB;
xSrc = pDrawable->x;
ySrc = pDrawable->y;
mfbGetPixelWidthAndPointer(pDrawable, nlwidth, addrlBase);
tileWidth = pTile->drawable.width;
tileHeight = pTile->drawable.height;
xSrc += (pGC->patOrg.x % tileWidth) - tileWidth;
ySrc += (pGC->patOrg.y % tileHeight) - tileHeight;
while (n--)
{
iline = (ppt->y - ySrc) % tileHeight;
pdst = mfbScanline(addrlBase, ppt->x, ppt->y, nlwidth);
psrcT = (PixelType *) pTile->devPrivate.ptr + (iline * tlwidth);
x = ppt->x;
if (*pwidth)
{
width = *pwidth;
while(width > 0)
{
psrc = psrcT;
w = min(tileWidth, width);
if((rem = (x - xSrc) % tileWidth) != 0)
{
w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
endinc = rem / BITMAP_SCANLINE_PAD;
getandputrrop((psrc + endinc), (rem & PIM), (x & PIM),
w, pdst, rop)
if((x & PIM) + w >= PPW)
pdst++;
}
else if(((x & PIM) + w) < PPW)
{
putbitsrrop(*psrc, x & PIM, w, pdst, rop);
}
else
{
maskbits(x, w, startmask, endmask, nlMiddle);
if (startmask)
nstart = PPW - (x & PIM);
else
nstart = 0;
if (endmask)
nend = (x + w) & PIM;
else
nend = 0;
srcStartOver = nstart > PLST;
if(startmask)
{
putbitsrrop(*psrc, (x & PIM), nstart, pdst, rop);
pdst++;
if(srcStartOver)
psrc++;
}
while(nlMiddle--)
{
getandputrrop0(psrc, nstart, PPW, pdst, rop);
pdst++;
psrc++;
}
if(endmask)
{
getandputrrop0(psrc, nstart, nend, pdst, rop);
}
}
x += w;
width -= w;
}
}
ppt++;
pwidth++;
}
DEALLOCATE_LOCAL(pptFree);
DEALLOCATE_LOCAL(pwidthFree);
}