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

/**************************************************************************\
*
* Copyright (c) 1999  Microsoft Corporation
*
* Module Name:
*
*   MetaFile.cpp
*
* Abstract:
*
*   Metafile object handling
*
* Created:
*
*   4/14/1999 DCurtis
*
\**************************************************************************/

#include "precomp.hpp"
#include "..\imaging\api\comutils.hpp"

#define META_FORMAT_ENHANCED        0x10000         // Windows NT format

VOID
FrameToMM100(
    const GpRectF *         frameRect,
    GpPageUnit              frameUnit,
    GpRectF &               frameRectMM100,
    REAL                    dpiX,               // only used for pixel case
    REAL                    dpiY
    );

/**************************************************************************\
*
* Function Description:
*
*   Determine if the REAL points can be converted to GpPoint16 points without
*   losing accuracy.  If so, then do the conversion, and set the flags to say
*   we're using 16-bit points.
*
* Arguments:
*
*   [IN]      points        - the REAL points to try to convert
*   [IN]      count         - the number of points
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
MetafilePointData::MetafilePointData(
    const GpPointF *    points,
    INT                 count
    )
{
    ASSERT((count > 0) && (points != NULL));

    // Assume that the conversion to GpPoint16 will fail
    PointData     = (BYTE *)points;
    PointDataSize = count * sizeof(points[0]);
    Flags         = 0;
    AllocedPoints = NULL;

    GpPoint16 *  points16 = PointBuffer;

    if (count > GDIP_POINTDATA_BUFFERSIZE)
    {
        AllocedPoints = new GpPoint16[count];
        if (AllocedPoints == NULL)
        {
            return; // live with REAL data
        }
        points16 = AllocedPoints;
    }

    GpPoint16 *     curPoint16 = points16;
    INT             i          = count;

    do
    {
        curPoint16->X = (INT16)GpRound(points->X);
        curPoint16->Y = (INT16)GpRound(points->Y);

        if (!IsPoint16Equal(curPoint16, points))
        {
            return; // the point data doesn't fit in 16 bits per value
        }
        curPoint16++;
        points++;
    } while (--i > 0);

    // We succeeded in converting the point data to 16 bits per value
    PointData     = (BYTE *)points16;
    PointDataSize = count * sizeof(points16[0]);
    Flags         = GDIP_EPRFLAGS_COMPRESSED;
}

/**************************************************************************\
*
* Function Description:
*
*   Determine if the REAL rects can be converted to GpRect16 points without
*   losing accuracy.  If so, then do the conversion, and set the flags to say
*   we're using 16-bit rects.
*
* Arguments:
*
*   [IN]      rects         - the REAL rects to try to convert
*   [IN]      count         - the number of rects
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
MetafileRectData::MetafileRectData(
    const GpRectF *     rects,
    INT                 count
    )
{
    ASSERT((count > 0) && (rects != NULL));

    // Assume that the conversion to GpRect16 will fail
    RectData     = (BYTE *)rects;
    RectDataSize = count * sizeof(rects[0]);
    Flags        = 0;
    AllocedRects = NULL;

    GpRect16 *  rects16 = RectBuffer;

    if (count > GDIP_RECTDATA_BUFFERSIZE)
    {
        AllocedRects = new GpRect16[count];
        if (AllocedRects == NULL)
        {
            return; // live with REAL data
        }
        rects16 = AllocedRects;
    }

    GpRect16 *  curRect16 = rects16;
    INT         i         = count;

    do
    {
        curRect16->X      = (INT16)GpRound(rects->X);
        curRect16->Y      = (INT16)GpRound(rects->Y);
        curRect16->Width  = (INT16)GpRound(rects->Width);
        curRect16->Height = (INT16)GpRound(rects->Height);

        if (!IsRect16Equal(curRect16, rects))
        {
            return; // the rect data doesn't fit in 16 bits per value
        }
        curRect16++;
        rects++;
    } while (--i > 0);

    // We succeeded in converting the rect data to 16 bits per value
    RectData     = (BYTE *)rects16;
    RectDataSize = count * sizeof(rects16[0]);
    Flags        = GDIP_EPRFLAGS_COMPRESSED;
}

///////////////////////////////////////////////////////////////////////////
// classes for handling recording of objects within the metafile

class MetafileRecordObject
{
friend class MetafileRecordObjectList;
protected:
    const GpObject *    ObjectPointer;
    UINT                Uid;
    ObjectType          Type;
    UINT                Next;
    UINT                Prev;

public:
    MetafileRecordObject()
    {
        ObjectPointer     = NULL;
        Uid               = 0;
        Type              = ObjectTypeInvalid;
        Next              = GDIP_LIST_NIL;
        Prev              = GDIP_LIST_NIL;
    }

    const GpObject * GetObject() const
    {
        return ObjectPointer;
    }
    UINT GetUid() const
    {
        return Uid;
    }
    ObjectType GetType() const
    {
        return Type;
    }
};

class MetafileRecordObjectList
{
protected:
    INT                     Count;
    UINT                    LRU;
    UINT                    MRU;
    MetafileRecordObject    Objects[GDIP_MAX_OBJECTS];

public:
    MetafileRecordObjectList()
    {
        Count    = 0;
        LRU      = GDIP_LIST_NIL;
        MRU      = GDIP_LIST_NIL;
    }

    MetafileRecordObject * GetMetaObject(UINT metaObjectID)
    {
        ASSERT(metaObjectID < GDIP_MAX_OBJECTS);
        return Objects + metaObjectID;
    }

    // Search through the list, starting at the MRU entry, to see if we
    // can find the object.  If we do find it, return the index to the
    // object in metaObjectId (even if the Uid's don't match).  Return
    // TRUE only if we found the object and the Uid's match.
    BOOL
    IsInList(
        const GpObject *            object,
        ObjectType                  objectType,
        UINT32 *                    metaObjectId
        );

#if 0   // not used
    VOID
    RemoveAt(
        UINT32                      metaObjectId
        );
#endif

    // if metaObjectId is GDIP_LIST_NIL, use the next available slot
    VOID
    InsertAt(
        const GpObject *            object,
        UINT32 *                    metaObjectId
        );

    VOID
    UpdateMRU(
        UINT32                      metaObjectId
        );
};

// Search through the list, starting at the MRU entry, to see if we
// can find the object.  If we do find it, return the index to the
// object in metaObjectId (even if the Uid's don't match).  Return
// TRUE only if we found the object and the Uid's match.
BOOL
MetafileRecordObjectList::IsInList(
    const GpObject *            object,
    ObjectType                  objectType,
    UINT32 *                    metaObjectId
    )
{
    ASSERT(object != NULL);
    ASSERT(metaObjectId != NULL);

    BOOL        isInList = FALSE;

    isInList = FALSE;               // indicate object not found
    *metaObjectId = GDIP_LIST_NIL;  // indicate object not found

    if (Count != 0)
    {
        UINT    curIndex;
        UINT    uid;

        curIndex = MRU;
        uid      = object->GetUid();

        do
        {
            if (Objects[curIndex].ObjectPointer == object)
            {
                *metaObjectId = curIndex;
                isInList = ((Objects[curIndex].Uid  == uid) &&
                            (Objects[curIndex].Type == objectType));
                break;
            }
            curIndex = Objects[curIndex].Prev;
        } while (curIndex != GDIP_LIST_NIL);
    }

    return isInList;
}

#if 0   // not used
// We don't actually remove it from the list, we just put it at the
// front of the LRU so its spot gets used next.  So the count stays
// the same.
VOID
MetafileRecordObjectList::RemoveAt(
    UINT32                  metaObjectId
    )
{
    ASSERT(metaObjectId < GDIP_MAX_OBJECTS);

    MetafileRecordObject *      removeObject = Objects + metaObjectId;

    ASSERT(Count > 0);
    removeObject->ObjectPointer     = NULL;
    removeObject->Uid               = 0;
    removeObject->Type              = EmfPlusRecordTypeInvalid;

    INT     removeNext = removeObject->Next;
    INT     removePrev = removeObject->Prev;

    if (removeNext != GDIP_LIST_NIL)
    {
        Objects[removeNext].Prev = removePrev;
    }
    else
    {
        ASSERT(MRU == metaObjectId);
        if (removePrev != GDIP_LIST_NIL)
        {
            MRU = removePrev;
        }
    }

    if (removePrev != GDIP_LIST_NIL)
    {
        ASSERT(LRU != metaObjectId);
        Objects[removePrev].Next = removeNext;
        removeObject->Prev = GDIP_LIST_NIL;
        removeObject->Next = LRU;
        Objects[LRU].Prev = metaObjectId;
        LRU = metaObjectId;
    }
    else
    {
        ASSERT(LRU == metaObjectId);
    }
}
#endif

// Make the specified object the MRU object.
VOID
MetafileRecordObjectList::UpdateMRU(
    UINT32                      metaObjectId
    )
{
    if (MRU != metaObjectId)
    {
        // Now we know there are at least 2 objects
        MetafileRecordObject *      object = &Objects[metaObjectId];
        if (LRU != metaObjectId)
        {
            Objects[object->Prev].Next = object->Next;
        }
        else
        {
            LRU = object->Next;
        }
        Objects[object->Next].Prev = object->Prev;
        object->Prev = MRU;
        object->Next = GDIP_LIST_NIL;
        Objects[MRU].Next = metaObjectId;
        MRU = metaObjectId;
    }
}

// if metaObjectId is GDIP_LIST_NIL, use the next available slot
VOID
MetafileRecordObjectList::InsertAt(
    const GpObject *            object,
    UINT32 *                    metaObjectId
    )
{
    MetafileRecordObject *      newObject;
    UINT                        newIndex = *metaObjectId;

    if (newIndex == GDIP_LIST_NIL)
    {
        if (Count != 0)
        {
            // use freed object before adding new one
            if ((Objects[LRU].ObjectPointer == NULL) ||
                (Count == GDIP_MAX_OBJECTS))
            {
                newIndex = LRU;
UseLRU:
                LRU = Objects[newIndex].Next;
                Objects[LRU].Prev = GDIP_LIST_NIL;
            }
            else
            {
                newIndex = Count++;
            }
InsertObject:
            Objects[MRU].Next = newIndex;

SetupObject:
            *metaObjectId                = newIndex;
            newObject                    = &Objects[newIndex];
            newObject->Next              = GDIP_LIST_NIL;
            newObject->Prev              = MRU;
            MRU                          = newIndex;
UseMRU:
            newObject->ObjectPointer     = object;
            newObject->Uid               = object->GetUid();
            newObject->Type              = object->GetObjectType();
            return;
        }
        // else first object
        newIndex = 0;
        LRU      = 0;
        Count    = 1;
        goto SetupObject;
    }
    else    // we already know where to put the object
    {
        ASSERT(Count > 0);
        ASSERT(newIndex < GDIP_MAX_OBJECTS);

        if (newIndex == MRU)
        {
            // This covers the case where there is only 1 object
            newObject = &Objects[newIndex];
            goto UseMRU;
        }
        // else there must be at least 2 objects
        ASSERT(Count > 1);

        if (newIndex == LRU)
        {
            goto UseLRU;
        }
        // Move middle object to MRU
        newObject = &Objects[newIndex];
        Objects[newObject->Prev].Next = newObject->Next;
        Objects[newObject->Next].Prev = newObject->Prev;
        goto InsertObject;
    }
}

#define GDIP_MAX_COMMENT_SIZE         65020 // must be <= 65520 for Win9x bug

class EmfPlusCommentStream : public IUnknownBase<IStream>
{
private:
    ObjectTag           Tag;    // Keep this as the 1st value in the object!

protected:
    VOID SetValid(BOOL valid)
    {
        Tag = valid ? ObjectTagEmfPlusCommentStream : ObjectTagInvalid;
    }

public:
    EmfPlusCommentStream(HDC hdc)
    {
        ASSERT(hdc != NULL);

        MetafileHdc                 = hdc;
        Position                    = 0;   // starts after signature
        ((INT32 *)CommentBuffer)[0] = EMFPLUS_SIGNATURE;
        RecordDataStart             = CommentBuffer + sizeof(INT32);
        ContinuingObjectRecord      = FALSE;
        SetValid(TRUE);
    }

    ~EmfPlusCommentStream()
    {
        this->Flush();
    }

    BOOL IsValid() const
    {
        ASSERT((Tag == ObjectTagEmfPlusCommentStream) || (Tag == ObjectTagInvalid));
        return (Tag == ObjectTagEmfPlusCommentStream);
    }

    ULONG SpaceLeft() const
    {
        return (GDIP_MAX_COMMENT_SIZE - Position);
    }

    VOID
    EndObjectRecord()
    {
        ASSERT ((Position & 0x03) == 0);    // records should be 4-byte aligned

        if (ContinuingObjectRecord)
        {
            ContinuingObjectRecord = FALSE;
            if (Position > sizeof(EmfPlusContinueObjectRecord))
            {
                // Fix up the size of the last chunck of this object record
                EmfPlusContinueObjectRecord *   recordData;
                recordData = (EmfPlusContinueObjectRecord *)RecordDataStart;
                recordData->Size     = Position;
                recordData->DataSize = Position - sizeof(EmfPlusRecord);
            }
            else
            {
                // The object record ended exacly at the end of the buffer
                // and has already been flushed.
                Position = 0;
            }
        }
    }

    VOID
    WriteRecordHeader(
        UINT32                      dataSize,       // size of data (w/o record header)
        EmfPlusRecordType           type,
        INT                         flags           // 16 bits of flags
        );

    VOID Flush();

    HRESULT STDMETHODCALLTYPE Write(
        VOID const HUGEP *pv,
        ULONG cb,
        ULONG *pcbWritten)
    {
        if (cb == 0)
        {
            if (pcbWritten != NULL)
            {
                *pcbWritten = cb;
            }
            return S_OK;
        }

        ASSERT (pv != NULL);

        if (IsValid())
        {
            // We've already written the record header; now we're writing
            // the record data.
            ASSERT(Position >= sizeof(EmfPlusRecord));

            ULONG   spaceLeft = SpaceLeft();
            BYTE *  recordData = RecordDataStart + Position;

            // We flush as soon as we reach the end.  We don't wait for
            // the next write call to flush.
            ASSERT(spaceLeft > 0);

            if (pcbWritten)
            {
                *pcbWritten = cb;
            }

            // see if there is enough room for the data
            if (cb <= spaceLeft)
            {
                GpMemcpy(recordData, pv, cb);
                Position += cb;

                if (Position < GDIP_MAX_COMMENT_SIZE)
                {
                    return S_OK;
                }
                this->Flush();
                if (IsValid())
                {
                    return S_OK;
                }
                if (pcbWritten)
                {
                    *pcbWritten = 0;
                }
                return E_FAIL;
            }

            ASSERT(ContinuingObjectRecord);

        LoopStart:
            GpMemcpy(recordData, pv, spaceLeft);
            Position += spaceLeft;
            if (Position == GDIP_MAX_COMMENT_SIZE)
            {
                this->Flush();
                if (!IsValid())
                {
                    if (pcbWritten)
                    {
                        *pcbWritten = 0;    // not accurate, but who cares!
                    }
                    return E_FAIL;
                }
            }
            cb -= spaceLeft;
            if (cb == 0)
            {
                return S_OK;
            }
            pv = ((BYTE *)pv) + spaceLeft;
            recordData = RecordDataStart + sizeof(EmfPlusContinueObjectRecord);
            spaceLeft  = GDIP_MAX_COMMENT_SIZE-sizeof(EmfPlusContinueObjectRecord);
            if (spaceLeft > cb)
            {
                spaceLeft = cb;
            }
            goto LoopStart;
        }
        return E_FAIL;
    }

    HRESULT STDMETHODCALLTYPE Read(
        VOID HUGEP *pv,
        ULONG cb,
        ULONG *pcbRead)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE Seek(
        LARGE_INTEGER dlibMove,
        DWORD dwOrigin,
        ULARGE_INTEGER *plibNewPosition)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE SetSize(
        ULARGE_INTEGER libNewSize)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE CopyTo(
        IStream *pstm,
        ULARGE_INTEGER cb,
        ULARGE_INTEGER *pcbRead,
        ULARGE_INTEGER *pcbWritten)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE Commit(
        DWORD grfCommitFlags)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE Revert(VOID)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE LockRegion(
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE UnlockRegion(
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE Stat(
        STATSTG *pstatstg,
        DWORD grfStatFlag)
    {
        return E_NOTIMPL;
    }

    HRESULT STDMETHODCALLTYPE Clone(
        IStream **ppstm)
    {
        return E_NOTIMPL;
    }

private:
    BYTE    CommentBuffer[GDIP_MAX_COMMENT_SIZE + sizeof(INT32)];
    BYTE *  RecordDataStart;
    ULONG   Position;
    HDC     MetafileHdc;
    BOOL    ContinuingObjectRecord;
};

VOID
EmfPlusCommentStream::Flush()
{
    ASSERT ((Position & 0x03) == 0);    // records should be 4-byte aligned

    if (IsValid() && (Position >= sizeof(EmfPlusRecord)))
    {
        // write the signature as well as the records
        SetValid(GdiComment(MetafileHdc, (INT)Position + sizeof(INT32),
                            CommentBuffer) != 0);

#if DBG
        if (!IsValid())
        {
            WARNING(("Failed to write GdiComment"));
        }
#endif

        if (!ContinuingObjectRecord)
        {
            Position = 0;
        }
        else
        {
            ASSERT(Position == GDIP_MAX_COMMENT_SIZE);

            // Leave the object record header intact for the rest of the
            // object data.
            Position = sizeof(EmfPlusContinueObjectRecord);
        }
    }
}

VOID
EmfPlusCommentStream::WriteRecordHeader(
    UINT32                      dataSize,       // size of data (w/o record header)
    EmfPlusRecordType           type,
    INT                         flags           // 16 bits of flags
    )
{
    ASSERT ((flags & 0xFFFF0000) == 0);
    ASSERT (ContinuingObjectRecord == FALSE);
    ASSERT ((Position & 0x03) == 0);    // records should be 4-byte aligned
    ASSERT ((dataSize & 0x03) == 0);    // records should be 4-byte aligned

    if (IsValid())
    {
        ULONG   spaceLeft  = SpaceLeft();
        ULONG   recordSize = sizeof(EmfPlusRecord) + dataSize;

        ASSERT(spaceLeft > 0);

        // see if the record fits in the space left
        if (recordSize <= spaceLeft)
        {
    RecordFits:
            EmfPlusRecord *     recordData;

            recordData = (EmfPlusRecord *)(RecordDataStart + Position);

            recordData->Type     = type;
            recordData->Flags    = (INT16)flags;
            recordData->Size     = recordSize;
            recordData->DataSize = dataSize;
            Position         += sizeof(EmfPlusRecord);
            if (Position < GDIP_MAX_COMMENT_SIZE)
            {
                return;
            }
            ASSERT((recordSize == sizeof(EmfPlusRecord)) && (dataSize == 0));
            this->Flush();
            return;
        }
        else // it doesn't fit in the space left
        {
            // maybe it will fit after flushing the current record buffer
            if (spaceLeft < GDIP_MAX_COMMENT_SIZE)
            {
                this->Flush();
                if (!IsValid())
                {
                    return;
                }
                if (recordSize <= GDIP_MAX_COMMENT_SIZE)
                {
                    goto RecordFits;
                }
            }

            // Now we know the record does not fit in a single comment.
            // This better be an object record!
            ASSERT(type == EmfPlusRecordTypeObject);

            flags |= GDIP_EPRFLAGS_CONTINUEOBJECT;
            ContinuingObjectRecord = TRUE;

            // We know that Position is 0
            EmfPlusContinueObjectRecord *   recordData;
            recordData = (EmfPlusContinueObjectRecord *)RecordDataStart;

            recordData->Type             = type;
            recordData->Flags            = (INT16)flags;
            recordData->Size             = GDIP_MAX_COMMENT_SIZE;
            recordData->DataSize         = GDIP_MAX_COMMENT_SIZE - sizeof(EmfPlusRecord);
            recordData->TotalObjectSize  = dataSize;    // size of object data (w/o header size)
            Position                     = sizeof(EmfPlusContinueObjectRecord);
        }
    }
}

class MetafileRecorder : public IMetafileRecord
{
friend class GpMetafile;

private:
    ObjectTag           Tag;    // Keep this as the 1st value in the object!

protected:
    VOID SetValid(BOOL valid)
    {
        Tag = valid ? ObjectTagMetafileRecorder : ObjectTagInvalid;
    }

public:
    BOOL                                    WroteFrameRect;
    SIZEL                                   Millimeters;

protected:
    EmfPlusCommentStream *                  EmfPlusStream; // memory buffer stream
    GpMetafile *                            Metafile;   // being recorded
    EmfType                                 Type;
    REAL                                    XMinDevice; // device bounds
    REAL                                    YMinDevice;
    REAL                                    XMaxDevice;
    REAL                                    YMaxDevice;
    BOOL                                    BoundsInit;
    INT                                     NumRecords; // for debugging only
    INT                                     MaxStackSize;
    HDC                                     MetafileHdc;
    DynArrayIA<INT,GDIP_SAVE_STACK_SIZE>    SaveRestoreStack;
    MetafileRecordObjectList                ObjectList;
    GpRectF                                 MetafileBounds;

public:
    MetafileRecorder(
        GpMetafile *    metafile,
        EmfType         type,
        HDC             metafileHdc,
        BOOL            wroteFrameRect,
        SIZEL &         effectiveMillimeters,
        GpRectF &       metafileBounds
        );

    ~MetafileRecorder() // called by EndRecording
    {
        // Release the memory stream for writing the GdiComments
        if (EmfPlusStream != NULL)
        {
            EmfPlusStream->Release();
        }
    }

    BOOL IsValid() const
    {
        ASSERT((Tag == ObjectTagMetafileRecorder) || (Tag == ObjectTagInvalid));
        return (Tag == ObjectTagMetafileRecorder);
    }

    virtual VOID GetMetafileBounds(GpRect & metafileBounds) const
    {
        // Use Floor to make sure we don't miss any pixels
        metafileBounds.X      = GpFloor(MetafileBounds.X);
        metafileBounds.Y      = GpFloor(MetafileBounds.Y);
        metafileBounds.Width  = GpCeiling(MetafileBounds.GetRight())  - metafileBounds.X;
        metafileBounds.Height = GpCeiling(MetafileBounds.GetBottom()) - metafileBounds.Y;
    }

    virtual GpStatus
    RecordClear(
        const GpRectF *             deviceBounds,
        GpColor                     color
        );

    virtual GpStatus
    RecordFillRects(
        const GpRectF *             deviceBounds,
        GpBrush *                   brush,
        const GpRectF *             rects,
        INT                         count
        );

    virtual GpStatus
    RecordDrawRects(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpRectF *             rects,
        INT                         count
        );

    virtual GpStatus
    RecordFillPolygon(
        const GpRectF *             deviceBounds,
        GpBrush*                    brush,
        const GpPointF *            points,
        INT                         count,
        GpFillMode                  fillMode
        );

    virtual GpStatus
    RecordDrawLines(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpPointF *            points,
        INT                         count,
        BOOL                        closed
        );

    virtual GpStatus
    RecordFillEllipse(
        const GpRectF *             deviceBounds,
        GpBrush *                   brush,
        const GpRectF &             rect
        );

    virtual GpStatus
    RecordDrawEllipse(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpRectF &             rect
        );

    virtual GpStatus
    RecordFillPie(
        const GpRectF *             deviceBounds,
        GpBrush *                   brush,
        const GpRectF &             rect,
        REAL                        startAngle,
        REAL                        sweepAngle
        );

    virtual GpStatus
    RecordDrawPie(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpRectF &             rect,
        REAL                        startAngle,
        REAL                        sweepAngle
        );

    virtual GpStatus
    RecordDrawArc(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpRectF &             rect,
        REAL                        startAngle,
        REAL                        sweepAngle
        );

    virtual GpStatus
    RecordFillRegion(
        const GpRectF *             deviceBounds,
        GpBrush *                   brush,
        GpRegion *                  region
        );

    virtual GpStatus
    RecordFillPath(
        const GpRectF *             deviceBounds,
        const GpBrush *             brush,
        GpPath *                    path
        );

    virtual GpStatus
    RecordDrawPath(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        GpPath *                    path
        );

    virtual GpStatus
    RecordFillClosedCurve(
        const GpRectF *             deviceBounds,
        GpBrush *                   brush,
        const GpPointF *            points,
        INT                         count,
        REAL                        tension,
        GpFillMode                  fillMode
        );

    virtual GpStatus
    RecordDrawClosedCurve(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpPointF *            points,
        INT                         count,
        REAL                        tension
        );

    virtual GpStatus
    RecordDrawCurve(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpPointF *            points,
        INT                         count,
        REAL                        tension,
        INT                         offset,
        INT                         numberOfSegments
        );

    virtual GpStatus
    RecordDrawBeziers(
        const GpRectF *             deviceBounds,
        GpPen *                     pen,
        const GpPointF *            points,
        INT                         count
        );

    virtual GpStatus
    RecordDrawImage(
        const GpRectF *             deviceBounds,
        const GpImage *             image,
        const GpRectF &             destRect,
        const GpRectF &             srcRect,
        GpPageUnit                  srcUnit,
        const GpImageAttributes *         imageAttributes
        );

    virtual GpStatus
    RecordDrawImage(
        const GpRectF *             deviceBounds,
        const GpImage *             image,
        const GpPointF *            destPoints,
        INT                         count,
        const GpRectF &             srcRect,
        GpPageUnit                  srcUnit,
        const GpImageAttributes *         imageAttributes
        );

    virtual GpStatus
    RecordDrawString(
        const GpRectF *             deviceBounds,
        const WCHAR                *string,
        INT                         length,
        const GpFont               *font,
        const RectF                *layoutRect,
        const GpStringFormat       *format,
        const GpBrush              *brush
        );

    virtual GpStatus
    RecordDrawDriverString(
        const GpRectF *             deviceBounds,
        const UINT16               *text,
        INT                         glyphCount,
        const GpFont               *font,
        const GpBrush              *brush,
        const PointF               *positions,
        INT                         flags,
        const GpMatrix             *matrix
        );

    virtual GpStatus
    RecordSave(
        INT         gstate
        );

    virtual GpStatus
    RecordRestore(
        INT         gstate
        );

    virtual GpStatus
    RecordBeginContainer(
        const GpRectF &             destRect,
        const GpRectF &             srcRect,
        GpPageUnit                  srcUnit,
        INT                         containerState
        );

    virtual GpStatus
    RecordBeginContainer(
        INT                         containerState
        );

    virtual GpStatus
    RecordEndContainer(
        INT                         containerState
        );

    virtual GpStatus
    RecordSetWorldTransform(
        const GpMatrix &            matrix
        );

    virtual GpStatus
    RecordResetWorldTransform();

    virtual GpStatus
    RecordMultiplyWorldTransform(
        const GpMatrix &            matrix,
        GpMatrixOrder               order
        );

    virtual GpStatus
    RecordTranslateWorldTransform(
        REAL                        dx,
        REAL                        dy,
        GpMatrixOrder               order
        );

    virtual GpStatus
    RecordScaleWorldTransform(
        REAL                        sx,
        REAL                        sy,
        GpMatrixOrder               order
        );

    virtual GpStatus
    RecordRotateWorldTransform(
        REAL                        angle,
        GpMatrixOrder               order
        );

    virtual GpStatus
    RecordSetPageTransform(
        GpPageUnit                  unit,
        REAL                        scale
        );

    virtual GpStatus
    RecordResetClip();

    virtual GpStatus
    RecordSetClip(
        const GpRectF &             rect,
        CombineMode                 combineMode
        );

    virtual GpStatus
    RecordSetClip(
        GpRegion *                  region,
        CombineMode                 combineMode
        );

    virtual GpStatus
    RecordSetClip(
        GpPath *                    path,
        CombineMode                 combineMode,
        BOOL                        isDevicePath
        );

    virtual GpStatus
    RecordOffsetClip(
        REAL                        dx,
        REAL                        dy
        );

    virtual GpStatus
    RecordGetDC();

    virtual GpStatus
    RecordSetAntiAliasMode(
        BOOL                        newMode
        );

    virtual GpStatus
    RecordSetTextRenderingHint(
        TextRenderingHint           newMode
        );

    virtual GpStatus
    RecordSetTextContrast(
        UINT                        gammaValue
        );

    virtual GpStatus
    RecordSetInterpolationMode(
        InterpolationMode           newMode
        );

    virtual GpStatus
    RecordSetPixelOffsetMode(
        PixelOffsetMode             newMode
        );

    virtual GpStatus
    RecordSetCompositingMode(
        GpCompositingMode           newMode
        );

    virtual GpStatus
    RecordSetCompositingQuality(
        GpCompositingQuality        newQuality
        );

    virtual GpStatus
    RecordSetRenderingOrigin(
        INT x,
        INT y
    );

    virtual GpStatus
    RecordComment(
        UINT            sizeData,
        const BYTE *    data
        );

    virtual VOID
    EndRecording();

    virtual GpStatus
    RecordBackupObject(
        const GpObject *            object
        );

protected:

    GpStatus
    RecordHeader(
        INT                 logicalDpiX,
        INT                 logicalDpiY,
        INT                 emfPlusFlags
        );
    VOID RecordEndOfFile();

    VOID
    WriteObject(
        ObjectType                  type,
        const GpObject *            object,
        UINT32                      metaObjectId
        );

    VOID
    RecordObject(
        const GpObject *            object,
        UINT32*                     metaObjectId
        );

    GpStatus
    RecordZeroDataRecord(
        EmfPlusRecordType           type,
        INT                         flags
        );

    VOID
    WriteRecordHeader(
        UINT32                      dataSize,
        EmfPlusRecordType           type,
        INT                         flags        = 0,   // 16 bits of flags
        const GpRectF *             deviceBounds = NULL
        );

    // To keep the number of comments low, this only needs to be called
    // when there is a down-level representation of the GDI+ record.
    VOID
    WriteGdiComment()
    {
        // If we're doing dual (which means we're about to write
        // down-level records) then write out the current list
        // of records in the EmfPlusStream buffer.
        if (Type == EmfTypeEmfPlusDual)
        {
            EmfPlusStream->Flush();
        }
    }

    VOID
    GetBrushValueForRecording(
        const GpBrush *brush,
        UINT32        &brushValue,
        INT           &flags
        );
};

/**************************************************************************\
*
* Function Description:
*
*   Construct a MetafileRecorder object and initialize it.
*
* Arguments:
*
*   [IN]  metafile    - pointer to the metafile object being recorded
*   [IN]  stream      - the stream being recorded into (if any)
*   [IN]  metafileHdc - handle to metafile DC being recorded into (if any)
*   [IN]  dpiX        - the horizontal DPI
*   [IN]  dpiY        - the vertical   DPI
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
MetafileRecorder::MetafileRecorder(
    GpMetafile *    metafile,
    EmfType         emfType,
    HDC             metafileHdc,
    BOOL            wroteFrameRect,
    SIZEL &         effectiveMillimeters,
    GpRectF &       metafileBounds
    )
{
    SetValid(FALSE);
    Type                    = emfType;
    Metafile                = metafile;
    WroteFrameRect          = wroteFrameRect;
    NumRecords              = 0;        // currently for debugging only
    MaxStackSize            = 0;
    MetafileHdc             = metafileHdc;
    XMinDevice              = FLT_MAX;
    YMinDevice              = FLT_MAX;
    XMaxDevice              = -FLT_MAX;
    YMaxDevice              = -FLT_MAX;
    BoundsInit              = FALSE;
    EmfPlusStream           = NULL;
    Millimeters             = effectiveMillimeters;

    // The metafileBounds are used as the bounds for FillRegion
    // calls when the region has infinite bounds, to keep from
    // exploding the bounds of the metafile.
    MetafileBounds          = metafileBounds;

    if (emfType == EmfTypeEmfOnly)
    {
        Metafile->Header.Type = MetafileTypeEmf;
        SetValid(TRUE);
    }
    else
    {
        // gets freed in the destructor
        EmfPlusStream = new EmfPlusCommentStream(metafileHdc);

        if (EmfPlusStream == NULL)
        {
            return;
        }

        SetValid(TRUE);

        INT                 logicalDpiX  = GetDeviceCaps(metafileHdc, LOGPIXELSX);
        INT                 logicalDpiY  = GetDeviceCaps(metafileHdc, LOGPIXELSY);
        INT                 emfPlusFlags = 0;

        if (GetDeviceCaps(metafileHdc, TECHNOLOGY) == DT_RASDISPLAY)
        {
            emfPlusFlags |= GDIP_EMFPLUSFLAGS_DISPLAY;
        }

        MetafileHeader * header = &(metafile->Header);

        header->EmfPlusHeaderSize = sizeof(EmfPlusRecord) + sizeof(EmfPlusHeaderRecord);
        header->LogicalDpiX       = logicalDpiX;
        header->LogicalDpiY       = logicalDpiY;
        header->EmfPlusFlags      = emfPlusFlags;
        if (emfType == EmfTypeEmfPlusOnly)
        {
            header->Type          = MetafileTypeEmfPlusOnly;
        }
        else
        {
            ASSERT(emfType == EmfTypeEmfPlusDual);
            header->Type          = MetafileTypeEmfPlusDual;
        }

        if (RecordHeader(logicalDpiX, logicalDpiY, emfPlusFlags) != Ok)
        {
            SetValid(FALSE);
            EmfPlusStream->Release();
            EmfPlusStream = NULL;
        }
    }
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordClear.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  color        - the clear color
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*  04/28/2000 AGodfrey
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordClear(
    const GpRectF *             deviceBounds,
    GpColor                     color
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            ASSERT (deviceBounds != NULL);

            ARGB argbColor = color.GetValue();

            UINT32              dataSize = sizeof(argbColor);
            EmfPlusRecordType   type     = EmfPlusRecordTypeClear;
            INT                 flags    = 0;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, argbColor);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write Clear record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordFillRects.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  brush        - brush to draw with
*   [IN]  rects        - rectangles to fill
*   [IN]  count        - number of rects
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordFillRects(
    const GpRectF *             deviceBounds,
    GpBrush *                   brush,
    const GpRectF *             rects,
    INT                         count
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (brush != NULL) &&
                (rects != NULL) && (count > 0));

        if (IsValid())
        {
            MetafileRectData    rectData(rects, count);
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue) +
                                           sizeof(UINT32/* count */) +
                                           rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeFillRects;
            INT                 flags    = rectData.GetFlags();

            GetBrushValueForRecording(brush, brushValue, flags);

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteInt32(EmfPlusStream, count);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write FillRects record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawRects.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  pen          - pen to draw with
*   [IN]  rects        - rectangles to draw
*   [IN]  count        - number of rects
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawRects(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpRectF *             rects,
    INT                         count
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL) &&
                (rects != NULL) && (count > 0));

        if (IsValid())
        {
            MetafileRectData    rectData(rects, count);
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(UINT32/* count */) +
                                           rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawRects;
            INT                 flags    = rectData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaPenId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, count);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawRects record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordFillPolygon.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  brush        - brush to draw with
