windows-server-2003/windows/advcore/gdiplus/engine/entry/metaemf.cpp

/**************************************************************************\
*
* Copyright (c) 2000  Microsoft Corporation
*
* Module Name:
*
*   MetaEmf.cpp
*
* Abstract:
*
*   Methods for playing and recoloring an EMF.
*
* Created:
*
*   1/6/2000 DCurtis
*
\**************************************************************************/

#include "Precomp.hpp"
#include "MetaWmf.hpp"

//----------------------------------------------------------------------------
//  File format signatures for Office Art data.
//------------------------------------------------------------------- JohnBo
#define msoszOfficeSignature "MSOFFICE"
#define msocbOfficeSignature 8
#define msoszOfficeAuthentication "9.0"
#define msocbOfficeAuthentication 3
#define msoszOfficeIdent msoszOfficeSignature msoszOfficeAuthentication
#define msocbOfficeIdent (msocbOfficeSignature+msocbOfficeAuthentication)

#define msoszOAPNGChunk "msOA"
#define msocbOAPNGChunk 4
#define msoszOADataHeader msoszOAPNGChunk msoszOfficeIdent
#define msocbOADataHeader (msocbOAPNGChunk+msocbOfficeIdent)

#define msoszOAKind "OA"
#define msocbOAKind 2

/* This defines an OZ chunk, like OA but Zlib compressed. */
#define msoszOZPNGChunk "msOZ"
#define msocbOZPNGChunk 4
#define msoszOZDataHeader msoszOZPNGChunk msoszOfficeIdent
#define msocbOZDataHeader (msocbOZPNGChunk+msocbOfficeIdent)

// These are needed for IA64 compatibility with X86
// Since we are reading this record from a stream, on IA64
// The EXTLOGPEN structure has a ULONG_PTR member which is not the same size
// on IA64 and X86. Since all output to files will keep the X86 format we need
// to make sure that we can read this format in IA64, so we make it compatible
// by changing the ULONG_PTR to a ULONG (32bit). The packing of the structure
// will them be the same and the members will be at the same offset

typedef struct tagEXTLOGPEN32 {
    DWORD       elpPenStyle;
    DWORD       elpWidth;
    UINT        elpBrushStyle;
    COLORREF    elpColor;
    ULONG       elpHatch;
    DWORD       elpNumEntries;
    DWORD       elpStyleEntry[1];
} EXTLOGPEN32, *PEXTLOGPEN32;

typedef struct tagEMREXTCREATEPEN32
{
    EMR     emr;
    DWORD   ihPen;              // Pen handle index
    DWORD   offBmi;             // Offset to the BITMAPINFO structure if any
    DWORD   cbBmi;              // Size of the BITMAPINFO structure if any
                                // The bitmap info is followed by the bitmap
                                // bits to form a packed DIB.
    DWORD   offBits;            // Offset to the brush bitmap bits if any
    DWORD   cbBits;             // Size of the brush bitmap bits if any
    EXTLOGPEN32 elp;              // The extended pen with the style array.
} EMREXTCREATEPEN32, *PEMREXTCREATEPEN32;

typedef struct tagEMRRCLBOUNDS
{
    EMR     emr;
    RECTL   rclBounds;
} EMRRCLBOUNDS, *PEMRRCLBOUNDS;

typedef struct EMROFFICECOMMENT
{
    EMR     emr;
    DWORD   cbData;             // Size of following fields and data
    DWORD   ident;              // GDICOMMENT_IDENTIFIER
    DWORD   iComment;           // Comment type e.g. GDICOMMENT_WINDOWS_METAFILE
} EMROFFICECOMMENT, *PEMROFFICECOMMENT;

RecolorStockObject RecolorStockObjectList[NUM_STOCK_RECOLOR_OBJS] =
{
    { WHITE_BRUSH,    (COLORREF)RGB(0xFF, 0xFF, 0xFF),   TRUE  },
    { LTGRAY_BRUSH,   (COLORREF)RGB(0xC0, 0xC0, 0xC0),   TRUE  },
    { GRAY_BRUSH,     (COLORREF)RGB(0x80, 0x80, 0x80),   TRUE  },
    { DKGRAY_BRUSH,   (COLORREF)RGB(0x40, 0x40 ,0x40),   TRUE  },
    { BLACK_BRUSH,    (COLORREF)RGB(0, 0, 0),            TRUE  },
    { WHITE_PEN,      (COLORREF)RGB(0xFF, 0xFF, 0xFF),   FALSE },
    { BLACK_PEN,      (COLORREF)RGB(0, 0 ,0),            FALSE }
};

inline static RGBQUAD *
GetDibColorTable(
    BITMAPINFOHEADER *      dibInfo
    )
{
    return ( RGBQUAD *)(((BYTE *)dibInfo) + dibInfo->biSize);
}

BOOL
EmfEnumState::CreateCopyOfCurrentRecord()
{
    if (ModifiedRecordSize > 0)
    {
        // We already made a modified record.  Don't do it again.
        ASSERT(ModifiedRecord != NULL);
        return TRUE;
    }

    INT     size = this->GetCurrentRecordSize();

    if (CreateRecordToModify(size))
    {
        ENHMETARECORD * modifiedRecord = (ENHMETARECORD *)ModifiedRecord;

        modifiedRecord->iType = RecordType;
        modifiedRecord->nSize = size;

        if (RecordDataSize > 0)
        {
            GpMemcpy(modifiedRecord->dParm, RecordData, RecordDataSize);
        }
        return TRUE;
    }

    WARNING(("Failed to create copy of current record"));
    return FALSE;
}

BOOL
EmfEnumState::CreateAndPlayOutputDIBRecord(
    HDC                           hdc,
    const RECTL *                 bounds,
    INT                           dstX,
    INT                           dstY,
    INT                           dstWidth,
    INT                           dstHeight,
    INT                           srcX,
    INT                           srcY,
    INT                           srcWidth,
    INT                           srcHeight,
    UNALIGNED BITMAPINFOHEADER *  dibInfo,
    BYTE *                        bits,   // if NULL, this is a packed DIB
    UINT                          usage,
    DWORD                         rop
    )
{
    ASSERT(!Globals::IsNt);

    INT  bitsSize = GetDibBitsSize(dibInfo);
    UINT sizePalEntries;

    if (GetDibNumPalEntries(FALSE,
                            dibInfo->biSize,
                            dibInfo->biBitCount,
                            dibInfo->biCompression,
                            dibInfo->biClrUsed,
                            &sizePalEntries))
    {
        // We need to get the palette size that corresponds to the type
        // If we have a DIB_PAL_COLORS then each entry is 16bits
        sizePalEntries *= ((usage == DIB_PAL_COLORS)?2:sizeof(RGBQUAD));
    }
    else
    {
        sizePalEntries = 0 ;
    }

    // We need at least a BITMAPINFO structure in there, but if there is a
    // palette, calculate the full size of the structure including the
    // palette

    INT bitmapHeaderSize = sizeof(BITMAPINFOHEADER) + sizePalEntries;
    INT size = sizeof(EMRSTRETCHDIBITS) + bitmapHeaderSize + bitsSize ;

    // We cannot use the CreateRecordToModify because the record has already
    // been modified
    size = (size + 3) & ~3;
    EMRSTRETCHDIBITS* emrStretchDIBits = (EMRSTRETCHDIBITS*) GpMalloc(size);
    if (emrStretchDIBits != NULL)
    {
        emrStretchDIBits->emr.iType = EmfRecordTypeStretchDIBits;
        emrStretchDIBits->emr.nSize = size;
        emrStretchDIBits->rclBounds = *bounds;
        emrStretchDIBits->xDest = dstX;
        emrStretchDIBits->yDest = dstY;
        emrStretchDIBits->xSrc = srcX;
        emrStretchDIBits->ySrc = srcY;
        emrStretchDIBits->cxSrc = srcWidth;
        emrStretchDIBits->cySrc = srcHeight;
        emrStretchDIBits->offBmiSrc = sizeof(EMRSTRETCHDIBITS);
        emrStretchDIBits->cbBmiSrc = bitmapHeaderSize;
        emrStretchDIBits->offBitsSrc = emrStretchDIBits->offBmiSrc + emrStretchDIBits->cbBmiSrc;
        emrStretchDIBits->cbBitsSrc = bitsSize;
        emrStretchDIBits->iUsageSrc = usage;
        emrStretchDIBits->dwRop = rop;
        emrStretchDIBits->cxDest = dstWidth;
        emrStretchDIBits->cyDest = dstHeight;
        GpMemcpy((BYTE*)emrStretchDIBits + emrStretchDIBits->offBmiSrc, dibInfo, emrStretchDIBits->cbBmiSrc);
        GpMemcpy((BYTE*)emrStretchDIBits + emrStretchDIBits->offBitsSrc, bits, emrStretchDIBits->cbBitsSrc);

        ::PlayEnhMetaFileRecord(hdc, HandleTable, (ENHMETARECORD *)emrStretchDIBits, NumObjects);
        GpFree(emrStretchDIBits);
        return TRUE;
    }
    return FALSE;
}

