/**************************************************************************** * Handlers.c - Handlers for the Win32 metafile records * * DATE: 11-Dec-1991 * Author: Jeffrey Newman (c-jeffn) * * Copyright (c) Microsoft Inc. 1991 ****************************************************************************/ #include "precomp.h" #pragma hdrstop // Max number of pointl's allowed on stack before explicit memory allocation. #define MAX_STACK_POINTL 128 // Convert array of POINTSs to POINTLs. #define POINTS_TO_POINTL(pptl, ppts, cpt) \ { \ DWORD i; \ for (i = 0; i < (cpt); i++) \ { \ (pptl)[i].x = (LONG) (ppts)[i].x; \ (pptl)[i].y = (LONG) (ppts)[i].y; \ } \ } /************************************************************************** * Handler - NotImplemented * * The following 32-bit records have no equivalent 16-bit metafile records: * SETBRUSHORGEX * *************************************************************************/ BOOL bHandleNotImplemented(PVOID pVoid, PLOCALDC pLocalDC) { PENHMETARECORD pemr ; INT iType ; NOTUSED(pLocalDC) ; pemr = (PENHMETARECORD) pVoid ; iType = pemr->iType ; if (iType != EMR_SETBRUSHORGEX && iType != EMR_SETCOLORADJUSTMENT && iType != EMR_SETMITERLIMIT && iType != EMR_SETICMMODE && iType != EMR_CREATECOLORSPACE && iType != EMR_SETCOLORSPACE && iType != EMR_DELETECOLORSPACE && iType != EMR_GLSRECORD && iType != EMR_GLSBOUNDEDRECORD && iType != EMR_PIXELFORMAT) { PUTS1("MF3216: bHandleNotImplemented - record not supported: %d\n", iType) ; } return(TRUE) ; } /************************************************************************** * Handler - GdiComment *************************************************************************/ BOOL bHandleGdiComment(PVOID pVoid, PLOCALDC pLocalDC) { return(DoGdiComment(pLocalDC, (PEMR) pVoid)); } /************************************************************************** * Handler - SetPaletteEntries *************************************************************************/ BOOL bHandleSetPaletteEntries(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETPALETTEENTRIES pMfSetPaletteEntries ; DWORD ihPal, iStart, cEntries ; PPALETTEENTRY pPalEntry ; pMfSetPaletteEntries = (PEMRSETPALETTEENTRIES) pVoid ; // Now do the translation. ihPal = pMfSetPaletteEntries->ihPal ; iStart = pMfSetPaletteEntries->iStart ; cEntries = pMfSetPaletteEntries->cEntries ; pPalEntry = pMfSetPaletteEntries->aPalEntries ; b = DoSetPaletteEntries(pLocalDC, ihPal, iStart, cEntries, pPalEntry) ; return (b) ; } /************************************************************************** * Handler - CreatePalette *************************************************************************/ BOOL bHandleCreatePalette(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRCREATEPALETTE pMfCreatePalette ; LPLOGPALETTE lpLogPal ; DWORD ihPal ; pMfCreatePalette = (PEMRCREATEPALETTE) pVoid ; // Now do the translation. ihPal = pMfCreatePalette->ihPal ; lpLogPal = &pMfCreatePalette->lgpl ; b = DoCreatePalette(pLocalDC, ihPal, lpLogPal) ; return (b) ; } /************************************************************************** * Handler - RealizePalette *************************************************************************/ BOOL bHandleRealizePalette(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid); // Now do the translation. b = DoRealizePalette(pLocalDC) ; return (b) ; } /************************************************************************** * Handler - ResizePalette *************************************************************************/ BOOL bHandleResizePalette(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRRESIZEPALETTE pMfResizePalette ; DWORD ihPal, cEntries ; pMfResizePalette = (PEMRRESIZEPALETTE) pVoid ; // Now do the translation. ihPal = pMfResizePalette->ihPal ; cEntries = pMfResizePalette->cEntries ; b = DoResizePalette(pLocalDC, ihPal, cEntries) ; return (b) ; } /************************************************************************** * Handler - SelectPalette *************************************************************************/ BOOL bHandleSelectPalette(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSELECTPALETTE pMfSelectPalette ; DWORD ihPal ; pMfSelectPalette = (PEMRSELECTPALETTE) pVoid ; // Now do the translation. ihPal = pMfSelectPalette->ihPal ; b = DoSelectPalette(pLocalDC, ihPal) ; return (b) ; } /************************************************************************** * Handler - OffsetClipRgn *************************************************************************/ BOOL bHandleOffsetClipRgn(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMROFFSETCLIPRGN pMfOffsetClipRgn ; INT x, y ; pMfOffsetClipRgn = (PEMROFFSETCLIPRGN) pVoid ; // Now do the translation. x = pMfOffsetClipRgn->ptlOffset.x ; y = pMfOffsetClipRgn->ptlOffset.y ; b = DoOffsetClipRgn(pLocalDC, x, y) ; return (b) ; } /************************************************************************** * Handler - ExtSelectClipRgn *************************************************************************/ BOOL bHandleExtSelectClipRgn(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMREXTSELECTCLIPRGN pMfExtSelectClipRgn ; INT cbRgnData, iMode ; LPRGNDATA pRgnData ; pMfExtSelectClipRgn = (PEMREXTSELECTCLIPRGN) pVoid ; // Now do the translation. cbRgnData = pMfExtSelectClipRgn->cbRgnData ; pRgnData = (LPRGNDATA) pMfExtSelectClipRgn->RgnData; iMode = pMfExtSelectClipRgn->iMode ; b = DoExtSelectClipRgn(pLocalDC, cbRgnData, pRgnData, iMode) ; return (b) ; } /************************************************************************** * Handler - SetMetaRgn *************************************************************************/ BOOL bHandleSetMetaRgn(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoSetMetaRgn(pLocalDC) ; return(b) ; } /************************************************************************** * Handler - PaintRgn *************************************************************************/ BOOL bHandlePaintRgn(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPAINTRGN pMfPaintRgn ; INT cbRgnData; LPRGNDATA pRgnData ; pMfPaintRgn = (PEMRPAINTRGN) pVoid ; // Now do the translation. cbRgnData = pMfPaintRgn->cbRgnData ; pRgnData = (LPRGNDATA) pMfPaintRgn->RgnData; b = DoDrawRgn(pLocalDC, 0, 0, 0, cbRgnData, pRgnData, EMR_PAINTRGN); return (b) ; } /************************************************************************** * Handler - InvertRgn *************************************************************************/ BOOL bHandleInvertRgn(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRINVERTRGN pMfInvertRgn ; INT cbRgnData; LPRGNDATA pRgnData ; pMfInvertRgn = (PEMRINVERTRGN) pVoid ; // Now do the translation. cbRgnData = pMfInvertRgn->cbRgnData ; pRgnData = (LPRGNDATA) pMfInvertRgn->RgnData; b = DoDrawRgn(pLocalDC, 0, 0, 0, cbRgnData, pRgnData, EMR_INVERTRGN); return (b) ; } /************************************************************************** * Handler - FrameRgn *************************************************************************/ BOOL bHandleFrameRgn(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRFRAMERGN pMfFrameRgn ; INT ihBrush, cbRgnData, nWidth, nHeight ; LPRGNDATA pRgnData ; pMfFrameRgn = (PEMRFRAMERGN) pVoid ; // Now do the translation. ihBrush = pMfFrameRgn->ihBrush ; nWidth = pMfFrameRgn->szlStroke.cx ; nHeight = pMfFrameRgn->szlStroke.cy ; cbRgnData = pMfFrameRgn->cbRgnData ; pRgnData = (LPRGNDATA) pMfFrameRgn->RgnData; b = DoDrawRgn(pLocalDC, ihBrush, nWidth, nHeight, cbRgnData, pRgnData, EMR_FRAMERGN); return (b) ; } /************************************************************************** * Handler - FillRgn *************************************************************************/ BOOL bHandleFillRgn(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRFILLRGN pMfFillRgn ; INT ihBrush, cbRgnData; LPRGNDATA pRgnData ; // Set up the pointer the Doer uses to reference the // the Win32 drawing order. Also setup the drawing order specific // pointer. pMfFillRgn = (PEMRFILLRGN) pVoid ; // Now do the translation. ihBrush = pMfFillRgn->ihBrush ; cbRgnData = pMfFillRgn->cbRgnData ; pRgnData = (LPRGNDATA) pMfFillRgn->RgnData; b = DoDrawRgn(pLocalDC, ihBrush, 0, 0, cbRgnData, pRgnData, EMR_FILLRGN); return (b) ; } /************************************************************************** * Handler - IntersectClipRect *************************************************************************/ BOOL bHandleIntersectClipRect(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRINTERSECTCLIPRECT pMfIntersectClipRect ; INT xLeft, yTop, xRight, yBottom ; pMfIntersectClipRect = (PEMRINTERSECTCLIPRECT) pVoid ; // Now do the translation. xLeft = pMfIntersectClipRect->rclClip.left ; yTop = pMfIntersectClipRect->rclClip.top ; xRight = pMfIntersectClipRect->rclClip.right ; yBottom = pMfIntersectClipRect->rclClip.bottom ; b = DoClipRect(pLocalDC, xLeft, yTop, xRight, yBottom, EMR_INTERSECTCLIPRECT) ; return (b) ; } /************************************************************************** * Handler - ExcludeClipRect *************************************************************************/ BOOL bHandleExcludeClipRect(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMREXCLUDECLIPRECT pMfExcludeClipRect ; INT xLeft, yTop, xRight, yBottom ; pMfExcludeClipRect = (PEMREXCLUDECLIPRECT) pVoid ; // Now do the translation. xLeft = pMfExcludeClipRect->rclClip.left ; yTop = pMfExcludeClipRect->rclClip.top ; xRight = pMfExcludeClipRect->rclClip.right ; yBottom = pMfExcludeClipRect->rclClip.bottom ; b = DoClipRect(pLocalDC, xLeft, yTop, xRight, yBottom, EMR_EXCLUDECLIPRECT) ; return (b) ; } /************************************************************************** * Handler - SetPixel *************************************************************************/ BOOL bHandleSetPixel(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETPIXELV pMfSetPixel ; INT x, y ; COLORREF crColor ; pMfSetPixel = (PEMRSETPIXELV) pVoid ; // Now do the translation. x = (INT) pMfSetPixel->ptlPixel.x ; y = (INT) pMfSetPixel->ptlPixel.y ; crColor = pMfSetPixel->crColor ; b = DoSetPixel(pLocalDC, x, y, crColor) ; return (b) ; } /************************************************************************** * Handler - ExtFloodFill *************************************************************************/ BOOL bHandleExtFloodFill(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMREXTFLOODFILL pMfExtFloodFill ; INT x, y ; COLORREF crColor ; DWORD iMode ; pMfExtFloodFill = (PEMREXTFLOODFILL) pVoid ; // Now do the translation. x = (INT) pMfExtFloodFill->ptlStart.x ; y = (INT) pMfExtFloodFill->ptlStart.y ; crColor = pMfExtFloodFill->crColor ; iMode = pMfExtFloodFill->iMode ; b = DoExtFloodFill(pLocalDC, x, y, crColor, iMode) ; return (b) ; } /************************************************************************** * Handler - ModifyWorldTransform *************************************************************************/ BOOL bHandleModifyWorldTransform(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRMODIFYWORLDTRANSFORM pMfModifyWorldTransform ; PXFORM pxform ; DWORD iMode ; pMfModifyWorldTransform = (PEMRMODIFYWORLDTRANSFORM) pVoid ; // get a pointer to the xform matrix pxform = &pMfModifyWorldTransform->xform ; iMode = pMfModifyWorldTransform->iMode ; // Now do the translation. b = DoModifyWorldTransform(pLocalDC, pxform, iMode) ; return (b) ; } /************************************************************************** * Handler - SetWorldTransform *************************************************************************/ BOOL bHandleSetWorldTransform(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETWORLDTRANSFORM pMfSetWorldTransform ; PXFORM pxform ; pMfSetWorldTransform = (PEMRSETWORLDTRANSFORM) pVoid ; // get a pointer to the xform matrix pxform = &pMfSetWorldTransform->xform ; // Now do the translation. b = DoSetWorldTransform(pLocalDC, pxform) ; return (b) ; } /************************************************************************** * Handler - PolyBezierTo *************************************************************************/ BOOL bHandlePolyBezierTo(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYBEZIERTO pMfPolyBezierTo ; DWORD nCount ; PPOINTL pptl ; pMfPolyBezierTo = (PEMRPOLYBEZIERTO) pVoid ; // Copy the BezierTo count and the polyBezierTo verticies to // the record. nCount = pMfPolyBezierTo->cptl ; pptl = pMfPolyBezierTo->aptl ; // Now do the translation. b = DoPolyBezierTo(pLocalDC, (LPPOINT) pptl, nCount) ; return (b) ; } /************************************************************************** * Handler - PolyDraw *************************************************************************/ BOOL bHandlePolyDraw(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYDRAW pMfPolyDraw ; DWORD nCount ; PPOINTL pptl ; PBYTE pb ; pMfPolyDraw = (PEMRPOLYDRAW) pVoid ; // Copy the Draw count and the polyDraw verticies to // the record. nCount = pMfPolyDraw->cptl ; pptl = pMfPolyDraw->aptl ; pb = (PBYTE) &pMfPolyDraw->aptl[nCount]; // Now do the translation. b = DoPolyDraw(pLocalDC, (LPPOINT) pptl, pb, nCount) ; return (b) ; } /************************************************************************** * Handler - PolyBezier *************************************************************************/ BOOL bHandlePolyBezier(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYBEZIER pMfPolyBezier ; DWORD nCount ; PPOINTL pptl ; pMfPolyBezier = (PEMRPOLYBEZIER) pVoid ; // Copy the Bezier count and the polyBezier verticies to // the record. nCount = pMfPolyBezier->cptl ; pptl = pMfPolyBezier->aptl ; // Now do the translation. b = DoPolyBezier(pLocalDC, (LPPOINT) pptl, nCount) ; return (b) ; } /************************************************************************** * Handler - Begin Path *************************************************************************/ BOOL bHandleBeginPath(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoBeginPath(pLocalDC) ; return (b) ; } /************************************************************************** * Handler - End Path *************************************************************************/ BOOL bHandleEndPath(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoEndPath(pLocalDC) ; return (b) ; } /************************************************************************** * Handler - Flatten Path *************************************************************************/ BOOL bHandleFlattenPath(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoFlattenPath(pLocalDC) ; return (b) ; } /************************************************************************** * Handler - CloseFigure *************************************************************************/ BOOL bHandleCloseFigure(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoCloseFigure(pLocalDC) ; return (b) ; } /************************************************************************** * Handler - Abort Path *************************************************************************/ BOOL bHandleAbortPath(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoAbortPath(pLocalDC) ; return (b) ; } /************************************************************************** * Handler - Stroke Path *************************************************************************/ BOOL bHandleStrokePath(PVOID pVoid, PLOCALDC pLocalDC) { NOTUSED(pVoid) ; return(DoRenderPath(pLocalDC, EMR_STROKEPATH)); } /************************************************************************** * Handler - Fill Path *************************************************************************/ BOOL bHandleFillPath(PVOID pVoid, PLOCALDC pLocalDC) { NOTUSED(pVoid) ; return(DoRenderPath(pLocalDC, EMR_FILLPATH)); } /************************************************************************** * Handler - Stroke and Fill Path *************************************************************************/ BOOL bHandleStrokeAndFillPath(PVOID pVoid, PLOCALDC pLocalDC) { NOTUSED(pVoid) ; return(DoRenderPath(pLocalDC, EMR_STROKEANDFILLPATH)); } /************************************************************************** * Handler - Widen Path *************************************************************************/ BOOL bHandleWidenPath(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoWidenPath(pLocalDC) ; return(b) ; } /************************************************************************** * Handler - Select Clip Path *************************************************************************/ BOOL bHandleSelectClipPath(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSELECTCLIPPATH pMfSelectClipPath ; INT iMode ; pMfSelectClipPath = (PEMRSELECTCLIPPATH) pVoid ; iMode = (INT) pMfSelectClipPath->iMode ; b = DoSelectClipPath(pLocalDC, iMode) ; return(b) ; } /************************************************************************** * Handler - StretchDIBits *************************************************************************/ BOOL bHandleStretchDIBits(PVOID pVoid, PLOCALDC pLocalDC) { PEMRSTRETCHDIBITS pMfStretchDIBits ; BOOL b ; LONG xDest ; LONG yDest ; LONG xSrc ; LONG ySrc ; LONG cxSrc ; LONG cySrc ; DWORD offBmiSrc ; DWORD cbBmiSrc ; DWORD offBitsSrc ; DWORD cbBitsSrc ; DWORD iUsageSrc ; DWORD dwRop ; LONG cxDest ; LONG cyDest ; LPBITMAPINFO lpBitmapInfo ; LPBYTE lpBits ; pMfStretchDIBits = (PEMRSTRETCHDIBITS) pVoid ; xDest = pMfStretchDIBits->xDest ; yDest = pMfStretchDIBits->yDest ; xSrc = pMfStretchDIBits->xSrc ; ySrc = pMfStretchDIBits->ySrc ; cxSrc = pMfStretchDIBits->cxSrc ; cySrc = pMfStretchDIBits->cySrc ; offBmiSrc = pMfStretchDIBits->offBmiSrc ; cbBmiSrc = pMfStretchDIBits->cbBmiSrc ; offBitsSrc = pMfStretchDIBits->offBitsSrc ; cbBitsSrc = pMfStretchDIBits->cbBitsSrc ; iUsageSrc = pMfStretchDIBits->iUsageSrc ; dwRop = pMfStretchDIBits->dwRop ; cxDest = pMfStretchDIBits->cxDest ; cyDest = pMfStretchDIBits->cyDest ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfStretchDIBits, offBmiSrc, cbBmiSrc) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfStretchDIBits, offBitsSrc, cbBitsSrc)) { EMFVALFAIL(("MF3216: bHandleStrectchDIBits failed\n")); return(FALSE); } lpBitmapInfo = (LPBITMAPINFO) ((PBYTE) pMfStretchDIBits + offBmiSrc) ; lpBits = (PBYTE) pMfStretchDIBits + offBitsSrc ; b = DoStretchDIBits(pLocalDC, xDest, yDest, cxDest, cyDest, dwRop, xSrc, ySrc, cxSrc, cySrc, iUsageSrc, lpBitmapInfo, cbBmiSrc, lpBits, cbBitsSrc ) ; return(b) ; } /************************************************************************** * Handler - SetDIBitsToDevice *************************************************************************/ BOOL bHandleSetDIBitsToDevice(PVOID pVoid, PLOCALDC pLocalDC) { PEMRSETDIBITSTODEVICE pMfSetDIBitsToDevice ; BOOL b ; LONG xDest ; LONG yDest ; LONG xSrc ; LONG ySrc ; LONG cxSrc ; LONG cySrc ; DWORD offBmiSrc ; DWORD cbBmiSrc ; DWORD offBitsSrc ; DWORD cbBitsSrc ; DWORD iUsageSrc ; DWORD iStartScan ; DWORD cScans ; LPBITMAPINFO lpBitmapInfo ; LPBYTE lpBits ; pMfSetDIBitsToDevice = (PEMRSETDIBITSTODEVICE) pVoid ; xDest = pMfSetDIBitsToDevice->xDest ; yDest = pMfSetDIBitsToDevice->yDest ; xSrc = pMfSetDIBitsToDevice->xSrc ; ySrc = pMfSetDIBitsToDevice->ySrc ; cxSrc = pMfSetDIBitsToDevice->cxSrc ; cySrc = pMfSetDIBitsToDevice->cySrc ; offBmiSrc = pMfSetDIBitsToDevice->offBmiSrc ; cbBmiSrc = pMfSetDIBitsToDevice->cbBmiSrc ; offBitsSrc = pMfSetDIBitsToDevice->offBitsSrc ; cbBitsSrc = pMfSetDIBitsToDevice->cbBitsSrc ; iUsageSrc = pMfSetDIBitsToDevice->iUsageSrc ; iStartScan = pMfSetDIBitsToDevice->iStartScan ; cScans = pMfSetDIBitsToDevice->cScans ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfSetDIBitsToDevice, offBmiSrc, cbBmiSrc) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfSetDIBitsToDevice, offBitsSrc, cbBitsSrc)) { EMFVALFAIL(("MF3216: bHandleSetDIBitsToDevice failed\n")); return(FALSE); } lpBitmapInfo = (LPBITMAPINFO) ((PBYTE) pMfSetDIBitsToDevice + offBmiSrc) ; lpBits = (PBYTE) pMfSetDIBitsToDevice + offBitsSrc ; b = DoSetDIBitsToDevice(pLocalDC, xDest, yDest, xSrc, ySrc, cxSrc, cySrc, iUsageSrc, iStartScan, cScans, lpBitmapInfo, cbBmiSrc, lpBits, cbBitsSrc ) ; return(b) ; } /************************************************************************** * Handler - BitBlt *************************************************************************/ BOOL bHandleBitBlt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRBITBLT pMfBitBlt ; LONG xDest ; LONG yDest ; LONG cxDest ; LONG cyDest ; DWORD dwRop ; LONG xSrc ; LONG ySrc ; PXFORM pxformSrc ; COLORREF crBkColorSrc ; DWORD iUsageSrc ; DWORD offBmiSrc ; DWORD cbBmiSrc ; DWORD offBitsSrc ; DWORD cbBitsSrc ; PBITMAPINFO pbmi ; LPBYTE lpBits ; pMfBitBlt = (PEMRBITBLT) pVoid ; xDest = pMfBitBlt->xDest ; yDest = pMfBitBlt->yDest ; cxDest = pMfBitBlt->cxDest ; cyDest = pMfBitBlt->cyDest ; dwRop = pMfBitBlt->dwRop ; xSrc = pMfBitBlt->xSrc ; ySrc = pMfBitBlt->ySrc ; pxformSrc =&(pMfBitBlt->xformSrc) ; crBkColorSrc = pMfBitBlt->crBkColorSrc ; // not used iUsageSrc = pMfBitBlt->iUsageSrc ; offBmiSrc = pMfBitBlt->offBmiSrc ; cbBmiSrc = pMfBitBlt->cbBmiSrc ; offBitsSrc = pMfBitBlt->offBitsSrc ; cbBitsSrc = pMfBitBlt->cbBitsSrc ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfBitBlt, offBmiSrc, cbBmiSrc) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfBitBlt, offBitsSrc, cbBitsSrc)) { EMFVALFAIL(("MF3216: bHandleBitBlt failed\n")); return(FALSE); } lpBits = (PBYTE) pMfBitBlt + offBitsSrc ; pbmi = (PBITMAPINFO) ((PBYTE) pMfBitBlt + offBmiSrc) ; b = DoStretchBlt(pLocalDC, xDest, yDest, cxDest, cyDest, dwRop, xSrc, ySrc, cxDest, cyDest, pxformSrc, iUsageSrc, pbmi, cbBmiSrc, lpBits, cbBitsSrc); return(b) ; } /************************************************************************** * Handler - StretchBlt *************************************************************************/ BOOL bHandleStretchBlt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSTRETCHBLT pMfStretchBlt ; LONG xDest ; LONG yDest ; LONG cxDest ; LONG cyDest ; DWORD dwRop ; LONG xSrc ; LONG ySrc ; LONG cxSrc ; LONG cySrc ; PXFORM pxformSrc ; COLORREF crBkColorSrc ; DWORD iUsageSrc ; DWORD offBmiSrc ; DWORD cbBmiSrc ; DWORD offBitsSrc ; DWORD cbBitsSrc ; PBITMAPINFO pbmi ; LPBYTE lpBits ; pMfStretchBlt = (PEMRSTRETCHBLT) pVoid ; xDest = pMfStretchBlt->xDest ; yDest = pMfStretchBlt->yDest ; cxDest = pMfStretchBlt->cxDest ; cyDest = pMfStretchBlt->cyDest ; dwRop = pMfStretchBlt->dwRop ; xSrc = pMfStretchBlt->xSrc ; ySrc = pMfStretchBlt->ySrc ; pxformSrc =&(pMfStretchBlt->xformSrc) ; crBkColorSrc = pMfStretchBlt->crBkColorSrc ; // not used iUsageSrc = pMfStretchBlt->iUsageSrc ; offBmiSrc = pMfStretchBlt->offBmiSrc ; cbBmiSrc = pMfStretchBlt->cbBmiSrc ; offBitsSrc = pMfStretchBlt->offBitsSrc ; cbBitsSrc = pMfStretchBlt->cbBitsSrc ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfStretchBlt, offBmiSrc, cbBmiSrc) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfStretchBlt, offBitsSrc, cbBitsSrc)) { EMFVALFAIL(("MF3216: bHandleStretchBlt failed\n")); return(FALSE); } lpBits = (PBYTE) pMfStretchBlt + offBitsSrc ; pbmi = (PBITMAPINFO) ((PBYTE) pMfStretchBlt + offBmiSrc) ; cxSrc = pMfStretchBlt->cxSrc ; cySrc = pMfStretchBlt->cySrc ; b = DoStretchBlt(pLocalDC, xDest, yDest, cxDest, cyDest, dwRop, xSrc, ySrc, cxSrc, cySrc, pxformSrc, iUsageSrc, pbmi, cbBmiSrc, lpBits, cbBitsSrc); return(b) ; } /************************************************************************** * Handler - MaskBlt *************************************************************************/ BOOL bHandleMaskBlt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRMASKBLT pMfMaskBlt ; LONG xDest ; LONG yDest ; LONG cxDest ; LONG cyDest ; DWORD dwRop ; LONG xSrc ; LONG ySrc ; PXFORM pxformSrc ; COLORREF crBkColorSrc ; DWORD iUsageSrc ; DWORD offBmiSrc ; DWORD cbBmiSrc ; DWORD offBitsSrc ; DWORD cbBitsSrc ; PBITMAPINFO pbmi ; LPBYTE lpBits ; LONG xMask ; LONG yMask ; DWORD iUsageMask ; DWORD offBmiMask ; DWORD cbBmiMask ; DWORD offBitsMask ; DWORD cbBitsMask ; PBITMAPINFO pbmiMask ; LPBYTE lpMaskBits ; pMfMaskBlt = (PEMRMASKBLT) pVoid ; xDest = pMfMaskBlt->xDest ; yDest = pMfMaskBlt->yDest ; cxDest = pMfMaskBlt->cxDest ; cyDest = pMfMaskBlt->cyDest ; dwRop = pMfMaskBlt->dwRop ; xSrc = pMfMaskBlt->xSrc ; ySrc = pMfMaskBlt->ySrc ; pxformSrc =&(pMfMaskBlt->xformSrc) ; crBkColorSrc = pMfMaskBlt->crBkColorSrc ; // not used iUsageSrc = pMfMaskBlt->iUsageSrc ; offBmiSrc = pMfMaskBlt->offBmiSrc ; cbBmiSrc = pMfMaskBlt->cbBmiSrc ; offBitsSrc = pMfMaskBlt->offBitsSrc ; cbBitsSrc = pMfMaskBlt->cbBitsSrc ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfMaskBlt, offBmiSrc, cbBmiSrc) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfMaskBlt, offBitsSrc, cbBitsSrc)) { EMFVALFAIL(("MF3216: bHandleMaskBlt failed\n")); return(FALSE); } lpBits = (PBYTE) pMfMaskBlt + offBitsSrc ; pbmi = (PBITMAPINFO) ((PBYTE) pMfMaskBlt + offBmiSrc) ; xMask = pMfMaskBlt->xMask ; yMask = pMfMaskBlt->yMask ; iUsageMask = pMfMaskBlt->iUsageMask ; offBmiMask = pMfMaskBlt->offBmiMask ; cbBmiMask = pMfMaskBlt->cbBmiMask ; offBitsMask = pMfMaskBlt->offBitsMask ; cbBitsMask = pMfMaskBlt->cbBitsMask ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfMaskBlt, offBmiMask, cbBmiMask) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfMaskBlt, offBitsMask, cbBitsMask)) { EMFVALFAIL(("MF3216: bHandleMaskBlt failed\n")); return(FALSE); } lpMaskBits = (PBYTE) pMfMaskBlt + offBitsMask ; pbmiMask = (PBITMAPINFO) ((PBYTE) pMfMaskBlt + offBmiMask) ; b = DoMaskBlt(pLocalDC, xDest, yDest, cxDest, cyDest, dwRop, xSrc, ySrc, pxformSrc, iUsageSrc, pbmi, cbBmiSrc, lpBits, cbBitsSrc, xMask, yMask, iUsageMask, pbmiMask, cbBmiMask, lpMaskBits, cbBitsMask); return(b) ; } /************************************************************************** * Handler - PlgBlt *************************************************************************/ BOOL bHandlePlgBlt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPLGBLT pMfPlgBlt ; PPOINTL pptlDest ; LONG xSrc ; LONG ySrc ; LONG cxSrc ; LONG cySrc ; PXFORM pxformSrc ; COLORREF crBkColorSrc ; DWORD iUsageSrc ; DWORD offBmiSrc ; DWORD cbBmiSrc ; DWORD offBitsSrc ; DWORD cbBitsSrc ; PBITMAPINFO pbmi ; LPBYTE lpBits ; LONG xMask ; LONG yMask ; DWORD iUsageMask ; DWORD offBmiMask ; DWORD cbBmiMask ; DWORD offBitsMask ; DWORD cbBitsMask ; PBITMAPINFO pbmiMask ; LPBYTE lpMaskBits ; pMfPlgBlt = (PEMRPLGBLT) pVoid ; pptlDest = pMfPlgBlt->aptlDest ; xSrc = pMfPlgBlt->xSrc ; ySrc = pMfPlgBlt->ySrc ; cxSrc = pMfPlgBlt->cxSrc ; cySrc = pMfPlgBlt->cySrc ; pxformSrc =&(pMfPlgBlt->xformSrc) ; crBkColorSrc = pMfPlgBlt->crBkColorSrc ; // not used iUsageSrc = pMfPlgBlt->iUsageSrc ; offBmiSrc = pMfPlgBlt->offBmiSrc ; cbBmiSrc = pMfPlgBlt->cbBmiSrc ; offBitsSrc = pMfPlgBlt->offBitsSrc ; cbBitsSrc = pMfPlgBlt->cbBitsSrc ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfPlgBlt, offBmiSrc, cbBmiSrc) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfPlgBlt, offBitsSrc, cbBitsSrc)) { EMFVALFAIL(("MF3216: bHandlePlgBlt failed\n")); return(FALSE); } lpBits = (PBYTE) pMfPlgBlt + offBitsSrc ; pbmi = (PBITMAPINFO) ((PBYTE) pMfPlgBlt + offBmiSrc) ; xMask = pMfPlgBlt->xMask ; yMask = pMfPlgBlt->yMask ; iUsageMask = pMfPlgBlt->iUsageMask ; offBmiMask = pMfPlgBlt->offBmiMask ; cbBmiMask = pMfPlgBlt->cbBmiMask ; offBitsMask = pMfPlgBlt->offBitsMask ; cbBitsMask = pMfPlgBlt->cbBitsMask ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfPlgBlt, offBmiMask, cbBmiMask) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfPlgBlt, offBitsMask, cbBitsMask)) { EMFVALFAIL(("MF3216: bHandlePlgBlt failed\n")); return(FALSE); } lpMaskBits = (PBYTE) pMfPlgBlt + offBitsMask ; pbmiMask = (PBITMAPINFO) ((PBYTE) pMfPlgBlt + offBmiMask) ; b = DoPlgBlt(pLocalDC, pptlDest, xSrc, ySrc, cxSrc, cySrc, pxformSrc, iUsageSrc, pbmi, cbBmiSrc, lpBits, cbBitsSrc, xMask, yMask, iUsageMask, pbmiMask, cbBmiMask, lpMaskBits, cbBitsMask); return(b) ; } /************************************************************************** * Handler - Save DC *************************************************************************/ BOOL bHandleSaveDC(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; NOTUSED(pVoid) ; b = DoSaveDC(pLocalDC) ; return(b) ; } /************************************************************************** * Handler - Restore DC *************************************************************************/ BOOL bHandleRestoreDC(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRRESTOREDC pMfRestoreDc ; INT nSavedDC ; pMfRestoreDc = (PEMRRESTOREDC) pVoid ; nSavedDC = (INT) pMfRestoreDc->iRelative ; b = DoRestoreDC(pLocalDC, nSavedDC) ; return(b) ; } /************************************************************************** * Handler - End of File *************************************************************************/ BOOL bHandleEOF(PVOID pVoid, PLOCALDC pLocalDC) { NOTUSED(pVoid) ; DoEOF(pLocalDC) ; return (TRUE) ; } /************************************************************************** * Handler - Header *************************************************************************/ BOOL bHandleHeader(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PENHMETAHEADER pemfheader ; pemfheader = (PENHMETAHEADER) pVoid ; b = DoHeader(pLocalDC, pemfheader) ; return (b) ; } /************************************************************************** * Handler - ScaleWindowExtEx *************************************************************************/ BOOL bHandleScaleWindowExt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSCALEWINDOWEXTEX pMfScaleWindowExt ; INT Xnum, Xdenom, Ynum, Ydenom ; pMfScaleWindowExt = (PEMRSCALEWINDOWEXTEX) pVoid ; // Scale the MapMode Mode Xnum = (INT) pMfScaleWindowExt->xNum ; Xdenom = (INT) pMfScaleWindowExt->xDenom ; Ynum = (INT) pMfScaleWindowExt->yNum ; Ydenom = (INT) pMfScaleWindowExt->yDenom ; // Do the translation. b = DoScaleWindowExt(pLocalDC, Xnum, Xdenom, Ynum, Ydenom) ; return (b) ; } /************************************************************************** * Handler - ScaleViewportExtEx *************************************************************************/ BOOL bHandleScaleViewportExt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSCALEVIEWPORTEXTEX pMfScaleViewportExt ; INT Xnum, Xdenom, Ynum, Ydenom ; pMfScaleViewportExt = (PEMRSCALEVIEWPORTEXTEX) pVoid ; // Scale the MapMode Mode Xnum = (INT) pMfScaleViewportExt->xNum ; Xdenom = (INT) pMfScaleViewportExt->xDenom ; Ynum = (INT) pMfScaleViewportExt->yNum ; Ydenom = (INT) pMfScaleViewportExt->yDenom ; // Do the translation. b = DoScaleViewportExt(pLocalDC, Xnum, Xdenom, Ynum, Ydenom) ; return (b) ; } /************************************************************************** * Handler - SetViewportExtEx *************************************************************************/ BOOL bHandleSetViewportExt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETVIEWPORTEXTEX pMfSetViewportExt ; LONG x, y ; pMfSetViewportExt = (PEMRSETVIEWPORTEXTEX) pVoid ; // Set the MapMode Mode x = pMfSetViewportExt->szlExtent.cx ; y = pMfSetViewportExt->szlExtent.cy ; // Do the translation. b = DoSetViewportExt(pLocalDC, (INT) x, (INT) y) ; return (b) ; } /************************************************************************** * Handler - SetViewportOrgEx *************************************************************************/ BOOL bHandleSetViewportOrg(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETVIEWPORTORGEX pMfSetViewportOrg ; LONG x, y ; pMfSetViewportOrg = (PEMRSETVIEWPORTORGEX) pVoid ; // Set the MapMode Mode x = pMfSetViewportOrg->ptlOrigin.x ; y = pMfSetViewportOrg->ptlOrigin.y ; // Do the translation. b = DoSetViewportOrg(pLocalDC, (INT) x, (INT) y) ; return (b) ; } /************************************************************************** * Handler - SetWindowExtEx *************************************************************************/ BOOL bHandleSetWindowExt(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETWINDOWEXTEX pMfSetWindowExt ; LONG x, y ; pMfSetWindowExt = (PEMRSETWINDOWEXTEX) pVoid ; // Set the MapMode Mode x = pMfSetWindowExt->szlExtent.cx ; y = pMfSetWindowExt->szlExtent.cy ; // Do the translation. b = DoSetWindowExt(pLocalDC, (INT) x, (INT) y) ; return (b) ; } /************************************************************************** * Handler - SetWindowOrgEx *************************************************************************/ BOOL bHandleSetWindowOrg(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETWINDOWORGEX pMfSetWindowOrg ; LONG x, y ; pMfSetWindowOrg = (PEMRSETWINDOWORGEX) pVoid ; // Set the MapMode Mode x = pMfSetWindowOrg->ptlOrigin.x ; y = pMfSetWindowOrg->ptlOrigin.y ; // Do the translation. b = DoSetWindowOrg(pLocalDC, (INT) x, (INT) y) ; return (b) ; } /************************************************************************** * Handler - SetMapMode *************************************************************************/ BOOL bHandleSetMapMode(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; DWORD iMapMode ; PEMRSETMAPMODE pMfSetMapMode ; pMfSetMapMode = (PEMRSETMAPMODE) pVoid ; // Set the MapMode Mode iMapMode = pMfSetMapMode->iMode ; // Do the translation. b = DoSetMapMode(pLocalDC, iMapMode) ; return (b) ; } /************************************************************************** * Handler - SetArcDirection *************************************************************************/ BOOL bHandleSetArcDirection(PVOID pVoid, PLOCALDC pLocalDC) { PEMRSETARCDIRECTION pMfSetArcDirection ; INT iArcDirection ; BOOL b ; pMfSetArcDirection = (PEMRSETARCDIRECTION) pVoid ; iArcDirection = (INT) pMfSetArcDirection->iArcDirection ; b = DoSetArcDirection(pLocalDC, iArcDirection) ; return (b) ; } /************************************************************************** * Handler - AngleArc *************************************************************************/ BOOL bHandleAngleArc(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRANGLEARC pMfAngleArc ; int x, y; DWORD nRadius ; FLOAT eStartAngle, eSweepAngle ; pMfAngleArc = (PEMRANGLEARC) pVoid ; // Set the Arc center x = (int) pMfAngleArc->ptlCenter.x ; y = (int) pMfAngleArc->ptlCenter.y ; // Get the radius of the Arc nRadius = (INT) pMfAngleArc->nRadius ; // Set the start & sweep angles eStartAngle = pMfAngleArc->eStartAngle ; eSweepAngle = pMfAngleArc->eSweepAngle ; b = DoAngleArc(pLocalDC, x, y, nRadius, eStartAngle, eSweepAngle) ; return (b) ; } /************************************************************************** * Handler - ArcTo *************************************************************************/ BOOL bHandleArcTo(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRARCTO pMfArcTo ; INT x1, x2, x3, x4, y1, y2, y3, y4 ; pMfArcTo = (PEMRARCTO) pVoid ; // Set up the ellipse box, this will be the same as the bounding // rectangle. x1 = (INT) pMfArcTo->rclBox.left ; y1 = (INT) pMfArcTo->rclBox.top ; x2 = (INT) pMfArcTo->rclBox.right ; y2 = (INT) pMfArcTo->rclBox.bottom ; // Set the start point. x3 = (INT) pMfArcTo->ptlStart.x ; y3 = (INT) pMfArcTo->ptlStart.y ; // Set the end point. x4 = (INT) pMfArcTo->ptlEnd.x ; y4 = (INT) pMfArcTo->ptlEnd.y ; b = DoArcTo(pLocalDC, x1, y1, x2, y2, x3, y3, x4, y4) ; return (b) ; } /************************************************************************** * Handler - Arc *************************************************************************/ BOOL bHandleArc(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRARC pMfArc ; INT x1, x2, x3, x4, y1, y2, y3, y4 ; pMfArc = (PEMRARC) pVoid ; // Set up the ellipse box, this will be the same as the bounding // rectangle. x1 = (INT) pMfArc->rclBox.left ; y1 = (INT) pMfArc->rclBox.top ; x2 = (INT) pMfArc->rclBox.right ; y2 = (INT) pMfArc->rclBox.bottom ; // Set the start point. x3 = (INT) pMfArc->ptlStart.x ; y3 = (INT) pMfArc->ptlStart.y ; // Set the end point. x4 = (INT) pMfArc->ptlEnd.x ; y4 = (INT) pMfArc->ptlEnd.y ; b = DoArc(pLocalDC, x1, y1, x2, y2, x3, y3, x4, y4) ; return (b) ; } /************************************************************************** * Handler - Ellipse *************************************************************************/ BOOL bHandleEllipse(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; INT x1, y1, x2, y2 ; PEMRELLIPSE pMfEllipse ; pMfEllipse = (PEMRELLIPSE) pVoid ; // Set up the ellipse box, this will be the same as the bounding // rectangle. x1 = (INT) pMfEllipse->rclBox.left ; y1 = (INT) pMfEllipse->rclBox.top ; x2 = (INT) pMfEllipse->rclBox.right ; y2 = (INT) pMfEllipse->rclBox.bottom ; // Do the Ellipse translation. b = DoEllipse(pLocalDC, x1, y1, x2, y2) ; return (b) ; } /************************************************************************** * Handler - SelectObject *************************************************************************/ BOOL bHandleSelectObject(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSELECTOBJECT pMfSelectObject ; INT ihObject ; pMfSelectObject = (PEMRSELECTOBJECT) pVoid ; // Get the Object (it's really a Long) ihObject = (INT) pMfSelectObject->ihObject ; // Do the translation b = DoSelectObject(pLocalDC, ihObject) ; return (b) ; } /************************************************************************** * Handler - DeleteObject *************************************************************************/ BOOL bHandleDeleteObject(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRDELETEOBJECT pMfDeleteObject ; INT ihObject ; pMfDeleteObject = (PEMRDELETEOBJECT) pVoid ; ihObject = (INT) pMfDeleteObject->ihObject ; b = DoDeleteObject(pLocalDC, ihObject) ; return(b) ; } /************************************************************************** * Handler - CreateBrushIndirect *************************************************************************/ BOOL bHandleCreateBrushIndirect(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRCREATEBRUSHINDIRECT pMfCreateBrushIndirect ; LOGBRUSH LogBrush ; INT ihBrush ; pMfCreateBrushIndirect = (PEMRCREATEBRUSHINDIRECT) pVoid ; // Get the Brush parameters. LogBrush.lbStyle = pMfCreateBrushIndirect->lb.lbStyle; LogBrush.lbColor = pMfCreateBrushIndirect->lb.lbColor; LogBrush.lbHatch = (ULONG_PTR)pMfCreateBrushIndirect->lb.lbHatch; ihBrush = pMfCreateBrushIndirect->ihBrush ; // Do the translation. b = DoCreateBrushIndirect(pLocalDC, ihBrush, &LogBrush) ; return (b) ; } /************************************************************************** * Handler - CreateMonoBrush *************************************************************************/ BOOL bHandleCreateMonoBrush(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRCREATEMONOBRUSH pMfCreateMonoBrush ; DWORD ihBrush ; DWORD iUsage ; DWORD offBmi ; DWORD cbBmi ; DWORD offBits ; DWORD cbBits ; PBITMAPINFO pBmi ; PBYTE pBits ; pMfCreateMonoBrush = (PEMRCREATEMONOBRUSH) pVoid ; ihBrush = pMfCreateMonoBrush->ihBrush ; iUsage = pMfCreateMonoBrush->iUsage ; offBmi = pMfCreateMonoBrush->offBmi ; cbBmi = pMfCreateMonoBrush->cbBmi ; offBits = pMfCreateMonoBrush->offBits ; cbBits = pMfCreateMonoBrush->cbBits ; pBmi = (PBITMAPINFO) ((PBYTE) pVoid + offBmi) ; pBits = (PBYTE) pVoid + offBits ; b = DoCreateMonoBrush(pLocalDC, ihBrush, pBmi, cbBmi, pBits, cbBits, iUsage) ; return (b) ; } /************************************************************************** * Handler - CreateDIBPatternBrush *************************************************************************/ BOOL bHandleCreateDIBPatternBrush(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRCREATEDIBPATTERNBRUSHPT pMfCreateDIBPatternBrush ; DWORD ihBrush ; DWORD iUsage ; DWORD offBmi ; DWORD cbBmi ; DWORD offBits ; DWORD cbBits ; PBITMAPINFO pBmi ; PBYTE pBits ; pMfCreateDIBPatternBrush = (PEMRCREATEDIBPATTERNBRUSHPT) pVoid ; ihBrush = pMfCreateDIBPatternBrush->ihBrush ; iUsage = pMfCreateDIBPatternBrush->iUsage ; offBmi = pMfCreateDIBPatternBrush->offBmi ; cbBmi = pMfCreateDIBPatternBrush->cbBmi ; offBits = pMfCreateDIBPatternBrush->offBits ; cbBits = pMfCreateDIBPatternBrush->cbBits ; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfCreateDIBPatternBrush, offBmi, cbBmi) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfCreateDIBPatternBrush, offBits, cbBits)) { EMFVALFAIL(("MF3216: bHandleCreateDIBPatternBrush failed\n")); return(FALSE); } pBmi = (PBITMAPINFO) ((PBYTE) pVoid + offBmi) ; pBits = (PBYTE) pVoid + offBits ; b = DoCreateDIBPatternBrush(pLocalDC, ihBrush, pBmi, cbBmi, pBits, cbBits, iUsage) ; return (b) ; } /************************************************************************** * Handler - CreatePen *************************************************************************/ BOOL bHandleCreatePen(PVOID pVoid, PLOCALDC pLocalDC) { PEMRCREATEPEN pMfCreatePen ; INT ihPen ; PLOGPEN pLogPen ; BOOL b ; pMfCreatePen = (PEMRCREATEPEN) pVoid ; ihPen = pMfCreatePen->ihPen ; pLogPen = &pMfCreatePen->lopn ; b = DoCreatePen(pLocalDC, ihPen, pLogPen) ; return(b) ; } /************************************************************************** * Handler - ExtCreatePen *************************************************************************/ BOOL bHandleExtCreatePen(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMREXTCREATEPEN pMfExtCreatePen ; PEXTLOGPEN pExtLogPen ; INT ihPen ; pMfExtCreatePen = (PEMREXTCREATEPEN) pVoid ; pExtLogPen = &pMfExtCreatePen->elp ; ihPen = pMfExtCreatePen->ihPen ; b = DoExtCreatePen(pLocalDC, ihPen, pExtLogPen) ; return (b) ; } /************************************************************************** * Handler - MoveToEx *************************************************************************/ BOOL bHandleMoveTo(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRMOVETOEX pMfMoveTo ; INT x, y ; pMfMoveTo = (PEMRMOVETOEX) pVoid ; // Get the position. x = (INT) pMfMoveTo->ptl.x ; y = (INT) pMfMoveTo->ptl.y ; // Do the translation. b = DoMoveTo(pLocalDC, x, y) ; return (b) ; } /************************************************************************** * Handler - LineTo *************************************************************************/ BOOL bHandleLineTo(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRLINETO pMfLineTo ; INT x, y ; pMfLineTo = (PEMRLINETO) pVoid ; // Get the new point. x = (INT) pMfLineTo->ptl.x ; y = (INT) pMfLineTo->ptl.y ; // Do the translation. b = DoLineTo(pLocalDC, x, y) ; return (b) ; } /************************************************************************** * Handler - Chord *************************************************************************/ BOOL bHandleChord(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRCHORD pMfChord ; INT x1, x2, x3, x4, y1, y2, y3, y4 ; pMfChord = (PEMRCHORD) pVoid ; // Set the rectangle x1 = (INT) pMfChord->rclBox.left ; y1 = (INT) pMfChord->rclBox.top ; x2 = (INT) pMfChord->rclBox.right ; y2 = (INT) pMfChord->rclBox.bottom ; // Set the start point. x3 = (INT) pMfChord->ptlStart.x ; y3 = (INT) pMfChord->ptlStart.y ; // Set the end point. x4 = (INT) pMfChord->ptlEnd.x ; y4 = (INT) pMfChord->ptlEnd.y ; // Do the translation b = DoChord(pLocalDC, x1, y1, x2, y2, x3, y3, x4, y4) ; return (b) ; } /************************************************************************** * Handler - Pie *************************************************************************/ BOOL bHandlePie(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPIE pMfPie ; INT x1, x2, x3, x4, y1, y2, y3, y4 ; pMfPie = (PEMRPIE) pVoid ; // Set up the ellipse box x1 = (INT) pMfPie->rclBox.left ; y1 = (INT) pMfPie->rclBox.top ; x2 = (INT) pMfPie->rclBox.right ; y2 = (INT) pMfPie->rclBox.bottom ; // Set the start point. x3 = (INT) pMfPie->ptlStart.x ; y3 = (INT) pMfPie->ptlStart.y ; // Set the end point. x4 = (INT) pMfPie->ptlEnd.x ; y4 = (INT) pMfPie->ptlEnd.y ; // Do the Pie translation. b = DoPie(pLocalDC, x1, y1, x2, y2, x3, y3, x4, y4) ; return (b) ; } /************************************************************************** * Handler - Polyline *************************************************************************/ BOOL bHandlePolyline(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYLINE pMfPolyline ; INT nCount ; PPOINTL pptl ; pMfPolyline = (PEMRPOLYLINE) pVoid ; // Copy the line count and the polyline verticies to // the record. nCount = (INT) pMfPolyline->cptl ; pptl = pMfPolyline->aptl ; // Now do the translation. b = DoPoly(pLocalDC, pptl, nCount, EMR_POLYLINE) ; return (b) ; } /************************************************************************** * Handler - PolylineTo *************************************************************************/ BOOL bHandlePolylineTo (PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYLINETO pMfPolylineTo ; INT nCount ; PPOINTL pptl ; pMfPolylineTo = (PEMRPOLYLINETO) pVoid ; // Copy the line count and the polyline verticies to // the record. nCount = (INT) pMfPolylineTo->cptl ; pptl = pMfPolylineTo->aptl ; // Now do the translation. b = DoPolylineTo(pLocalDC, pptl, nCount) ; return (b) ; } /************************************************************************** * Handler - PolyBezier16,Polygon16,Polyline16,PolyBezierTo16,PolylineTo16 * PolyDraw16 *************************************************************************/ BOOL bHandlePoly16 (PVOID pVoid, PLOCALDC pLocalDC) { BOOL b = FALSE; PEMRPOLYLINE16 pMfPoly16 ; // common structure for the poly16 records PEMRPOLYDRAW16 pMfPolyDraw16 ; POINTL aptl[MAX_STACK_POINTL]; PPOINTL pptl ; INT nCount ; PBYTE pb ; // PolyDraw16 contains the structure of Poly16 followed by the byte array. pMfPoly16 = (PEMRPOLYLINE16) pVoid ; nCount = (INT) pMfPoly16->cpts ; if (nCount <= MAX_STACK_POINTL) pptl = aptl; else if (!(pptl = (PPOINTL) LocalAlloc(LMEM_FIXED, nCount * sizeof(POINTL)))) return(b); POINTS_TO_POINTL(pptl, pMfPoly16->apts, (DWORD) nCount); // Now do the translation. switch (pMfPoly16->emr.iType) { case EMR_POLYBEZIER16: b = DoPolyBezier(pLocalDC, (LPPOINT) pptl, nCount) ; break; case EMR_POLYGON16: b = DoPoly(pLocalDC, pptl, nCount, EMR_POLYGON) ; break; case EMR_POLYLINE16: b = DoPoly(pLocalDC, pptl, nCount, EMR_POLYLINE) ; break; case EMR_POLYBEZIERTO16: b = DoPolyBezierTo(pLocalDC, (LPPOINT) pptl, nCount) ; break; case EMR_POLYLINETO16: b = DoPolylineTo(pLocalDC, pptl, nCount) ; break; case EMR_POLYDRAW16: pMfPolyDraw16 = (PEMRPOLYDRAW16) pVoid ; pb = (PBYTE) &pMfPolyDraw16->apts[nCount]; b = DoPolyDraw(pLocalDC, (LPPOINT) pptl, pb, nCount); break; default: ASSERTGDI(FALSE, "Bad record type"); break; } if (nCount > MAX_STACK_POINTL) if (LocalFree(pptl)) ASSERTGDI(FALSE, "bHandlePoly16: LocalFree failed"); return (b) ; } /************************************************************************** * Handler - PolyPolyline *************************************************************************/ BOOL bHandlePolyPolyline(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYPOLYLINE pMfPolyPolyline ; PDWORD pPolyCount ; PPOINTL pptl ; INT nPolys ; pMfPolyPolyline = (PEMRPOLYPOLYLINE) pVoid ; // Copy the Polycount count, the polycount array // and the polyline verticies to // the record. nPolys = (INT) pMfPolyPolyline->nPolys ; pPolyCount = pMfPolyPolyline->aPolyCounts ; pptl = (PPOINTL) &pMfPolyPolyline->aPolyCounts[nPolys] ; // Now do the translation. b = DoPolyPolyline(pLocalDC, pptl, pPolyCount, nPolys) ; return (b) ; } /************************************************************************** * Handler - PolyPolyline16,PolyPolygon16 *************************************************************************/ BOOL bHandlePolyPoly16 (PVOID pVoid, PLOCALDC pLocalDC) { BOOL b = FALSE; PEMRPOLYPOLYLINE16 pMfPolyPoly16 ; // common structure for polypoly16 records PDWORD pPolyCount ; POINTL aptl[MAX_STACK_POINTL]; PPOINTL pptl ; INT nCount; DWORD cpts ; pMfPolyPoly16 = (PEMRPOLYPOLYLINE16) pVoid ; nCount = (INT) pMfPolyPoly16->nPolys ; cpts = pMfPolyPoly16->cpts; pPolyCount = pMfPolyPoly16->aPolyCounts ; if (cpts <= MAX_STACK_POINTL) pptl = aptl; else if (!(pptl = (PPOINTL) LocalAlloc(LMEM_FIXED, cpts * sizeof(POINTL)))) return(b); POINTS_TO_POINTL(pptl, (PPOINTS) &pMfPolyPoly16->aPolyCounts[nCount], cpts); // Now do the translation. switch (pMfPolyPoly16->emr.iType) { case EMR_POLYPOLYLINE16: b = DoPolyPolyline(pLocalDC, pptl, pPolyCount, nCount) ; break; case EMR_POLYPOLYGON16: b = DoPolyPolygon(pLocalDC, pptl, pPolyCount, cpts, nCount) ; break; default: ASSERTGDI(FALSE, "Bad record type"); break; } if (cpts > MAX_STACK_POINTL) if (LocalFree(pptl)) ASSERTGDI(FALSE, "bHandlePolyPoly16: LocalFree failed"); return (b) ; } /************************************************************************** * Handler - Polygon *************************************************************************/ BOOL bHandlePolygon (PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYGON pMfPolygon ; PPOINTL pptl ; INT nCount ; pMfPolygon = (PEMRPOLYGON) pVoid ; // Copy the line count and the Polygon verticies to // the record. nCount = (INT) pMfPolygon->cptl ; pptl = pMfPolygon->aptl ; // Now do the translation. b = DoPoly(pLocalDC, pptl, nCount, EMR_POLYGON) ; return (b) ; } /************************************************************************** * Handler - PolyPolygon *************************************************************************/ BOOL bHandlePolyPolygon(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRPOLYPOLYGON pMfPolyPolygon ; PDWORD pPolyCount ; PPOINTL pptl ; DWORD cptl ; INT nPolys ; pMfPolyPolygon = (PEMRPOLYPOLYGON) pVoid ; // Copy the Polycount count, the polycount array // and the polygon verticies to // the record. nPolys = (INT) pMfPolyPolygon->nPolys ; pPolyCount = pMfPolyPolygon->aPolyCounts ; pptl = (PPOINTL) &pMfPolyPolygon->aPolyCounts[nPolys] ; cptl = pMfPolyPolygon->cptl ; // Now do the translation. b = DoPolyPolygon(pLocalDC, pptl, pPolyCount, cptl, nPolys) ; return (b) ; } /************************************************************************** * Handler - Rectangle *************************************************************************/ BOOL bHandleRectangle(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRRECTANGLE pMfRectangle ; INT x1, y1, x2, y2 ; pMfRectangle = (PEMRRECTANGLE) pVoid ; // Set up the Rectangle box, this will be the same as the bounding // rectangle. x1 = (INT) pMfRectangle->rclBox.left ; y1 = (INT) pMfRectangle->rclBox.top ; x2 = (INT) pMfRectangle->rclBox.right ; y2 = (INT) pMfRectangle->rclBox.bottom ; // Do the Rectangle translation. b = DoRectangle(pLocalDC, x1, y1, x2, y2) ; return (b) ; } /************************************************************************** * Handler - RoundRect *************************************************************************/ BOOL bHandleRoundRect (PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRROUNDRECT pMfRoundRect ; INT x1, y1, x2, y2, x3, y3 ; pMfRoundRect = (PEMRROUNDRECT) pVoid ; // Set up the RoundRect box, this will be the same as the bounding // RoundRect. x1 = (INT) pMfRoundRect->rclBox.left ; y1 = (INT) pMfRoundRect->rclBox.top ; x2 = (INT) pMfRoundRect->rclBox.right ; y2 = (INT) pMfRoundRect->rclBox.bottom ; x3 = (INT) pMfRoundRect->szlCorner.cx ; y3 = (INT) pMfRoundRect->szlCorner.cy ; // Do the RoundRect translation. b = DoRoundRect(pLocalDC, x1, y1, x2, y2, x3, y3) ; return (b) ; } /************************************************************************** * Handler - ExtTextOut for both ANSI and UNICODE characters. **************************************************************************/ BOOL bHandleExtTextOut(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMREXTTEXTOUTA pMfExtTextOut ; // same for both ansi and unicode INT x, y, nCount ; DWORD flOptions ; PRECTL pRectl ; PLONG pDx ; PWCH pwchar ; DWORD iGraphicsMode; pMfExtTextOut = (PEMREXTTEXTOUTA) pVoid ; ASSERTGDI(pMfExtTextOut->emr.iType == EMR_EXTTEXTOUTA || pMfExtTextOut->emr.iType == EMR_EXTTEXTOUTW, "MF3216: bHandleExtTextOut: bad record type"); if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfExtTextOut, pMfExtTextOut->emrtext.offString, 0) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfExtTextOut, pMfExtTextOut->emrtext.offDx, 0)) { EMFVALFAIL(("MF3216: bHandleExtTextOut failed\n")); return(FALSE); } // Copy over the start position for the string. x = (INT) pMfExtTextOut->emrtext.ptlReference.x ; y = (INT) pMfExtTextOut->emrtext.ptlReference.y ; // Now copy over the Options flag, character count, // the clip/opaque rectangle, and the Ansi/Unicode string. flOptions = pMfExtTextOut->emrtext.fOptions ; nCount = (INT) pMfExtTextOut->emrtext.nChars ; pRectl = &pMfExtTextOut->emrtext.rcl ; pwchar = (PWCH) ((PBYTE) pMfExtTextOut + pMfExtTextOut->emrtext.offString); iGraphicsMode = pMfExtTextOut->iGraphicsMode; // Set up the spacing vector pDx = (PLONG) ((PBYTE) pMfExtTextOut + pMfExtTextOut->emrtext.offDx); // Now do the conversion. b = DoExtTextOut(pLocalDC, x, y, flOptions, pRectl, pwchar, nCount, pDx, iGraphicsMode, pMfExtTextOut->emr.iType); return (b) ; } /************************************************************************** * Handler - PolyTextOut for both ANSI and UNICODE characters. **************************************************************************/ BOOL bHandlePolyTextOut(PVOID pVoid, PLOCALDC pLocalDC) { PEMRPOLYTEXTOUTA pMfPolyTextOut; // same for both ansi and unicode PWCH pwchar; LONG i; DWORD iType; LONG cStrings; PEMRTEXT pemrtext; PLONG pDx ; DWORD iGraphicsMode; pMfPolyTextOut = (PEMRPOLYTEXTOUTA) pVoid ; ASSERTGDI(pMfPolyTextOut->emr.iType == EMR_POLYTEXTOUTA || pMfPolyTextOut->emr.iType == EMR_POLYTEXTOUTW, "MF3216: bHandlePolyTextOut: bad record type"); iType = pMfPolyTextOut->emr.iType == EMR_POLYTEXTOUTA ? EMR_EXTTEXTOUTA : EMR_EXTTEXTOUTW; cStrings = pMfPolyTextOut->cStrings; iGraphicsMode = pMfPolyTextOut->iGraphicsMode; // Convert to ExtTextOut for (i = 0; i < cStrings; i++) { pemrtext = &pMfPolyTextOut->aemrtext[i]; if (!IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfPolyTextOut, pemrtext->offString, 0) || !IsValidEnhMetaRecordOffExt(pLocalDC->pht, pMfPolyTextOut, pemrtext->offDx, 0)) { EMFVALFAIL(("MF3216: bHandlePolyTextOut failed\n")); return(FALSE); } pwchar = (PWCH) ((PBYTE) pMfPolyTextOut + pemrtext->offString); pDx = (PLONG) ((PBYTE) pMfPolyTextOut + pemrtext->offDx); if (!DoExtTextOut(pLocalDC, pemrtext->ptlReference.x, pemrtext->ptlReference.y, pemrtext->fOptions, &pemrtext->rcl, pwchar, pemrtext->nChars, pDx, iGraphicsMode, iType)) return(FALSE); } return(TRUE); } /************************************************************************** * Handler - ExtCreateFont *************************************************************************/ BOOL bHandleExtCreateFont(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b; PEMREXTCREATEFONTINDIRECTW pMfExtCreateFontW; PLOGFONTW plfw; INT ihFont; pMfExtCreateFontW = (PEMREXTCREATEFONTINDIRECTW) pVoid ; // Get the font parameters. ihFont = (INT) pMfExtCreateFontW->ihFont ; plfw = &pMfExtCreateFontW->elfw.elfLogFont; // Do the translation. b = DoExtCreateFont(pLocalDC, ihFont, plfw); return (b) ; } /************************************************************************** * Handler - SetBkColor *************************************************************************/ BOOL bHandleSetBkColor(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETBKCOLOR pMfSetBkColor ; pMfSetBkColor = (PEMRSETBKCOLOR) pVoid ; // Do the translation. b = DoSetBkColor(pLocalDC, pMfSetBkColor->crColor) ; return (b) ; } /************************************************************************** * Handler - SetBkMode *************************************************************************/ BOOL bHandleSetBkMode(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; DWORD iBkMode ; PEMRSETBKMODE pMfSetBkMode ; pMfSetBkMode = (PEMRSETBKMODE) pVoid ; // Set the Background Mode variable iBkMode = pMfSetBkMode->iMode ; // Do the translation. b = DoSetBkMode(pLocalDC, iBkMode) ; return (b) ; } /************************************************************************** * Handler - SetMapperFlags *************************************************************************/ BOOL bHandleSetMapperFlags(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; DWORD f ; PEMRSETMAPPERFLAGS pMfSetMapperFlags ; pMfSetMapperFlags = (PEMRSETMAPPERFLAGS) pVoid ; f = pMfSetMapperFlags->dwFlags ; // Do the translation. b = DoSetMapperFlags(pLocalDC, f) ; return (b) ; } /************************************************************************** * Handler - SetPolyFillMode *************************************************************************/ BOOL bHandleSetPolyFillMode(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; INT iPolyFillMode ; PEMRSETPOLYFILLMODE pMfSetPolyFillMode ; pMfSetPolyFillMode = (PEMRSETPOLYFILLMODE) pVoid ; // Set the PolyFill Mode iPolyFillMode = (INT) pMfSetPolyFillMode->iMode ; // Do the translation. b = DoSetPolyFillMode(pLocalDC, iPolyFillMode) ; return (b) ; } /************************************************************************** * Handler - SetRop2 *************************************************************************/ BOOL bHandleSetRop2(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; DWORD iDrawMode ; PEMRSETROP2 pMfSetROP2 ; pMfSetROP2 = (PEMRSETROP2) pVoid ; // Set the Draw Mode iDrawMode = pMfSetROP2->iMode ; // Do the translation. b = DoSetRop2(pLocalDC, iDrawMode) ; return (b) ; } /************************************************************************** * Handler - SetStretchBltMode *************************************************************************/ BOOL bHandleSetStretchBltMode(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; DWORD iStretchMode ; PEMRSETSTRETCHBLTMODE pMfSetStretchBltMode ; pMfSetStretchBltMode = (PEMRSETSTRETCHBLTMODE) pVoid ; // Set the StretchBlt Mode iStretchMode = pMfSetStretchBltMode->iMode ; // Do the translation. b = DoSetStretchBltMode(pLocalDC, iStretchMode) ; return (b) ; } /************************************************************************** * Handler - SetTextAlign *************************************************************************/ BOOL bHandleSetTextAlign(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; DWORD fMode ; PEMRSETTEXTALIGN pMfSetTextAlign ; pMfSetTextAlign = (PEMRSETTEXTALIGN) pVoid ; // Set the TextAlign Mode fMode = pMfSetTextAlign->iMode ; // Do the translation. b = DoSetTextAlign(pLocalDC, fMode) ; return (b) ; } /************************************************************************** * Handler - SetTextColor *************************************************************************/ BOOL bHandleSetTextColor(PVOID pVoid, PLOCALDC pLocalDC) { BOOL b ; PEMRSETTEXTCOLOR pMfSetTextColor ; pMfSetTextColor = (PEMRSETTEXTCOLOR) pVoid ; // Do the translation. b = DoSetTextColor(pLocalDC, pMfSetTextColor->crColor) ; return (b) ; }