*   [IN]  points       - polygon points
*   [IN]  count        - number of points
*   [IN]  fillMode     - Alternate or Winding
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordFillPolygon(
    const GpRectF *             deviceBounds,
    GpBrush*                    brush,
    const GpPointF *            points,
    INT                         count,
    GpFillMode                  fillMode
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (brush != NULL) &&
                (points != NULL) && (count > 0));

        if (IsValid())
        {
            MetafilePointData   pointData(points, count);
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue) +
                                           sizeof(UINT32/* count */) +
                                           pointData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeFillPolygon;
            INT                 flags    = pointData.GetFlags();

            GetBrushValueForRecording(brush, brushValue, flags);

            if (fillMode == FillModeWinding)
            {
                flags |= GDIP_EPRFLAGS_WINDINGFILL;
            }

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteInt32(EmfPlusStream, count);
            pointData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write FillPolygon record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawLines.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  pen          - pen to draw with
*   [IN]  points       - polyline points
*   [IN]  count        - number of points
*   [IN]  closed       - TRUE if closed
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawLines(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpPointF *            points,
    INT                         count,
    BOOL                        closed
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL) &&
                (points != NULL) && (count > 0));

        if (IsValid())
        {
            MetafilePointData   pointData(points, count);
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(UINT32/* count */) +
                                           pointData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawLines;
            INT                 flags    = pointData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaPenId;

            if (closed)
            {
                flags |= GDIP_EPRFLAGS_CLOSED;
            }

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, count);
            pointData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawLines record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordFillEllipse.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  brush        - brush to draw with