BITMAPINFOHEADER *
EmfEnumState::CreateModifiedDib(
    BITMAPINFOHEADER *  srcDibInfo,
    BYTE *              srcBits,
    UINT &              usage,
    DWORD               rop
    )
{
    BITMAPINFOHEADER *  dstDibInfo = NULL;
    UINT                numPalEntries;
    UINT                dibBitsSize;

    if ((srcDibInfo->biSize >= sizeof(BITMAPINFOHEADER)) &&
        GetDibNumPalEntries(FALSE,
                            srcDibInfo->biSize,
                            srcDibInfo->biBitCount,
                            srcDibInfo->biCompression,
                            srcDibInfo->biClrUsed,
                            &numPalEntries) &&
        ((dibBitsSize = GetDibBitsSize(srcDibInfo)) > 0))
    {
        if (numPalEntries == 2 && rop != SRCCOPY)
        {
            DWORD  *rgb = (DWORD*) GetDibColorTable(srcDibInfo);
            if (rgb[0] == 0x00000000 && rgb[1] == 0x00FFFFFF)
            {
                return dstDibInfo;
            }
        }

        // We need to pass in to ModifyDib the old Usage value because we haven't modified
        // the bitmap yet. Once we do then we will return the new usage of the palette.
        UINT oldUsage = usage;
        INT dstDibSize = GetModifiedDibSize(srcDibInfo, numPalEntries, dibBitsSize, usage);

        if ((dstDibSize > 0) && CreateRecordToModify(dstDibSize))
        {
            dstDibInfo = (BITMAPINFOHEADER *)ModifiedRecord;
            ModifyDib(oldUsage, srcDibInfo, srcBits, dstDibInfo,
                      numPalEntries, dibBitsSize, ColorAdjustTypeBitmap);
        }
    }
    return dstDibInfo;
}

VOID
EmfEnumState::BitBlt(
    )
{
    const EMRBITBLT *  bitBltRecord = (const EMRBITBLT *)GetPartialRecord();

    DWORD rop = bitBltRecord->dwRop;

    // If No-Op ROP, do nothing; just return
    if ((rop & 0xFFFF0000) == (GDIP_NOOP_ROP3 & 0xFFFF0000))
    {
        return;
    }

    // On NT4, PATCOPYs fail to draw correctly if there is a skew/rotate
    // in the matrix.  So use a rectangle call instead.
    if ((rop == PATCOPY) && Globals::IsNt && (Globals::OsVer.dwMajorVersion <= 4))
    {
        XFORM   xform;
        if (::GetWorldTransform(Hdc, &xform) &&
            ((xform.eM12 != 0.0f) || (xform.eM21 != 0.0f)))
        {
            HPEN    hPenOld = (HPEN)::SelectObject(Hdc, ::GetStockObject(NULL_PEN));
            DWORD   dcRop = ::GetROP2(Hdc);

            if (dcRop != R2_COPYPEN)
            {
                ::SetROP2(Hdc, R2_COPYPEN);
            }
            ::Rectangle(Hdc, bitBltRecord->xDest, bitBltRecord->yDest,
                        bitBltRecord->xDest + bitBltRecord->cxDest,
                        bitBltRecord->yDest + bitBltRecord->cyDest);
            ::SelectObject(Hdc, hPenOld);
            if (dcRop != R2_COPYPEN)
            {
                ::SetROP2(Hdc, dcRop);
            }
            return;
        }
    }

    if (rop != SRCCOPY &&
        rop != NOTSRCCOPY &&
        rop != PATCOPY &&
        rop != BLACKNESS &&
        rop != WHITENESS)
    {
        RopUsed = TRUE;
    }

    if ((bitBltRecord->cbBitsSrc > 0) &&
        (bitBltRecord->cbBmiSrc > 0)  &&
        IsSourceInRop3(rop))
    {
        // Should we modify the dib if it is monochrome?
        // What if there is a non-identity transform for the src DC?

        UINT                usage      = bitBltRecord->iUsageSrc;
        BITMAPINFOHEADER *  srcDibInfo = (BITMAPINFOHEADER *)(((BYTE *)bitBltRecord) + bitBltRecord->offBmiSrc);
        BYTE *              srcBits    = ((BYTE *)bitBltRecord) + bitBltRecord->offBitsSrc;
        BITMAPINFOHEADER *  dstDibInfo = CreateModifiedDib(srcDibInfo, srcBits, usage, rop);

        if (dstDibInfo != NULL)
        {
            srcDibInfo = dstDibInfo;
            srcBits = NULL;
        }

        if (SrcCopyOnly && rop != SRCCOPY)
        {
            rop = SRCCOPY;
        }

        OutputDIB(Hdc,
                  &bitBltRecord->rclBounds,
                  bitBltRecord->xDest,  bitBltRecord->yDest,
                  bitBltRecord->cxDest, bitBltRecord->cyDest,
                  bitBltRecord->xSrc,   bitBltRecord->ySrc,
                  bitBltRecord->cxDest, bitBltRecord->cyDest,
                  srcDibInfo, srcBits, usage, rop, FALSE);
    }
    else
    {
        if (SrcCopyOnly && rop != PATCOPY && !IsSourceInRop3(rop) && CreateCopyOfCurrentRecord())
        {
            EMRBITBLT *  newBitBltRecord = (EMRBITBLT *) ModifiedEmfRecord;
            newBitBltRecord->dwRop = PATCOPY;
        }
        ResetRecordBounds();
        this->PlayRecord();
    }
}

