/* See Porting Layer Definition - p. 55 */
void
winSetSpansNativeGDI (DrawablePtr pDrawable,
GCPtr pGC,
char *pSrcs,
DDXPointPtr pPoints,
int *piWidths,
int iSpans,
int fSorted)
{
winGCPriv(pGC);
PixmapPtr pPixmap = NULL;
winPrivPixmapPtr pPixmapPriv = NULL;
int iSpan;
int *piWidth = NULL;
DDXPointPtr pPoint = NULL;
char *pSrc = pSrcs;
HDC hdcMem;
BITMAPINFOHEADER *pbmih;
HBITMAP hBitmap = NULL;
HBITMAP hbmpOrig = NULL;
DEBUG_FN_NAME("winSetSpans");
DEBUGVARS;
DEBUGPROC_MSG;
/* Branch on the drawable type */
switch (pDrawable->type)
{
case DRAWABLE_PIXMAP:
pPixmap = (PixmapPtr) pDrawable;
pPixmapPriv = winGetPixmapPriv (pPixmap);
/* Select the drawable pixmap into a DC */
hbmpOrig = SelectObject (pGCPriv->hdcMem, pPixmapPriv->hBitmap);
if (hbmpOrig == NULL)
FatalError ("winSetSpans - DRAWABLE_PIXMAP - SelectObject () "
"failed on pPixmapPriv->hBitmap\n");
/* Branch on the raster operation type */
switch (pGC->alu)
{
case GXclear:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXclear\n");
break;
case GXand:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXand\n");
break;
case GXandReverse:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXandReverse\n");
break;
case GXcopy:
ErrorF ("winSetSpans - DRAWABLE_PIXMAP - GXcopy %08x\n",
pDrawable);
/* Loop through spans */
for (iSpan = 0; iSpan < iSpans; ++iSpan)
{
piWidth = piWidths + iSpan;
pPoint = pPoints + iSpan;
/* Blast the bits to the drawable */
SetDIBits (pGCPriv->hdcMem,
pPixmapPriv->hBitmap,
pPoint->y, 1,
pSrc,
(BITMAPINFO *) pPixmapPriv->pbmih,
0);
/* Display some useful information */
ErrorF ("(%dx%dx%d) (%d,%d) w: %d ps: %08x\n",
pDrawable->width, pDrawable->height, pDrawable->depth,
pPoint->x, pPoint->y, *piWidth, pSrc);
/* Calculate offset of next bit source */
pSrc += 4 * ((*piWidth + 31) / 32);
}
/*
* REMOVE - Visual verification only.
*/
BitBlt (pGCPriv->hdc,
pDrawable->width * 2, pDrawable->height,
pDrawable->width, pDrawable->height,
pGCPriv->hdcMem,
0, 0,
SRCCOPY);
DEBUG_MSG ("DRAWABLE_PIXMAP - GXcopy");
break;
case GXandInverted:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXandInverted\n");
break;
case GXnoop:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXnoop\n");
break;
case GXxor:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXxor\n");
break;
case GXor:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXor\n");
break;
case GXnor:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXnor\n");
break;
case GXequiv:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXequiv\n");
break;
case GXinvert:
ErrorF ("winSetSpans - DRAWABLE_PIXMAP - GXinvert %08x\n",
pDrawable);
/* Create a temporary DC */
hdcMem = CreateCompatibleDC (NULL);
/* Loop through spans */
for (iSpan = 0; iSpan < iSpans; ++iSpan)
{
piWidth = piWidths + iSpan;
pPoint = pPoints + iSpan;
/* Create a one-line DIB for the bit data */
hBitmap = winCreateDIBNativeGDI (*piWidth, 1, pDrawable->depth,
NULL, (BITMAPINFO **) &pbmih);
/* Select the span line line bitmap into the temporary DC */
hbmpOrig = SelectObject (hdcMem, hBitmap);
/* Blast bit data to the one-line DIB */
SetDIBits (hdcMem, hBitmap,
0, 1,
pSrc,
(BITMAPINFO *) pbmih,
DIB_RGB_COLORS);
/* Blit the span line to the drawable */
BitBlt (pGCPriv->hdcMem,
pPoint->x, pPoint->y,
*piWidth, 1,
hdcMem,
0, 0,
NOTSRCCOPY);
/*
* REMOVE - Visual verification only.
*/
BitBlt (pGCPriv->hdc,
pDrawable->width, pDrawable->height + pPoint->y,
*piWidth, 1,
hdcMem,
0, 0,
SRCCOPY);
/* Display some useful information */
ErrorF ("(%dx%dx%d) (%d,%d) w: %d ps: %08x\n",
pDrawable->width, pDrawable->height, pDrawable->depth,
pPoint->x, pPoint->y, *piWidth, pSrc);
/* Calculate offset of next bit source */
pSrc += 4 * ((*piWidth + 31) / 32);
/* Pop the span line bitmap out of the memory DC */
SelectObject (hdcMem, hbmpOrig);
/* Free the temporary bitmap */
DeleteObject (hBitmap);
hBitmap = NULL;
}
/*
* REMOVE - Visual verification only.
*/
DEBUG_MSG ("DRAWABLE_PIXMAP - GXinvert - Prior to invert");
BitBlt (pGCPriv->hdc,
pDrawable->width * 2, pDrawable->height,
pDrawable->width, pDrawable->height,
pGCPriv->hdcMem,
0, 0,
SRCCOPY);
DEBUG_MSG ("DRAWABLE_PIXMAP - GXinvert - Finished invert");
/* Release the scratch DC */
DeleteDC (hdcMem);
break;
case GXorReverse:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXorReverse\n");
break;
case GXcopyInverted:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXcopyInverted\n");
break;
case GXorInverted:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXorInverted\n");
break;
case GXnand:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXnand\n");
break;
case GXset:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - GXset\n");
break;
default:
FatalError ("winSetSpans - DRAWABLE_PIXMAP - Unknown ROP\n");
break;
}
/* Push the drawable pixmap out of the GC HDC */
SelectObject (pGCPriv->hdcMem, hbmpOrig);
break;
case DRAWABLE_WINDOW:
FatalError ("\nwinSetSpansNativeGDI - DRAWABLE_WINDOW\n\n");
/* Branch on the raster operation type */
switch (pGC->alu)
{
case GXclear:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXclear\n");
break;
case GXand:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXand\n");
break;
case GXandReverse:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXandReverse\n");
break;
case GXcopy:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXcopy\n");
break;
case GXandInverted:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXandInverted\n");
break;
case GXnoop:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXnoop\n");
break;
case GXxor:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXxor\n");
break;
case GXor:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXor\n");
break;
case GXnor:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXnor\n");
break;
case GXequiv:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXequiv\n");
break;
case GXinvert:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXinvert\n");
break;
case GXorReverse:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXorReverse\n");
break;
case GXcopyInverted:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXcopyInverted\n");
break;
case GXorInverted:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXorInverted\n");
break;
case GXnand:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXnand\n");
break;
case GXset:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - GXset\n");
break;
default:
ErrorF ("winSetSpans () - DRAWABLE_WINDOW - Unknown ROP\n");
break;
}
break;
case UNDRAWABLE_WINDOW:
FatalError ("\nwinSetSpansNativeGDI - UNDRAWABLE_WINDOW\n\n");
break;
case DRAWABLE_BUFFER:
FatalError ("\nwinSetSpansNativeGDI - DRAWABLE_BUFFER\n\n");
break;
default:
FatalError ("\nwinSetSpansNativeGDI - Unknown drawable type\n\n");
break;
}
}
/* See Porting Layer Definition - p. 55 */
void
winGetSpansNativeGDI(DrawablePtr pDrawable,
int nMax,
DDXPointPtr pPoints,
int *piWidths, int iSpans, char *pDsts)
{
PixmapPtr pPixmap = NULL;
winPrivPixmapPtr pPixmapPriv = NULL;
int iSpan;
DDXPointPtr pPoint = NULL;
int *piWidth = NULL;
char *pDst = pDsts;
HBITMAP hbmpWindow, hbmpOrig, hbmpOrig1;
BYTE *pbWindow = NULL;
HDC hdcMem, hdcMem1;
ScreenPtr pScreen = pDrawable->pScreen;
winScreenPriv(pScreen);
/* Branch on the drawable type */
switch (pDrawable->type) {
case DRAWABLE_PIXMAP:
winDebug ("winGetSpans - DRAWABLE_PIXMAP %08x\n", pDrawable);
pPixmap = (PixmapPtr) pDrawable;
pPixmapPriv = winGetPixmapPriv(pPixmap);
/* Open a memory HDC */
hdcMem1 = CreateCompatibleDC(NULL);
hdcMem = CreateCompatibleDC(NULL);
/* Select the drawable pixmap into a DC */
hbmpOrig1 = SelectObject(hdcMem1, pPixmapPriv->hBitmap);
if (hbmpOrig1 == NULL)
FatalError("winGetSpans - DRAWABLE_PIXMAP - SelectObject () "
"failed on pPixmapPriv->hBitmap\n");
/* Loop through spans */
for (iSpan = 0; iSpan < iSpans; ++iSpan) {
pPoint = pPoints + iSpan;
piWidth = piWidths + iSpan;
hbmpWindow = winCreateDIBNativeGDI(*piWidth, 1,
pDrawable->depth,
&pbWindow, NULL);
hbmpOrig = SelectObject(hdcMem, hbmpWindow);
/* Transfer the window bits to the window bitmap */
BitBlt(hdcMem,
0, 0, *piWidth, 1, hdcMem1, pPoint->x, pPoint->y, SRCCOPY);
memcpy(pDst,
(char *) pbWindow,
PixmapBytePad(*piWidth, pDrawable->depth));
/* Pop the window bitmap out of the HDC and delete the bitmap */
SelectObject(hdcMem, hbmpOrig);
DeleteObject(hbmpWindow);
/* Calculate offset of next bit destination */
pDst += PixmapBytePad(*piWidth, pDrawable->depth);
}
/* Pop the pixmap's bitmap out of the HDC */
SelectObject(hdcMem1, hbmpOrig1);
/* Delete the HDCs */
DeleteDC(hdcMem1);
DeleteDC(hdcMem);
break;
case DRAWABLE_WINDOW:
/* Open a memory HDC */
hdcMem = CreateCompatibleDC(NULL);
/* Loop through spans */
for (iSpan = 0; iSpan < iSpans; ++iSpan) {
pPoint = pPoints + iSpan;
piWidth = piWidths + iSpan;
hbmpWindow = winCreateDIBNativeGDI(*piWidth, 1,
pDrawable->depth,
&pbWindow, NULL);
hbmpOrig = SelectObject(hdcMem, hbmpWindow);
/* Transfer the window bits to the window bitmap */
BitBlt(hdcMem,
0, 0,
*piWidth, 1,
pScreenPriv->hdcScreen, pPoint->x, pPoint->y, SRCCOPY);
memcpy(pDst,
(char *) pbWindow,
PixmapBytePad(*piWidth, pDrawable->depth));
/* Pop the window bitmap out of the HDC */
SelectObject(hdcMem, hbmpOrig);
DeleteObject(hbmpWindow);
/* Calculate offset of next bit destination */
pDst += PixmapBytePad(*piWidth, pDrawable->depth);
}
/* Delete the window bitmap */
DeleteDC(hdcMem);
break;
default:
FatalError("winGetSpans - Unknown drawable type\n");
break;
}
}
/* See Porting Layer Definition - p. 55 */
void
winGetSpansNativeGDI (DrawablePtr pDrawable,
int nMax,
DDXPointPtr pPoints,
int *piWidths,
int iSpans,
char *pDsts)
{
PixmapPtr pPixmap = NULL;
winPrivPixmapPtr pPixmapPriv = NULL;
int iSpan;
DDXPointPtr pPoint = NULL;
int *piWidth = NULL;
char *pDst = pDsts;
int iBytesToCopy;
HBITMAP hbmpWindow, hbmpOrig;
BYTE *pbWindow = NULL;
HDC hdcMem;
ScreenPtr pScreen = pDrawable->pScreen;
winScreenPriv(pScreen);
int iByteWidth;
/* Branch on the drawable type */
switch (pDrawable->type)
{
case DRAWABLE_PIXMAP:
ErrorF ("winGetSpans - DRAWABLE_PIXMAP %08x\n",
pDrawable);
pPixmap = (PixmapPtr) pDrawable;
pPixmapPriv = winGetPixmapPriv (pPixmap);
/* Loop through spans */
for (iSpan = 0; iSpan < iSpans; ++iSpan)
{
pPoint = pPoints + iSpan;
piWidth = piWidths + iSpan;
iBytesToCopy = PixmapBytePad (*piWidth, pDrawable->depth);
memcpy (pDst,
pPixmapPriv->pbBits
+ pPixmapPriv->dwScanlineBytes * pPoint->y,
iBytesToCopy);
ErrorF ("(%dx%dx%d) (%d,%d) w: %d\n",
pDrawable->width, pDrawable->height, pDrawable->depth,
pPoint->x, pPoint->y, *piWidth);
/* Calculate offset of next bit destination */
pDst += 4 * ((*piWidth + 31) / 32);
}
break;
case DRAWABLE_WINDOW:
ErrorF ("winGetSpans - DRAWABLE_WINDOW\n");
/*
* FIXME: Making huge assumption here that we are copying the
* area behind where the cursor will be displayed. We already
* know the size of the cursor, so this works, for now.
*/
/* Create a bitmap to blit the window data to */
hbmpWindow = winCreateDIBNativeGDI (*piWidths,
*piWidths,
pDrawable->depth,
&pbWindow,
NULL);
/* Open a memory HDC */
hdcMem = CreateCompatibleDC (NULL);
/* Select the window bitmap */
hbmpOrig = SelectObject (hdcMem, hbmpWindow);
/* Transfer the window bits to the window bitmap */
BitBlt (hdcMem,
0, 0,
*piWidths, *piWidths, /* FIXME: Assuming square region */
pScreenPriv->hdcScreen,
pPoints->x, pPoints->y,
SRCCOPY);
/* Pop the window bitmap out of the HDC */
SelectObject (hdcMem, hbmpOrig);
/* Delete the memory HDC */
DeleteDC (hdcMem);
hdcMem = NULL;
iByteWidth = PixmapBytePad (*piWidths, pDrawable->depth);
/* Loop through spans */
for (iSpan = 0; iSpan < iSpans; ++iSpan)
{
pPoint = pPoints + iSpan;
piWidth = piWidths + iSpan;
iBytesToCopy = PixmapBytePad (*piWidth, pDrawable->depth);
memcpy (pDst,
pbWindow + iByteWidth * (pPoint->y - pPoints->y),
iBytesToCopy);
ErrorF ("(%dx%dx%d) (%d,%d) w: %d\n",
pDrawable->width, pDrawable->height, pDrawable->depth,
pPoint->x, pPoint->y, *piWidth);
/* Calculate offset of next bit destination */
pDst += 4 * ((*piWidth + 31) / 32);
}
/* Delete the window bitmap */
DeleteObject (hbmpWindow);
break;
case UNDRAWABLE_WINDOW:
FatalError ("winGetSpans - UNDRAWABLE_WINDOW\n");
break;
case DRAWABLE_BUFFER:
FatalError ("winGetSpans - DRAWABLE_BUFFER\n");
break;
default:
FatalError ("winGetSpans - Unknown drawable type\n");
break;
}
}
