/* 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; } }