VOID
EmfEnumState::StretchBlt(
    )
{
    const EMRSTRETCHBLT *  stretchBltRecord = (const EMRSTRETCHBLT *)GetPartialRecord();

    DWORD rop = stretchBltRecord->dwRop;

    // If No-Op ROP, do nothing; just return
    if ((rop & 0xFFFF0000) == (GDIP_NOOP_ROP3 & 0xFFFF0000))
    {
        return;
    }

    if (rop != SRCCOPY &&
        rop != NOTSRCCOPY &&
        rop != PATCOPY &&
        rop != BLACKNESS &&
        rop != WHITENESS)
    {
        RopUsed = TRUE;
    }

    if ((stretchBltRecord->cbBitsSrc > 0) &&
        (stretchBltRecord->cbBmiSrc > 0)  &&
        IsSourceInRop3(rop))
    {
        // Should we modify the dib if it is monochrome?
        // What if there is a non-identity transform for the src DC?

        UINT                usage      = stretchBltRecord->iUsageSrc;
        BITMAPINFOHEADER *  srcDibInfo = (BITMAPINFOHEADER *)(((BYTE *)stretchBltRecord) + stretchBltRecord->offBmiSrc);
        BYTE *              srcBits    = ((BYTE *)stretchBltRecord) + stretchBltRecord->offBitsSrc;
        BITMAPINFOHEADER *  dstDibInfo = CreateModifiedDib(srcDibInfo, srcBits, usage, rop);

        if (SrcCopyOnly && rop != SRCCOPY)
        {
            rop = SRCCOPY;
        }

        ASSERT(sizeof(XFORM) == sizeof(REAL)*6);

        GpMatrix xForm((REAL*) &(stretchBltRecord->xformSrc));

        if (dstDibInfo != NULL)
        {
            srcDibInfo = dstDibInfo;
            srcBits = NULL;
        }

        GpRectF  srcRect((REAL)stretchBltRecord->xSrc,
                         (REAL)stretchBltRecord->ySrc,
                         (REAL)stretchBltRecord->cxSrc,
                         (REAL)stretchBltRecord->cySrc);

        if (!xForm.IsIdentity())
        {
            // We cannot use TransformRect, because the output rect will always
            // have a positive Width and Height which we don't want
            GpPointF points[2];
            points[0] = GpPointF(srcRect.X, srcRect.Y);
            points[1] = GpPointF(srcRect.GetRight(), srcRect.GetBottom());
            xForm.Transform(points, 2);
            srcRect.X = points[0].X;
            srcRect.Y = points[0].Y;
            srcRect.Width = points[1].X - points[0].X;
            srcRect.Height = points[1].Y - points[0].Y;
        }

        // StretchBlt takes as parameters the top left corner of the dest
        // whereas StretchDIBits takes the offset in the source image.
        // For bottom up dibs those are not the same and we need to offset
        // the srcrect's Y coodinate by the difference
        if (srcDibInfo->biHeight > 0 &&
            srcRect.Height < srcDibInfo->biHeight)
        {
            srcRect.Y = srcDibInfo->biHeight - srcRect.Height - srcRect.Y;
        }

        OutputDIB(Hdc,
                  &stretchBltRecord->rclBounds,
                  stretchBltRecord->xDest,  stretchBltRecord->yDest,
                  stretchBltRecord->cxDest, stretchBltRecord->cyDest,
                  GpRound(srcRect.X),   GpRound(srcRect.Y),
                  GpRound(srcRect.Width), GpRound(srcRect.Height),
                  srcDibInfo, srcBits, usage, rop, FALSE);
    }
    else
    {
        if (SrcCopyOnly && rop != PATCOPY && !IsSourceInRop3(rop) && CreateCopyOfCurrentRecord())
        {
            EMRSTRETCHBLT *  stretchBltRecord = (EMRSTRETCHBLT *)ModifiedEmfRecord;
            stretchBltRecord->dwRop = PATCOPY;
        }
        ResetRecordBounds();
        this->PlayRecord();
    }
}

VOID
EmfEnumState::StretchDIBits(
    )
{
    const EMRSTRETCHDIBITS *  stretchDIBitsRecord = (const EMRSTRETCHDIBITS *)GetPartialRecord();

    DWORD rop = stretchDIBitsRecord->dwRop;

    // If No-Op ROP, do nothing; just return
    if ((rop & 0xFFFF0000) == (GDIP_NOOP_ROP3 & 0xFFFF0000))
    {
        return;
    }

    if (rop != SRCCOPY &&
        rop != NOTSRCCOPY &&
        rop != PATCOPY &&
        rop != BLACKNESS &&
        rop != WHITENESS)
    {
        RopUsed = TRUE;
    }

    if ((stretchDIBitsRecord->cbBitsSrc > 0) &&
        (stretchDIBitsRecord->cbBmiSrc > 0)  &&
        IsSourceInRop3(rop))
    {
        UINT                usage      = stretchDIBitsRecord->iUsageSrc;
        BITMAPINFOHEADER *  srcDibInfo = (BITMAPINFOHEADER *)(((BYTE *)stretchDIBitsRecord) + stretchDIBitsRecord->offBmiSrc);
        BYTE *              srcBits    = ((BYTE *)stretchDIBitsRecord) + stretchDIBitsRecord->offBitsSrc;
        BITMAPINFOHEADER *  dstDibInfo = CreateModifiedDib(srcDibInfo, srcBits, usage, rop);

        if (dstDibInfo != NULL)
        {
            srcDibInfo = dstDibInfo;
            srcBits = NULL;
        }

        if (SrcCopyOnly && rop != SRCCOPY)
        {
            rop = SRCCOPY;
        }

        OutputDIB(Hdc,
                  &stretchDIBitsRecord->rclBounds,
                  stretchDIBitsRecord->xDest,  stretchDIBitsRecord->yDest,
                  stretchDIBitsRecord->cxDest, stretchDIBitsRecord->cyDest,
                  stretchDIBitsRecord->xSrc,   stretchDIBitsRecord->ySrc,
                  stretchDIBitsRecord->cxSrc,  stretchDIBitsRecord->cySrc,
                  srcDibInfo, srcBits, usage,  rop, FALSE);
    }
    else
    {
        if (SrcCopyOnly && rop != PATCOPY && !IsSourceInRop3(rop) && CreateCopyOfCurrentRecord())
        {
            EMRSTRETCHDIBITS*  stretchDIBitsRecord = (EMRSTRETCHDIBITS *)ModifiedEmfRecord;
            stretchDIBitsRecord->dwRop = PATCOPY;
        }
        ResetRecordBounds();
        this->PlayRecord();
    }
}

VOID
EmfEnumState::SetDIBitsToDevice(
    )
{
    // !!! to do

    // In SetDIBitsToDevice, the destination width and height
    // are in device units but in StretchDIBits, they are in world units.
    // Plus, the DIB header is for the entire DIB, but only part of the
    // DIB may be here (based on the number of scans).
    // So this record requires special handling if we are to process it.

    ResetRecordBounds();
    this->PlayRecord();
}

VOID
EmfEnumState::CreateDibPatternBrushPt(
    )
{
    const EMRCREATEDIBPATTERNBRUSHPT *  brushRecord = (const EMRCREATEDIBPATTERNBRUSHPT *)GetPartialRecord();
    INT     objectIndex = brushRecord->ihBrush;

    if (ValidObjectIndex(objectIndex) && (HandleTable != NULL))
    {
        UINT                usage      = brushRecord->iUsage;
        BITMAPINFOHEADER *  srcDibInfo = (BITMAPINFOHEADER *)(((UNALIGNED BYTE *)brushRecord) + brushRecord->offBmi);
        BITMAPINFOHEADER *  dstDibInfo = CreateModifiedDib(srcDibInfo, NULL, usage, SRCCOPY);

        if (dstDibInfo != NULL)
        {
            HandleTable->objectHandle[objectIndex] =
                    CreateDIBPatternBrushPt((BITMAPINFO *)dstDibInfo, usage);
            return;
        }
    }

    this->PlayRecord();
}

inline static BOOL
IsOfficeArtData(
    UINT                    recordSize,
    const EMRGDICOMMENT *   commentRecord
    )
{
    return ((recordSize >= (12 + 4 + msocbOADataHeader)) &&
            (commentRecord->cbData >= (msocbOADataHeader + 4)) &&
            ((GpMemcmp(commentRecord->Data, msoszOADataHeader, msocbOADataHeader) == 0) ||
             (GpMemcmp(commentRecord->Data, msoszOZDataHeader, msocbOZDataHeader) == 0)));
}

inline static const EMROFFICECOMMENT *
GetEmfComment(
    const BYTE *        emfRecord,
    ULONG               signature,
    UINT                kind
    )
{
    const EMROFFICECOMMENT *  emfComment = (const EMROFFICECOMMENT*)(emfRecord);
    if ((emfComment->ident == signature) && (emfComment->iComment == kind))
    {
        return emfComment;
    }
    return NULL;
}