*   [IN]  rect         - bounding rect of ellipse
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordFillEllipse(
    const GpRectF *             deviceBounds,
    GpBrush *                   brush,
    const GpRectF &             rect
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (brush != NULL));

        if (IsValid())
        {
            MetafileRectData    rectData(&rect, 1);
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue) +
                                           rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeFillEllipse;
            INT                 flags    = rectData.GetFlags();

            GetBrushValueForRecording(brush, brushValue, flags);

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write FillEllipse record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawEllipse.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  pen          - pen to draw with
*   [IN]  rect         - bounding rect of ellipse
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawEllipse(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpRectF &             rect
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL));

        if (IsValid())
        {
            MetafileRectData    rectData(&rect, 1);
            UINT32              metaPenId;
            UINT32              dataSize = rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawEllipse;
            INT                 flags    = rectData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaPenId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawEllipse record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordFillPie.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  brush        - brush to draw with
*   [IN]  rect         - bounding rect of ellipse
*   [IN]  startAngle   - starting angle of pie
*   [IN]  sweepAngle   - sweep angle of pie
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordFillPie(
    const GpRectF *             deviceBounds,
    GpBrush *                   brush,
    const GpRectF &             rect,
    REAL                        startAngle,
    REAL                        sweepAngle
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (brush != NULL));

        if (IsValid())
        {
            MetafileRectData    rectData(&rect, 1);
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue) +
                                           sizeof(startAngle) +
                                           sizeof(sweepAngle) +
                                           rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeFillPie;
            INT                 flags    = rectData.GetFlags();

            GetBrushValueForRecording(brush, brushValue, flags);

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteReal (EmfPlusStream, startAngle);
            WriteReal (EmfPlusStream, sweepAngle);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write FillPie record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawPie.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  pen          - pen to draw with
*   [IN]  rect         - bounding rect of ellipse
*   [IN]  startAngle   - starting angle of pie
*   [IN]  sweepAngle   - sweep angle of pie
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawPie(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpRectF &             rect,
    REAL                        startAngle,
    REAL                        sweepAngle
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL));

        if (IsValid())
        {
            MetafileRectData    rectData(&rect, 1);
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(startAngle) +
                                           sizeof(sweepAngle) +
                                           rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawPie;
            INT                 flags    = rectData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags  |= metaPenId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteReal (EmfPlusStream, startAngle);
            WriteReal (EmfPlusStream, sweepAngle);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawPie record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawArc.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  pen          - pen to draw with
*   [IN]  rect         - bounding rect of ellipse
*   [IN]  startAngle   - starting angle of arc
*   [IN]  sweepAngle   - sweep angle of arc
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawArc(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpRectF &             rect,
    REAL                        startAngle,
    REAL                        sweepAngle
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL));

        if (IsValid())
        {
            MetafileRectData    rectData(&rect, 1);
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(startAngle) +
                                           sizeof(sweepAngle) +
                                           rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawArc;
            INT                 flags    = rectData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags  |= metaPenId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteReal (EmfPlusStream, startAngle);
            WriteReal (EmfPlusStream, sweepAngle);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawArc record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordFillRegion.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  brush        - brush to draw with
*   [IN]  region       - region to fill
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordFillRegion(
    const GpRectF *             deviceBounds,
    GpBrush *                   brush,
    GpRegion *                  region
    )
{
    // The deviceBounds should never be infinite, because they are
    // intersected with the metafileBounds before being passed in.

    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (brush != NULL) && (region != NULL));

        if (IsValid())
        {
            UINT32              metaRegionId;
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue);
            EmfPlusRecordType   type     = EmfPlusRecordTypeFillRegion;
            INT                 flags    = 0;

            GetBrushValueForRecording(brush, brushValue, flags);

            RecordObject(region, &metaRegionId);
            ASSERT((metaRegionId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaRegionId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write FillRegion record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordFillPath.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  brush        - brush to draw with
*   [IN]  path         - path to fill
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordFillPath(
    const GpRectF *             deviceBounds,
    const GpBrush *                   brush,
    GpPath *                    path
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (brush != NULL) && (path != NULL));

        if (IsValid())
        {
            UINT32              metaPathId;
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue);
            EmfPlusRecordType   type     = EmfPlusRecordTypeFillPath;
            INT                 flags    = 0;

            GetBrushValueForRecording(brush, brushValue, flags);

            RecordObject(path, &metaPathId);
            ASSERT((metaPathId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaPathId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write FillPath record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawPath.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  pen          - pen to draw with
*   [IN]  path         - path to draw
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawPath(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    GpPath *                    path
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL) && (path != NULL));

        if (IsValid())
        {
            UINT32              metaPathId;
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(metaPenId);
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawPath;
            INT                 flags    = 0;

            RecordObject(pen, &metaPenId);

            RecordObject(path, &metaPathId);
            ASSERT((metaPathId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags  |= metaPathId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, metaPenId);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawPath record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordFillClosedCurve.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  brush        - brush to draw with
*   [IN]  points       - curve points
*   [IN]  count        - number of points
*   [IN]  tension      - how tight to make curve
*   [IN]  fillMode     - Alternate or Winding
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordFillClosedCurve(
    const GpRectF *             deviceBounds,
    GpBrush *                   brush,
    const GpPointF *            points,
    INT                         count,
    REAL                        tension,
    GpFillMode                  fillMode
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (brush != NULL) &&
                (points != NULL) && (count > 0));

        if (IsValid())
        {
            MetafilePointData   pointData(points, count);
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue) +
                                           sizeof(tension) +
                                           sizeof(UINT32 /* count */) +
                                           pointData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeFillClosedCurve;
            INT                 flags    = pointData.GetFlags();

            GetBrushValueForRecording(brush, brushValue, flags);

            if (fillMode == FillModeWinding)
            {
                flags |= GDIP_EPRFLAGS_WINDINGFILL;
            }

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteReal (EmfPlusStream, tension);
            WriteInt32(EmfPlusStream, count);
            pointData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write FillClosedCurve record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawClosedCurve.
*
* Arguments:
*
*   [IN]  deviceBounds - the bounding rect, in device units
*   [IN]  pen          - pen to draw with
*   [IN]  points       - curve points
*   [IN]  count        - number of points
*   [IN]  tension      - how tight to make curve
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawClosedCurve(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpPointF *            points,
    INT                         count,
    REAL                        tension
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL) &&
                (points != NULL) && (count > 0));

        if (IsValid())
        {
            MetafilePointData   pointData(points, count);
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(tension) +
                                           sizeof(UINT32/* count */) +
                                           pointData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawClosedCurve;
            INT                 flags    = pointData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags  |= metaPenId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteReal (EmfPlusStream, tension);
            WriteInt32(EmfPlusStream, count);
            pointData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawClosedCurve record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawCurve.
*
* Arguments:
*
*   [IN]  deviceBounds     - the bounding rect, in device units
*   [IN]  pen              - pen to draw with
*   [IN]  points           - curve points
*   [IN]  count            - number of points
*   [IN]  tension          - how tight to make curve
*   [IN]  offset           - offset
*   [IN]  numberOfSegments - number of segments
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawCurve(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpPointF *            points,
    INT                         count,
    REAL                        tension,
    INT                         offset,
    INT                         numberOfSegments
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL) &&
                (points != NULL) && (count > 0));

        if (IsValid())
        {
            MetafilePointData   pointData(points, count);
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(tension) +
                                           sizeof(INT32 /* offset */) +
                                           sizeof(UINT32/* numberOfSegments */) +
                                           sizeof(UINT32/* count */) +
                                           pointData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawCurve;
            INT                 flags    = pointData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags  |= metaPenId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteReal (EmfPlusStream, tension);
            WriteInt32(EmfPlusStream, offset);
            WriteInt32(EmfPlusStream, numberOfSegments);
            WriteInt32(EmfPlusStream, count);
            pointData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawCurve record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawBeziers.
*
* Arguments:
*
*   [IN]  deviceBounds     - the bounding rect, in device units
*   [IN]  pen              - pen to draw with
*   [IN]  points           - curve points
*   [IN]  count            - number of points
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawBeziers(
    const GpRectF *             deviceBounds,
    GpPen *                     pen,
    const GpPointF *            points,
    INT                         count
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (pen != NULL) &&
                (points != NULL) && (count > 0));

        if (IsValid())
        {
            MetafilePointData   pointData(points, count);
            UINT32              metaPenId;
            UINT32              dataSize = sizeof(UINT32/* count */) +
                                           pointData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawBeziers;
            INT                 flags    = pointData.GetFlags();

            RecordObject(pen, &metaPenId);
            ASSERT((metaPenId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags  |= metaPenId;

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, count);
            pointData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawBeziers record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawImage.
*
* Arguments:
*
*   [IN]  deviceBounds     - the bounding rect, in device units
*   [IN]  image            - image to draw
*   [IN]  destRect         - where to draw image
*   [IN]  srcRect          - portion of image to draw
*   [IN]  srcUnit          - units of srcRect
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawImage(
    const GpRectF *             deviceBounds,
    const GpImage *             image,
    const GpRectF &             destRect,
    const GpRectF &             srcRect,
    GpPageUnit                  srcUnit,
    const GpImageAttributes *         imageAttributes
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (image != NULL));

        if (IsValid())
        {
            MetafileRectData    rectData(&destRect, 1);
            UINT32              metaImageId;
            UINT32              metaImageAttributesId;

            UINT32              dataSize = sizeof(INT32) +   /* metaImageAttributesId*/
                                           sizeof(INT32) +   /* srcUnit */
                                           sizeof(srcRect) +
                                           rectData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawImage;
            INT                 flags    = rectData.GetFlags();

            RecordObject(image, &metaImageId);
            ASSERT((metaImageId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags  |= metaImageId;

            // Record the imageAttributes;
            // imageAttributes can be NULL

            RecordObject(imageAttributes, &metaImageAttributesId);

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, metaImageAttributesId);
            WriteInt32(EmfPlusStream, srcUnit);
            WriteRect (EmfPlusStream, srcRect);
            rectData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawImage record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawImage.
*
* Arguments:
*
*   [IN]  deviceBounds     - the bounding rect, in device units
*   [IN]  image            - image to draw
*   [IN]  destPoints       - where to draw image
*   [IN]  count            - number of destPoints
*   [IN]  srcRect          - portion of image to draw
*   [IN]  srcUnit          - units of srcRect
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawImage(
    const GpRectF *             deviceBounds,
    const GpImage *             image,
    const GpPointF *            destPoints,
    INT                         count,
    const GpRectF &             srcRect,
    GpPageUnit                  srcUnit,
    const GpImageAttributes *         imageAttributes
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT ((deviceBounds != NULL) && (image != NULL) &&
                (destPoints != NULL) && (count > 0));

        if (IsValid())
        {
            MetafilePointData   pointData(destPoints, count);
            UINT32              metaImageId;
            UINT32              metaImageAttributesId;

            UINT32              dataSize = sizeof(INT32) +   /* metaImageAttributesId*/
                                           sizeof(INT32) +   /* srcUnit */
                                           sizeof(srcRect) +
                                           sizeof(UINT32) +  /* count */
                                           pointData.GetDataSize();
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawImagePoints;
            INT                 flags    = pointData.GetFlags();

            RecordObject(image, &metaImageId);
            ASSERT((metaImageId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaImageId;

            // Record the imageAttributes;
            // imageAttributes can be NULL

            RecordObject(imageAttributes, &metaImageAttributesId);

            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, metaImageAttributesId);
            WriteInt32(EmfPlusStream, srcUnit);
            WriteRect (EmfPlusStream, srcRect);
            WriteInt32(EmfPlusStream, count);
            pointData.WriteData(EmfPlusStream);
            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawImagePoints record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawString.
*
* Arguments:
*
*   [IN]  string           - string to draw
*   [IN]  length           - length of string
*   [IN]  font             - font to use when drawing string
*   [IN]  layoutRect       - where to draw the string
*   [IN]  format           - format
*   [IN]  brush            - brush to draw with
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawString(
    const GpRectF *             deviceBounds,
    const WCHAR                *string,
    INT                         length,
    const GpFont               *font,
    const RectF                *layoutRect,
    const GpStringFormat       *format,
    const GpBrush              *brush
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT (string && font && brush && layoutRect);

        if (length < 0)
        {
            if (length == -1)
            {
                length = 0;
                while (string[length] && (length < INT_MAX))
                {
                    length++;
                }
            }
            else
            {
                return InvalidParameter;
            }
        }

        ASSERT (length > 0);

        if (IsValid())
        {
            const BYTE *        strData    = (BYTE *)string;    // BYTE or WCHAR
            INT                 sizeString = length * sizeof(WCHAR);
            INT                 flags      = 0;

            // !!! TODO:
            // Compress the Unicode string.
            // Use the GDIP_EPRFLAGS_COMPRESSED to indicate that
            // the string has been compressed to ANSI.

            UINT32              metaFontId;
            UINT32              metaFormatId;
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              dataSize = sizeof(brushValue) +
                                           sizeof(metaFormatId) +
                                           sizeof(INT32 /* len */) +
                                           sizeof(*layoutRect) +
                                           sizeString;
            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawString;

            dataSize = (dataSize + 3) & (~3);    // align

            RecordObject(font, &metaFontId);
            ASSERT((metaFontId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaFontId;

            // the format can be NULL
            RecordObject(format, &metaFormatId);

            GetBrushValueForRecording(brush, brushValue, flags);
            WriteRecordHeader(dataSize, type, flags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteInt32(EmfPlusStream, metaFormatId);
            WriteInt32(EmfPlusStream, length);
            WriteRect (EmfPlusStream, *layoutRect);
            WriteBytes(EmfPlusStream, strData, sizeString);

            // align
            if ((length & 0x01) != 0)
            {
                length = 0;
                EmfPlusStream->Write(&length, sizeof(WCHAR), NULL);
            }

            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawString record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordDrawdriverString.
*
* Arguments:
*
*   [IN]  text              - string/glyphs
*   [IN]  glyphCount        - string length
*   [IN]  font              - font to use when drawing string
*   [IN]  brush             - brush to draw with
*   [IN]  positions         - character/glyphs origins
*   [IN]  flags             - API flags
*   [IN]  matrix            - transofrmation matrix
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   7/11/2000 Tarekms
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordDrawDriverString(
    const GpRectF       *deviceBounds,
    const UINT16        *text,
    INT                  glyphCount,
    const GpFont        *font,
    const GpBrush       *brush,
    const PointF        *positions,
    INT                  flags,
    const GpMatrix      *matrix
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        ASSERT (text && font && brush && positions);

        if (glyphCount <= 0)
        {
            return InvalidParameter;
        }

        if (IsValid())
        {
            const BYTE *        textData      = (BYTE *)text;
            const BYTE *        positionData  = (BYTE *)positions;
            INT                 sizeText      = glyphCount * sizeof(UINT16);
            INT                 sizePositions = glyphCount * sizeof(PointF);
            INT                 metaFlags     = 0;

            UINT32              metaFontId;
            UINT32              brushValue; // Metafile Brush Id or ARGB value
            UINT32              matrixPresent;
            UINT32              dataSize = sizeof(brushValue)   + // brush value
                                           sizeof(flags)        + // API flags
                                           sizeof(matrixPresent)+ // matix prensences
                                           sizeof(UINT32)       + // glyphCoumt
                                           sizeText             + // Text
                                           sizePositions;         // Positions
            if (matrix == NULL)
            {
                matrixPresent = 0;
            }
            else
            {
                matrixPresent = 1;
                dataSize += GDIP_MATRIX_SIZE;
            }

            EmfPlusRecordType   type     = EmfPlusRecordTypeDrawDriverString;

            dataSize = (dataSize + 3) & (~3);    // align

            RecordObject(font, &metaFontId);
            ASSERT((metaFontId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            metaFlags |= metaFontId;

            GetBrushValueForRecording(brush, brushValue, metaFlags);
            WriteRecordHeader(dataSize, type, metaFlags, deviceBounds);
            WriteInt32(EmfPlusStream, brushValue);
            WriteInt32(EmfPlusStream, flags);
            WriteInt32(EmfPlusStream, matrixPresent);
            WriteInt32(EmfPlusStream, glyphCount);
            WriteBytes(EmfPlusStream, textData, sizeText);
            WriteBytes(EmfPlusStream, positionData, sizePositions);

            if (matrix != NULL)
            {
                WriteMatrix(EmfPlusStream, *matrix);
            }

            // align
            if ((glyphCount & 0x01) != 0)
            {
                sizeText = 0;
                EmfPlusStream->Write(&sizeText, sizeof(WCHAR), NULL);
            }

            WriteGdiComment();  // is down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write DrawDriverString record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSave.
*
* Arguments:
*
*   [IN]  gstate - the pushed state (restore to state before this)
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSave(
    INT         gstate
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(UINT32/* index */);
            EmfPlusRecordType   type     = EmfPlusRecordTypeSave;
            INT                 index    = SaveRestoreStack.GetCount();

            SaveRestoreStack.Add(gstate);

            WriteRecordHeader(dataSize, type);
            WriteInt32(EmfPlusStream, index);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write Save record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordRestore.
*
* Arguments:
*
*   [IN]  gstate - the pushed state (restore to state before this)
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordRestore(
    INT         gstate
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            INT         count = SaveRestoreStack.GetCount();
            INT *       stack = SaveRestoreStack.GetDataBuffer();

            if ((count > 0) && (stack != NULL))
            {
                UINT32              dataSize = sizeof(UINT32/* index */);
                EmfPlusRecordType   type     = EmfPlusRecordTypeRestore;

                do
                {
                    if (stack[--count] == gstate)
                    {
                        SaveRestoreStack.SetCount(count);
                        WriteRecordHeader(dataSize, type);
                        WriteInt32(EmfPlusStream, count);
                        // WriteGdiComment(); no down-level for this record

                        if (EmfPlusStream->IsValid())
                        {
                            return Ok;
                        }
                        SetValid(FALSE);
                        break;
                    }
                } while (count > 0);
            }
        }
        WARNING(("Failed to write Restore record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordBeginContainer.
*
* Arguments:
*
*   [IN]  destRect       - rect to draw container inside of
*   [IN]  srcRect        - maps source size to destRect
*   [IN]  srcUnit        - units of srcRect
*   [IN]  containerState - the pushed state (restore to state before this)
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordBeginContainer(
    const GpRectF &             destRect,
    const GpRectF &             srcRect,
    GpPageUnit                  srcUnit,
    INT                         containerState
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = GDIP_RECTF_SIZE /* destRect */ +
                                           GDIP_RECTF_SIZE /* srcRect */ +
                                           sizeof(UINT32/* index */);
            EmfPlusRecordType   type     = EmfPlusRecordTypeBeginContainer;
            INT                 index    = SaveRestoreStack.GetCount();
            INT                 flags    = srcUnit;

            ASSERT((flags & (~GDIP_EPRFLAGS_PAGEUNIT)) == 0);

            if (index >= MaxStackSize)
            {
                MaxStackSize = index + 1;
            }

            SaveRestoreStack.Add(containerState);

            WriteRecordHeader(dataSize, type, flags);
            WriteRect(EmfPlusStream, destRect);
            WriteRect(EmfPlusStream, srcRect);
            WriteInt32(EmfPlusStream, index);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write BeginContainer record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordBeginContainer.
*
* Arguments:
*
*   [IN]  containerState - the pushed state (restore to state before this)
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordBeginContainer(
    INT                         containerState
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(UINT32/* index */);
            EmfPlusRecordType   type     = EmfPlusRecordTypeBeginContainerNoParams;
            INT                 index    = SaveRestoreStack.GetCount();
            INT                 flags    = 0;

            if (index >= MaxStackSize)
            {
                MaxStackSize = index + 1;
            }

            SaveRestoreStack.Add(containerState);

            WriteRecordHeader(dataSize, type, flags);
            WriteInt32(EmfPlusStream, index);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write BeginContainer record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordEndContainer.
*
* Arguments:
*
*   [IN]  containerState - the pushed state (restore to state before this)
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordEndContainer(
    INT                         containerState
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            INT         count = SaveRestoreStack.GetCount();
            INT *       stack = SaveRestoreStack.GetDataBuffer();

            if ((count > 0) && (stack != NULL))
            {
                UINT32              dataSize = sizeof(UINT32/* index */);
                EmfPlusRecordType   type     = EmfPlusRecordTypeEndContainer;

                do
                {
                    if (stack[--count] == containerState)
                    {
                        SaveRestoreStack.SetCount(count);
                        WriteRecordHeader(dataSize, type);
                        WriteInt32(EmfPlusStream, count);
                        // WriteGdiComment(); no down-level for this record

                        if (EmfPlusStream->IsValid())
                        {
                            return Ok;
                        }
                        SetValid(FALSE);
                        break;
                    }
                } while (count > 0);
            }
        }
        WARNING(("Failed to write EndContainer record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetWorldTransform.
*
* Arguments:
*
*   [IN]  matrix - matrix to set in graphics
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetWorldTransform(
    const GpMatrix &            matrix
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = GDIP_MATRIX_SIZE;
            EmfPlusRecordType   type     = EmfPlusRecordTypeSetWorldTransform;

            WriteRecordHeader(dataSize, type);
            WriteMatrix(EmfPlusStream, matrix);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write SetWorldTransform record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordResetWorldTransform.
*
* Arguments:
*
*   NONE
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordResetWorldTransform()
{
    return RecordZeroDataRecord(EmfPlusRecordTypeResetWorldTransform, 0);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordMultiplyWorldTransform.
*
* Arguments:
*
*   [IN]  matrix - matrix to set in graphics
*   [IN]  order  - Append or Prepend
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordMultiplyWorldTransform(
    const GpMatrix &            matrix,
    GpMatrixOrder               order
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = GDIP_MATRIX_SIZE;
            EmfPlusRecordType   type     = EmfPlusRecordTypeMultiplyWorldTransform;
            INT                 flags    = 0;

            if (order == MatrixOrderAppend)
            {
                flags |= GDIP_EPRFLAGS_APPEND;
            }

            WriteRecordHeader(dataSize, type, flags);
            WriteMatrix(EmfPlusStream, matrix);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write MultiplyWorldTransform record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordTranslateWorldTransform.
*
* Arguments:
*
*   [IN]  dx     - x translation
*   [IN]  dy     - y translation
*   [IN]  order  - Append or Prepend
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordTranslateWorldTransform(
    REAL                        dx,
    REAL                        dy,
    GpMatrixOrder               order
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(dx) + sizeof(dy);
            EmfPlusRecordType   type     = EmfPlusRecordTypeTranslateWorldTransform;
            INT                 flags    = 0;

            if (order == MatrixOrderAppend)
            {
                flags |= GDIP_EPRFLAGS_APPEND;
            }

            WriteRecordHeader(dataSize, type, flags);
            WriteReal(EmfPlusStream, dx);
            WriteReal(EmfPlusStream, dy);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write TranslateWorldTransform record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordScaleWorldTransform.
*
* Arguments:
*
*   [IN]  sx     - x scale
*   [IN]  sy     - y scale
*   [IN]  order  - Append or Prepend
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordScaleWorldTransform(
    REAL                        sx,
    REAL                        sy,
    GpMatrixOrder               order
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(sx) + sizeof(sy);
            EmfPlusRecordType   type     = EmfPlusRecordTypeScaleWorldTransform;
            INT                 flags    = 0;

            if (order == MatrixOrderAppend)
            {
                flags |= GDIP_EPRFLAGS_APPEND;
            }

            WriteRecordHeader(dataSize, type, flags);
            WriteReal(EmfPlusStream, sx);
            WriteReal(EmfPlusStream, sy);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write ScaleWorldTransform record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordRotateWorldTransform.
*
* Arguments:
*
*   [IN]  angle  - rotation angle
*   [IN]  order  - Append or Prepend
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordRotateWorldTransform(
    REAL                        angle,
    GpMatrixOrder               order
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(angle);
            EmfPlusRecordType   type     = EmfPlusRecordTypeRotateWorldTransform;
            INT                 flags    = 0;

            if (order == MatrixOrderAppend)
            {
                flags |= GDIP_EPRFLAGS_APPEND;
            }

            WriteRecordHeader(dataSize, type, flags);
            WriteReal(EmfPlusStream, angle);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write RotateWorldTransform record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetPageTransform.
*
* Arguments:
*
*   [IN]  unit   - units to use
*   [IN]  scale  - scale factor to apply
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetPageTransform(
    GpPageUnit                  unit,
    REAL                        scale
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(scale);
            EmfPlusRecordType   type     = EmfPlusRecordTypeSetPageTransform;
            INT                 flags    = unit;

            ASSERT((flags & (~GDIP_EPRFLAGS_PAGEUNIT)) == 0);

            WriteRecordHeader(dataSize, type, flags);
            WriteReal(EmfPlusStream, scale);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write SetPageTransform record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordResetClip.
*
* Arguments:
*
*   NONE
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordResetClip()
{
    return RecordZeroDataRecord(EmfPlusRecordTypeResetClip, 0);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetClip.
*
* Arguments:
*
*   [IN]  rect        - set clipping to this rect
*   [IN]  combineMode - the combine operator (and, or, xor, exclude, complement)
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetClip(
    const GpRectF &             rect,
    CombineMode                 combineMode
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = GDIP_RECTF_SIZE;
            EmfPlusRecordType   type     = EmfPlusRecordTypeSetClipRect;
            INT                 flags    = (combineMode << 8);

            ASSERT((flags & (~GDIP_EPRFLAGS_COMBINEMODE)) == 0);

            WriteRecordHeader(dataSize, type, flags);
            WriteRect(EmfPlusStream, rect);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write SetClipRect record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetClip.
*
* Arguments:
*
*   [IN]  region      - set clipping to this region
*   [IN]  combineMode - the combine operator (and, or, xor, exclude, complement)
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetClip(
    GpRegion *                  region,
    CombineMode                 combineMode
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = 0;
            EmfPlusRecordType   type     = EmfPlusRecordTypeSetClipRegion;
            INT                 flags    = (combineMode << 8);
            UINT32              metaRegionId;

            ASSERT((flags & (~GDIP_EPRFLAGS_COMBINEMODE)) == 0);

            RecordObject(region, &metaRegionId);
            ASSERT((metaRegionId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaRegionId;

            WriteRecordHeader(dataSize, type, flags);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write SetClipRegion record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetClip.
*
* Arguments:
*
*   [IN]  path        - set clipping to this path
*   [IN]  combineMode - the combine operator (and, or, xor, exclude, complement)
*   [IN]  isDevicePath- if path is already in device units
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetClip(
    GpPath *                    path,
    CombineMode                 combineMode,
    BOOL                        isDevicePath
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = 0;
            EmfPlusRecordType   type     = EmfPlusRecordTypeSetClipPath;
            INT                 flags    = (combineMode << 8);
            UINT32              metaPathId;

            ASSERT((flags & (~GDIP_EPRFLAGS_COMBINEMODE)) == 0);

            RecordObject(path, &metaPathId);
            ASSERT((metaPathId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
            flags |= metaPathId;

            if (isDevicePath)
            {
                flags |= GDIP_EPRFLAGS_ISDEVICEPATH;
            }

            WriteRecordHeader(dataSize, type, flags);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write SetClipPath record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordOffsetClip.
*
* Arguments:
*
*   [IN]  dx   - x translation amount
*   [IN]  dy   - y translation amount
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordOffsetClip(
    REAL                        dx,
    REAL                        dy
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(dx) + sizeof(dy);
            EmfPlusRecordType   type     = EmfPlusRecordTypeOffsetClip;

            WriteRecordHeader(dataSize, type);
            WriteReal(EmfPlusStream, dx);
            WriteReal(EmfPlusStream, dy);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write OffsetClip record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordGetDC.
*
* Arguments:
*
*   NONE
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordGetDC()
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        GpStatus status = RecordZeroDataRecord(EmfPlusRecordTypeGetDC, 0);
        // WriteGdiComment();  // is down-level for this record
        // WriteGdiComment will only flush if writing EMF+ dual,
        // but for EMF+-only, we also have to flush GetDC records!
        EmfPlusStream->Flush();
        return status;
    }
    return Ok;
}

// Write a record with no data besides the EMF+ record header
GpStatus
MetafileRecorder::RecordZeroDataRecord(
    EmfPlusRecordType   type,
    INT                 flags
    )
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = 0;

            WriteRecordHeader(dataSize, type, flags);
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write record"));
        return Win32Error;
    }
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetAntiAliasMode.
*
* Arguments:
*
*   [IN]  newMode   - new anti aliasing mode
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetAntiAliasMode(
    BOOL                        newMode
    )
{
    return RecordZeroDataRecord(EmfPlusRecordTypeSetAntiAliasMode,
                                newMode ? GDIP_EPRFLAGS_ANTIALIAS : 0);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetTextRenderingHint.
*
* Arguments:
*
*   [IN]  newMode   - new rendering hint
*
* Return Value:
*
*   NONE
*
* Created:
*
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetTextRenderingHint(
    TextRenderingHint               newMode
    )
{
    ASSERT ((newMode & (~GDIP_EPRFLAGS_TEXTRENDERINGHINT)) == 0);
    return RecordZeroDataRecord(EmfPlusRecordTypeSetTextRenderingHint, newMode);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetTextContrast.
*
* Arguments:
*
*   [IN]  gammaValue   - new contrast value
*
* Return Value:
*
*   NONE
*
* Created:
*
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetTextContrast(
    UINT                    contrast
    )
{
    ASSERT ((contrast & (~GDIP_EPRFLAGS_CONTRAST)) == 0);
    return RecordZeroDataRecord(EmfPlusRecordTypeSetTextContrast, contrast);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetInterpolationMode.
*
* Arguments:
*
*   [IN]  newMode   - new interpolation mode
*
* Return Value:
*
*   NONE
*
* Created:
*
*   5/1/2000 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetInterpolationMode(
    InterpolationMode           newMode
    )
{
    ASSERT ((newMode & (~GDIP_EPRFLAGS_INTERPOLATIONMODE)) == 0);
    return RecordZeroDataRecord(EmfPlusRecordTypeSetInterpolationMode, newMode);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetPixelOffsetMode.
*
* Arguments:
*
*   [IN]  newMode   - new pixel offset mode
*
* Return Value:
*
*   NONE
*
* Created:
*
*   5/1/2000 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetPixelOffsetMode(
    PixelOffsetMode             newMode
    )
{
    ASSERT ((newMode & (~GDIP_EPRFLAGS_PIXELOFFSETMODE)) == 0);
    return RecordZeroDataRecord(EmfPlusRecordTypeSetPixelOffsetMode, newMode);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetRenderingOrigin.
*
* Arguments:
*
*   [IN]  x, y   - new rendering origin
*
* Return Value:
*
*   NONE
*
* Created:
*
*   5/4/2000 asecchia
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetRenderingOrigin(
    INT x,
    INT y
)
{
    // If doing down-level only, then EmfPlusStream will be NULL
    if (EmfPlusStream != NULL)
    {
        if (IsValid())
        {
            UINT32              dataSize = sizeof(x) + sizeof(y);
            EmfPlusRecordType   type     = EmfPlusRecordTypeSetRenderingOrigin;

            WriteRecordHeader(dataSize, type);
            WriteInt32(EmfPlusStream, x);
            WriteInt32(EmfPlusStream, y);

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        WARNING(("Failed to write SetRenderingOrigin record"));
        return Win32Error;
    }
    return Ok;
}


/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetCompositingMode.
*
* Arguments:
*
*   [IN]  newMode   - new compositing mode
*
* Return Value:
*
*   NONE
*
* Created:
*
*   10/11/1999 AGodfrey
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetCompositingMode(
    GpCompositingMode newMode
    )
{
    ASSERT ((newMode & (~GDIP_EPRFLAGS_COMPOSITINGMODE)) == 0);
    return RecordZeroDataRecord(EmfPlusRecordTypeSetCompositingMode, newMode);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordSetCompositingQuality.
*
* Arguments:
*
*   [IN]  newQuality   - new quality setting
*
* Return Value:
*
*   NONE
*
* Created:
*
*   04/22/2000 AGodfrey
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordSetCompositingQuality(
    GpCompositingQuality newQuality
    )
{
    ASSERT ((newQuality & (~GDIP_EPRFLAGS_COMPOSITINGQUALITY)) == 0);
    return RecordZeroDataRecord(EmfPlusRecordTypeSetCompositingQuality, newQuality);
}

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - RecordComment.
*
* Arguments:
*
*   [IN]  sizeData - number of bytes of data
*   [IN]  data     - pointer to the data
*
* Return Value:
*
*   GpStatus - Ok or failure status
*
* Created:
*
*   6/29/1999 DCurtis
*
\**************************************************************************/
GpStatus
MetafileRecorder::RecordComment(
    UINT            sizeData,
    const BYTE *    data
    )
{
    if (IsValid() && (sizeData > 0) && (data != NULL))
    {
        // If doing down-level only, then EmfPlusStream will be NULL
        if (EmfPlusStream != NULL)
        {
            UINT32              dataSize = (sizeData + 3) & (~3);
            EmfPlusRecordType   type     = EmfPlusRecordTypeComment;
            INT                 pad      = dataSize - sizeData;
            INT                 flags    = pad;

            WriteRecordHeader(dataSize, type, flags);
            WriteBytes(EmfPlusStream, data, sizeData);
            while(pad--)
            {
                WriteByte(EmfPlusStream, 0);
            }
            // WriteGdiComment(); no down-level for this record

            if (EmfPlusStream->IsValid())
            {
                return Ok;
            }
            SetValid(FALSE);
        }
        else if (Type == EmfTypeEmfOnly)
        {
            GdiComment(MetafileHdc, sizeData, data);
            return Ok;
        }
    }
    WARNING(("Failed to write Comment record"));
    return GenericError;
}

GpStatus
MetafileRecorder::RecordHeader(
    INT                 logicalDpiX,
    INT                 logicalDpiY,
    INT                 emfPlusFlags
    )
{
    // Don't need to check for EmfPlusStream or Valid

    UINT32              dataSize     = sizeof(EmfPlusHeaderRecord);
    EmfPlusRecordType   type         = EmfPlusRecordTypeHeader;
    INT                 flags        = 0;

    if (Type != EmfTypeEmfPlusOnly)
    {
        flags |= GDIP_EPRFLAGS_EMFPLUSDUAL;
    }

    EmfPlusHeaderRecord emfPlusHeader(emfPlusFlags, logicalDpiX, logicalDpiY);

    WriteRecordHeader(dataSize, type, flags);
    WriteBytes(EmfPlusStream, &emfPlusHeader, sizeof(emfPlusHeader));

    // We have to flush the EMF+ header immediately to guarantee that it
    // is the first record in the EMF after the EMF header.  Otherwise,
    // CloneColorAdjusted fails, because immediately after the metafile
    // constructor, it calls Play into the new metafile which writes a
    // SaveDC record into the metafile.
    EmfPlusStream->Flush();

    if (EmfPlusStream->IsValid())
    {
        return Ok;
    }
    SetValid(FALSE);
    WARNING(("Failed to write Metafile Header record"));
    return Win32Error;
}

VOID
MetafileRecorder::RecordEndOfFile()
{
    RecordZeroDataRecord(EmfPlusRecordTypeEndOfFile, 0);
}

extern "C"
int CALLBACK
EnumEmfToStream(
    HDC                     hdc,
    HANDLETABLE FAR *       gdiHandleTable,
    CONST ENHMETARECORD *   emfRecord,
    int                     numHandles,
    LPARAM                  stream
    );

/**************************************************************************\
*
* Function Description:
*
*   IMetafileRecord interface method - EndRecording.
*
* Arguments:
*
*   NONE
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
VOID
MetafileRecorder::EndRecording()
{
    GpMetafile::MetafileState   state = GpMetafile::InvalidMetafileState;

    if (IsValid() && (Metafile->State == GpMetafile::RecordingMetafileState))
    {
        INT         success = 1;    // assume success

        // If doing down-level only, then EmfPlusStream will be NULL
        if (EmfPlusStream != NULL)
        {
            // Force a flush of the Stream buffer to the EMF+ file
            EmfPlusStream->Flush();

            // We put a no-op PatBlt into the metafile to guarantee that
            // the header of the metafile has the same size bounds and
            // frame rect that GDI+ has recorded so that the EMF will
            // play back the same way, whether GDI plays it back or we do.
            // Otherwise, this may not be the case.  For example, on a
            // bezier curve, the GDI+ bounds would include the control
            // points, whereas the down-level representation may not.

            // If we haven't written any records to the file, then XMinDevice
            // and other bounds are still initialized at FLT_MAX and can cause
            // an exception. We don't need the empty PatBlt record in that case
            // because we haven't written anything.
            if (BoundsInit != FALSE)
            {
                // Try to match the GDI+ rasterizer
                INT     left   = RasterizerCeiling(XMinDevice);
                INT     top    = RasterizerCeiling(YMinDevice);
                INT     right  = RasterizerCeiling(XMaxDevice); // exclusive
                INT     bottom = RasterizerCeiling(YMaxDevice); // exclusive

                // to get the inclusive right and bottom, we'd now
                // have to subtract 1 from each of them
                if ((right > left) && (bottom > top))
                {
                    Metafile->MetaGraphics->NoOpPatBlt(left, top, right - left, bottom - top);
                }
            }

            // must be the last record in the file, except the EMF EOF record
            RecordEndOfFile();
            EmfPlusStream->Flush();
        }

        HENHMETAFILE    hEmf = CloseEnhMetaFile(MetafileHdc);

        if (hEmf == NULL)
        {
            goto Done;
        }

        // Get the EMF header
        ENHMETAHEADER3      emfHeader;
        if ((GetEnhMetaFileHeader(hEmf, sizeof(emfHeader),
                                  (ENHMETAHEADER*)(&emfHeader)) <= 0) ||
            !EmfHeaderIsValid(emfHeader))
        {
            DeleteEnhMetaFile(hEmf);
            goto Done;
        }

#if DBG
        if ((emfHeader.rclBounds.right  == -1) &&
            (emfHeader.rclBounds.bottom == -1) &&
            (emfHeader.rclBounds.left   ==  0) &&
            (emfHeader.rclBounds.top    ==  0))
        {
            WARNING1("Empty metafile -- no drawing records");
        }
#endif

        MetafileHeader *    header       = &Metafile->Header;
        INT32               emfPlusFlags = header->EmfPlusFlags;

        // Save the header and various other info in the Metafile
        Metafile->Hemf         = hEmf;
        Metafile->MaxStackSize = MaxStackSize;
        header->EmfPlusFlags   = emfPlusFlags;
        header->EmfHeader      = emfHeader;
        header->Size           = emfHeader.nBytes;

        // Set the bounds in the Metafile header
        {
            REAL    multiplierX = header->DpiX / 2540.0f;
            REAL    multiplierY = header->DpiY / 2540.0f;

            // The frameRect is inclusive-inclusive, but the bounds in
            // the header is inclusive-exclusive.
            REAL    x = (multiplierX * (REAL)(emfHeader.rclFrame.left));
            REAL    y = (multiplierY * (REAL)(emfHeader.rclFrame.top));
            REAL    w = (multiplierX * (REAL)(emfHeader.rclFrame.right -
                                              emfHeader.rclFrame.left)) + 1.0f;
            REAL    h = (multiplierY * (REAL)(emfHeader.rclFrame.bottom -
                                              emfHeader.rclFrame.top)) + 1.0f;
            header->X      = GpRound(x);
            header->Y      = GpRound(y);
            header->Width  = GpRound(w);
            header->Height = GpRound(h);
        }

        // The metafile is either supposed to be in memory, in a file,
        // or in a stream.

        // If it goes in a file, we're done unless we need to rewrite
        // any of the header information.
        if (Metafile->Filename != NULL)
        {
            state = GpMetafile::DoneRecordingMetafileState;
        }
        else
        {
            // If it goes in memory, we're done.

            // If it goes in a stream, then we have to write
            // the bits to the stream.

            if (Metafile->Stream != NULL)
            {
                // Write the emf data buffer to the stream,
                // and leave the stream position at the end of the metafile.
                if (!::EnumEnhMetaFile(NULL, hEmf, EnumEmfToStream,
                    Metafile->Stream, NULL))
                {
                    WARNING(("Problem retrieving EMF Data"));
                    DeleteEnhMetaFile(hEmf);
                    Metafile->Hemf = NULL;
                    goto Done;
                }

                // Don't need the Stream any longer
                Metafile->Stream->Release();
                Metafile->Stream = NULL;
            }
            state = GpMetafile::DoneRecordingMetafileState;
        }
    }
    else
    {
        DeleteEnhMetaFile(CloseEnhMetaFile(MetafileHdc));
        WARNING(("Metafile in wrong state in EndRecording"));
    }

Done:
    Metafile->MetaGraphics->Metafile = NULL; // Graphics can't point to us anymore
    Metafile->MetaGraphics->SetValid(FALSE); // Don't allow anymore operations on
                                           // the graphics
    Metafile->MetaGraphics = NULL;         // graphics is not valid any more
    Metafile->State        = state;
    delete this;
}

#if 0
inline INT
WriteActualSize(
    IStream *   stream,
    LONGLONG &  startOfRecord,
    ULONG       actualSize
    )
{
    ASSERT (actualSize > 0);

    // get to size field
    INT success = SeekFromStart(stream, startOfRecord + sizeof(INT32));

    if (success)
    {
        success &= WriteInt32(stream, actualSize);
    }

    // get back to end of record
    success &= SeekFromStart(stream, startOfRecord + actualSize);

    return success;
}
#endif

/**************************************************************************\
*
* Function Description:
*
*   Write an object (pen, brush, image, region, path, font) to metafile by
*   writing its header, calling its serialize method, and then re-writing
*   the size.
*
* Arguments:
*
*   [IN]  type           - the record type
*   [IN]  flags          - any flags for the record header
*   [IN]  object         - pointer to the object to be recorded
*   [IN]  metaObjectId   - ID to store in file that identifies object
*   [IN]  extraData      - any extra data to store with object
*   [IN]  extraDataSize  - size in BYTES of extraData
*
* Return Value:
*
*   INT - 1 if we succeeded, else 0 if we failed
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
VOID
MetafileRecorder::WriteObject(
    ObjectType                  type,
    const GpObject *            object,
    UINT32                      metaObjectId
    )
{
    ULONG               objectDataSize  = object->GetDataSize();
    INT                 flags = ((INT)type << 8);

    ASSERT((objectDataSize & 0x03) == 0);
    ASSERT((flags & (~GDIP_EPRFLAGS_OBJECTTYPE)) == 0);
    ASSERT((metaObjectId & (~GDIP_EPRFLAGS_METAOBJECTID)) == 0);
    ASSERT(objectDataSize != 0);    // cannot have an empty object

    flags |= metaObjectId;

    WriteRecordHeader(objectDataSize, EmfPlusRecordTypeObject, flags, NULL);

    if (object->GetData(EmfPlusStream) != Ok)
    {
        WARNING(("GetData failed"));
    }
    EmfPlusStream->EndObjectRecord();
}

VOID
MetafileRecorder::RecordObject(
    const GpObject *            object,
    UINT32*                     metaObjectId
    )
{
    if (object)
    {
        ObjectType      type  = object->GetObjectType();

        if (ObjectList.IsInList(object, type, metaObjectId))
        {
            ObjectList.UpdateMRU(*metaObjectId);
        }
        else
        {
            ObjectList.InsertAt(object, metaObjectId);
            WriteObject(type, object, *metaObjectId);
        }
    }
    else
    {
        *metaObjectId = GDIP_OBJECTID_NONE;
    }
}

// This is for backward compatiblity.  If we are using a new object
// (such as a new kind of brush), then we can record a backup object
// for down-level apps to use when they see a new object that they
// don't know how to deal with.
GpStatus
MetafileRecorder::RecordBackupObject(
    const GpObject *            object
    )
{
    WriteObject(object->GetObjectType(), object, GDIP_BACKUP_OBJECTID) ;
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   Write the initial portion of an EMF+ record.  Every EMF+ record contains
*   a size, a type, and some flags.  Many also contain a rect that specifies
*   the bounds of a drawing operation in REAL device units.
*
* Arguments:
*
*   [IN]  size         - the size of the record (excluding the header)
*   [IN]  type         - the EMF+ record type
*   [IN]  flags        - any flags that are defined for this record
*   [IN]  deviceBounds - bounds of drawing operation, or NULL
*
* Return Value:
*
*   INT - 1 if we succeeded, else 0 if we failed
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
VOID
MetafileRecorder::WriteRecordHeader(
    UINT32                      dataSize,
    EmfPlusRecordType           type,
    INT                         flags,          // 16 bits of flags
    const GpRectF *             deviceBounds
    )
{
    ASSERT((dataSize & 0x03) == 0);

    EmfPlusStream->WriteRecordHeader(dataSize, type, flags);

    NumRecords++;

    if (deviceBounds != NULL)
    {
        // If the bounds aren't initalized then make sure we have 4 valid
        // coordinates
        ASSERT(BoundsInit ||
               ((deviceBounds->X < XMinDevice) &&
                (deviceBounds->GetRight() > XMaxDevice) &&
                (deviceBounds->Y < YMinDevice) &&
                (deviceBounds->GetBottom() > YMaxDevice)));
        BoundsInit = TRUE;
        // Update the device bounds
        if (deviceBounds->X < XMinDevice)
        {
            XMinDevice = deviceBounds->X;
        }
        if (deviceBounds->GetRight() > XMaxDevice)
        {
            XMaxDevice = deviceBounds->GetRight();  // exclusive
        }
        if (deviceBounds->Y < YMinDevice)
        {
            YMinDevice = deviceBounds->Y;
        }
        if (deviceBounds->GetBottom() > YMaxDevice)
        {
            YMaxDevice = deviceBounds->GetBottom(); // exclusive
        }
    }
}

/**************************************************************************\
*
* Function Description:
*
*   If the brush is a 32-bit solid color, then return the solid color as
*   the brush value and set the flags to indicate it's a solid color.
*   Otherwise, record the brush and return the metafile brush id as the
*   brush value.
*
* Arguments:
*
*   [IN]  brush      - the brush that needs to be recorded
*   [OUT] brushValue - the 32-bit color or metafile brush ID
*   [OUT] flags      - set if we're using a solid color
*
* Return Value:
*
*   INT - 1 if we succeeded, else 0 if we failed
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
VOID
MetafileRecorder::GetBrushValueForRecording(
    const GpBrush *brush,
    UINT32        &brushValue,
    INT           &flags
    )
{
    if (brush->GetBrushType() == BrushTypeSolidColor)
    {
        const GpSolidFill * solidBrush = static_cast<const GpSolidFill *>(brush);
        brushValue = solidBrush->GetColor().GetValue();
        flags |= GDIP_EPRFLAGS_SOLIDCOLOR;
    }
    else
    {
        RecordObject(brush, &brushValue);
    }
}

/**************************************************************************\
*
* Function Description:
*
*   GpMetafile constructor for write/read access to a metafile.  (Write must
*   precede the read.)
*
*   This version records an EMF+ to memory.  The type specifies whether
*   to record dual GDI records or not.
*
*   If the frameRect is NULL, it will be calculated by accumulating the
*   device bounds of the metafile.  Otherwise, the supplied frameRect and
*   corresponding frameUnit will be used to record the frameRect in the
*   metafile header. The frameRect is inclusive-inclusive, which means
*   that the width value is actually 1 less than the actual width.
*   For example, a width of 0 is accepted and really means a width of 1.
*
*   If the optional description is supplied, it will become part of the
*   EMF header.
*
* Arguments:
*
*   [IN]  fileName      - where to write the metafile
*   [IN]  referenceHdc  - an HDC to use as a reference for creating metafile
*   [IN]  type          - whether to record EMF+-only or EMF+-dual
*   [IN]  frameRect     - optional frame rect for recording in header
*   [IN]  frameUnit     - the units of the frameRect
*   [IN]  description   - optional metafile description
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpMetafile::GpMetafile(
    HDC                 referenceHdc,
    EmfType             type,
    const GpRectF *     frameRect,      // can be NULL
    MetafileFrameUnit   frameUnit,      // if NULL frameRect, doesn't matter
    const WCHAR *       description     // can be NULL
    ) : GpImage(ImageTypeMetafile)
{
    ASSERT(referenceHdc != NULL);

    InitDefaults();

    if ((referenceHdc != NULL) &&
        InitForRecording(
            referenceHdc,
            type,
            frameRect,      // can be NULL
            frameUnit,      // if NULL frameRect, doesn't matter
            description     // can be NULL
            ))
    {
        State = RecordingMetafileState;
    }
}

/**************************************************************************\
*
* Function Description:
*
*   GpMetafile constructor for write/read access to a metafile.  (Write must
*   precede the read.)
*
*   This version records an EMF+ to a file.  The type specifies whether
*   to record dual GDI records or not.
*
*   If the frameRect is NULL, it will be calculated by accumulating the
*   device bounds of the metafile.  Otherwise, the supplied frameRect and
*   corresponding frameUnit will be used to record the frameRect in the
*   metafile header. The frameRect is inclusive-inclusive, which means
*   that the width value is actually 1 less than the actual width.
*   For example, a width of 0 is accepted and really means a width of 1.
*
*   If the optional description is supplied, it will become part of the
*   EMF header.
*
* Arguments:
*
*   [IN]  fileName      - where to write the metafile
*   [IN]  referenceHdc  - an HDC to use as a reference for creating metafile
*   [IN]  type          - whether to record EMF+-only or EMF+-dual
*   [IN]  frameRect     - optional frame rect for recording in header
*   [IN]  frameUnit     - the units of the frameRect
*   [IN]  description   - optional metafile description
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpMetafile::GpMetafile(
    const WCHAR*        fileName,
    HDC                 referenceHdc,
    EmfType             type,
    const GpRectF *     frameRect,      // can be NULL
    MetafileFrameUnit   frameUnit,      // if NULL frameRect, doesn't matter
    const WCHAR *       description     // can be NULL
    ) : GpImage(ImageTypeMetafile)
{
    ASSERT((fileName != NULL) && (referenceHdc != NULL));

    InitDefaults();

    if ((fileName != NULL) && (referenceHdc != NULL) &&
        ((Filename = UnicodeStringDuplicate(fileName)) != NULL) &&
        InitForRecording(
            referenceHdc,
            type,
            frameRect,      // can be NULL
            frameUnit,      // if NULL frameRect, doesn't matter
            description     // can be NULL
            ))
    {
        State = RecordingMetafileState;
    }
}

/**************************************************************************\
*
* Function Description:
*
*   GpMetafile constructor for write/read access to a metafile.  (Write must
*   precede the read.)
*
*   This version records an EMF+ to a file.  The type specifies whether
*   to record dual GDI records or not.
*
*   The metafile is first recorded to a temporary file, then it is copied
*   from the file into the stream.
*
*   If the frameRect is NULL, it will be calculated by accumulating the
*   device bounds of the metafile.  Otherwise, the supplied frameRect and
*   corresponding frameUnit will be used to record the frameRect in the
*   metafile header. The frameRect is inclusive-inclusive, which means
*   that the width value is actually 1 less than the actual width.
*   For example, a width of 0 is accepted and really means a width of 1.
*
*   If the optional description is supplied, it will become part of the
*   EMF header.
*
* Arguments:
*
*   [IN]  stream        - where to copy the metafile, after it's recorded
*   [IN]  referenceHdc  - an HDC to use as a reference for creating metafile
*   [IN]  type          - whether to record EMF+-only or EMF+-dual
*   [IN]  frameRect     - optional frame rect for recording in header
*   [IN]  frameUnit     - the units of the frameRect
*   [IN]  description   - optional metafile description
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
GpMetafile::GpMetafile(
    IStream *           stream,
    HDC                 referenceHdc,
    EmfType             type,
    const GpRectF *     frameRect,      // can be NULL
    MetafileFrameUnit   frameUnit,      // if NULL frameRect, doesn't matter
    const WCHAR *       description     // can be NULL
    ) : GpImage(ImageTypeMetafile)
{
    ASSERT((stream != NULL) && (referenceHdc != NULL));

    InitDefaults();

    if ((stream != NULL) && (referenceHdc != NULL))
    {
        if (InitForRecording(
                referenceHdc,
                type,
                frameRect,      // can be NULL
                frameUnit,      // if NULL frameRect, doesn't matter
                description     // can be NULL
                ))
        {
            stream->AddRef();
            Stream = stream;
            State = RecordingMetafileState;
        }
    }
}

inline HDC CreateEmf(
    HDC             referenceHdc,
    const WCHAR *   fileName,
    RECT *          frameRect
    )
{
    HDC         metafileHdc = NULL;

    if (Globals::IsNt)
    {
        metafileHdc = CreateEnhMetaFileW(referenceHdc, fileName, frameRect, NULL);
    }
    else
    {
        AnsiStrFromUnicode fileBuffer(fileName);

        if (fileBuffer.IsValid())
        {
            metafileHdc = CreateEnhMetaFileA(referenceHdc, fileBuffer, frameRect, NULL);
        }
    }
    return metafileHdc;
}

static BOOL
GetFrameRectInMM100Units(
    HDC                 hdc,
    const GpRectF *     frameRect,
    MetafileFrameUnit   frameUnit,
    RECT &              rclFrame
    )
{
    SIZEL   szlDevice;              // Size of device in pels
    SIZEL   szlMillimeters;         // Size of device in millimeters
    REAL    dpiX;
    REAL    dpiY;

    // NOTE: We have to use the szlDevice and szlMillimeters to get
    // the dpi (instead of getting it directly from LOGPIXELSX/Y)
    // so that the frame rect that is calculated for the metafile by GDI
    // matches the one that GDI+ would have calculated.  Because it's
    // these 2 metrics that the GDI metafile code uses to get the frame
    // rect from the bounds, not the logical DPI.

    szlDevice.cx      = ::GetDeviceCaps(hdc, HORZRES);
    szlDevice.cy      = ::GetDeviceCaps(hdc, VERTRES);
    szlMillimeters.cx = ::GetDeviceCaps(hdc, HORZSIZE);
    szlMillimeters.cy = ::GetDeviceCaps(hdc, VERTSIZE);

    if ((szlDevice.cx <= 0) || (szlDevice.cy <= 0) ||
        (szlMillimeters.cx <= 0) || (szlMillimeters.cy <= 0))
    {
        WARNING(("GetDeviceCaps failed"));
        return FALSE;
    }

    // Now get the real DPI, adjusted for the round-off error.
    dpiX = ((REAL)(szlDevice.cx) / (REAL)(szlMillimeters.cx)) * 25.4f;
    dpiY = ((REAL)(szlDevice.cy) / (REAL)(szlMillimeters.cy)) * 25.4f;

    GpRectF     frameRectMM100;

    FrameToMM100(frameRect, (GpPageUnit)frameUnit, frameRectMM100,
                 dpiX, dpiY);

    rclFrame.left   = GpRound(frameRectMM100.X);
    rclFrame.top    = GpRound(frameRectMM100.Y);
    rclFrame.right  = GpRound(frameRectMM100.GetRight());
    rclFrame.bottom = GpRound(frameRectMM100.GetBottom());
    
    // Make sure the .01MM frameRect is valid
    // It's okay for left == right, because the frameRect
    // is inclusive-inclusive.
    if ((rclFrame.left > rclFrame.right) ||
        (rclFrame.top  > rclFrame.bottom))
    {
        WARNING(("Invalid GDI frameRect"));
        return FALSE;
    }

    return TRUE;
}

/**************************************************************************\
*
* Function Description:
*
*   Convert a frameRect in any units, to a frame rect that is in .01 MM units.
*
* Arguments:
*
*   [IN]  frameRect      - the source frameRect
*   [IN]  frameUnit      - the units of the source frameRect
*   [OUT] frameRectMM100 - the frameRect in inch units
*   [IN]  dpiX           - the horizontal DPI
*   [IN]  dpiY           - the vertical   DPI
*
* Return Value:
*
*   NONE
*
* Created:
*
*   6/15/1999 DCurtis
*
\**************************************************************************/
static VOID
FrameToMM100(
    const GpRectF *         frameRect,
    GpPageUnit              frameUnit,
    GpRectF &               frameRectMM100,
    REAL                    dpiX,               // only used for pixel case
    REAL                    dpiY
    )
{
    REAL        pixelsToMM100X   = (2540.0f / dpiX);
    REAL        pixelsToMM100Y   = (2540.0f / dpiY);

    // The GDI frameRect has right and bottom values that are
    // inclusive, whereas the GDI+ frameRect has GetRight() and
    // GetBottom() values that are exclusive (because GDI+ rects
    // are specified with width/height, not right/bottom.  To convert
    // from the GDI+ value to the GDI value, we have to subtract 1 pixel.
    // This means that we first convert the units to pixel units, then 
    // subtract one, then convert to MM100 units.
    switch (frameUnit)
    {
    default:
        ASSERT(0);
        // FALLTHRU

    case UnitPixel:             // Each unit represents one device pixel.
        frameRectMM100.X      = frameRect->X * pixelsToMM100X;
        frameRectMM100.Y      = frameRect->Y * pixelsToMM100Y;
        frameRectMM100.Width  = frameRect->Width;
        frameRectMM100.Height = frameRect->Height;
        break;

    case UnitPoint:             // Each unit represents 1/72 inch.
        frameRectMM100.X      = frameRect->X * (2540.0f / 72.0f);
        frameRectMM100.Y      = frameRect->Y * (2540.0f / 72.0f);
        frameRectMM100.Width  = frameRect->Width  * (dpiX / 72.0f);
        frameRectMM100.Height = frameRect->Height * (dpiY / 72.0f);
        break;

    case UnitInch:              // Each unit represents 1 inch.
        frameRectMM100.X      = frameRect->X * 2540.0f;
        frameRectMM100.Y      = frameRect->Y * 2540.0f;
        frameRectMM100.Width  = frameRect->Width  * dpiX;
        frameRectMM100.Height = frameRect->Height * dpiY;
        break;

    case UnitDocument:          // Each unit represents 1/300 inch.
        frameRectMM100.X      = frameRect->X * (2540.0f / 300.0f);
        frameRectMM100.Y      = frameRect->Y * (2540.0f / 300.0f);
        frameRectMM100.Width  = frameRect->Width  * (dpiX / 300.0f);
        frameRectMM100.Height = frameRect->Height * (dpiY / 300.0f);
        break;

    case UnitMillimeter:        // Each unit represents 1 millimeter.
                                // One Millimeter is 0.03937 inches
                                // One Inch is 25.4 millimeters
        frameRectMM100.X      = frameRect->X * (100.0f);
        frameRectMM100.Y      = frameRect->Y * (100.0f);
        frameRectMM100.Width  = frameRect->Width  * (dpiX / 25.4f);
        frameRectMM100.Height = frameRect->Height * (dpiY / 25.4f);
        break;
    }
    frameRectMM100.Width  = (frameRectMM100.Width  - 1.0f) * pixelsToMM100X;
    frameRectMM100.Height = (frameRectMM100.Height - 1.0f) * pixelsToMM100Y;
}

BOOL
GpMetafile::InitForRecording(
    HDC                 referenceHdc,
    EmfType             type,
    const GpRectF *     frameRect,      // can be NULL
    MetafileFrameUnit   frameUnit,      // if NULL frameRect, doesn't matter
    const WCHAR *       description     // can be NULL
    )
{
    RECT *  frameRectParam = NULL;
    RECT    rclFrame;

    if (frameRect != NULL)
    {
        // Validate the frameRect
        // 0 is allowed, since the frameRect is inclusive-inclusive, which
        // means that a width of 0 is actually a width of 1
        if ((frameRect->Width < 0.0f) || (frameRect->Height < 0.0f))
        {
            WARNING(("Invalid frameRect"));
            return FALSE;
        }

        if (frameUnit == MetafileFrameUnitGdi)
        {
            // Typically, the GDI+ frameRect is inclusive/exclusive
            // as far as the GetLeft()/GetRight() values go, but the
            // MetafileFrameUnitGdi unit is a special type of unit
            // that specifies compatibility with GDI which is
            // inclusive/inclusive, so we don't do any adjustment
            // on those values at all -- we just assume they are ready
            // to pass directly to GDI.
            rclFrame.left   = GpRound(frameRect->X);
            rclFrame.top    = GpRound(frameRect->Y);
            rclFrame.right  = GpRound(frameRect->GetRight());
            rclFrame.bottom = GpRound(frameRect->GetBottom());

            // Make sure the .01MM frameRect is valid
            // It's okay for left == right, because the GDI frameRect
            // is inclusive-inclusive.
            if ((rclFrame.left > rclFrame.right) ||
                (rclFrame.top  > rclFrame.bottom))
            {
                WARNING(("Invalid GDI frameRect"));
                return FALSE;
            }
        }
        else
        {
            if (!GetFrameRectInMM100Units(referenceHdc, frameRect, frameUnit, rclFrame))
            {
                return FALSE;
            }
        }

        frameRectParam = &rclFrame;
    }
    
    HDC     metafileHdc;

    // Now create the metafile HDC
    // Note that FileName might be NULL
    metafileHdc = CreateEmf(referenceHdc, Filename, frameRectParam);
    if (metafileHdc == NULL)
    {
        return FALSE;       // failed
    }

    // Now get the dpi based on the metafileHdc (which could be different
    // than the referenceHdc).
    
    SIZEL   szlDevice;              // Size of metafile device in pels
    SIZEL   szlMillimeters;         // Size of metafile device in millimeters
    GpRectF metafileBounds;
    
    // NOTE: We have to use the szlDevice and szlMillimeters to get
    // the dpi (instead of getting it directly from LOGPIXELSX/Y)
    // so that the frame rect that is calculated for the metafile by GDI
    // matches the one that GDI+ would have calculated.  Because it's
    // these 2 metrics that the GDI metafile code uses to get the frame
    // rect from the bounds, not the logical DPI.

    szlDevice.cx      = ::GetDeviceCaps(metafileHdc, HORZRES);
    szlDevice.cy      = ::GetDeviceCaps(metafileHdc, VERTRES);
    szlMillimeters.cx = ::GetDeviceCaps(metafileHdc, HORZSIZE);
    szlMillimeters.cy = ::GetDeviceCaps(metafileHdc, VERTSIZE);

    if ((szlDevice.cx <= 0) || (szlDevice.cy <= 0) ||
        (szlMillimeters.cx <= 0) || (szlMillimeters.cy <= 0))
    {
        WARNING(("GetDeviceCaps failed"));
        goto ErrorExit;
    }

    REAL    dpiX;
    REAL    dpiY;
    REAL    dpmmX = (REAL)(szlDevice.cx) / (REAL)(szlMillimeters.cx);
    REAL    dpmmY = (REAL)(szlDevice.cy) / (REAL)(szlMillimeters.cy);

    // Now get the real DPI, adjusted for the round-off error.
    dpiX = dpmmX * 25.4f;
    dpiY = dpmmY * 25.4f;

    // Set the DPI in the metafile
    this->Header.DpiX = dpiX;
    this->Header.DpiY = dpiY;

    // NOTE: On Win9x there are some hi-res printer drivers that use a
    // different resolution for the metafileHdc than they do for the 
    // referenceHdc (Probably to avoid overflow.)  The problem with that 
    // is, that the differing resolutions make it impossible for us to 
    // know which frameRect to use, because we don't know for certain 
    // what DPI the application is going to assume to do its drawing -- 
    // whether the metafile resolution or the printer resolution.  In any
    // case, it's a safe bet that the original frameRect is wrong.

    if (!Globals::IsNt && (frameRectParam != NULL) &&
        (::GetDeviceCaps(metafileHdc, LOGPIXELSX) != ::GetDeviceCaps(referenceHdc, LOGPIXELSX)))
    {
        frameRectParam = NULL;  // give up on the frameRect

        // Now recreate the metafile HDC
        ::DeleteEnhMetaFile(::CloseEnhMetaFile(metafileHdc));
        metafileHdc = CreateEmf(referenceHdc, Filename, frameRectParam);
        if (metafileHdc == NULL)
        {
            return FALSE;       // failed
        }
    }

    // The metafileBounds are used as the bounds for FillRegion
    // calls when the region has infinite bounds, to keep from
    // exploding the bounds of the metafile.
    if (frameRectParam != NULL)
    {

        dpmmX *= 0.01f;
        dpmmY *= 0.01f;

        metafileBounds.X      = rclFrame.left * dpmmX;
        metafileBounds.Y      = rclFrame.top  * dpmmY;
        metafileBounds.Width  = (rclFrame.right  - rclFrame.left) * dpmmX;
        metafileBounds.Height = (rclFrame.bottom - rclFrame.top)  * dpmmY;
    }
    else
    {
        metafileBounds.X      = 0.0f;
        metafileBounds.Y      = 0.0f;
        metafileBounds.Width  = (REAL)szlDevice.cx - 1; // metafile bounds are inclusive
        metafileBounds.Height = (REAL)szlDevice.cy - 1;
    }

    // Now create the recorder object
    MetafileRecorder *  recorder = new MetafileRecorder(
                                        this,
                                        type,
                                        metafileHdc,
                                        (frameRectParam != NULL),
                                        szlMillimeters,
                                        metafileBounds);
    if (CheckValid(recorder))
    {
        MetaGraphics = GpGraphics::GetForMetafile(recorder, type, metafileHdc);
        if (MetaGraphics != NULL)
        {
            if (MetaGraphics->IsValid())
            {
                return TRUE;
            }
            recorder->SetValid(FALSE);// so we don't record stuff in EndRecording
            delete MetaGraphics;    // calls EndRecording which deletes recorder
            MetaGraphics = NULL;
        }
        else
        {
            delete recorder;
        }
    }
ErrorExit:
    DeleteEnhMetaFile(CloseEnhMetaFile(metafileHdc));
    return FALSE;
}

// Returns NULL if the metafile was opened for reading or if already got
// the context for writing.
GpGraphics *
GpMetafile::GetGraphicsContext()
{
    if (!RequestedMetaGraphics)
    {
        RequestedMetaGraphics = TRUE;
        return MetaGraphics;
    }
    WARNING(("Requesting MetaGraphics more than once"));
    return NULL;
}

GpStatus 
GpMetafile::SetDownLevelRasterizationLimit(
    UINT                    metafileRasterizationLimitDpi
    )
{
    ASSERT(IsValid());
    // 0 means restore it to the default value; otherwise, the minumum is 10 dpi
    if ((metafileRasterizationLimitDpi == 0) || (metafileRasterizationLimitDpi >= 10))
    {
        if ((State == GpMetafile::RecordingMetafileState) &&
            (MetaGraphics != NULL))
        {
            MetaGraphics->Context->SetMetafileDownLevelRasterizationLimit(metafileRasterizationLimitDpi);
            return Ok;
        }
        WARNING1("Metafile in Wrong State for this operation");
        return WrongState;
    }
    WARNING1("rasterizationDpiLimit is non-zero but too small");
    return InvalidParameter;
}

GpStatus 
GpMetafile::GetDownLevelRasterizationLimit(
    UINT *                  metafileRasterizationLimitDpi
    ) const
{
    ASSERT(metafileRasterizationLimitDpi != NULL);
    ASSERT(IsValid());
    if ((State == GpMetafile::RecordingMetafileState) &&
        (MetaGraphics != NULL))
    {
        *metafileRasterizationLimitDpi = MetaGraphics->Context->GetMetafileDownLevelRasterizationLimit();
        return Ok;
    }
    WARNING1("Metafile in Wrong State for this operation");
    return WrongState;
}