VOID
EmfEnumState::GdiComment(
    )
{
    // Skip Office Art data when playing into another metafile
    if (IsMetafile() &&
        IsOfficeArtData(
            GetCurrentRecordSize(),
            (const EMRGDICOMMENT *)GetPartialRecord()))
    {
        return;
    }

    if (IsPostscript())
    {
        if (GetEmfComment((BYTE*)CurrentEmfRecord, msosignature, msocommentBeginSrcCopy))
        {
            SrcCopyOnly = TRUE;
            return;
        }
        if (GetEmfComment((BYTE*)CurrentEmfRecord, msosignature, msocommentEndSrcCopy))
        {
            SrcCopyOnly = FALSE;
            return;
        }
    }

    this->PlayRecord();
}

BOOL
IsPenCosmetic(
    HDC     hdc,
    int     penWidth
    )
{
    penWidth <<= 7;

    INT     newPenWidth = penWidth;
    POINT   points[2];

    points[0].x = 0;
    points[0].y = 0;
    points[1].x = 1 << 7;
    points[1].y = 0;

    if (::DPtoLP(hdc, points, 2))
    {
        newPenWidth = points[1].x - points[0].x;
        if (newPenWidth < 0)
        {
            newPenWidth = -newPenWidth;
        }
    }
    return (penWidth <= newPenWidth);
}

VOID
EmfEnumState::CreatePen(
    )
{
    const EMRCREATEPEN *    penRecord = (const EMRCREATEPEN *)GetPartialRecord();
    DWORD                   oldStyle  = penRecord->lopn.lopnStyle;

    if (oldStyle == PS_NULL)
    {
        this->PlayRecord();
    }
    else if (IsMetafile())
    {
        ModifyRecordColor(4, ColorAdjustTypePen);
        this->PlayRecord();
    }
    else
    {
        INT     objectIndex = penRecord->ihPen;

        if (ValidObjectIndex(objectIndex) && (HandleTable != NULL))
        {
            LOGBRUSH    logBrush;

            logBrush.lbStyle = PS_SOLID;
            logBrush.lbColor = ModifyColor(penRecord->lopn.lopnColor, ColorAdjustTypePen);
            logBrush.lbHatch = 0;

            INT         penWidth = penRecord->lopn.lopnWidth.x;
            DWORD       style;

            if (!Globals::IsNt && !IsMetafile())
            {
                //IsPenCosmetic is gonna call DPtoLP... Make sure to invalidate
                //the transform before
                CreateAndPlayCommentRecord();
            }

            if (IsPenCosmetic(Hdc, penWidth))
            {
                switch (oldStyle)
                {
                case PS_SOLID:
                case PS_DASH:           // on Win9x, cosmetic only
                case PS_DOT:            // on Win9x, cosmetic only
                case PS_DASHDOT:        // on Win9x, cosmetic only
                case PS_DASHDOTDOT:     // on Win9x, cosmetic only
                    break;

                case PS_ALTERNATE:      // cosmetic only, NT only
                    if (Globals::IsNt)
                    {
                        break;
                    }
                    // FALLTHRU

                case PS_USERSTYLE:      // NT only
                case PS_INSIDEFRAME:    // geometric only
                default:
                    oldStyle = PS_SOLID;
                    break;
                }
                penWidth = 1;
                style = PS_COSMETIC | oldStyle;
            }
            else
            {
                switch (oldStyle)
                {
                case PS_SOLID:
                case PS_INSIDEFRAME:    // geometric only
                    break;

                case PS_DASH:           // on Win9x, cosmetic only
                case PS_DOT:            // on Win9x, cosmetic only
                case PS_DASHDOT:        // on Win9x, cosmetic only
                case PS_DASHDOTDOT:     // on Win9x, cosmetic only
                    if (Globals::IsNt)
                    {
                        break;
                    }
                    // FALLTHRU

                case PS_ALTERNATE:      // cosmetic only, NT only
                case PS_USERSTYLE:      // NT only
                default:
                    oldStyle = PS_SOLID;
                    break;
                }
                style = PS_GEOMETRIC | oldStyle | PS_ENDCAP_ROUND | PS_JOIN_ROUND;
            }

            HandleTable->objectHandle[objectIndex] = ::ExtCreatePen(style, penWidth, &logBrush, 0, NULL);
        }
    }
}

HFONT CreateTrueTypeFont(
    HFONT   hFont
    )
{
    if (hFont)
    {
        if (Globals::IsNt)
        {
            LOGFONT  logFont;
            
            if (GetObject(hFont, sizeof(logFont), &logFont) > 0)
            {
                logFont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
                return CreateFontIndirect(&logFont);
            }
            else
            {
                WARNING1("GetObject for hFont failed");
            }

        }
        else
        {
            LOGFONTA  logFont;

            if (GetObjectA(hFont, sizeof(logFont), &logFont) > 0)
            {
                logFont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
                // We have a bug in Win9x that the OUT_TT_ONLY_PRECIS flag is
                // not always respected so if the font name is MS SANS SERIF
                // change it to Times New Roman
                if (lstrcmpiA(logFont.lfFaceName, "MS SANS SERIF") == 0)
                {
                    GpMemcpy(logFont.lfFaceName, "Times New Roman", sizeof("Times New Roman"));
                }
                return CreateFontIndirectA(&logFont);
            }
            else
            {
                WARNING1("GetObject for hFont failed");
            }
        }            
    }
    else
    {
        WARNING1("NULL hFont");
    }
    return NULL;
}

VOID
EmfEnumState::ExtCreateFontIndirect(
    )
{
    const EMREXTCREATEFONTINDIRECTW *    fontRecord = (const EMREXTCREATEFONTINDIRECTW *)GetPartialRecord();
    BOOL recordCopied = FALSE;
    if (!Globals::IsNt)
    {
        // We have a bug in Win9x that the OUT_TT_ONLY_PRECIS flag is
        // not always respected so if the font name is MS SANS SERIF
        // change it to Times New Roman
        if (UnicodeStringCompareCI(fontRecord->elfw.elfFullName, L"MS SANS SERIF") == 0)
        {
            if (CreateCopyOfCurrentRecord())
            {
                GpMemcpy(((EMREXTCREATEFONTINDIRECTW *)ModifiedEmfRecord)->elfw.elfFullName,
                         L"Times New Roman", sizeof(L"Times New Roman"));
                recordCopied = TRUE;
            }
        }
    }


    if (fontRecord->elfw.elfLogFont.lfOutPrecision != OUT_TT_ONLY_PRECIS)
    {
        if (recordCopied || CreateCopyOfCurrentRecord())
        // Instruct GDI to use only True Type fonts, since bitmap fonts
        // are not scalable.
        {
            ((EMREXTCREATEFONTINDIRECTW *)ModifiedEmfRecord)->elfw.elfLogFont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
        }
    }
    this->PlayRecord();
}

VOID
EmfEnumState::SelectObject(
    )
{
    const EMRSELECTOBJECT *     selectRecord = (const EMRSELECTOBJECT *)GetPartialRecord();
    DWORD                       handleIndex  = selectRecord->ihObject;

    // See if we're selecting in a stock font
    if ((handleIndex & ENHMETA_STOCK_OBJECT) != 0)
    {
        handleIndex &= (~ENHMETA_STOCK_OBJECT);

        // handleIndex >= (WHITE_BRUSH==0) && <= BLACK_PEN
        if ((handleIndex <= BLACK_PEN) && (Recolor != NULL))
        {
            union {
                LOGBRUSH lb;
                LOGPEN lp;
            };

            RecolorStockObject* stockObj;
            int i;

            for (stockObj = &RecolorStockObjectList[0],
                 i = 0;
                 i < NUM_STOCK_RECOLOR_OBJS;
                 i++,
                 stockObj++)
            {
                if (stockObj->Handle == handleIndex)
                {
                    // Already have a cached recolored handle lying around.
                    HGDIOBJ stockHandle = RecoloredStockHandle[i];

                    if (stockHandle == NULL)
                    {
                        // No cached recolored stock object handle, recreate
                        // one here.
                        COLORREF newColor;

                        if (stockObj->Brush)
                        {
                            newColor = ModifyColor(stockObj->Color, ColorAdjustTypeBrush);

                            lb.lbStyle = BS_SOLID;
                            lb.lbColor = newColor;
                            lb.lbHatch = 0;

                            stockHandle = ::CreateBrushIndirect(&lb);

                            RecoloredStockHandle[i] = stockHandle;
                        }
                        else
                        {
                            newColor = ModifyColor(stockObj->Color, ColorAdjustTypePen);

                            lp.lopnStyle = PS_SOLID;
                            lp.lopnWidth.x = 1;
                            lp.lopnWidth.y = 0;
                            lb.lbColor = newColor;

                            stockHandle = ::CreatePenIndirect(&lp);

                            RecoloredStockHandle[i] = stockHandle;
                        }
                    }

                    if (stockHandle != NULL)
                    {
                        ::SelectObject(Hdc, stockHandle);
                        return;
                    }
                }
            }
        }
        else if ((handleIndex >= OEM_FIXED_FONT) &&
                 (handleIndex <= DEFAULT_GUI_FONT))
        {
            // It is a stock font -- create a true type font, instead of
            // using the stock font directly to guarantee that we don't
            // use bitmap fonts which don't scale well.

            HFONT   hFont = StockFonts[handleIndex - OEM_FIXED_FONT];

            if (hFont == NULL)
            {
                hFont = CreateTrueTypeFont((HFONT)GetStockObject(handleIndex));
                StockFonts[handleIndex - OEM_FIXED_FONT] = hFont;
            }

            if (hFont != NULL)
            {
                ::SelectObject(Hdc, hFont);
                return;
            }
        }
    }
    this->PlayRecord();

    // In case we select a region, intersect with the destrect
    if (!Globals::IsNt)
    {
        if (((handleIndex & ENHMETA_STOCK_OBJECT) == 0) &&
            (GetObjectTypeInternal((*HandleTable).objectHandle[handleIndex]) == OBJ_REGION))
        {
            this->IntersectDestRect();
        }
    }
}

VOID
EmfEnumState::ExtCreatePen(
    )
{
    const EMREXTCREATEPEN32 *  penRecord = (const EMREXTCREATEPEN32 *)GetPartialRecord();
    UINT    brushStyle = penRecord->elp.elpBrushStyle;

    if (brushStyle != BS_HOLLOW)
    {
        if (IsMetafile())
        {
            if ((brushStyle == BS_SOLID) || (brushStyle == BS_HATCHED))
            {
                ModifyRecordColor(8, ColorAdjustTypePen);
            }
            // else don't worry about recoloring pattern brushes for now

            this->PlayRecord();
            return;
        }

        INT     objectIndex = penRecord->ihPen;

        if (ValidObjectIndex(objectIndex) && (HandleTable != NULL))
        {
            if (!Globals::IsNt && !IsMetafile())
            {
                //IsPenCosmetic is gonna call DPtoLP... Make sure to invalidate
                //the transform before
                CreateAndPlayCommentRecord();
            }

            DWORD       penWidth   = penRecord->elp.elpWidth;
            BOOL        isCosmetic = IsPenCosmetic(Hdc, penWidth);
            DWORD       oldStyle   = penRecord->elp.elpPenStyle;

            if (!Globals::IsNt)
            {
                DWORD       style;

                if (isCosmetic)
                {
                    oldStyle &= PS_STYLE_MASK;

                    switch (oldStyle)
                    {
                    case PS_SOLID:
                    case PS_DASH:           // on Win9x, cosmetic only
                    case PS_DOT:            // on Win9x, cosmetic only
                    case PS_DASHDOT:        // on Win9x, cosmetic only
                    case PS_DASHDOTDOT:     // on Win9x, cosmetic only
                        break;

                    case PS_ALTERNATE:      // cosmetic only, NT only
                    case PS_USERSTYLE:      // NT only
                    case PS_INSIDEFRAME:    // geometric only
                    default:
                        oldStyle = PS_SOLID;
                        break;
                    }
                    penWidth = 1;
                    style = PS_COSMETIC | oldStyle;
                }
                else
                {
                    oldStyle &= (~PS_TYPE_MASK);

                    switch (oldStyle & PS_STYLE_MASK)
                    {
                    case PS_SOLID:
                    case PS_INSIDEFRAME:    // geometric only
                        break;

                    case PS_DASH:           // on Win9x, cosmetic only
                    case PS_DOT:            // on Win9x, cosmetic only
                    case PS_DASHDOT:        // on Win9x, cosmetic only
                    case PS_DASHDOTDOT:     // on Win9x, cosmetic only
                    case PS_ALTERNATE:      // cosmetic only, NT only
                    case PS_USERSTYLE:      // NT only
                    default:
                        oldStyle = (oldStyle & (~PS_STYLE_MASK)) | PS_SOLID;
                        break;
                    }
                    style = PS_GEOMETRIC | oldStyle;
                }

                COLORREF    color = RGB(0,0,0);

                if ((brushStyle == BS_SOLID) || (brushStyle == BS_HATCHED))
                {
                    color = penRecord->elp.elpColor;
                }

                color = ModifyColor(color, ColorAdjustTypePen);

                // Only solid brushes are supported on Win9x
                LOGBRUSH    logBrush;
                logBrush.lbStyle = PS_SOLID;
                logBrush.lbColor = color;
                logBrush.lbHatch = 0;

                HandleTable->objectHandle[objectIndex] = ::ExtCreatePen(style, penWidth, &logBrush, 0, NULL);
                return;
            }

            // else it is NT
            if ((brushStyle == BS_SOLID) || (brushStyle == BS_HATCHED))
            {
                ModifyRecordColor(8, ColorAdjustTypePen);
            }
            // else don't worry about recoloring pattern brushes for now

            if (isCosmetic && CreateCopyOfCurrentRecord())
            {
                oldStyle &= PS_STYLE_MASK;
                if (oldStyle == PS_INSIDEFRAME) // geometric only
                {
                    oldStyle = PS_SOLID;
                }
                ((EMREXTCREATEPEN32 *)ModifiedEmfRecord)->elp.elpPenStyle = PS_COSMETIC | oldStyle;
                ((EMREXTCREATEPEN32 *)ModifiedEmfRecord)->elp.elpWidth    = 1;
            }
        }
    }
    this->PlayRecord();
}

VOID
EmfEnumState::CreateBrushIndirect(
    )
{
    const EMRCREATEBRUSHINDIRECT *  brushRecord = (const EMRCREATEBRUSHINDIRECT *)GetPartialRecord();

    if (brushRecord->lb.lbStyle != BS_HOLLOW)
    {
        ModifyRecordColor(2, ColorAdjustTypeBrush);

        if (ModifiedEmfRecord != NULL)
        {
            brushRecord = (const EMRCREATEBRUSHINDIRECT *)ModifiedEmfRecord;
        }

        // See if we need to halftone the color.  We do if it is a solid
        // color, and we have a halftone palette, and the color is not
        // an exact match in the palette.

        COLORREF    color;

        if (IsHalftonePalette && (brushRecord->lb.lbStyle == BS_SOLID) &&
            (((color = brushRecord->lb.lbColor) & 0x02000000) == 0))
        {
            // create a halftone brush, instead of a solid brush

            INT     objectIndex = brushRecord->ihBrush;

            if (ValidObjectIndex(objectIndex) && (HandleTable != NULL))
            {
                BYTE dib[sizeof(BITMAPINFOHEADER) + // DIB 8 bpp header
                         (8 * sizeof(RGBQUAD)) +    // DIB 8 colors
                         (8* 8)];                   // DIB 8x8 pixels

                HalftoneColorRef_216(color, dib);

                HandleTable->objectHandle[objectIndex] =
                        CreateDIBPatternBrushPt(dib, DIB_RGB_COLORS);
                return;
            }
        }
    }
    this->PlayRecord();
}

BOOL
EmfEnumState::PlayRecord(
    )
{
    const ENHMETARECORD *  recordToPlay = ModifiedEmfRecord;

    // See if we've modified the record
    if (recordToPlay == NULL)
    {
        // We haven't.  See if we have a valid current record
        if (CurrentEmfRecord != NULL)
        {
            recordToPlay = CurrentEmfRecord;
        }
        else
        {
            // we don't so we have to create one
            if (!CreateCopyOfCurrentRecord())
            {
                return FALSE;
            }
            recordToPlay = ModifiedEmfRecord;
        }
    }
    return PlayEnhMetaFileRecord(Hdc, HandleTable, recordToPlay, NumObjects);
}

VOID
EmfEnumState::RestoreHdc(
    )
{
    LONG    relativeCount = ((const EMRRESTOREDC *)GetPartialRecord())->iRelative;

    if (SaveDcCount < 0)
    {
        if (relativeCount >= SaveDcCount)
        {
            if (relativeCount >= 0)
            {
                // Modify the record
                CreateCopyOfCurrentRecord();    // guaranteed to succeed
                relativeCount = -1;
                ((EMRRESTOREDC *)ModifiedEmfRecord)->iRelative = -1;
            }
        }
        else
        {
            // Modify the record
            CreateCopyOfCurrentRecord();    // guaranteed to succeed
            relativeCount = SaveDcCount;
            ((EMRRESTOREDC *)ModifiedEmfRecord)->iRelative = relativeCount;
        }
        SaveDcCount -= relativeCount;
        this->PlayRecord();
    }
    else
    {
        WARNING(("RestoreDC not matched to a SaveDC"));
    }
}

VOID
EmfEnumState::ModifyRecordColor(
    INT             paramIndex,
    ColorAdjustType adjustType
    )
{
    COLORREF    origColor = ((COLORREF *)RecordData)[paramIndex];
    COLORREF    modifiedColor = ModifyColor(origColor, adjustType);

    if (modifiedColor != origColor)
    {
        if (CreateCopyOfCurrentRecord())
        {
            *((COLORREF*)&(ModifiedEmfRecord->dParm[paramIndex])) = modifiedColor;
        }
    }
}

VOID
EmfEnumState::ExtEscape(
    )
{
    if (IsPostscriptPrinter())
    {
        // Bug #98743 (Windows Bugs) Gdiplus must overcome GDI limitation
        // with POSTSCRIPT_INJECTION.  Comments from Rammanohar Arumugam:
        //
        // Being in xx-centric mode means POSTSCRIPT_DATA won't work. I
        // take that to mean that PlayMetaFileRecord only works in
        // compatibility mode.
        //
        // GdiPlus will check for the printer mode. In GDI-centric and
        // Postscript-centric mode, it will not do PlayMetaFileRecord for
        // any record that has POSTSCRIPT_DATA. Instead, it will output
        // the postscript data through a PASSTHRU (for GDI-centric mode)
        // or a POSTSCRIPT_PASSTHRU (for Postscript-Centric mode).
        //
        // You can find out the mode by querying the escape support.
        // 1. Query for POSTSCRIPT_INJECTION support. If not supported,
        // it's compat mode. If supported, find out the mode by doing step 2/3
        // 2. Query for PASSTHROUGH support. If supported, it's GDI-centric.
        // 3. Query for POSTSCRIPT_PASSTHROUGH support. If supported, it's PS-centric.

        PEMREXTESCAPE escRecord = (PEMREXTESCAPE) RecordData;

        //    EMR     emr;
        //    INT     iEscape;            // Escape code
        //    INT     cbEscData;          // Size of escape data
        //    BYTE    EscData[1];         // Escape data

        if (escRecord->iEscape == POSTSCRIPT_DATA)
        {
            if (Globals::IsNt)
            {
                DWORD EscapeValue = POSTSCRIPT_IDENTIFY;

                if (::ExtEscape(Hdc,
                              QUERYESCSUPPORT,
                              sizeof(DWORD),
                              (LPSTR)&EscapeValue,
                              0,
                              NULL) <= 0)
                {
                    // POSTSCRIPT_IDENTITY is not supported if the mode has
                    // been set because it can only be set once.

                    EscapeValue = POSTSCRIPT_PASSTHROUGH;
                    if (::ExtEscape(Hdc,
                                  QUERYESCSUPPORT,
                                  sizeof(DWORD),
                                  (LPSTR)&EscapeValue,
                                  0,
                                  NULL) <= 0)
                    {
                        // GDI-centric mode
                        if (CreateCopyOfCurrentRecord())
                        {
                            ((EMREXTESCAPE *)ModifiedEmfRecord)->iEscape = PASSTHROUGH;
                        }
                    }
                    else
                    {
                        // PS-centric mode
                        if (CreateCopyOfCurrentRecord())
                        {
                            ((EMREXTESCAPE *)ModifiedEmfRecord)->iEscape = POSTSCRIPT_PASSTHROUGH;
                        }
                    }

                    this->PlayRecord();
                    return;
                }
                else
                {
                    // compatibility mode uses POSTSCRIPT_DATA
                }
            }
            else
            {
                // Win98 doesn't distinguish between GDI & compatibility mode
                if (CreateCopyOfCurrentRecord())
                {
                    ((EMREXTESCAPE *)ModifiedEmfRecord)->iEscape = PASSTHROUGH;
                }
            }
        }
    }

    this->PlayRecord();
}

EmfEnumState::EmfEnumState(
    HDC                 hdc,
    HENHMETAFILE        hEmf,
    const RECT *        dest,
    const RECT *        deviceRect,
    BOOL                externalEnumeration,
    InterpolationMode   interpolation,
    DpContext *         context,
    GpRecolor *         recolor,
    ColorAdjustType     adjustType
    )
    : MfEnumState(hdc, externalEnumeration, interpolation,
                  recolor, adjustType, deviceRect, context)
{
    if (IsValid())
    {
        ClipRgn    = NULL;
        Palette    = NULL;
        BrushOrg.x = 0;
        BrushOrg.y = 0;

        // Bug 166280 from Office:
        // PROBLEM: If the DC has any clipping region in it, EnumEnhMetaFile
        //          will create a region before calling the EnumProc for the
        //          first time.  And, this region is not deleted and cannot be
        //          recovered through RestoreDC. (Only on Win9x)
        // FIX:     Before calling EnumEnhMetafile, save the clipping region
        //          and set the Clipping region to NULL.  Select the saved
        //          clipping region in the CallBack at EMR_HEADER.
        //          We will not do this on Metafile DC.  Put clipping region
        //          records in Metafile may cause other rendering problems.

        if (!Globals::IsNt && !IsMetafile())
        {
            HRGN    clipRgn = ::CreateRectRgn(0,0,0,0);

            if (clipRgn != NULL)
            {
                switch (::GetClipRgn(hdc, clipRgn))
                {
                case -1:        // error
                case 0:         // no initial clip region
                    ::DeleteObject(clipRgn);
                    break;
                case 1:         // has initial clip region
                    ::SelectClipRgn(hdc, NULL);
                    ClipRgn = clipRgn;
                    break;
                }
            }
        }

        // Bug 160932 from Office:  Redraw problems with EMFs
        // The fix is to make the drawing independent of where
        // the EMF is drawn - this can be done easily by setting the
        // brush origin before the first record is played (in the
        // record callback proc) to a value which is the top left of the
        // output rectangle of the EMF in device coordinates (i.e. LPtoDP of
        // the logical coordinate top left).

        BrushOrg.x = dest->left;
        BrushOrg.y = dest->top;
        LPtoDP(hdc, &BrushOrg, 1);

        // EnumEnhMetafile selects in the DEFAULT_PALETTE, but we may need
        // another palette to remain selected in (for halftoning, etc.)
        // so save the current palette and select it back in when the
        // header record is received.

        HPALETTE    hpal = (HPALETTE)GetCurrentObject(hdc, OBJ_PAL);
        if (hpal != (HPALETTE)GetStockObject(DEFAULT_PALETTE))
        {
            Palette = hpal;
        }
        BkColor   = ::GetBkColor(hdc);
        TextColor = ::GetTextColor(hdc);
    }
}

VOID
EmfEnumState::Header(
    )
{
    ::SetBrushOrgEx(Hdc, BrushOrg.x, BrushOrg.y, NULL);
    if (ClipRgn != (HRGN)0)
    {
        ::SelectClipRgn(Hdc, ClipRgn);
        ::DeleteObject(ClipRgn);
        ClipRgn = NULL;
    }
    if (Palette != NULL)
    {
        ::SelectPalette(Hdc, Palette, TRUE);
    }

    // Bitmap fonts are not good for playing metafiles because they
    // don't scale well, so use a true type font instead as the default font.

    HFONT hFont = CreateTrueTypeFont((HFONT)GetCurrentObject(Hdc, OBJ_FONT));

    if (hFont != NULL)
    {
        DefaultFont = hFont;
        ::SelectObject(Hdc, hFont);
    }

    this->PlayRecord();
}

VOID
EmfEnumState::SelectPalette(INT objectIndex)
{
    if (objectIndex == (ENHMETA_STOCK_OBJECT | DEFAULT_PALETTE))
    {
        CurrentPalette = (HPALETTE)::GetStockObject(DEFAULT_PALETTE);
    }
    else
    {
        MfEnumState::SelectPalette(objectIndex);
    }
}

VOID
EmfEnumState::IntersectDestRect()
{
    if (!IsMetafile())
    {
        // Make the transform the identity
        POINT windowOrg;
        SIZE  windowExt;
        POINT viewportOrg;
        SIZE  viewportExt;
        ::SetViewportOrgEx(Hdc, 0, 0, &viewportOrg);
        ::SetViewportExtEx(Hdc, 1, 1, &viewportExt);
        ::SetWindowOrgEx(Hdc, 0, 0, &windowOrg);
        ::SetWindowExtEx(Hdc, 1, 1, &windowExt);

        // We are always in device units
        ::IntersectClipRect(Hdc, DestRectDevice.left, DestRectDevice.top,
                            DestRectDevice.right, DestRectDevice.bottom);

        // Restore the transform
        ::SetViewportOrgEx(Hdc, viewportOrg.x, viewportOrg.y, NULL);
        ::SetViewportExtEx(Hdc, viewportExt.cx, viewportExt.cy, NULL);
        ::SetWindowOrgEx(Hdc, windowOrg.x, windowOrg.y, NULL);
        ::SetWindowExtEx(Hdc, windowExt.cx, windowExt.cy, NULL);
    }
}

VOID EmfEnumState::SetROP2()
{
    DWORD    dwROP = ((const EMRSETROP2 *)GetPartialRecord())->iMode;

    if (dwROP != R2_BLACK &&
        dwROP != R2_COPYPEN &&
        dwROP != R2_NOTCOPYPEN &&
        dwROP != R2_WHITE )
    {
        RopUsed = TRUE;
    }
    this->PlayRecord();
}

VOID EmfEnumState::ExtTextOutW()
{
    if (!this->PlayRecord())
    {
        BYTE* emrTextOut = (BYTE*) GetPartialRecord();
        if(CreateCopyOfCurrentRecord())
        {
            // !!! Shouldn't this use the offset in the record?

            BYTE * ptr = emrTextOut + sizeof(EMREXTTEXTOUTW);
            AnsiStrFromUnicode ansistr((WCHAR*)ptr);
            INT len = strlen(ansistr);
            // Don't forget to copy the NULL byte
            GpMemcpy((BYTE*)ModifiedEmfRecord + sizeof(EMREXTTEXTOUTW), (char*)ansistr, len+1);
            EMREXTTEXTOUTA *record = (EMREXTTEXTOUTA*) ModifiedEmfRecord;
            record->emr.iType = EmfRecordTypeExtTextOutA;

            // Keep the size of the record intact because of the spacing vector
            this->PlayRecord();
        }
    }
}

VOID EmfEnumState::Rectangle()
{
    // On NT convert the rectangle call to a polygon call because rectangle
    // seem to have a special case that can draw outside of the metafile
    // bounds. GDI seems to Ceil the coordinates instead of rounding them for
    // rectangles.

    if (!Globals::IsNt || IsMetafile())
    {
        this->PlayRecord();
        return;
    }
    const EMRRECTANGLE *emrRect = (const EMRRECTANGLE*) GetPartialRecord();
    
    POINT points[4] = {emrRect->rclBox.left,  emrRect->rclBox.top,
                       emrRect->rclBox.right, emrRect->rclBox.top,
                       emrRect->rclBox.right, emrRect->rclBox.bottom,
                       emrRect->rclBox.left,  emrRect->rclBox.bottom};

    ::Polygon(Hdc, points, 4);
    return;
}

BOOL
EmfEnumState::ProcessRecord(
    EmfPlusRecordType       recordType,
    UINT                    recordDataSize,
    const BYTE *            recordData
    )
{
    BOOL        forceCallback = FALSE;

    // See if we're doing enumeration for an external app
    if (ExternalEnumeration)
    {
        if (recordData == NULL)
        {
            recordDataSize = 0;
        }
        else if (recordDataSize == 0)
        {
            recordData = NULL;
        }

        // See if the app changed the record at all.
        if ((recordType != RecordType) ||
            (recordDataSize != RecordDataSize) ||
            ((recordDataSize > 0) &&
             ((CurrentEmfRecord == NULL) ||
              (recordData != (const BYTE *)(const BYTE *)CurrentEmfRecord->dParm))))
        {
            // Yes, we need to override what happened in StartRecord
            CurrentEmfRecord  = NULL;
            RecordType        = recordType;
            RecordData        = recordData;
            RecordDataSize    = recordDataSize;
        }
    }

    GDIP_TRY

    switch (recordType)
    {
    case EmfRecordTypeHeader:
        this->Header();
        break;

#if 0
    // Do we really need to do anything for PolyPolygon records?
    // If so, why not for PolyPolyline too?
    case EmfRecordTypePolyPolygon:
        this->PolyPolygon();
        break;

    case EmfRecordTypePolyPolygon16:
        this->PolyPolygon16();
        break;
#endif

    case EmfRecordTypeExtEscape:
        this->ExtEscape();
        break;

    case EmfRecordTypeSetPixelV:
        this->SetPixelV();
        break;

    case EmfRecordTypeSetTextColor:
        this->SetTextColor();
        break;

    case EmfRecordTypeSetBkColor:
        this->SetBkColor();
        break;

    case EmfRecordTypeSetMetaRgn:
        // Office Bug 154881.  Win9x doesn't handle MetaRgn correctly.
        if (Globals::IsNt)
        {
            this->PlayRecord();
        }
        break;

    case EmfRecordTypeSaveDC:
        this->SaveHdc();
        break;

    case EmfRecordTypeRestoreDC:
        this->RestoreHdc();
        break;

    case EmfRecordTypeCreatePen:
        this->CreatePen();
        break;

   case EmfRecordTypeCreateBrushIndirect:
        this->CreateBrushIndirect();
        break;

    case EmfRecordTypeSelectPalette:
        // We don't select in any palettes when playing the metafile,
        // because we don't want to invalidate our halftoning palette.
        // Keep track of the palette so we can map from PALETTEINDEXes
        // to RGB values.
        this->SelectPalette(((UINT32 *)recordData)[0]);
        break;

    case EmfRecordTypeRealizePalette:
        // We don't want to invalidate our halftoning palette by realizing one
        // from a metafile.
        break;

    case EmfRecordTypeExtFloodFill:
        this->ExtFloodFill();
        break;

    case EmfRecordTypeGdiComment:
        this->GdiComment();
        break;

    case EmfRecordTypeBitBlt:
        this->BitBlt();
        forceCallback = TRUE;
        break;

    case EmfRecordTypeStretchBlt:
        this->StretchBlt();
        forceCallback = TRUE;
        break;

    case EmfRecordTypeMaskBlt:
        this->MaskBlt();
        forceCallback = TRUE;
        break;

    case EmfRecordTypePlgBlt:
        this->PlgBlt();
        forceCallback = TRUE;
        break;

    case EmfRecordTypeSetDIBitsToDevice:
        this->SetDIBitsToDevice();
        forceCallback = TRUE;
        break;

    case EmfRecordTypeStretchDIBits:
        this->StretchDIBits();
        forceCallback = TRUE;
        break;

   // case EMR_CREATEMONOBRUSH:
   // A monochrome brush uses the text color and the background color,
   // so we shouldn't need to make any changes to the brush itself.

   case EmfRecordTypeCreateDIBPatternBrushPt:
        this->CreateDibPatternBrushPt();
        break;

    case EmfRecordTypeExtCreatePen:
        this->ExtCreatePen();
        break;

    case EmfRecordTypeSetICMMode:
    case EmfRecordTypeCreateColorSpace:
    case EmfRecordTypeSetColorSpace:
    case EmfRecordTypeDeleteColorSpace:
    case EmfRecordTypeSetICMProfileA:
    case EmfRecordTypeSetICMProfileW:
    case EmfRecordTypeCreateColorSpaceW:
        if (Globals::IsNt ||
            (!this->IsScreen() && !this->IsBitmap()))
        {
            this->PlayRecord();
        }
        // else skip the record
        break;

    case EmfRecordTypeAlphaBlend:
        this->AlphaBlend();
        forceCallback = TRUE;
        break;

    case EmfRecordTypeTransparentBlt:
        this->TransparentBlt();
        forceCallback = TRUE;
        break;

    case EmfRecordTypeGradientFill:
        this->GradientFill();
        forceCallback = TRUE;
        break;

    case EmfRecordTypeExtCreateFontIndirect:
        this->ExtCreateFontIndirect();
        break;

    case EmfRecordTypeSelectObject:
        this->SelectObject();
        break;

    case EmfRecordTypeSelectClipPath:
    case EmfRecordTypeExtSelectClipRgn:
    case EmfRecordTypeOffsetClipRgn:
        this->PlayRecord();
        if (!Globals::IsNt)
        {
            this->IntersectDestRect();
        }
        break;

    case EmfRecordTypeSetROP2:
        this->SetROP2();
        break;

    case EmfRecordTypeFillRgn:
    case EmfRecordTypeFrameRgn:
    case EmfRecordTypeInvertRgn:
    case EmfRecordTypePaintRgn:
        this->ResetRecordBounds();
        this->PlayRecord();
        break;

    case EmfRecordTypeExtTextOutW:
        this->ExtTextOutW();
        break;

    case EmfRecordTypeRectangle:
        this->Rectangle();
        break;

    case EmfRecordTypeSetMapMode:
    case EmfRecordTypeSetViewportExtEx:
    case EmfRecordTypeSetViewportOrgEx:
    case EmfRecordTypeSetWindowExtEx:
    case EmfRecordTypeSetWindowOrgEx:
    case EmfRecordTypePolyBezier:
    case EmfRecordTypePolygon:
    case EmfRecordTypePolyline:
    case EmfRecordTypePolyBezierTo:
    case EmfRecordTypePolyLineTo:
    case EmfRecordTypePolyPolyline:
    case EmfRecordTypePolyPolygon:
    case EmfRecordTypeSetBrushOrgEx:
    case EmfRecordTypeEOF:
    case EmfRecordTypeSetMapperFlags:
    case EmfRecordTypeSetBkMode:
    case EmfRecordTypeSetPolyFillMode:
    case EmfRecordTypeSetStretchBltMode:
    case EmfRecordTypeSetTextAlign:
    case EmfRecordTypeSetColorAdjustment:
    case EmfRecordTypeMoveToEx:
    case EmfRecordTypeExcludeClipRect:
    case EmfRecordTypeIntersectClipRect:
    case EmfRecordTypeScaleViewportExtEx:
    case EmfRecordTypeScaleWindowExtEx:
    case EmfRecordTypeSetWorldTransform:
    case EmfRecordTypeModifyWorldTransform:
    case EmfRecordTypeDeleteObject:
    case EmfRecordTypeAngleArc:
    case EmfRecordTypeEllipse:
    case EmfRecordTypeRoundRect:
    case EmfRecordTypeArc:
    case EmfRecordTypeChord:
    case EmfRecordTypePie:
    case EmfRecordTypeCreatePalette:
    case EmfRecordTypeSetPaletteEntries:
    case EmfRecordTypeResizePalette:
    case EmfRecordTypeLineTo:
    case EmfRecordTypeArcTo:
    case EmfRecordTypePolyDraw:
    case EmfRecordTypeSetArcDirection:
    case EmfRecordTypeSetMiterLimit:
    case EmfRecordTypeBeginPath:
    case EmfRecordTypeEndPath:
    case EmfRecordTypeCloseFigure:
    case EmfRecordTypeFillPath:
    case EmfRecordTypeStrokeAndFillPath:
    case EmfRecordTypeStrokePath:
    case EmfRecordTypeFlattenPath:
    case EmfRecordTypeWidenPath:
    case EmfRecordTypeAbortPath:
    case EmfRecordTypeReserved_069:
    case EmfRecordTypeExtTextOutA:
    case EmfRecordTypePolyBezier16:
    case EmfRecordTypePolygon16:
    case EmfRecordTypePolyline16:
    case EmfRecordTypePolyBezierTo16:
    case EmfRecordTypePolylineTo16:
    case EmfRecordTypePolyPolyline16:
    case EmfRecordTypePolyPolygon16:
    case EmfRecordTypePolyDraw16:
    case EmfRecordTypeCreateMonoBrush:
    case EmfRecordTypePolyTextOutA:
    case EmfRecordTypePolyTextOutW:
    case EmfRecordTypeGLSRecord:
    case EmfRecordTypeGLSBoundedRecord:
    case EmfRecordTypePixelFormat:
    case EmfRecordTypeDrawEscape:
    case EmfRecordTypeStartDoc:
    case EmfRecordTypeSmallTextOut:
    case EmfRecordTypeForceUFIMapping:
    case EmfRecordTypeNamedEscape:
    case EmfRecordTypeColorCorrectPalette:
    case EmfRecordTypeSetLayout:
    case EmfRecordTypeReserved_117:
    case EmfRecordTypeSetLinkedUFIs:
    case EmfRecordTypeSetTextJustification:
    case EmfRecordTypeColorMatchToTargetW:
        // Play the current record.
        // Even if it fails, we keep playing the rest of the metafile.
        this->PlayRecord();
        break;

    default:
        // unknown record -- ignore it
        WARNING1("Unknown EMF Record");
        break;
    }

    GDIP_CATCH
        forceCallback = TRUE;
    GDIP_ENDCATCH

    return forceCallback;
}

VOID EmfEnumState::ResetRecordBounds()
{
    if (Globals::IsNt && IsMetafile())
    {
        if (ModifiedEmfRecord == NULL)
        {
            CreateCopyOfCurrentRecord();
        }
        // In case the previous call failed
        if (ModifiedEmfRecord != NULL)
        {
            RECTL rect = {INT_MIN, INT_MIN, INT_MAX, INT_MAX};
            EMRRCLBOUNDS *record = (EMRRCLBOUNDS*) ModifiedEmfRecord;
            record->rclBounds = rect;
        }
    }
}