windows-server-2003/windows/core/ntgdi/client/mfrec.hxx

/*************************************************************************\
* Module Name: mfrec.hxx
*
* This file contains the definitions for the metafile record classes.
*
* Note that we do not use constructors in the record classes because they
* do not have return codes.
*
* Every record class has an init function which initializes the data
* structure.  The commit function emits the record to the metafile.
*
* Created: 12-June-1991 13:46:00
* Author: Hock San Lee [hockl]
*
* Copyright (c) 1991-1999 Microsoft Corporation
\*************************************************************************/

#include "nt.h"
#include "ntrtl.h"
#include "nturtl.h"
#define STRSAFE_NO_DEPRECATE
#include "strsafe.h"

extern RECTL rclNull;           // METAFILE.CXX

extern "C" int GetDeviceCapsP(HDC hdc,int iCap);

// Size of a padded character element in structure.

#define PADCHAR_SIZE    4

/*********************************Class************************************\
* class MR
*
* Header for metafile records.
*
* History:
*  Wed Jul 17 17:10:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MR        /* mr */
{
protected:
    DWORD   iType;      // Record type EMR_.
    DWORD   nSize;      // Record size in bytes.  Set in MDC::pvNewRecord.

public:
// vInit -- Initializer.

    VOID vInit(DWORD iType1)    { iType = iType1; }

// vCommit -- Commit the record to metafile.

    VOID vCommit(PMDC pmdc)
    {
        pmdc->vCommit(*(PENHMETARECORD) this);
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht)
    {
        USE(hdc);
        USE(pht);
        USE(cht);

        #if DBG
        DbgPrint("MR::bPlay: don't know how to play record 0x%lx : Size 0x%lx\n",iType,nSize);
        DbgBreakPoint();
        #endif

        return(FALSE);
    };

// bValidOff -- Check if the offset passed is within the metafile bounds.

    BOOL bValidOff(PHANDLETABLE pht, DWORD Off)
    {
        PMF pmf;

        if (Off >= nSize)
            return(FALSE);

        if (!(pmf = GET_PMF((HENHMETAFILE)pht->objectHandle[0])))
            return(FALSE);

        if (!pmf->bValidBoundedSize((PVOID)this,Off))
            return(FALSE);

        return TRUE;
    }

//
// bValidSize -- Check if the size (which is converted to an offset) is valid
//               within the meta file bounds.

    BOOL bValidSize(PHANDLETABLE pht, DWORD Size)
    {
        if (Size & 3)
        {
            EMFVALFAIL(("MR::bValidSize failed %08x (misaligned)\n", Size));
            return(FALSE);
        }

        if (Size - 1 < Size)
            return bValidOff(pht,Size-1);
        EMFVALFAIL(("MR::bValidSize failed %08x\n", Size));
        return(FALSE);
    }

//
// bValidOffExt -- Check if the offset and extent following the offset is
//                 within the metafile bounds.

    BOOL bValidOffExt(PHANDLETABLE pht, DWORD Off, DWORD Ext)
    {
        if (bValidOff(pht, Off))
        {
            if (Ext == 0)
                return(TRUE);

            // Make sure no arithmetic over/underflows happen.
            if ((Ext - 1 < Ext) && (Off + Ext > Off))
            {
                DWORD OffExt = Off + Ext - 1;
                if (bValidOff(pht, OffExt))
                    return(TRUE);
            }
        }
        EMFVALFAIL(("MR::bValidOffExt (%08x, %08x) failed\n", Off, Ext));
        return(FALSE);
    }

// bCheckRecord -- Check and make sure record is fine.

    BOOL bCheckRecord(PHANDLETABLE pht);

// vMarkFoundBad -- Mark the metafile that there are bad/malformed records.

    void vMarkFoundBad(PHANDLETABLE pht)
    {
       PMF pmf;

       if (pmf = GET_PMF((HENHMETAFILE)pht->objectHandle[0]))
       {
           pmf->fl |= MF_FOUNDBAD;
       }
       else
       {
           EMFVALFAIL(("MR::vMarkFoundBad PMF is null for pht (%p)\n", pht));
       }
    }
};

typedef MR *PMR;
#define SIZEOF_MR       (sizeof(MR))

inline BOOL MR::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MR == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MR::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRB : public MR
*
* Header with bounds for metafile records.
*
* History:
*  Wed Jul 17 17:10:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRB : public MR           /* mrb */
{
protected:
    ERECTL      erclBounds;     // Inclusive-inclusive bounds in device units

public:
// Initializer -- Initialize the bounded record.
// Flush previous bounds to prepare for bounds accumulation for this record.

    VOID vInit(DWORD iType, PMDC pmdc)
    {
        pmdc->vFlushBounds();
        MR::vInit(iType);
    }

// vCommit -- Commit the record to metafile.
// Postpone the commitment to the next pvNewRecord
// since we do not have the bounds before the call is made.  Note that
// if this is the last record, it will be committed by the MREOF record.
// It works both inside and outside a path bracket.

    VOID vCommit(PMDC pmdc)
    {
        pmdc->vDelayCommit();
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRB *PMRB;
#define SIZEOF_MRB      (sizeof(MRB))

inline BOOL MRB::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRB == nSize && bValidSize(pht,nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRB::bCheckRecord() failed\n"));
    return(FALSE);
}
/*********************************Class************************************\
* class MRD : public MR
*
* Metafile record with one DWORD.
*
* History:
*  Wed Jul 31 21:09:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRD : public MR           /* mrd */
{
protected:
    DWORD       d1;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(DWORD iType_, DWORD d1_)
    {
        MR::vInit(iType_);
        d1 = d1_;
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRD *PMRD;
#define SIZEOF_MRD      (sizeof(MRD))

inline BOOL MRD::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRD == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRD::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRDD : public MR
*
* Metafile record with two DWORDs.
*
* History:
*  Wed Jul 17 17:10:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRDD : public MR          /* mrdd */
{
protected:
    DWORD       d1;
    DWORD       d2;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(DWORD iType_, DWORD d1_, DWORD d2_)
    {
        MR::vInit(iType_);
        d1 = d1_;
        d2 = d2_;
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRDD *PMRDD;
#define SIZEOF_MRDD     (sizeof(MRDD))

inline BOOL MRDD::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRDD == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRDD::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRDDDD : public MR
*
* Metafile record with four DWORDs.
*
* History:
*  Wed Jul 31 21:09:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRDDDD : public MR        /* mrdddd */
{
protected:
    DWORD       d1;
    DWORD       d2;
    DWORD       d3;
    DWORD       d4;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(DWORD iType_, DWORD d1_, DWORD d2_, DWORD d3_, DWORD d4_)
    {
        MR::vInit(iType_);
        d1 = d1_;
        d2 = d2_;
        d3 = d3_;
        d4 = d4_;
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRDDDD *PMRDDDD;
#define SIZEOF_MRDDDD   (sizeof(MRDDDD))

inline BOOL MRDDDD::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRDDDD == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRDDDD::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRX : public MR
*
* Metafile record with a XFORM.
*
* History:
*  Wed Jul 31 21:09:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRX : public MR           /* mrx */
{
protected:
    XFORM       xform;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(DWORD iType_, CONST XFORM& xform_)
    {
        MR::vInit(iType_);
        xform = xform_;
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRX *PMRX;
#define SIZEOF_MRX      (sizeof(MRX))

inline BOOL MRX::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRX == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRX::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRXD : public MRX
*
* Metafile record with a XFORM followed by a DWORD.
*
* History:
*  Wed Jul 31 21:09:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRXD : public MRX         /* mrxd */
{
protected:
    DWORD       d1;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(DWORD iType_, CONST XFORM& xform_, DWORD d1_)
    {
        MRX::vInit(iType_, xform_);
        d1 = d1_;
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRXD *PMRXD;
#define SIZEOF_MRXD     (sizeof(MRXD))

inline BOOL MRXD::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRXD == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRXD::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRBP : public MRB
*
* Metafile record with Bounds and Polys.
*
* History:
*  Wed Jul 17 17:10:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBP : public MRB         /* mrbp */
{
protected:
    DWORD       cptl;           // Number of points in the array.
    POINTL      aptl[1];        // Array of POINTL structures.

public:
// Initializer -- Initialize the metafile Poly(To) record.

    VOID vInit(DWORD iType1, DWORD cptl1, CONST POINTL *aptl1, PMDC pmdc); // MFREC.CXX

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRBP *PMRBP;
#define SIZEOF_MRBP(cptl)  (sizeof(MRBP)-sizeof(POINTL)+(cptl)*sizeof(POINTL))

inline BOOL MRBP::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRBP(cptl) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRBP::bCheckRecord(%08x) failed\n", cptl));
    return(FALSE);
}
/*********************************Class************************************\
* class MRBP16 : public MRB
*
* Metafile record with Bounds and 16-bit Polys.
*
* History:
*  Sat Mar 07 15:06:16 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBP16 : public MRB               /* mrbp16 */
{
protected:
    DWORD       cpts;           // Number of points in the array.
    POINTS      apts[1];        // Array of POINTS structures.

public:
// Initializer -- Initialize the metafile Poly(To)16 record.

    VOID vInit(DWORD iType1, DWORD cptl1, CONST POINTL *aptl1, PMDC pmdc); // MFREC.CXX

// bPlay -- Play the records PolyBezier, Polygon, Polyline, PolyBezierTo and
// PolylineTo.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRBP16 *PMRBP16;
#define SIZEOF_MRBP16(cpts)     \
        (sizeof(MRBP16)-sizeof(POINTS)+(cpts)*sizeof(POINTS))

inline BOOL MRBP16::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRBP16(cpts) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRBP16::bCheckRecord(%08x) failed\n", cpts));
    return(FALSE);
}
/*********************************Class************************************\
* class MRBPP : public MRB
*
* Metafile record with Bounds and PolyPolys.
*
* History:
*  Wed Jul 17 17:10:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBPP : public MRB                /* mrbpp */
{
protected:
    DWORD       cPoly;      // Number of entries in the ac array.
    DWORD       cptl;       // Number of points in the aptl array.
    DWORD       ac[1];      // Array of number of points for each poly in aptl.
    POINTL      aptl[1];    // Array of POINTL for vertices in all polys.

public:
// Initializer -- Initialize the metafile PolyPoly record.

    VOID vInit
    (
        DWORD       iType1,
        DWORD       cPoly1,
        DWORD       cptl1,
        CONST DWORD     *ac1,
        CONST POINTL    *aptl1,
        PMDC        pmdc
    );                                  // MFREC.CXX

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRBPP *PMRBPP;
#define SIZEOF_MRBPP(cptl,cPoly)                        \
        (sizeof(MRBPP)-sizeof(POINTL)-sizeof(DWORD)     \
        +(cptl)*sizeof(POINTL)+(cPoly)*sizeof(DWORD))

inline BOOL MRBPP::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRBPP(cptl,cPoly) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRBPP::bCheckRecord(%08x,%08x) failed\n", cptl,cPoly));
    return(FALSE);
}
/*********************************Class************************************\
* class MRBPP16 : public MRB
*
* Metafile record with Bounds and 16-bit PolyPolys.
*
* History:
*  Sat Mar 07 15:06:16 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBPP16 : public MRB              /* mrbpp16 */
{
protected:
    DWORD       cPoly;      // Number of entries in the ac array.
    DWORD       cpts;       // Number of points in the apts array.
    DWORD       ac[1];      // Array of number of points for each poly in apts.
    POINTS      apts[1];    // Array of POINTS for vertices in all polys.

public:
// Initializer -- Initialize the metafile PolyPoly16 record.

    VOID vInit
    (
        DWORD       iType1,
        DWORD       cPoly1,
        DWORD       cptl1,
        CONST DWORD     *ac1,
        CONST POINTL    *aptl1,
        PMDC        pmdc
    );                                  // MFREC.CXX

// bPlay -- Play the records PolyPolyline, PolyPolygon.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRBPP16 *PMRBPP16;
#define SIZEOF_MRBPP16(cpts,cPoly)                      \
        (sizeof(MRBPP16)-sizeof(POINTS)-sizeof(DWORD)   \
        +(cpts)*sizeof(POINTS)+(cPoly)*sizeof(DWORD))

inline BOOL MRBPP16::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRBPP16(cpts,cPoly) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRBPP16::bCheckRecord(%08x,%08x) failed\n",cpts,cPoly));
    return(FALSE);
}

/*********************************Class************************************\
* class MRPOLYDRAW : public MRB
*
* POLYDRAW record.
*
* History:
*  Thu Oct 17 13:47:39 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRPOLYDRAW : public MRB   /* mrpd */
{
protected:
    DWORD       cptl;           // Number of points in the array.
    POINTL      aptl[1];        // Array of POINTL structures.
    BYTE        ab[1];          // Array of point types.

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(PMDC pmdc, CONST POINTL *aptl1, CONST BYTE *ab1, DWORD cptl1); // MFREC.CXX

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRPOLYDRAW *PMRPOLYDRAW;
#define SIZEOF_MRPOLYDRAW(cptl)                                 \
        ((sizeof(MRPOLYDRAW)-sizeof(POINTL)-PADCHAR_SIZE        \
         +(cptl)*(sizeof(POINTL)+sizeof(BYTE))                  \
         +3) / 4 * 4)

inline BOOL MRPOLYDRAW::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRPOLYDRAW(cptl) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRPOLYDRAW::bCheckRecord(%08x) failed\n", cptl));
    return(FALSE);
}

/*********************************Class************************************\
* class MRPOLYDRAW16 : public MRB
*
* POLYDRAW16 record.
*
* History:
*  Sat Mar 07 15:06:16 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRPOLYDRAW16 : public MRB /* mrpd16 */
{
protected:
    DWORD       cpts;           // Number of points in the array.
    POINTS      apts[1];        // Array of POINTS structures.
    BYTE        ab[1];          // Array of point types.

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(PMDC pmdc, CONST POINTL *aptl1, CONST BYTE *ab1, DWORD cptl1); // MFREC.CXX

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRPOLYDRAW16 *PMRPOLYDRAW16;
#define SIZEOF_MRPOLYDRAW16(cpts)                               \
        ((sizeof(MRPOLYDRAW16)-sizeof(POINTS)-PADCHAR_SIZE      \
         +(cpts)*(sizeof(POINTS)+sizeof(BYTE))                  \
         +3) / 4 * 4)

inline BOOL MRPOLYDRAW16::bCheckRecord(PHANDLETABLE pht)
{
    if(SIZEOF_MRPOLYDRAW16(cpts) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRPOLYDRAW16::bCheckRecord(%08x) failed\n", cpts));
    return(FALSE);
}

/*********************************Class************************************\
* class MRE : public MR
*
* Metafile record for ellipses and rectangles.
*
* History:
*  Fri Sep 27 15:55:57 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRE : public MR   /* mre */
{
protected:
    ERECTL      erclBox;        // Inclusive-inclusive box in world units

public:
// Initializer -- Initialize the metafile record.
// Returns MRI_OK if successful, MRI_ERROR if error and MRI_NULLBOX if
// the box is empty in device space.  We don't record if there is an error
// or the box is empty in device space.

    LONG iInit(DWORD iType, HDC hdc, LONG x1, LONG y1, LONG x2, LONG y2)
    {
        MR::vInit(iType);
        erclBox.vInit(x1, y1, x2, y2);

        LONG lRet = MRI_OK;

        // Make inclusive-exclusive box inclusive-inclusive if necessary.
        // Record it only if the box is not empty.

        if (GetGraphicsMode(hdc) == GM_COMPATIBLE)
        {
            lRet = NtGdiConvertMetafileRect(hdc, &erclBox);
        }

        return(lRet);
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRE *PMRE;
#define SIZEOF_MRE      (sizeof(MRE))

inline BOOL MRE::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRE == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRE::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MREPP : public MRE
*
* Metafile record for arcs, chords and pies.
*
* History:
*  Fri Sep 27 15:55:57 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MREPP : public MRE        /* mrepp */
{
protected:
    EPOINTL     eptlStart;
    EPOINTL     eptlEnd;

public:
// Initializer -- Initialize the metafile record.
// Returns MRI_OK if successful, MRI_ERROR if error and MRI_NULLBOX if
// the box is empty in device space.  We don't record if there is an error
// or the box is empty in device space.

    LONG iInit
    (
        DWORD iType,
        HDC   hdc,
        LONG  x1,
        LONG  y1,
        LONG  x2,
        LONG  y2,
        LONG  x3,
        LONG  y3,
        LONG  x4,
        LONG  y4
    )
    {
        eptlStart.vInit(x3,y3);
        eptlEnd.vInit(x4,y4);

        return(MRE::iInit(iType, hdc, x1, y1, x2, y2));
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MREPP *PMREPP;
#define SIZEOF_MREPP    (sizeof(MREPP))

inline BOOL MREPP::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MREPP == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MREPP::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRBR : public MRB
*
* Metafile record with a region.  The region data starts at offRgnData
* from the beginning of the record.
*
* History:
*  Tue Oct 29 10:43:25 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBR : public MRB         /* mrbr */
{
protected:
    DWORD       cRgnData;       // Size of region data in bytes.

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        DWORD   iType,
        PMDC    pmdc,
        HRGN    hrgn,
        DWORD   cRgnData_,
        DWORD   offRgnData_
    )
    {
        PUTS("MRBR::bInit\n");

        ASSERTGDI(cRgnData_, "MRBR::bInit: cRgnData_ is zero");
        ASSERTGDI(offRgnData_ % 4 == 0,
            "MRBR::bInit: offRgnData_ is not dword aligned");

        MRB::vInit(iType, pmdc);
        cRgnData   = cRgnData_;
        return
        (
            GetRegionData
            (
                hrgn,
                cRgnData_,
                (LPRGNDATA) &((PBYTE) this)[offRgnData_]
            ) == cRgnData_
        );
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRBR *PMRBR;
#define SIZEOF_MRBR(cRgnData)   (sizeof(MRBR) + ((cRgnData) + 3) / 4 * 4)

inline BOOL MRBR::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRBR(cRgnData) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRBR::bCheckRecord(%08x) failed\n", cRgnData));
    return(FALSE);
}

class MRINVERTRGN : public MRBR /* mrir */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRINVERTRGN *PMRINVERTRGN;

class MRPAINTRGN : public MRBR  /* mrpr */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPAINTRGN *PMRPAINTRGN;

/*********************************Class************************************\
* class MRFILLRGN : public MRBR
*
* FILLRGN record.
*
* History:
*  Tue Oct 29 10:43:25 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRFILLRGN : public MRBR           /* mrfr */
{
protected:
    DWORD       imheBrush;      // Brush index in Metafile Handle Table.

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit(PMDC pmdc, HRGN hrgn, DWORD cRgnData, DWORD imheBrush_)
    {
        PUTS("MRFILLRGN::bInit\n");

        ASSERTGDI(imheBrush_, "MRFILLRGN::bInit: imheBrush_ is zero");

        imheBrush = imheBrush_;
        return(MRBR::bInit(EMR_FILLRGN, pmdc, hrgn, cRgnData, sizeof(MRFILLRGN)));
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRFILLRGN *PMRFILLRGN;
#define SIZEOF_MRFILLRGN(cRgnData)      \
        (SIZEOF_MRBR(cRgnData) + sizeof(MRFILLRGN) - sizeof(MRBR))

inline BOOL MRFILLRGN::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRFILLRGN(cRgnData) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRFILLRGN::bCheckRecord(%08x) failed\n", cRgnData));
    return(FALSE);
}

/*********************************Class************************************\
* class MRFRAMERGN : public MRBR
*
* FRAMERGN record.
*
* History:
*  Tue Oct 29 10:43:25 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRFRAMERGN : public MRBR          /* mrfr */
{
protected:
    DWORD       imheBrush;      // Brush index in Metafile Handle Table.
    LONG        nWidth;         // Width of vert brush stroke in logical units.
    LONG        nHeight;        // Height of horz brush stroke in logical units.

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        PMDC  pmdc,
        HRGN  hrgn,
        DWORD cRgnData,
        DWORD imheBrush_,
        LONG  nWidth_,
        LONG  nHeight_
    )
    {
        PUTS("MRFRAMERGN::bInit\n");

        ASSERTGDI(imheBrush_, "MRFRAMERGN::bInit: imheBrush_ is zero");

        imheBrush = imheBrush_;
        nWidth    = nWidth_;
        nHeight   = nHeight_;
        return(MRBR::bInit(EMR_FRAMERGN, pmdc, hrgn, cRgnData, sizeof(MRFRAMERGN)));
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRFRAMERGN *PMRFRAMERGN;
#define SIZEOF_MRFRAMERGN(cRgnData)     \
        (SIZEOF_MRBR(cRgnData) + sizeof(MRFRAMERGN) - sizeof(MRBR))

inline BOOL MRFRAMERGN::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRFRAMERGN(cRgnData) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRFRAMERGN::bCheckRecord(%08x) failed\n",cRgnData));
    return(FALSE);
}

/*********************************Class************************************\
* class MREXTSELECTCLIPRGN : public MR
*
* EXTSELECTCLIPRGN record.  The region data follows iMode immediately.
*
* History:
*  Tue Oct 29 10:43:25 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MREXTSELECTCLIPRGN : public MR    /* mrescr */
{
protected:
    DWORD       cRgnData;       // Size of region data in bytes.
    DWORD       iMode;          // Region combine mode.

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit(HRGN hrgn, DWORD cRgnData_, DWORD iMode_)
    {
        PUTS("MREXTSELECTCLIPRGN::bInit\n");

        MR::vInit(EMR_EXTSELECTCLIPRGN);
        cRgnData   = cRgnData_;
        iMode = iMode_;

        // There is no region data if hrgn == 0 && iMode == RGNCOPY.

        if (!cRgnData_)
        {
            ASSERTGDI(iMode_ == RGN_COPY,
                "MREXTSELECTCLIPRGN::bInit: cRgnData_ is zero");
            return(TRUE);
        }
        else
        {

            return
            (
                GetRegionData
                (
                    hrgn,
                    cRgnData_,
                    (LPRGNDATA) &((PBYTE) this)[sizeof(MREXTSELECTCLIPRGN)]
                ) == cRgnData_
            );
        }
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MREXTSELECTCLIPRGN *PMREXTSELECTCLIPRGN;
#define SIZEOF_MREXTSELECTCLIPRGN(cRgnData)     \
        (sizeof(MREXTSELECTCLIPRGN) + ((cRgnData) + 3) / 4 * 4)

inline BOOL MREXTSELECTCLIPRGN::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MREXTSELECTCLIPRGN(cRgnData) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MREXTSELECTCLIPRGN::bCheckRecord(%08x) failed\n", cRgnData));
    return(FALSE);
}

/*********************************Class************************************\
* class MRTM : public MRB
*
* Metafile record with verticies and triangle mesh
*
* History:
*
*    12/3/1996 Mark Enstrom [marke]
*
\**************************************************************************/

class MRGRADIENTFILL : public MRB         /* mrbp */
{
protected:
    DWORD       nVer;           // Number of points in vertex array
    DWORD       nTri;           // number of tri triples
    ULONG       ulMode;         // Draw Mode
    TRIVERTEX   Ver[1];         // Array of TRIVERTEX structures +
                                // array of (GRADIENT_TRIANGLE or GRADIENT_RECT)

public:
// Initializer -- Initialize the metafile Poly(To) record.

    VOID vInit(DWORD nVer1, CONST TRIVERTEX *pVer1, DWORD nTri1,CONST PVOID pTri1,ULONG ulMode,PMDC pmdc); // MFREC.CXX
    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRGRADIENTFILL *PMRGRADIENTFILL;
#define SIZEOF_MRGRADIENTFILL(nVer,nTri)  (                                                \
                                            sizeof(MRGRADIENTFILL)                         \
                                            - sizeof(TRIVERTEX) + (nVer)*sizeof(TRIVERTEX) \
                                            + ((((sizeof(GRADIENT_TRIANGLE) * nTri) + 3)/4)*4)    \
                                          )

inline BOOL MRGRADIENTFILL::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRGRADIENTFILL(nVer,nTri) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRGRADIENTFILL::bCheckRecord(%08x,%08x) failed\n", nVer,nTri));
    return(FALSE);
}

/*********************************Class************************************\
* class MRMETAFILE : public MR
*
* METAFILE record.  This is the first record in any metafile.
*
* History:
*  Wed Jul 17 17:10:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRMETAFILE : public MR            /* mrmf */
{
protected:
    ERECTL      erclBounds;     // Inclusive-inclusive bounds in device units
    RECTL       rclFrame;       // Inclusive-inclusive Picture Frame of metafile in .01 mm units
    DWORD       dSignature;     // Signature.  Must be ENHMETA_SIGNATURE.
    ULONG       nVersion;       // Version number
    DWORD       nBytes;         // Size of the metafile in bytes
    DWORD       nRecords;       // Number of records in the metafile
    WORD        nHandles;       // Number of handles in the handle table
                                // Handle index zero is reserved.
    WORD        sReserved;      // Reserved.  Must be zero.
    DWORD       nDescription;   // Number of chars in the unicode description string
                                // This is 0 if there is no description string
    DWORD       offDescription; // Offset to the metafile description record.
                                // This is 0 if there is no description string
    DWORD       nPalEntries;    // Number of entries in the metafile palette.
    SIZEL       szlDevice;      // Size of the reference device in pels
    SIZEL       szlMillimeters; // Size of the reference device in millimeters
    DWORD       cbPixelFormat;  // Size of PIXELFORMATDESCRIPTOR information
                                // This is 0 if no pixel format is set
    DWORD       offPixelFormat; // Offset to PIXELFORMATDESCRIPTOR
                                // This is 0 if no pixel format is set
    DWORD       bOpenGL;        // TRUE if OpenGL commands are present in
                                // the metafile, otherwise FALSE
    SIZEL       szlMicrometers; // size of the reference device in micrometers

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(HDC hdcRef, LPCWSTR pwszDescription1, UINT cwszDescription1)
    {
        PUTS("MRMETAFILE::vInit\n");

        MR::vInit(EMR_HEADER);
        erclBounds.vInit(rclNull);      // Bounds is updated in recording.
        rclFrame   = rclNull;           // Frame is set at the end if not set by caller
        dSignature = ENHMETA_SIGNATURE;
        nVersion   = META_FORMAT_ENHANCED;
        nBytes     = 0;                 // Update in recording.
        nRecords   = 0;                 // Update in recording.
        nHandles   = 1;                 // Update in recording.
                                        // Handle index zero is reserved.
        sReserved  = 0;
        if (pwszDescription1 != (LPWSTR) NULL)
        {
            offDescription = sizeof(MRMETAFILE);
            nDescription   = cwszDescription1;
            RtlCopyMemory
            (
                (PBYTE) this + offDescription,
                (PBYTE) pwszDescription1,
                cwszDescription1 * sizeof(WCHAR)
            );
        }
        else
        {
            offDescription = 0;
            nDescription   = 0;
        }
        nPalEntries       = 0;          // Update in CloseEnhMetaFile.
        szlDevice.cx      = GetDeviceCaps(hdcRef, DESKTOPHORZRES);
        szlDevice.cy      = GetDeviceCaps(hdcRef, DESKTOPVERTRES);
        szlMillimeters.cx = GetDeviceCaps(hdcRef, HORZSIZE);
        szlMillimeters.cy = GetDeviceCaps(hdcRef, VERTSIZE);

        // If there's a pixel format in the reference device then
        // it will be picked up and added later
        cbPixelFormat = 0;
        offPixelFormat = 0;

        bOpenGL = FALSE;

        szlMicrometers.cx = GetDeviceCapsP(hdcRef, HORZSIZEP);
        szlMicrometers.cy = GetDeviceCapsP(hdcRef, VERTSIZEP);
    }


// bValid -- Is this a valid record?

    BOOL bValid();

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRMETAFILE *PMRMETAFILE;
#define SIZEOF_MRMETAFILE(cwszDescription)              \
        (sizeof(MRMETAFILE) + (((cwszDescription) * 2) + 3) / 4 * 4)

inline BOOL MRMETAFILE::bCheckRecord(PHANDLETABLE pht)
{
    // Note we need to allow for WINVER less than 0x500 and 0x400 generated metafiles. 
    if (((SIZEOF_MRMETAFILE(nDescription) == nSize) ||
         ((SIZEOF_MRMETAFILE(nDescription) - (sizeof(MRMETAFILE) - offsetof(MRMETAFILE,szlMicrometers))) == nSize) ||
         ((SIZEOF_MRMETAFILE(nDescription) - (sizeof(MRMETAFILE) - offsetof(MRMETAFILE,cbPixelFormat))) == nSize))
        && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRMETAFILE::bCheckRecord(%08x) failed\n", nDescription));
    return(FALSE);
}

/*********************************Class************************************\
* class MRSETPIXELV : public MR
*
* SETPIXELV record.
*
* History:
*  Wed Jul 31 21:09:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRSETPIXELV : public MR   /* mrspv */
{
protected:
    EPOINTL     eptl;
    COLORREF    crColor;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(DWORD x1, DWORD y1, COLORREF crColor1)
    {
        PUTS("MRSETPIXELV::vInit\n");

        MR::vInit(EMR_SETPIXELV);
        eptl.vInit(x1,y1);
        crColor = crColor1;
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRSETPIXELV *PMRSETPIXELV;
#define SIZEOF_MRSETPIXELV      (sizeof(MRSETPIXELV))

inline BOOL MRSETPIXELV::bCheckRecord(PHANDLETABLE pht)
{
    if(SIZEOF_MRSETPIXELV == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRSETPIXELV::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRANGLEARC : public MR
*
* ANGLEARC record.
*
* History:
*  Fri Sep 13 17:46:41 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRANGLEARC : public MR    /* mraa */
{
protected:
    EPOINTL     eptl;
    DWORD       nRadius;
    FLOAT       eStartAngle;
    FLOAT       eSweepAngle;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        LONG x,
        LONG y,
        DWORD nRadius_,
        FLOAT eStartAngle_,
        FLOAT eSweepAngle_
    )
    {
        PUTS("MRANGLEARC::vInit\n");

        MR::vInit(EMR_ANGLEARC);
        eptl.vInit(x,y);
        nRadius     = nRadius_;
        eStartAngle = eStartAngle_;
        eSweepAngle = eSweepAngle_;
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRANGLEARC *PMRANGLEARC;
#define SIZEOF_MRANGLEARC       (sizeof(MRANGLEARC))

inline BOOL MRANGLEARC::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRANGLEARC == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRANGLEARC::bCheckRecord() failed\n"));
    return(FALSE);
}

class MRELLIPSE : public MRE    /* mre */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRELLIPSE *PMRELLIPSE;

class MRRECTANGLE : public MRE  /* mrr */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRRECTANGLE *PMRRECTANGLE;

/*********************************Class************************************\
* class MRROUNDRECT : public MRE
*
* ROUNDRECT record.
*
* History:
*  Fri Sep 27 15:55:57 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRROUNDRECT : public MRE  /* mrrr */
{
protected:
    SIZEL       szlEllipse;

public:
// Initializer -- Initialize the metafile record.
// Returns MRI_OK if successful, MRI_ERROR if error and MRI_NULLBOX if
// the box is empty in device space.  We don't record if there is an error
// or the box is empty in device space.

    LONG iInit(HDC hdc, LONG x1, LONG y1, LONG x2, LONG y2, LONG x3, LONG y3)
    {
        PUTS("MRROUNDRECT::iInit\n");

        szlEllipse.cx = x3;
        szlEllipse.cy = y3;

        return(MRE::iInit(EMR_ROUNDRECT, hdc, x1, y1, x2, y2));
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRROUNDRECT *PMRROUNDRECT;
#define SIZEOF_MRROUNDRECT      (sizeof(MRROUNDRECT))

inline BOOL MRROUNDRECT::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRROUNDRECT == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRROUNDRECT::bCheckRecord() failed\n"));
    return(FALSE);
}

class MRARC : public MREPP      /* mra */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRARC *PMRARC;

class MRARCTO : public MREPP    /* mrat */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRARCTO *PMRARCTO;

class MRCHORD : public MREPP    /* mrc */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRCHORD *PMRCHORD;

class MRPIE : public MREPP      /* mrp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPIE *PMRPIE;

/*********************************Class************************************\
* class MRCREATEPEN: public MR
*
* CREATEPEN record.
*
* History:
*  Wed Jul 31 21:09:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRCREATEPEN : public MR   /* mrcp */
{
protected:
    DWORD       imhe;                   // Pen index in Metafile Handle Table.
    LOGPEN      logpen;                 // Logical Pen.

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit(HANDLE hpen_, ULONG imhe_)
    {
        PUTS("MRCREATEPEN::bInit\n");

        MR::vInit(EMR_CREATEPEN);
        imhe = imhe_;
        return
        (
            GetObjectA(hpen_, (int) sizeof(LOGPEN), (LPVOID) &logpen)
            == (int) sizeof(LOGPEN)
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

// GetPenColor -- return the color

    COLORREF GetPenColor()
    {
        return logpen.lopnColor;
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRCREATEPEN *PMRCREATEPEN;
#define SIZEOF_MRCREATEPEN      (sizeof(MRCREATEPEN))

inline BOOL MRCREATEPEN::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRCREATEPEN == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRCREATEPEN::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MREXTCREATEPEN: public MR
*
* EXTCREATEPEN record.
*
* History:
*  Mon Mar 16 18:20:11 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/
typedef struct tagEXTLOGPEN32 {
    DWORD       elpPenStyle;
    DWORD       elpWidth;
    UINT        elpBrushStyle;
    COLORREF    elpColor;
    ULONG       elpHatch;
    DWORD       elpNumEntries;
    DWORD       elpStyleEntry[1];
} EXTLOGPEN32, *PEXTLOGPEN32;
class MREXTCREATEPEN : public MR        /* mrecp */
{
protected:
    DWORD       imhe;           // Ext pen index in Metafile Handle Table.
    DWORD       offBitsInfo;    // offset to brush bitmap info if any
    DWORD       cbBitsInfo;     // size of brush bitmap info if any
    DWORD       offBits;        // offset to brush bits if any
    DWORD       cbBits;         // size of brush bits buffer if any
    EXTLOGPEN32 elp;            // The extended pen with the style array.
                                // If elpBrushStyle specifies BS_PATTERN,
                                // it contains a monochrome brush.  If it
                                // is BS_DIBPATTERNPT, it is a DIB brush.
                                // The elpColor field for a monochrome brush
                                // is DIB_PAL_INDICES.

public:
// Initializer -- Initialize the metafile MREXTCREATEPEN record.
// This is similiar to the brush initialization code.

    BOOL bInit
    (
        HDC         hdc1,
        ULONG       imhe1,
        int         cbelp1,
        PEXTLOGPEN32 pelp1,
        HBITMAP     hbmRemote1,
        BMIH&       bmih1,
        DWORD       cbBitsInfo1,
        DWORD       cbBits1
    )
    {
        PUTS("MREXTCREATEPEN::bInit\n");

        MR::vInit(EMR_EXTCREATEPEN);
        imhe        = imhe1;
        offBitsInfo = sizeof(MREXTCREATEPEN) - sizeof(EXTLOGPEN32) + cbelp1;
        cbBitsInfo  = cbBitsInfo1;
        offBits     = offBitsInfo + (cbBitsInfo1 + 3) / 4 * 4;
        cbBits      = cbBits1;

        // Copy the extended pen.

        RtlCopyMemory((PBYTE) &elp, (PBYTE) pelp1, cbelp1);

        // Record the brush bitmap if any.

        if (hbmRemote1)
        {
            // Initialize the bitmap info header first.

            *(PBMIH) ((PBYTE) this + offBitsInfo) = bmih1;

            // Get bitmap info and bits.

            BOOL bRet = GetBrushBits(hdc1,
                            hbmRemote1,
                            *(PUINT) &pelp1->elpColor,
                            cbBitsInfo1,
                            (LPVOID) ((PBYTE) this + offBits),
                            (LPBITMAPINFO) ((PBYTE) this + offBitsInfo));

            // for optimized printing we want to determine if this
            // is a monochrome only brush

            fColor = LDC_COLOR_PAGE;
            if (bmih1.biBitCount == 1 && pelp1->elpColor == DIB_RGB_COLORS)
            {
                COLORREF *pColor = (COLORREF *)((PBYTE) this + offBitsInfo + bmih1.biSize);
                if (IS_COLOR_MONO(pColor[0]) && IS_COLOR_MONO(pColor[1]))
                {
                    fColor = 0;
                }
            }
            return (bRet);
        }
        else
        {
            return(TRUE);
        }
    }
    ULONG fColor;

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht); 
};

typedef MREXTCREATEPEN *PMREXTCREATEPEN;
#define SIZEOF_MREXTCREATEPEN(cbelp,cbBitsInfo,cbBits)          \
        (sizeof(MREXTCREATEPEN) - sizeof(EXTLOGPEN32)           \
      + (cbelp)                                                 \
      + ((cbBitsInfo) + 3) / 4 * 4                              \
      + ((cbBits) + 3) / 4 * 4)

inline BOOL MREXTCREATEPEN::bCheckRecord(PHANDLETABLE pht)
{
    DWORD cbelp = sizeof(EXTLOGPEN32) - sizeof(DWORD);
    if ((elp.elpPenStyle & PS_STYLE_MASK) == PS_USERSTYLE)
        cbelp += sizeof(DWORD) * elp.elpNumEntries;
    if (((nSize == SIZEOF_MREXTCREATEPEN(cbelp,cbBitsInfo,cbBits)) ||
         (nSize == SIZEOF_MREXTCREATEPEN(cbelp,cbBitsInfo,cbBits) - sizeof(fColor))) &&
        bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MREXTCREATEPEN::bCheckRecord(%08x,%08x,%08x) failed\n",cbelp,cbBitsInfo,cbBits));
    return(FALSE);
}

/*********************************Class************************************\
* class MRCREATEPALETTE: public MR
*
* CREATEPALETTE record.
*
* History:
*  Sun Sep 22 14:40:40 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRCREATEPALETTE : public MR       /* mrcp */
{
protected:
    DWORD       imhe;           // LogPalette index in Metafile Handle Table.
    LOGPALETTE  logpal;         // Logical Palette.

public:
// Initializer -- Initialize the metafile MRCREATEPALETTE record.
// It sets the peFlags in the palette entries to zeroes.

    BOOL bInit(HPALETTE hpal_, ULONG imhe_, USHORT cEntries_);  // MFREC.CXX

// bCommit -- Commit the record to metafile.
// It updates the metafile palette.

    BOOL bCommit(PMDC pmdc)
    {
        return
        (
            pmdc->bCommit
            (
                *(PENHMETARECORD) this,
                (UINT) logpal.palNumEntries,
                logpal.palPalEntry
            )
        );
    }

// vCommit -- use bCommit!

    VOID vCommit(PMDC pmdc)
    {
        USE(pmdc);
        ASSERTGDI(FALSE, "MRCREATEPALETTE::vCommit: use bCommit!");
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRCREATEPALETTE *PMRCREATEPALETTE;
#define SIZEOF_MRCREATEPALETTE(cEntries)        \
        (sizeof(MRCREATEPALETTE)-sizeof(PALETTEENTRY)+(cEntries)*sizeof(PALETTEENTRY))

inline BOOL MRCREATEPALETTE::bCheckRecord(PHANDLETABLE pht)
{
    DWORD cEntries = logpal.palNumEntries;
    if (nSize == SIZEOF_MRCREATEPALETTE(cEntries) && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRCREATEPALETTE::bCheckRecord(%08x) failed\n", cEntries));
    return(FALSE);
}
/*********************************Class************************************\
* class MRCREATECOLORSPACE: public MR
*
* CREATECOLORSPACE record. (Windows 98 ansi record)
*
* History:
\**************************************************************************/

class MRCREATECOLORSPACE : public MR       /* mrcp */
{
protected:
    DWORD           imhe;    // LogColorSpace index in Metafile Handle Table.
    LOGCOLORSPACEA  lcsp;    // Logical Color Space.

public:
// Initializer -- Initialize the metafile MRCREATECOLORSPACE record.

    VOID vInit(ULONG imhe_, LOGCOLORSPACEA& lcsp_)
    {
        PUTS("MRCREATECOLORSPACE::vInit\n");

        MR::vInit(EMR_CREATECOLORSPACE);
        imhe = imhe_;
        lcsp = lcsp_;
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRCREATECOLORSPACE *PMRCREATECOLORSPACE;
#define SIZEOF_MRCREATECOLORSPACE (sizeof(MRCREATECOLORSPACE))

inline BOOL MRCREATECOLORSPACE::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRCREATECOLORSPACE == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRCREATECOLORSPACE::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRCREATECOLORSPACEW: public MR
*
* CREATECOLORSPACE record. (Windows NT unicode record)
*
* History:
\**************************************************************************/

class MRCREATECOLORSPACEW : public MR     /* mrcpw */
{
protected:
    DWORD           imhe;       // LogColorSpace index in Metafile Handle Table.
    LOGCOLORSPACEW  lcsp;       // Logical Color Space.
    DWORD           dwFlags;    // flags
    DWORD           cbData;     // size of raw source profile data if attached
    BYTE            Data[1];    // Array size is cbData

public:
// Initializer -- Initialize the metafile MRCREATECOLORSPACEW record.

    VOID vInit(ULONG imhe_, LOGCOLORSPACEW& lcsp_,
               DWORD dwFlags_, DWORD cbData_, BYTE *Data_)
    {
        PUTS("MRCREATECOLORSPACEW::vInit\n");

        MR::vInit(EMR_CREATECOLORSPACEW);
        imhe    = imhe_;
        lcsp    = lcsp_;
        dwFlags = dwFlags_;
        cbData  = cbData_;
        RtlCopyMemory(Data,Data_,cbData_);
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRCREATECOLORSPACEW *PMRCREATECOLORSPACEW;
#define SIZEOF_MRCREATECOLORSPACEW(cb)      \
        ((sizeof(MRCREATECOLORSPACEW)-PADCHAR_SIZE+(cb)+3)& ~3)

inline BOOL MRCREATECOLORSPACEW::bCheckRecord(PHANDLETABLE pht)
{
    if (nSize == SIZEOF_MRCREATECOLORSPACEW(cbData) && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRCREATECOLORSPACEW::bCheckRecord(%08x) failed\n", cbData));
    return(FALSE);
}

/*********************************Class************************************\
* class MRDELETECOLORSPACE: public MR
*
* CREATECOLORSPACE record.
*
* History:
\**************************************************************************/

class MRDELETECOLORSPACE : public MR       /* mrcp */
{
    DWORD           imhe;      // LogColorSpace index in Metafile Handle Table.

public:
// Initializer -- Initialize the metafile MRCREATEPALETTE record.
// It sets the peFlags in the palette entries to zeroes.

    VOID vInit(ULONG imhe_, LOGCOLORSPACEW& lcsp_);

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRDELETECOLORSPACE *PMRDELETECOLORSPACE;
#define SIZEOF_MRDELETECOLORSPACE (sizeof(MRDELETECOLORSPACE))

inline BOOL MRDELETECOLORSPACE::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRDELETECOLORSPACE == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRDELETECOLORSPACE::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRCREATEBRUSHINDIRECT: public MR
*
* CREATEBRUSHINDIRECT record.
*
* History:
*  Wed Jul 31 21:09:28 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRCREATEBRUSHINDIRECT : public MR /* mrcbi */
{
protected:
    DWORD       imhe;                   // Brush index in Metafile Handle Table.
    LOGBRUSH32  lb;                     // Logical brush.

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(ULONG imhe_, LOGBRUSH& lb_)
    {
        PUTS("MRCREATEBRUSHINDIRECT::vInit\n");

        MR::vInit(EMR_CREATEBRUSHINDIRECT);
        imhe = imhe_;
        lb.lbStyle   = lb_.lbStyle;
        lb.lbColor = lb_.lbColor;
        lb.lbHatch = (ULONG)lb_.lbHatch;
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRCREATEBRUSHINDIRECT *PMRCREATEBRUSHINDIRECT;
#define SIZEOF_MRCREATEBRUSHINDIRECT    (sizeof(MRCREATEBRUSHINDIRECT))

inline BOOL MRCREATEBRUSHINDIRECT::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRCREATEBRUSHINDIRECT == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRCREATEBRUSHINDIRECT::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRBRUSH: public MR
*
* Metafile record for mono and dib pattern brushes.
*
* History:
*  Thu Mar 12 16:20:15 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBRUSH : public MR       /* mrbr */
{
protected:
    DWORD       imhe;           // Brush index in Metafile Handle Table.
    DWORD       iUsage;         // color table usage in bitmap info.
                                // For mono brush, it is DIB_PAL_INDICES.
    DWORD       offBitsInfo;    // offset to bitmap info
    DWORD       cbBitsInfo;     // size of bitmap info
    DWORD       offBits;        // offset to bits
    DWORD       cbBits;         // size of bits buffer

public:
// Initializer -- Initialize the metafile record.
// See also extcreatepen initialization code.

    BOOL bInit
    (
        DWORD   iType1,
        HDC     hdc1,
        ULONG   imhe1,
        HBITMAP hbmRemote1,
        BMIH&   bmih1,
        DWORD   iUsage1,
        DWORD   cbBitsInfo1,
        DWORD   cbBits1
    )
    {
        PUTS("MRBRUSH::bInit\n");

        MR::vInit(iType1);
        imhe        = imhe1;
        iUsage      = iUsage1;
        offBitsInfo = sizeof(MRBRUSH);
        cbBitsInfo  = cbBitsInfo1;
        offBits     = sizeof(MRBRUSH) + (cbBitsInfo1 + 3) / 4 * 4;
        cbBits      = cbBits1;

        // Initialize the bitmap info header first.

        *(PBMIH) ((PBYTE) this + offBitsInfo) = bmih1;

        // Get bitmap info and bits.
        // We could have called InternalGetDIBits directly if not for
        // the gdisrv brush hack.

        BOOL bRet = GetBrushBits(hdc1,
                            hbmRemote1,
                            (UINT) iUsage1,
                            cbBitsInfo1,
                            (LPVOID) ((PBYTE) this + offBits),
                            (LPBITMAPINFO) ((PBYTE) this + offBitsInfo));

        // for optimized printing we want to determine if this
        // is a monochrome only brush

        fColor = LDC_COLOR_PAGE;
        if (bmih1.biBitCount == 1 && iUsage == DIB_RGB_COLORS)
        {
            COLORREF *pColor = (COLORREF *)((PBYTE) this + offBitsInfo + bmih1.biSize);
            if (IS_COLOR_MONO(pColor[0]) && IS_COLOR_MONO(pColor[1]))
            {
                fColor = 0;
            }
        }

        return (bRet);
    }
    // flag specifying whether the color table for this dib is
    // known to only contain black or white
    ULONG fColor;

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRBRUSH *PMRBRUSH;
#define SIZEOF_MRBRUSH(cbBitsInfo,cbBits)                       \
        (sizeof(MRBRUSH)                                        \
      + ((cbBitsInfo) + 3) / 4 * 4                              \
      + ((cbBits) + 3) / 4 * 4)

inline BOOL MRBRUSH::bCheckRecord(PHANDLETABLE pht)
{
    if ((SIZEOF_MRBRUSH(cbBitsInfo,cbBits) == nSize ||
         (SIZEOF_MRBRUSH(cbBitsInfo,cbBits) - sizeof(fColor)) == nSize) &&
        bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRBRUSH::bCheckRecord(%08x,%08x) failed\n", cbBitsInfo,cbBits));
    return(FALSE);
}

class MRCREATEMONOBRUSH : public MRBRUSH                /* mrcmb */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRCREATEMONOBRUSH *PMRCREATEMONOBRUSH;

class MRCREATEDIBPATTERNBRUSHPT : public MRBRUSH        /* mrcdpb */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRCREATEDIBPATTERNBRUSHPT *PMRCREATEDIBPATTERNBRUSHPT;

/*********************************Class************************************\
* class MREXTCREATEFONTINDIRECTW: public MR
*
* EXTCREATEFONTINDIRECTW record.
*
*  Thu 19-Dec-1996 -by- Bodin Dresevic [BodinD]
* update: changed initializer to take into account new 5.0 ENUMLOGFONTEXDVW
* structure
*
* History:
*  Tue Jan 14 13:52:35 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MREXTCREATEFONTINDIRECTW : public MR      /* mrecfiw */
{
protected:
    DWORD       imhe;           // Font index in Metafile Handle Table.
    EXTLOGFONTW elfw;           // Logical font.

public:

// In 5.0 we always record ENUMLOGFONTEXDVW.
// However, we bPlay can play both ENUMLOGFONTEXDVW records as well as
// EXTLOGFONTW records (in case the file is recored on <= 4.0 or win 9x system)
// We differentiate between old and new style records based on the size of
// record.

    VOID vInit(HANDLE hfont_, ULONG imhe_, ENUMLOGFONTEXDVW *pelfw)
    {
        PUTS("MREXTCREATEFONTINDIRECTW::bInit\n");

        MR::vInit(EMR_EXTCREATEFONTINDIRECTW);
        imhe = imhe_;

        RtlMoveMemory(&this->elfw,
                      pelfw,
                      offsetof(ENUMLOGFONTEXDVW,elfDesignVector) + SIZEOFDV(pelfw->elfDesignVector.dvNumAxes));
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht)
    {
        // Review by Mleonov.
        if (((nSize == sizeof(MREXTCREATEFONTINDIRECTW)) ||
             ((nSize == offsetof(EMREXTCREATEFONTINDIRECTW,elfw) +
                      offsetof(ENUMLOGFONTEXDVW,elfDesignVector)+
                      SIZEOFDV((*(ENUMLOGFONTEXDVW*)&elfw).elfDesignVector.dvNumAxes)) && ((*(ENUMLOGFONTEXDVW*)&elfw).elfDesignVector.dvNumAxes <= MM_MAX_NUMAXES))) &&
            bValidSize(pht, nSize))
        {
            return(TRUE);
        }
        vMarkFoundBad(pht);
        EMFVALFAIL(("MREXTCREATEFONTINDIRECTW::bCheckRecord failed\n"));
        return(FALSE);
    }
};

typedef MREXTCREATEFONTINDIRECTW *PMREXTCREATEFONTINDIRECTW;

// sizeof old EXTLOGFONT records

#define SIZEOF_MREXTCREATEFONTINDIRECTW (sizeof(MREXTCREATEFONTINDIRECTW))

// sizeof new ENUMLOGFONTEXDVW records

#define SIZEOF_MRCREATEFONTINDIRECTEXW(iSize) (offsetof(EMREXTCREATEFONTINDIRECTW,elfw)+(DWORD)(iSize))


/*********************************Class************************************\
* class MRSETPALETTEENTRIES: public MR
*
* SETPALETTEENTRIES record.
*
* History:
*  Sun Sep 22 14:40:40 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRSETPALETTEENTRIES : public MR   /* mrspe */
{
protected:
    DWORD        imhe;          // LogPalette index in Metafile Handle Table.
    DWORD        iStart;        // First entry to be set.
    DWORD        cEntries;      // Number of entries to be set.
    PALETTEENTRY aPalEntry[1];  // Palette entries.

public:
// Initializer -- Initialize the metafile MRSETPALETTEENTRIES record.
// It sets the peFlags in the palette entries to zeroes.

    VOID vInit
    (
        ULONG imhe_,
        UINT  iStart_,
        UINT  cEntries_,
        CONST PALETTEENTRY *pPalEntries_
    );                                  // MFREC.CXX

// bCommit -- Commit the record to metafile.
// It updates the metafile palette.

    BOOL bCommit(PMDC pmdc)
    {
        return
        (
            pmdc->bCommit(*(PENHMETARECORD) this, (UINT) cEntries, aPalEntry)
        );
    }

// vCommit -- use bCommit!

    VOID vCommit(PMDC pmdc)
    {
        USE(pmdc);
        ASSERTGDI(FALSE, "MRSETPALETTEENTRIES::vCommit: use bCommit!");
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRSETPALETTEENTRIES *PMRSETPALETTEENTRIES;
#define SIZEOF_MRSETPALETTEENTRIES(cEntries)    \
        (sizeof(MRSETPALETTEENTRIES)-sizeof(PALETTEENTRY)+(cEntries)*sizeof(PALETTEENTRY))

inline BOOL MRSETPALETTEENTRIES::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRSETPALETTEENTRIES(cEntries) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRSETPALETTEENTRIES::bCheckRecord(%08x) failed\n", cEntries));
    return(FALSE);
}

class MRRESIZEPALETTE : public MRDD     /* mrrp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRRESIZEPALETTE *PMRRESIZEPALETTE;

/*********************************Class************************************\
* class MREXTFLOODFILL : public MR
*
* EXTFLOODFILL record.
*
* History:
*  Tue Apr 14 14:45:41 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MREXTFLOODFILL : public MR        /* mreff */
{
protected:
    EPOINTL     eptl;
    COLORREF    clrRef;
    DWORD       iMode;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(int x1, int y1, COLORREF clrRef1, DWORD iMode1)
    {
        PUTS("MREXTFLOODFILL::vInit\n");

        MR::vInit(EMR_EXTFLOODFILL);
        eptl.vInit(x1,y1);
        clrRef = clrRef1;
        iMode  = iMode1;
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MREXTFLOODFILL *PMREXTFLOODFILL;
#define SIZEOF_MREXTFLOODFILL   (sizeof(MREXTFLOODFILL))

inline BOOL MREXTFLOODFILL::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MREXTFLOODFILL == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MREXTFLOODFILL::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MREOF: public MR
*
* EOF record.
*
* History:
*  Fri Mar 20 09:37:47 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MREOF : public MR         /* mreof */
{
public:
    DWORD nPalEntries;          // Number of palette entries.
    DWORD offPalEntries;        // Offset to the palette entries.  For now,
                                // it points to the address immediately
                                // following this field (i.e. &cbEOF)!

    DWORD cbEOF;                // Size of the record.  This field does not
                                // follows offPalEntries!  It is always at
                                // the end of the EOF record to allow us to
                                // scan back to the beginning of the EOF
                                // record to find the metafile palette.

public:
// Initializer -- Initialize the metafile MREOF record.

    VOID vInit(DWORD cPalEntries_, PPALETTEENTRY pPalEntries_, DWORD cbEOF_)
    {
        ASSERTGDI(cbEOF_ == (sizeof(MREOF)+cPalEntries_*sizeof(PALETTEENTRY)),
            "MREOF::vInit: bad cbEOF_");

        MR::vInit(EMR_EOF);
        nPalEntries   = cPalEntries_;
        offPalEntries = sizeof(MR) + sizeof(nPalEntries) + sizeof(offPalEntries);

        // Initialize cbEOF at the end of the EOF record!

        ((PDWORD) ((PBYTE) this + cbEOF_))[-1] = cbEOF_;

        RtlCopyMemory
        (
            (PBYTE) this + offPalEntries,
            (PBYTE) pPalEntries_,
            cPalEntries_ * sizeof(PALETTEENTRY)
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MREOF *PMREOF;
#define SIZEOF_MREOF(cPalEntries)       \
        (sizeof(MREOF)+(cPalEntries)*sizeof(PALETTEENTRY))

inline BOOL MREOF::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MREOF(nPalEntries) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MREOF::bCheckRecord(%08x) failed\n", nPalEntries));
    return(FALSE);
}

/*********************************Class************************************\
* class MRGDICOMMENT: public MR
*
* GDICOMMENT record.
*
* History:
*  Wed Apr 28 10:43:12 1993     -by-    Hock San Lee    [hockl]
* Added public comments.
*  17-Oct-1991     -by-    John Colleran    [johnc]
* Wrote it.
\**************************************************************************/
//REVISIT
typedef struct _COMMENTDATABUF {
    UINT    size;
    PVOID   data;
} COMMENTDATABUF;

class MRGDICOMMENT : public MR     /* mrmd */
{
public:
    DWORD       cb;                 // Number of BYTES in the comment
    BYTE        abComment[1];       // the comment

public:
// Initializer -- Initialize the metafile MRGDICOMMENT record.

    VOID vInit(DWORD cb_, CONST BYTE *abComment_)
    {
        MR::vInit(EMR_GDICOMMENT);
        cb = cb_;
        RtlCopyMemory
        (
            (PBYTE) abComment,
            (PBYTE) abComment_,
            cb
        );
    }

// Initialize MRGDICOMMENT record using scattered input buffers

    VOID vInit(INT bufcnt, CONST COMMENTDATABUF *databuf)
    {
        MR::vInit(EMR_GDICOMMENT);
        cb = 0;

        for (INT i=0; i<bufcnt; i++)
        {
            UINT n;

            if (n = databuf[i].size)
            {
                RtlCopyMemory(&abComment[cb], databuf[i].data, n);
                cb += n;
            }
        }
    }

// Initializer -- Initialize the metafile comment record for windows metafile.

    VOID vInitWindowsMetaFile(DWORD cbWinMetaFile_, CONST BYTE *pbWinMetaFile_)
    {
        PEMRGDICOMMENT_WINDOWS_METAFILE pemrWinMF;

        MR::vInit(EMR_GDICOMMENT);
        pemrWinMF = (PEMRGDICOMMENT_WINDOWS_METAFILE) this;
        pemrWinMF->cbData    = cbWinMetaFile_
                                + sizeof(EMRGDICOMMENT_WINDOWS_METAFILE)
                                - sizeof(EMR)
                                - sizeof(DWORD);
        pemrWinMF->ident     = GDICOMMENT_IDENTIFIER;
        pemrWinMF->iComment  = GDICOMMENT_WINDOWS_METAFILE;
        pemrWinMF->nVersion  = (DWORD) ((PMETAHEADER) pbWinMetaFile_)->mtVersion;
        pemrWinMF->nChecksum = 0;       // to be filled in later
        pemrWinMF->fFlags    = 0;       // no compression
        pemrWinMF->cbWinMetaFile = cbWinMetaFile_;
        RtlCopyMemory((PBYTE) &pemrWinMF[1], pbWinMetaFile_, cbWinMetaFile_);
    }

// Initializer -- Initialize the metafile comment record for begin group for
//    the embedded enhanced metafile.

    VOID vInitBeginGroupEMF(PENHMETAHEADER pemfHeader)
    {
        PEMRGDICOMMENT_BEGINGROUP pemrBeginGroup;

        MR::vInit(EMR_GDICOMMENT);
        pemrBeginGroup = (PEMRGDICOMMENT_BEGINGROUP) this;
        pemrBeginGroup->cbData    = sizeof(WCHAR) * pemfHeader->nDescription
                                    + sizeof(EMRGDICOMMENT_BEGINGROUP)
                                    - sizeof(EMR)
                                    - sizeof(DWORD);
        pemrBeginGroup->ident     = GDICOMMENT_IDENTIFIER;
        pemrBeginGroup->iComment  = GDICOMMENT_BEGINGROUP;
        pemrBeginGroup->nDescription = pemfHeader->nDescription;
        if (pemfHeader->nDescription)
            RtlCopyMemory
            (
                (PBYTE) &pemrBeginGroup[1],
                (PBYTE) pemfHeader + pemfHeader->offDescription,
                pemfHeader->nDescription * sizeof(WCHAR)
            );

        // Get logical output rectangle from the frame rectangle.
        // The logical coordinates is actually in source device coordinates
        // at this time.  This is set up by PlayEnhMetaFile.

        pemrBeginGroup->rclOutput.left
               = (LONG) MulDiv((int) pemfHeader->rclFrame.left,
                               (int) pemfHeader->szlDevice.cx,
                               (int) (100 * pemfHeader->szlMillimeters.cx));
        pemrBeginGroup->rclOutput.right
               = (LONG) MulDiv((int) pemfHeader->rclFrame.right,
                               (int) pemfHeader->szlDevice.cx,
                               (int) (100 * pemfHeader->szlMillimeters.cx));
        pemrBeginGroup->rclOutput.top
               = (LONG) MulDiv((int) pemfHeader->rclFrame.top,
                               (int) pemfHeader->szlDevice.cy,
                               (int) (100 * pemfHeader->szlMillimeters.cy));
        pemrBeginGroup->rclOutput.bottom
               = (LONG) MulDiv((int) pemfHeader->rclFrame.bottom,
                               (int) pemfHeader->szlDevice.cy,
                               (int) (100 * pemfHeader->szlMillimeters.cy));
    }

// bIsPublicComment -- Is this the public metafile comment?

    BOOL bIsPublicComment()
    {
        PEMRGDICOMMENT_PUBLIC pemrc = (PEMRGDICOMMENT_PUBLIC) this;

        return
        (
            pemrc->emr.iType == EMR_GDICOMMENT
         && pemrc->emr.nSize >= sizeof(EMRGDICOMMENT_PUBLIC)
         && pemrc->ident     == GDICOMMENT_IDENTIFIER
        );
    }

// bIsWindowsMetaFile -- Is this the Windows metafile comment?

    BOOL bIsWindowsMetaFile()
    {
        PEMRGDICOMMENT_WINDOWS_METAFILE pemrWinMF;

        pemrWinMF = (PEMRGDICOMMENT_WINDOWS_METAFILE) this;

        return
        (
            bIsPublicComment()
         && pemrWinMF->iComment == GDICOMMENT_WINDOWS_METAFILE
        );
    }

// bIsCommentBeginGroup -- Is this the windows Comment Begin Group

    BOOL bIsCommentBeginGroup()
    {
         PEMRGDICOMMENT_BEGINGROUP pemrBeginGroup;

         pemrBeginGroup = (PEMRGDICOMMENT_BEGINGROUP) this;

         return
         (
             bIsPublicComment()
          && pemrBeginGroup->iComment == GDICOMMENT_BEGINGROUP
         );
    }
        

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRGDICOMMENT *PMRGDICOMMENT;
#define SIZEOF_MRGDICOMMENT(cb)      \
        ((sizeof(MRGDICOMMENT)-PADCHAR_SIZE+(cb)+3)& ~3)
#define SIZEOF_MRGDICOMMENT_WINDOWS_METAFILE(cb)      \
        ((sizeof(EMRGDICOMMENT_WINDOWS_METAFILE)+(cb)+3) & ~3)
#define SIZEOF_MRGDICOMMENT_BEGINGROUP(cb)            \
        ((sizeof(EMRGDICOMMENT_BEGINGROUP)+sizeof(WCHAR)*(cb)+3) & ~3)

inline BOOL MRGDICOMMENT::bCheckRecord(PHANDLETABLE pht)
{
    //Review by someone else/Mleonov:
    
    // Problem is we have the same METARECORD i.e MRGDICOMMENT for different
    // types of comments with different size. So what we do is to make sure
    // nSize matches each of these specific comments.

/*
    if (bIsWindowsMetaFile())
    {
        if (nSize == SIZEOF_MRGDICOMMENT_WINDOWS_METAFILE(cb))
        {
            if (bValidSize(pht, nSize))
                return(TRUE);
        }
    }
    else if (bIsCommentBeginGroup())
    {
        if (nSize == SIZEOF_MRGDICOMMENT_BEGINGROUP(cb))
        {
            if (bValidSize(pht, nSize))
                return(TRUE);
        }
    }
    else
*/
    {
        if (bValidSize(pht, nSize))
            return(TRUE);
    }
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRGDICOMMENT::bCheckRecord(%08x) failed\n", cb));
    return(FALSE);
}

/*********************************Class************************************\
* class MRBB : public MRB
*
* Metafile record with Bounds and BitBlts.
*
* History:
*  Fri Nov 22 17:17:02 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBB : public MRB         /* mrbb */
{
protected:
    LONG        xDst;           // destination x origin
    LONG        yDst;           // destination y origin
    LONG        cxDst;          // width
    LONG        cyDst;          // height
    DWORD       rop;            // raster operation code.
                                // For MaskBlt, this is rop3!
    LONG        xSrc;           // source x origin
    LONG        ySrc;           // source y origin
    XFORM       xformSrc;       // source DC transform
    COLORREF    clrBkSrc;       // source DC BkColor.  This must be a RGB value.

// The following are zeros if source does not contain a bitmap.
// The bitmap info, if exists, contains literal RGB values in the color table.

    DWORD       iUsageSrc;      // color table usage in bitmap info.
                                // This contains DIB_RGB_COLORS.
    DWORD       offBitsInfoSrc; // offset to bitmap info
    DWORD       cbBitsInfoSrc;  // size of bitmap info
    DWORD       offBitsSrc;     // offset to bits
    DWORD       cbBitsSrc;      // size of bits buffer

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        DWORD    iType1,
        PMDC     pmdc1,
        LONG     xDst1,
        LONG     yDst1,
        LONG     cxDst1,
        LONG     cyDst1,
        DWORD    rop1,
        LONG     xSrc1,
        LONG     ySrc1,
        PXFORM   pxformSrc1,
        COLORREF clrBkSrc1,
        PBMIH    pbmihSrc1,
        HBITMAP  hbmSrc1,
        DWORD    offBitsInfoSrc1,
        DWORD    cbBitsInfoSrc1,
        DWORD    offBitsSrc1,
        DWORD    cbBitsSrc1
    )
    {
        PUTS("MRBB::bInit\n");

        ASSERTGDI(offBitsInfoSrc1 % 4 == 0,
            "MRBB::bInit: offBitsInfoSrc1 is not dword aligned");
        ASSERTGDI(cbBitsInfoSrc1 % 4 == 0,
            "MRBB::bInit: cbBitsInfoSrc1 is not dword aligned");
        ASSERTGDI(offBitsSrc1 % 4 == 0,
            "MRBB::bInit: offBitsSrc1 is not dword aligned");
        ASSERTGDI(cbBitsSrc1 % 4 == 0,
            "MRBB::bInit: cbBitsSrc1 is not dword aligned");
        ASSERTGDI((clrBkSrc1 & 0xFF000000) == 0,
            "MRBB::bInit: bad cbBitsSrc1");

        MRB::vInit(iType1, pmdc1);
        xDst           = xDst1;
        yDst           = yDst1;
        cxDst          = cxDst1;
        cyDst          = cyDst1;
        rop            = rop1;
        xSrc           = xSrc1;
        ySrc           = ySrc1;
        xformSrc       = *pxformSrc1;
        clrBkSrc       = clrBkSrc1;
        iUsageSrc      = DIB_RGB_COLORS;
        offBitsInfoSrc = offBitsInfoSrc1;
        cbBitsInfoSrc  = cbBitsInfoSrc1;
        offBitsSrc     = offBitsSrc1;
        cbBitsSrc      = cbBitsSrc1;

        // Get the bits if it has a bitmap.

        if (hbmSrc1)
        {
            // Initialize the bitmap info header first.

            *(PBMIH) ((PBYTE) this + offBitsInfoSrc1) = *pbmihSrc1;

            // Get bitmap info and bits.

            if (!GetDIBits(pmdc1->hdcSrc,
                           hbmSrc1,
                           0,
                           (UINT) pbmihSrc1->biHeight,
                           (LPBYTE) ((PBYTE) this + offBitsSrc1),
                           (LPBITMAPINFO) ((PBYTE) this + offBitsInfoSrc1),
                           DIB_RGB_COLORS))
                {
                    return(FALSE);
                }

            // If it is a monochrome bitmap, we will overwrite the color
            // table with the current text color and background color.
            // We create only dib bitmaps at playback time so that we get
            // the same output on both monochrome and color playback devices.
            // We should probably record the correct colors (black/white or
            // text/background) depending on the recording device.  However,
            // we are only given a reference device that can be color or
            // monochrome if it is a memory DC.  For now, we assume color
            // conversion always occurs for monochrome bitmap
            // See also MRPLGBLT::bInit().

            if (MonoBitmap((HBITMAP)hbmSrc1))
            {
                RGBQUAD *prgbq;
                DWORD    rgb;

                prgbq = (RGBQUAD *) ((PBYTE) this
                                        + offBitsInfoSrc1
                                        + cbBitsInfoSrc1
                                        - 2 * sizeof(RGBQUAD));

                rgb = (DWORD) GetNearestColor(pmdc1->hdcRef,
                                              GetTextColor(pmdc1->hdcRef));
                prgbq[0].rgbBlue     = GetBValue(rgb);
                prgbq[0].rgbGreen    = GetGValue(rgb);
                prgbq[0].rgbRed      = GetRValue(rgb);
                prgbq[0].rgbReserved = 0;

                rgb = (DWORD) GetNearestColor(pmdc1->hdcRef,
                                              GetBkColor(pmdc1->hdcRef));
                prgbq[1].rgbBlue     = GetBValue(rgb);
                prgbq[1].rgbGreen    = GetGValue(rgb);
                prgbq[1].rgbRed      = GetRValue(rgb);
                prgbq[1].rgbReserved = 0;
            }
        }

        return(TRUE);
    }

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRBB *PMRBB;
#define SIZEOF_MRBB(cbBitsInfoSrc,cbBitsSrc)    \
        (sizeof(MRBB) + (cbBitsInfoSrc) + (cbBitsSrc))

inline BOOL MRBB::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRBB(cbBitsInfoSrc,cbBitsSrc) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRBB::bCheckRecord(%08x,%08x) failed\n", cbBitsInfoSrc,cbBitsSrc));
    return(FALSE);
}

class MRBITBLT : public MRBB            /* mrbb */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRBITBLT *PMRBITBLT;

/*********************************Class************************************\
* class MRSTRETCHBLT : public MRBB
*
* STRETCHBLT record.
*
* History:
*  Wed Nov 27 12:00:33 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRSTRETCHBLT : public MRBB        /* mrsb */
{
protected:
    LONG        cxSrc;          // source width
    LONG        cySrc;          // source height

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        PMDC     pmdc1,
        LONG     xDst1,
        LONG     yDst1,
        LONG     cxDst1,
        LONG     cyDst1,
        DWORD    rop1,
        LONG     xSrc1,
        LONG     ySrc1,
        LONG     cxSrc1,
        LONG     cySrc1,
        PXFORM   pxformSrc1,
        COLORREF clrBkSrc1,
        PBMIH    pbmihSrc1,
        HBITMAP  hbmSrc1,
        DWORD    offBitsInfoSrc1,
        DWORD    cbBitsInfoSrc1,
        DWORD    offBitsSrc1,
        DWORD    cbBitsSrc1
    )
    {
        PUTS("MRSTRETCHBLT::bInit\n");

        cxSrc = cxSrc1;
        cySrc = cySrc1;

        return
        (
            MRBB::bInit
            (
                EMR_STRETCHBLT,
                pmdc1,
                xDst1,
                yDst1,
                cxDst1,
                cyDst1,
                rop1,
                xSrc1,
                ySrc1,
                pxformSrc1,
                clrBkSrc1,
                pbmihSrc1,
                hbmSrc1,
                offBitsInfoSrc1,
                cbBitsInfoSrc1,
                offBitsSrc1,
                cbBitsSrc1
            )
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRSTRETCHBLT *PMRSTRETCHBLT;
#define SIZEOF_MRSTRETCHBLT(cbBitsInfoSrc,cbBitsSrc)    \
    (SIZEOF_MRBB((cbBitsInfoSrc),(cbBitsSrc))           \
   + sizeof(MRSTRETCHBLT)                               \
   - sizeof(MRBB))

inline BOOL MRSTRETCHBLT::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRSTRETCHBLT(cbBitsInfoSrc,cbBitsSrc) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRSTRETCHBLT::bCheckRecord(%08x,%08x) failed\n", cbBitsInfoSrc,cbBitsSrc));
    return(FALSE);
}

/*********************************Class************************************\
* class MRMASKBLT : public MRBB
*
* MASKBLT record.
*
* History:
*  Wed Nov 27 12:00:33 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRMASKBLT : public MRBB   /* mrsb */
{
protected:
    LONG        xMask;          // mask x origin
    LONG        yMask;          // mask y origin
    DWORD       iUsageMask;     // color table usage in mask's bitmap info.
                                // This contains DIB_PAL_INDICES.
    DWORD       offBitsInfoMask;// offset to mask bitmap info
    DWORD       cbBitsInfoMask; // size of mask bitmap info
    DWORD       offBitsMask;    // offset to mask bits
    DWORD       cbBitsMask;     // size of mask bits buffer

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        PMDC     pmdc1,
        LONG     xDst1,
        LONG     yDst1,
        LONG     cxDst1,
        LONG     cyDst1,
        DWORD    rop1,          // this is rop3!
        LONG     xSrc1,
        LONG     ySrc1,
        PXFORM   pxformSrc1,
        COLORREF clrBkSrc1,
        PBMIH    pbmihSrc1,
        HBITMAP  hbmSrc1,
        DWORD    offBitsInfoSrc1,
        DWORD    cbBitsInfoSrc1,
        DWORD    offBitsSrc1,
        DWORD    cbBitsSrc1,
        LONG     xMask1,
        LONG     yMask1,
        PBMIH    pbmihMask1,
        HBITMAP  hbmMask1,
        DWORD    offBitsInfoMask1,
        DWORD    cbBitsInfoMask1,
        DWORD    offBitsMask1,
        DWORD    cbBitsMask1
    )
    {
        PUTS("MRMASKBLT::bInit\n");

        ASSERTGDI(offBitsInfoMask1 % 4 == 0,
            "MRMASKBLT::bInit: offBitsInfoMask1 is not dword aligned");
        ASSERTGDI(cbBitsInfoMask1 % 4 == 0,
            "MRMASKBLT::bInit: cbBitsInfoMask1 is not dword aligned");
        ASSERTGDI(offBitsMask1 % 4 == 0,
            "MRMASKBLT::bInit: offBitsMask1 is not dword aligned");
        ASSERTGDI(cbBitsMask1 % 4 == 0,
            "MRMASKBLT::bInit: cbBitsMask1 is not dword aligned");

        xMask           = xMask1;
        yMask           = yMask1;
        iUsageMask      = DIB_PAL_INDICES;
        offBitsInfoMask = offBitsInfoMask1;
        cbBitsInfoMask  = cbBitsInfoMask1;
        offBitsMask     = offBitsMask1;
        cbBitsMask      = cbBitsMask1;

        // Get the mask bits if it has a mask.

        if (hbmMask1)
        {
            // Initialize the mask bitmap info header first.

            *(PBMIH) ((PBYTE) this + offBitsInfoMask1) = *pbmihMask1;

            // Get mask bitmap info and bits.

            if (!GetDIBits(pmdc1->hdcRef,
                           hbmMask1,
                           0,
                           (UINT) pbmihMask1->biHeight,
                           (LPBYTE) ((PBYTE) this + offBitsMask1),
                           (LPBITMAPINFO) ((PBYTE) this + offBitsInfoMask1),
                           DIB_PAL_INDICES))
                return(FALSE);
        }

        return
        (
            MRBB::bInit
            (
                EMR_MASKBLT,
                pmdc1,
                xDst1,
                yDst1,
                cxDst1,
                cyDst1,
                rop1,
                xSrc1,
                ySrc1,
                pxformSrc1,
                clrBkSrc1,
                pbmihSrc1,
                hbmSrc1,
                offBitsInfoSrc1,
                cbBitsInfoSrc1,
                offBitsSrc1,
                cbBitsSrc1
            )
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRMASKBLT *PMRMASKBLT;
#define SIZEOF_MRMASKBLT(cbBitsInfoSrc,cbBitsSrc,cbBitsInfoMask,cbBitsMask) \
    (SIZEOF_MRBB((cbBitsInfoSrc),(cbBitsSrc))                               \
   + sizeof(MRMASKBLT)                                                      \
   - sizeof(MRBB)                                                           \
   + (cbBitsInfoMask) + (cbBitsMask))

inline BOOL MRMASKBLT::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRMASKBLT(cbBitsInfoSrc,cbBitsSrc,cbBitsInfoMask,cbBitsMask) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRMASKBLT::bCheckRecord(%08x,%08x,%08x,%08x) failed\n", cbBitsInfoSrc,cbBitsSrc,cbBitsInfoMask,cbBitsMask));
    return(FALSE);
}

/*********************************Class************************************\
* class MRPLGBLT : public MRB
*
* PLGBLT record.
*
* History:
*  Wed Nov 27 12:00:33 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRPLGBLT : public MRB             /* mrpb */
{
protected:
    POINTL      aptlDst[3];     // destination parallelogram
    LONG        xSrc;           // source x origin
    LONG        ySrc;           // source y origin
    LONG        cxSrc;          // source width
    LONG        cySrc;          // source height
    XFORM       xformSrc;       // source DC transform
    COLORREF    clrBkSrc;       // source DC BkColor.  This must be a RGB value.

// The bitmap info contains literal RGB values in the color table.

    DWORD       iUsageSrc;      // color table usage in bitmap info.
                                // This contains DIB_RGB_COLORS.
    DWORD       offBitsInfoSrc; // offset to bitmap info
    DWORD       cbBitsInfoSrc;  // size of bitmap info
    DWORD       offBitsSrc;     // offset to bits
    DWORD       cbBitsSrc;      // size of bits buffer

    LONG        xMask;          // mask x origin
    LONG        yMask;          // mask y origin
    DWORD       iUsageMask;     // color table usage in mask's bitmap info.
                                // This contains DIB_PAL_INDICES.
    DWORD       offBitsInfoMask;// offset to mask bitmap info
    DWORD       cbBitsInfoMask; // size of mask bitmap info
    DWORD       offBitsMask;    // offset to mask bits
    DWORD       cbBitsMask;     // size of mask bits buffer

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        PMDC     pmdc1,
        CONST POINT *pptDst1,
        LONG     xSrc1,
        LONG     ySrc1,
        LONG     cxSrc1,
        LONG     cySrc1,
        PXFORM   pxformSrc1,
        COLORREF clrBkSrc1,
        PBMIH    pbmihSrc1,
        HBITMAP  hbmSrc1,
        DWORD    offBitsInfoSrc1,
        DWORD    cbBitsInfoSrc1,
        DWORD    offBitsSrc1,
        DWORD    cbBitsSrc1,
        LONG     xMask1,
        LONG     yMask1,
        PBMIH    pbmihMask1,
        HBITMAP  hbmMask1,
        DWORD    offBitsInfoMask1,
        DWORD    cbBitsInfoMask1,
        DWORD    offBitsMask1,
        DWORD    cbBitsMask1
    )
    {
        PUTS("MRPLGBLT::bInit\n");

        ASSERTGDI(offBitsInfoSrc1 % 4 == 0,
            "MRPLGBLT::bInit: offBitsInfoSrc1 is not dword aligned");
        ASSERTGDI(cbBitsInfoSrc1 % 4 == 0,
            "MRPLGBLT::bInit: cbBitsInfoSrc1 is not dword aligned");
        ASSERTGDI(offBitsSrc1 % 4 == 0,
            "MRPLGBLT::bInit: offBitsSrc1 is not dword aligned");
        ASSERTGDI(cbBitsSrc1 % 4 == 0,
            "MRPLGBLT::bInit: cbBitsSrc1 is not dword aligned");
        ASSERTGDI(offBitsInfoMask1 % 4 == 0,
            "MRPLGBLT::bInit: offBitsInfoMask1 is not dword aligned");
        ASSERTGDI(cbBitsInfoMask1 % 4 == 0,
            "MRPLGBLT::bInit: cbBitsInfoMask1 is not dword aligned");
        ASSERTGDI(offBitsMask1 % 4 == 0,
            "MRPLGBLT::bInit: offBitsMask1 is not dword aligned");
        ASSERTGDI(cbBitsMask1 % 4 == 0,
            "MRPLGBLT::bInit: cbBitsMask1 is not dword aligned");
        ASSERTGDI(pxformSrc1 != (PXFORM) NULL,
            "MRPLGBLT::bInit: pxformSrc1 is NULL");
        ASSERTGDI((clrBkSrc1 & 0xFF000000) == 0,
            "MRPLGBLT::bInit: bad cbBitsSrc1");

        MRB::vInit(EMR_PLGBLT, pmdc1);
        aptlDst[0]      = *(PPOINTL) &pptDst1[0];
        aptlDst[1]      = *(PPOINTL) &pptDst1[1];
        aptlDst[2]      = *(PPOINTL) &pptDst1[2];
        xSrc            = xSrc1;
        ySrc            = ySrc1;
        cxSrc           = cxSrc1;
        cySrc           = cySrc1;
        xformSrc        = *pxformSrc1;
        clrBkSrc        = clrBkSrc1;
        iUsageSrc       = DIB_RGB_COLORS;
        offBitsInfoSrc  = offBitsInfoSrc1;
        cbBitsInfoSrc   = cbBitsInfoSrc1;
        offBitsSrc      = offBitsSrc1;
        cbBitsSrc       = cbBitsSrc1;
        xMask           = xMask1;
        yMask           = yMask1;
        iUsageMask      = DIB_PAL_INDICES;
        offBitsInfoMask = offBitsInfoMask1;
        cbBitsInfoMask  = cbBitsInfoMask1;
        offBitsMask     = offBitsMask1;
        cbBitsMask      = cbBitsMask1;

        // Get the bits from the source bitmap.
        // Initialize the bitmap info header first.

        *(PBMIH) ((PBYTE) this + offBitsInfoSrc1) = *pbmihSrc1;

        // Get bitmap info and bits.

        if (!GetDIBits(pmdc1->hdcRef,
                       hbmSrc1,
                       0,
                       (UINT) pbmihSrc1->biHeight,
                       (LPBYTE) ((PBYTE) this + offBitsSrc1),
                       (LPBITMAPINFO) ((PBYTE) this + offBitsInfoSrc1),
                       DIB_RGB_COLORS))
            return(FALSE);

        // If it is a monochrome bitmap, we will overwrite the color
        // table with the current text color and background color.
        // We create only dib bitmaps at playback time so that we get
        // the same output on both monochrome and color playback devices.
        // We should probably record the correct colors (black/white or
        // text/background) depending on the recording device.  However,
        // we are only given a reference device that can be color or
        // monochrome if it is a memory DC.  For now, we assume color
        // conversion always occurs for monochrome bitmap!!!
        // See also MRBB::bInit().

        if (MonoBitmap((HBITMAP)hbmSrc1))
        {
            RGBQUAD *prgbq;
            DWORD    rgb;

            prgbq = (RGBQUAD *) ((PBYTE) this
                                        + offBitsInfoSrc1
                                        + cbBitsInfoSrc1
                                        - 2 * sizeof(RGBQUAD));

            rgb = (DWORD) GetNearestColor(pmdc1->hdcRef,
                                          GetTextColor(pmdc1->hdcRef));
            prgbq[0].rgbBlue     = GetBValue(rgb);
            prgbq[0].rgbGreen    = GetGValue(rgb);
            prgbq[0].rgbRed      = GetRValue(rgb);
            prgbq[0].rgbReserved = 0;

            rgb = (DWORD) GetNearestColor(pmdc1->hdcRef,
                                          GetBkColor(pmdc1->hdcRef));
            prgbq[1].rgbBlue     = GetBValue(rgb);
            prgbq[1].rgbGreen    = GetGValue(rgb);
            prgbq[1].rgbRed      = GetRValue(rgb);
            prgbq[1].rgbReserved = 0;
        }

        // Get the mask bits if it has a mask.

        if (hbmMask1)
        {
            // Initialize the mask bitmap info header first.

            *(PBMIH) ((PBYTE) this + offBitsInfoMask1) = *pbmihMask1;

            // Get mask bitmap info and bits.

            if (!GetDIBits(pmdc1->hdcRef,
                           hbmMask1,
                           0,
                           (UINT) pbmihMask1->biHeight,
                           (LPBYTE) ((PBYTE) this + offBitsMask1),
                           (LPBITMAPINFO) ((PBYTE) this + offBitsInfoMask1),
                           DIB_PAL_INDICES))
                return(FALSE);
        }

        return(TRUE);
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
    
    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRPLGBLT *PMRPLGBLT;
#define SIZEOF_MRPLGBLT(cbBitsInfoSrc,cbBitsSrc,cbBitsInfoMask,cbBitsMask) \
        (sizeof(MRPLGBLT) + (cbBitsInfoSrc) + (cbBitsSrc) + (cbBitsInfoMask) + (cbBitsMask))

inline BOOL MRPLGBLT::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRPLGBLT(cbBitsInfoSrc,cbBitsSrc,cbBitsInfoMask,cbBitsMask) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRPLGBLT::bCheckRecord(%08x,%08x,%08x,%08x) failed\n", cbBitsInfoSrc,cbBitsSrc,cbBitsInfoMask,cbBitsMask));
    return(FALSE);
}

/*********************************Class************************************\
* class MRALPHABLEND : public MRBB
*
* STRETCHBLT record.
*
* History:
*
*    12/3/1996 Mark Enstrom [marke]
*
\**************************************************************************/

class MRALPHABLEND : public MRBB        /* mrsb */
{
protected:
    LONG            cxSrc;          // source width
    LONG            cySrc;          // source height

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        PMDC     pmdc1,
        LONG     xDst1,
        LONG     yDst1,
        LONG     cxDst1,
        LONG     cyDst1,
        DWORD    rop1,
        LONG     xSrc1,
        LONG     ySrc1,
        LONG     cxSrc1,
        LONG     cySrc1,
        PXFORM   pxformSrc1,
        COLORREF clrBkSrc1,
        PBMIH    pbmihSrc1,
        HBITMAP  hbmSrc1,
        DWORD    offBitsInfoSrc1,
        DWORD    cbBitsInfoSrc1,
        DWORD    offBitsSrc1,
        DWORD    cbBitsSrc1
    )
    {
        PUTS("MRALPHABLEND::bInit\n");

        cxSrc = cxSrc1;
        cySrc = cySrc1;

        return
        (
            MRBB::bInit
            (
                EMR_ALPHABLEND,
                pmdc1,
                xDst1,
                yDst1,
                cxDst1,
                cyDst1,
                rop1,
                xSrc1,
                ySrc1,
                pxformSrc1,
                clrBkSrc1,
                pbmihSrc1,
                hbmSrc1,
                offBitsInfoSrc1,
                cbBitsInfoSrc1,
                offBitsSrc1,
                cbBitsSrc1
            )
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRALPHABLEND *PMRALPHABLEND;
#define SIZEOF_MRALPHABLEND(cbBitsInfoSrc,cbBitsSrc)    \
    (SIZEOF_MRBB((cbBitsInfoSrc),(cbBitsSrc))           \
   + sizeof(MRALPHABLEND)                               \
   - sizeof(MRBB))

inline BOOL MRALPHABLEND::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRALPHABLEND(cbBitsInfoSrc,cbBitsSrc) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRALPHABLEND::bCheckRecord(%08x,%08x) failed\n", cbBitsInfoSrc,cbBitsSrc));
    return(FALSE);
}

/*********************************Class************************************\
* class MRTRANSPARENTBLT : public MRBB
*
* STRETCHBLT record.
*
* History:
*
*    12/3/1996 Mark Enstrom [marke]
*
\**************************************************************************/

class MRTRANSPARENTBLT : public MRBB        /* mrsb */
{
protected:
    LONG            cxSrc;          // source width
    LONG            cySrc;          // source height

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        PMDC     pmdc1,
        LONG     xDst1,
        LONG     yDst1,
        LONG     cxDst1,
        LONG     cyDst1,
        DWORD    rop1,
        LONG     xSrc1,
        LONG     ySrc1,
        LONG     cxSrc1,
        LONG     cySrc1,
        PXFORM   pxformSrc1,
        COLORREF clrBkSrc1,
        PBMIH    pbmihSrc1,
        HBITMAP  hbmSrc1,
        DWORD    offBitsInfoSrc1,
        DWORD    cbBitsInfoSrc1,
        DWORD    offBitsSrc1,
        DWORD    cbBitsSrc1
    )
    {
        PUTS("MRTRANSPARENTBLT::bInit\n");

        cxSrc = cxSrc1;
        cySrc = cySrc1;

        return
        (
            MRBB::bInit
            (
                EMR_TRANSPARENTBLT,
                pmdc1,
                xDst1,
                yDst1,
                cxDst1,
                cyDst1,
                rop1,
                xSrc1,
                ySrc1,
                pxformSrc1,
                clrBkSrc1,
                pbmihSrc1,
                hbmSrc1,
                offBitsInfoSrc1,
                cbBitsInfoSrc1,
                offBitsSrc1,
                cbBitsSrc1
            )
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRTRANSPARENTBLT *PMRTRANSPARENTBLT;
#define SIZEOF_MRTRANSPARENTBLT(cbBitsInfoSrc,cbBitsSrc)    \
    (SIZEOF_MRBB((cbBitsInfoSrc),(cbBitsSrc))           \
   + sizeof(MRTRANSPARENTBLT)                               \
   - sizeof(MRBB))

inline BOOL MRTRANSPARENTBLT::bCheckRecord(PHANDLETABLE pht)
{
    if(SIZEOF_MRTRANSPARENTBLT(cbBitsInfoSrc,cbBitsSrc) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRTRANSPARENTBLT::bCheckRecord(%08x,%08x) failed\n", cbBitsInfoSrc,cbBitsSrc));
    return(FALSE);
}

/*********************************Class************************************\
* class MRBDIB : public MRB
*
* Metafile record with Bounds and Dib.
*
* History:
*  Wed Nov 27 12:00:33 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRBDIB : public MRB               /* mrsdb */
{
protected:
    LONG        xDst;           // destination x origin
    LONG        yDst;           // destination y origin
    LONG        xDib;           // dib x origin
    LONG        yDib;           // dib y origin
    LONG        cxDib;          // dib width
    LONG        cyDib;          // dib height
    DWORD       offBitsInfoDib; // offset to dib info, we don't store core info.
    DWORD       cbBitsInfoDib;  // size of dib info
    DWORD       offBitsDib;     // offset to dib bits
    DWORD       cbBitsDib;      // size of dib bits buffer
    DWORD       iUsageDib;      // color table usage in bitmap info.

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        DWORD iType1,
        PMDC  pmdc1,
        LONG  xDst1,
        LONG  yDst1,
        LONG  xDib1,
        LONG  yDib1,
        LONG  cxDib1,
        LONG  cyDib1,
        DWORD offBitsInfoDib1,
        DWORD cbBitsInfoDib1,
        CONST BITMAPINFO *pBitsInfoDib1,
        DWORD offBitsDib1,
        DWORD cbBitsDib1,
        CONST VOID * pBitsDib1,
        DWORD iUsageDib1,
        DWORD cbProfData1 = 0,         // Only used with BITMAPV5
        CONST VOID * pProfData1 = NULL // Only used with BITMAPV5
    )
    {
        PUTS("MRBDIB::vInit\n");

        // cbBitsInfoDib1 and cbBitsDib1 may not be dword sized!

        ASSERTGDI(offBitsDib1 % 4 == 0,
            "MRBDIB::vInit: offBitsDib1 is not dword aligned");
        ASSERTGDI(offBitsInfoDib1 % 4 == 0,
            "MRBDIB::vInit: offBitsInfoDib1 is not dword aligned");

        // +---------------------+ <--- offBitsInfoDib1
        // | Bitmap Info header  |   |
        // +- - - - - - - - - - -+   +- cbBitsInfoDib1
        // | Color Table         |   |
        // +- - - - - - - - - - -+  ---
        // |                     |   |
        // | Color Profile Data  |   +- cbProfData1
        // |   (BITMAPV5 only)   |   |
        // +---------------------+ <--- offBitsDib1
        // |                     |   |
        // | Bitmap Bits         |   +- cbBitsDib1
        // |                     |   |
        // +---------------------+  ---

        MRB::vInit(iType1, pmdc1);
        xDst            = xDst1;
        yDst            = yDst1;
        xDib            = xDib1;
        yDib            = yDib1;
        cxDib           = cxDib1;
        cyDib           = cyDib1;
        offBitsInfoDib  = offBitsInfoDib1;
        cbBitsInfoDib   = cbBitsInfoDib1 + cbProfData1;
        offBitsDib      = offBitsDib1;
        cbBitsDib       = cbBitsDib1;
        iUsageDib       = iUsageDib1;

        // Copy dib info if given.

        if (cbBitsInfoDib1)
        {
            if (pBitsInfoDib1->bmiHeader.biSize == sizeof(BMCH))
            {
                CopyCoreToInfoHeader
                (
                    (LPBITMAPINFOHEADER) ((PBYTE) this + offBitsInfoDib1),
                    (LPBITMAPCOREHEADER) pBitsInfoDib1
                );

                if (iUsageDib1 == DIB_RGB_COLORS)
                {
                    RGBQUAD   *prgbq;
                    RGBTRIPLE *prgbt;
                    UINT      ui;

                    prgbq = ((PBMI) ((PBYTE) this + offBitsInfoDib1))->bmiColors;
                    prgbt = ((PBMC) pBitsInfoDib1)->bmciColors;

                    ASSERTGDI(cbBitsInfoDib1 >= sizeof(BMIH),
                        "MRBDIB::vInit: Bad cbBitsInfoDib1 size");

                    for
                    (
                        ui = (UINT) (cbBitsInfoDib1 - sizeof(BMIH))
                                    / sizeof(RGBQUAD);
                        ui;
                        ui--
                    )
                    {
                        prgbq->rgbBlue     = prgbt->rgbtBlue;
                        prgbq->rgbGreen    = prgbt->rgbtGreen;
                        prgbq->rgbRed      = prgbt->rgbtRed;
                        prgbq->rgbReserved = 0;
                        prgbq++; prgbt++;
                    }
                }
                else
                {
                    RtlCopyMemory
                    (
                        (PBYTE) this + offBitsInfoDib1 + sizeof(BMIH),
                        (PBYTE) pBitsInfoDib1 + sizeof(BMCH),
                        cbBitsInfoDib1 - sizeof(BMIH)
                    );
                }
            }
            else
            {
                // Copy BitmapInfoHeader and color table

                RtlCopyMemory
                (
                    (PBYTE) this + offBitsInfoDib1,
                    (PBYTE) pBitsInfoDib1,
                    cbBitsInfoDib1
                );

                // Copy color profile (if nessesary)

                if (pProfData1 && cbProfData1)
                {
                    // This is BITMAPV5, get the pointer to the BITMAPV5 structure in metafile.

                    PBITMAPV5HEADER pBmih5 = (PBITMAPV5HEADER)((PBYTE)this + offBitsInfoDib1);

                    ASSERTGDI(pBmih5->bV5Size == sizeof(BITMAPV5HEADER),
                              "MRBDIB::vInit():Not Bitmap V5, but color profile\n");

                    // Copy color profile data right after the color table

                    DWORD offProfData = (cbBitsInfoDib1 + 3) / 4 * 4;

                    RtlCopyMemory
                    (
                        (PBYTE) this + offBitsInfoDib1 + offProfData,
                        (PBYTE) pProfData1,
                        cbProfData1
                    );

                    // Fix up the profile offset in BITMAPV5 header.

                    pBmih5->bV5ProfileData = offProfData;
                }
            }
        }
        // Copy dib bits.

        if (cbBitsDib1 >= MMAPCOPY_THRESHOLD && pmdc1->bIsEMFSpool())
        {
            CopyMemoryToMemoryMappedFile(
                    (PBYTE) this + offBitsDib1,
                    pBitsDib1,
                    cbBitsDib1);
        }
        else
        {
            RtlCopyMemory((PBYTE) this + offBitsDib1, pBitsDib1, cbBitsDib1);
        }
    }
};

/*********************************Class************************************\
* class MRSETDIBITSTODEVICE : public MRBDIB
*
* SETDIBITSTODEVICE record.
*
* History:
*  Wed Nov 27 12:00:33 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRSETDIBITSTODEVICE : public MRBDIB       /* mrsdb */
{
protected:
    DWORD       iStartScan;     // start scan
    DWORD       cScans;         // number of scans

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        PMDC  pmdc1,
        LONG  xDst1,
        LONG  yDst1,
        LONG  xDib1,
        LONG  yDib1,
        DWORD cxDib1,
        DWORD cyDib1,
        DWORD iStartScan1,
        DWORD cScans1,
        DWORD cbBitsDib1,
        CONST VOID * pBitsDib1,
        DWORD cbBitsInfoDib1,
        CONST BITMAPINFO *pBitsInfoDib1,
        DWORD cbProfData1,
        CONST VOID * pProfData1,
        DWORD iUsageDib1
    )
    {
        PUTS("MRSETDIBITSTODEVICE::vInit\n");

        iStartScan = iStartScan1;
        cScans     = cScans1;

        // cbBitsInfoDib1 and cbBitsDib1 may not be dword sized!

        MRBDIB::vInit
        (
            EMR_SETDIBITSTODEVICE,
            pmdc1,
            xDst1,
            yDst1,
            xDib1,
            yDib1,
            (LONG) cxDib1,
            (LONG) cyDib1,
            sizeof(MRSETDIBITSTODEVICE),
            cbBitsInfoDib1,
            pBitsInfoDib1,
            sizeof(MRSETDIBITSTODEVICE)            // Bitmap Bits will be located at
                + ((cbBitsInfoDib1 + 3) / 4 * 4)   // ater bitmap info header and
                + ((cbProfData1 + 3) / 4 * 4),     // color profile data.
            cbBitsDib1,
            pBitsDib1,
            iUsageDib1,
            cbProfData1,
            pProfData1
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRSETDIBITSTODEVICE *PMRSETDIBITSTODEVICE;
#define SIZEOF_MRSETDIBITSTODEVICE(cbBitsInfoDib,cbBitsDib,cbProfData) \
        (sizeof(MRSETDIBITSTODEVICE)                                   \
      + (((cbBitsInfoDib) + 3) / 4 * 4)                                \
      + (((cbProfData) + 3) / 4 * 4)                                   \
      + (((cbBitsDib) + 3) / 4 * 4))

inline BOOL MRSETDIBITSTODEVICE::bCheckRecord(PHANDLETABLE pht)
{
    // Note we pass 0 as cbProfData as cbBitsInfoDib is store as the sum of
    // the rounded up original cbProfData and rounded up original cbBitsInfoDib
    if (SIZEOF_MRSETDIBITSTODEVICE(cbBitsInfoDib,cbBitsDib,0) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRSETDIBITSTODEVICE::bCheckRecord(%08x,%08x,%08x) failed\n", cbBitsInfoDib,cbBitsDib,0));
    return(FALSE);
}

/*********************************Class************************************\
* class MRSTRETCHDIBITS : public MRBDIB
*
* STRETCHDIBITS record.
*
* History:
*  Wed Nov 27 12:00:33 1991     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRSTRETCHDIBITS : public MRBDIB   /* mrstrdb */
{
protected:
    DWORD       rop;            // raster operation code.
    LONG        cxDst;          // destination width
    LONG        cyDst;          // destination height

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        PMDC  pmdc1,
        LONG  xDst1,
        LONG  yDst1,
        LONG  cxDst1,
        LONG  cyDst1,
        LONG  xDib1,
        LONG  yDib1,
        LONG  cxDib1,
        LONG  cyDib1,
        DWORD cScans1,
        DWORD cbBitsDib1,
        CONST VOID * pBitsDib1,
        DWORD cbBitsInfoDib1,
        CONST BITMAPINFO *pBitsInfoDib1,
        DWORD iUsageDib1,
        DWORD cbProfData1,
        CONST VOID * pProfData1,
        DWORD rop1
    )
    {
        PUTS("MRSTRETCHDIBITS::vInit\n");

        rop   = rop1;
        cxDst = cxDst1;
        cyDst = cyDst1;

        // cbBitsInfoDib1 and cbBitsDib1 may not be dword sized!

        MRBDIB::vInit
        (
            EMR_STRETCHDIBITS,
            pmdc1,
            xDst1,
            yDst1,
            xDib1,
            yDib1,
            cxDib1,
            cyDib1,
            sizeof(MRSTRETCHDIBITS),
            cbBitsInfoDib1,
            pBitsInfoDib1,
            sizeof(MRSTRETCHDIBITS)                // Bitmap bits will be located at
                + ((cbBitsInfoDib1 + 3) / 4 * 4)   // after bitmap info header and
                + ((cbProfData1 + 3) / 4 * 4),     // color profile data.
            cbBitsDib1,
            pBitsDib1,
            iUsageDib1,
            cbProfData1,
            pProfData1
        );

        // set cScans1 in
        if (cScans1 && cbBitsInfoDib1)
        {
            PBITMAPINFO pBitInfoTemp = (PBITMAPINFO)((PBYTE)this + sizeof(MRSTRETCHDIBITS));

            pBitInfoTemp->bmiHeader.biHeight    = cScans1;
            pBitInfoTemp->bmiHeader.biSizeImage = cbBitsDib1;
        }
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRSTRETCHDIBITS *PMRSTRETCHDIBITS;
#define SIZEOF_MRSTRETCHDIBITS(cbBitsInfoDib,cbBitsDib,cbProfData)\
        (sizeof(MRSTRETCHDIBITS)                                  \
      + (((cbBitsInfoDib) + 3) / 4 * 4)                           \
      + (((cbProfData) + 3) / 4 * 4)                              \
      + (((cbBitsDib) + 3) / 4 * 4))

inline BOOL MRSTRETCHDIBITS::bCheckRecord(PHANDLETABLE pht)
{
    // Note we pass 0 as cbProfData as cbBitsInfoDib is stored as the sum
    // of the rounded up original cbProfData and rounded up original
    // cbBitsInfoDib
    if (nSize == SIZEOF_MRSTRETCHDIBITS(cbBitsInfoDib,cbBitsDib,0) && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRSTRETCHDIBITS::bCheckRecord(%08x,%08x,%08x) failed\n", cbBitsInfoDib,cbBitsDib,0));
    return(FALSE);
}
/*********************************Class************************************\
* class MTEXT
*
* Base record for all textout metafile records.
*
* History:
*  Thu Aug 24 15:20:33 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/
//NTFONT
class MTEXT
{
public:
    EPOINTL eptlRef;    // Logical coordinates of the reference point
    DWORD   cchString;  // Number of chars in the string.
    DWORD   offString;  // (Dword-aligned) offset to the string.
    DWORD   fOptions;   // Flags for rectangle usage.
    ERECTL  ercl;       // Opaque of clip rectangle if exists.
    DWORD   offaDx;     // (Dword-aligned) offset to the distance array.
                        // If the distance array does not exist, it
                        // will be queried and recorded!
public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        HDC        hdc1,
        int        x1,
        int        y1,
        UINT       fl1,
        CONST RECT *prc1,
        LPCSTR     pString1,
        int        cchString1,
        CONST INT *pdx1,
        PMR        pMR1,
        DWORD      offString1,          // dword-aligned aDx follows the string
        int        cjCh1                // size of a character in bytes
    );
};

/*********************************Class************************************\
* class MREXTTEXTOUT
*
* Metafile record for TextOutA, TextOutW, ExtTextOutA and ExtTextOutW.
*
* History:
*  Thu Aug 24 15:20:33 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MREXTTEXTOUT : public MRB         /* mreto */
{
protected:
    DWORD       iGraphicsMode;  // Advanced or compatible graphics mode
    FLOAT       exScale;        // X and Y scales from Page units to .01mm units
    FLOAT       eyScale;        //   if graphics mode is GM_COMPATIBLE.
    MTEXT       mtext;          // Base record for textout.

public:
// Initializer -- Initialize the metafile record.

    BOOL bInit
    (
        DWORD      iType1,
        PMDC       pmdc1,
        HDC        hdc1,
        int        x1,
        int        y1,
        UINT       fl1,
        CONST RECT *prc1,
        LPCSTR     pString1,
        int        cchString1,
        CONST INT *pdx1,
        int        cjCh1                // size of a character in bytes
    )
    {

        PUTS("MREXTTEXTOUT::bInit\n");

        ASSERTGDI(iType1 == EMR_EXTTEXTOUTA || iType1 == EMR_EXTTEXTOUTW,
            "MREXTTEXTOUT::bInit: Bad iType1");

        MRB::vInit(iType1, pmdc1);
        iGraphicsMode = GetGraphicsMode(hdc1);

        if(iGraphicsMode != GM_COMPATIBLE)
        {
            exScale = 0.0f;                 // not used in advanced mode
            eyScale = 0.0f;
        }
        else if (pmdc1->exFontScale() != 0.0f && pmdc1->eyFontScale() != 0.0f)
        {
            exScale = pmdc1->exFontScale(); // use recorded scales in the
            eyScale = pmdc1->eyFontScale(); //   original metafile
        }
        else
        {
            // Compute P . S     .  See metafile.cxx for definitions of S     .
            //          r   (m,n)                                        (m,n)

            XFORM xform;

            if (!GetTransform(hdc1, XFORM_PAGE_TO_DEVICE, &xform))
                return(FALSE);

            exScale = xform.eM11
                        * 100.0f
                        * (FLOAT) (pmdc1->cxMillimeters())
                        / (FLOAT) (pmdc1->cxDevice)();
            eyScale = xform.eM22
                        * 100.0f
                        * (FLOAT) (pmdc1->cyMillimeters())
                        / (FLOAT) (pmdc1->cyDevice());
        }

        return
        (
            mtext.bInit
            (
                hdc1,
                x1,
                y1,
                fl1,
                prc1,
                pString1,
                cchString1,
                pdx1,
                this,                           // pMR
                sizeof(MREXTTEXTOUT),           // offString
                cjCh1
            )
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MREXTTEXTOUT *PMREXTTEXTOUT;

#define SIZEOF_MREXTTEXTOUT(cchString, cjCh, bPdy)              \
        ((sizeof(MREXTTEXTOUT)                                  \
         +(cchString)*((cjCh) + sizeof(LONG)*((bPdy) ? 2 : 1))  \
         +3) / 4 * 4)

inline BOOL MREXTTEXTOUT::bCheckRecord(PHANDLETABLE pht)
{
    // Review by Mleonov:
    // Seems like cjCh is always set to sizeof(WCHAR). See metarec.cxx
    if (nSize > mtext.cchString &&
        nSize >= SIZEOF_MREXTTEXTOUT(mtext.cchString,
                                     iType == EMR_EXTTEXTOUTW ?
                                         sizeof(WCHAR) : sizeof(CHAR),
                                         (mtext.fOptions & ETO_PDY))
        && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MREXTTEXTOUT::bCheckRecord(%08x,%08x,%08x) failed\n", mtext.cchString, sizeof(WCHAR),(mtext.fOptions & ETO_PDY)));
    return(FALSE);
}

/*********************************Class************************************\
* class MRPOLYTEXTOUT
*
* Metafile record for PolyTextOutA and PolyTextOutW.
*
* History:
*  Tue 19-Apr-1994 11:32:44 by Kirk Olynyk [kirko]
* Removed bInit(...)
*  Thu Aug 24 15:20:33 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRPOLYTEXTOUT : public MRB        /* mrbpto */
{
protected:
    DWORD       iGraphicsMode;  // Advanced or compatible graphics mode
    FLOAT       exScale;        // X and Y scales from Page units to .01mm units
    FLOAT       eyScale;        //   if graphics mode is GM_COMPATIBLE.
    LONG        cmtext;         // Number of MTEXT structures
    MTEXT       amtext[1];      // Array of MTEXT structures
                                // This is followed by the strings and dx's
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRPOLYTEXTOUT *PMRPOLYTEXTOUT;

#define SIZEOF_MRPOLYTEXTOUT(cpt,cjTotal)               \
        (sizeof(MRPOLYTEXTOUT) - sizeof(MTEXT)          \
         + (cpt)*sizeof(MTEXT) + (cjTotal))

inline BOOL MRPOLYTEXTOUT::bCheckRecord(PHANDLETABLE pht)
{
    //Review by Mleonov: Looks like we never record a PolyTextOut record. Moreover this GDI api is not supported on the 9X platform. See comments in MF_PolyTextOut in metarec.cxx
    // But we need to support it. As we dont know exactly how many cjTotal was when we called SIZEOF_MTPOLYTEXTOUT we just check the nSize to be >= that value and in bPlay validate the mtext.offsets.
    if (nSize >= SIZEOF_MRPOLYTEXTOUT(cmtext,0) && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRPOLYTEXTOUT::bCheckRecord(%08x) failed\n", cmtext));
    return(FALSE);
}

/*********************************Class************************************\
* class MRSETCOLORADJUSTMENT : public MR
*
* SETCOLORADJUSTMENT record.
*
* History:
*  Tue Oct 27 09:59:28 1992     -by-    Hock San Lee    [hockl]
* Wrote it.
\**************************************************************************/

class MRSETCOLORADJUSTMENT : public MR  /* mrsca */
{
protected:
    COLORADJUSTMENT ColorAdjustment;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit(CONST COLORADJUSTMENT *pca)
    {
        PUTS("MRSETCOLORADJUSTMENT::vInit\n");

        MR::vInit(EMR_SETCOLORADJUSTMENT);
        RtlCopyMemory((PBYTE) &ColorAdjustment, (PBYTE) pca, pca->caSize);
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRSETCOLORADJUSTMENT *PMRSETCOLORADJUSTMENT;
#define SIZEOF_MRSETCOLORADJUSTMENT(pca)        \
        (sizeof(MRSETCOLORADJUSTMENT) - sizeof(COLORADJUSTMENT) + (pca)->caSize)

inline BOOL MRSETCOLORADJUSTMENT::bCheckRecord(PHANDLETABLE pht)
{
    if (nSize == SIZEOF_MRSETCOLORADJUSTMENT(&ColorAdjustment) && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRSETCOLORADJUSTMENT::bCheckRecord(%p) failed\n",&ColorAdjustment));
    return(FALSE);
}
/*********************************Class************************************\
* class MRGLSRECORD: public MR
*
* GLS record for OpenGL metafile support
*
* History:
*  Thu Feb 23 14:33:00 1995     -by-    Drew Bliss [drewb]
* Wrote it.
\**************************************************************************/


class MRGLSRECORD : public MR     /* mrgr */
{
public:
    DWORD       cb;                 // Number of BYTES in the record
    BYTE        abRecord[1];        // The record

public:
// Initializer -- Initialize the metafile MRGLSRECORD record.

    VOID vInit(DWORD cb_, CONST BYTE *abRecord_)
    {
        MR::vInit(EMR_GLSRECORD);
        cb = cb_;
        RtlCopyMemory
        (
            (PBYTE) abRecord,
            (PBYTE) abRecord_,
            cb
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRGLSRECORD *PMRGLSRECORD;
#define SIZEOF_MRGLSRECORD(cb)      \
        ((sizeof(MRGLSRECORD)-PADCHAR_SIZE+(cb)+3)& ~3)

inline BOOL MRGLSRECORD::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRGLSRECORD(cb) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRGLSRECORD::bCheckRecord(%08x) failed\n", cb));
    return(FALSE);
}

/*********************************Class************************************\
* class MRGLSBOUNDEDRECORD: public MR
*
* GLS record with bounds for OpenGL metafile support
*
* History:
*  Thu Feb 23 14:33:00 1995     -by-    Drew Bliss [drewb]
* Wrote it.
\**************************************************************************/


class MRGLSBOUNDEDRECORD : public MR     /* mrgbr */
{
public:
    RECTL       rclBounds;          // Bounds, must be first
    DWORD       cb;                 // Number of BYTES in the record
    BYTE        abRecord[1];        // The record

public:
// Initializer -- Initialize the metafile MRGLSRECORD record.

    VOID vInit(DWORD cb_, CONST BYTE *abRecord_, LPRECTL prclBounds)
    {
        MR::vInit(EMR_GLSBOUNDEDRECORD);
        cb = cb_;
        RtlCopyMemory
        (
            (PBYTE) abRecord,
            (PBYTE) abRecord_,
            cb
        );
        rclBounds = *prclBounds;
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRGLSBOUNDEDRECORD *PMRGLSBOUNDEDRECORD;
#define SIZEOF_MRGLSBOUNDEDRECORD(cb)      \
        ((sizeof(MRGLSBOUNDEDRECORD)-PADCHAR_SIZE+(cb)+3)& ~3)

inline BOOL MRGLSBOUNDEDRECORD::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRGLSBOUNDEDRECORD(cb) == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRGLSBOUNDEDRECORD::bCheckRecord(%08x) failed\n", cb));
    return(FALSE);
}

/*********************************Class************************************\
* class MRPIXELFORMAT: public MR
*
* PIXELFORMATDESCRIPTOR record
*
* History:
*  Thu Mar 27 14:33:00 1995     -by-    Drew Bliss [drewb]
* Wrote it.
\**************************************************************************/


class MRPIXELFORMAT : public MR     /* mrpf */
{
public:
    PIXELFORMATDESCRIPTOR pfd;

public:
// Initializer -- Initialize the metafile MRPIXELFORMAT record.

    VOID vInit(CONST PIXELFORMATDESCRIPTOR *ppfd)
    {
        MR::vInit(EMR_PIXELFORMAT);
        RtlCopyMemory
        (
            (PBYTE) &pfd,
            (PBYTE) ppfd,
            sizeof(PIXELFORMATDESCRIPTOR)
        );
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRPIXELFORMAT *PMRPIXELFORMAT;
#define SIZEOF_MRPIXELFORMAT (sizeof(MRPIXELFORMAT))

inline BOOL MRPIXELFORMAT::bCheckRecord(PHANDLETABLE pht)
{
    if (SIZEOF_MRPIXELFORMAT == nSize && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRPIXELFORMAT::bCheckRecord() failed\n"));
    return(FALSE);
}

/*********************************Class************************************\
* class MRSETICMPROFILE: public MR
*
* History:
*  Mon May 05 19:07:00 1997     -by-    Hideyuki Nagase [hideyukn]
* Wrote it.
\**************************************************************************/

class MRSETICMPROFILE : public MR  /* mrsip */
{
public:
    DWORD dwFlags; // Flags
    DWORD cbName;  // Size of desired profile name
    DWORD cbData;  // Size of raw profile data if attached
    BYTE  Data[1]; // Array size is cbName and cbData

public:
// vInit -- Initialize the record.

    VOID vInit(DWORD RecordType_,DWORD dwFlags_,
               DWORD cbName_,BYTE *Name_,
               DWORD cbData_,BYTE *Data_)
    {
        PUTS("MRSETICMPROFILE::bInit\n");

        ASSERTGDI(RecordType_ == EMR_SETICMPROFILEA ||
                  RecordType_ == EMR_SETICMPROFILEW, "Bad record type");

        MR::vInit(RecordType_);
        dwFlags = dwFlags_;
        cbName  = cbName_;
        cbData  = cbData_;
        RtlCopyMemory(Data,Name_,cbName_);
        RtlCopyMemory(Data+cbName_,Data_,cbData_);
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRSETICMPROFILE *PMRSETICMPROFILE;
#define SIZEOF_MRSETICMPROFILE(cb)      \
        ((sizeof(MRSETICMPROFILE)-PADCHAR_SIZE+(cb)+3)& ~3)

inline BOOL MRSETICMPROFILE::bCheckRecord(PHANDLETABLE pht)
{
    if (nSize == SIZEOF_MRSETICMPROFILE(cbName+cbData) && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRSETICMPROFILE::bCheckRecord(%08x) failed\n", cbName+cbData));
    return(FALSE);
}

/*********************************Class************************************\
* class MRCOLORMATCHTOTARGET: public MR
*
* History:
*  Mon Jun 22 17:22:00 1998     -by-    Hideyuki Nagase [hideyukn]
* Wrote it.
\**************************************************************************/

class MRCOLORMATCHTOTARGET : public MR  /* mrsip */
{
public:
    DWORD dwAction; // CS_ENABLE, CS_DISABLE or CS_DELETETRANSFORM
    DWORD dwFlags;  // Flags
    DWORD cbName;   // Size of desired profile name
    DWORD cbData;   // Size of raw profile data if attached
    BYTE  Data[1];  // Array size is cbName and cbData

public:
// vInit -- Initialize the record.

    VOID vInit(DWORD RecordType_,
               DWORD dwAction_,DWORD dwFlags_,
               DWORD cbName_,BYTE *Name_,
               DWORD cbData_,BYTE *Data_)
    {
        PUTS("MRCOLORMATCHTOTARGET::bInit\n");

        ASSERTGDI(RecordType_ == EMR_COLORMATCHTOTARGETW,"Bad record type");

        MR::vInit(RecordType_);
        dwAction = dwAction_;
        dwFlags = dwFlags_;
        cbName  = cbName_;
        cbData  = cbData_;
        RtlCopyMemory(Data,Name_,cbName_);
        RtlCopyMemory(Data+cbName_,Data_,cbData_);
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht);
};

typedef MRCOLORMATCHTOTARGET *PMRCOLORMATCHTOTARGET;
#define SIZEOF_MRCOLORMATCHTOTARGET(cb)      \
        ((sizeof(MRCOLORMATCHTOTARGET)-PADCHAR_SIZE+(cb)+3)& ~3)

inline BOOL MRCOLORMATCHTOTARGET::bCheckRecord(PHANDLETABLE pht)
{
    if (nSize == SIZEOF_MRCOLORMATCHTOTARGET(cbName+cbData) && bValidSize(pht, nSize))
        return(TRUE);
    vMarkFoundBad(pht);
    EMFVALFAIL(("MRCOLORMATCHTOTARGET::bCheckRecord(%08x) failed\n", cbName+cbData));
    return(FALSE);
}

class MRPOLYBEZIER : public MRBP        /* mrpb */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPOLYBEZIER *PMRPOLYBEZIER;

class MRPOLYGON : public MRBP           /* mrpg */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPOLYGON *PMRPOLYGON;

class MRPOLYLINE : public MRBP          /* mrpl */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPOLYLINE *PMRPOLYLINE;

class MRPOLYBEZIERTO : public MRBP      /* mrpbt */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPOLYBEZIERTO *PMRPOLYBEZIERTO;

class MRPOLYLINETO : public MRBP        /* mrplt */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPOLYLINETO *PMRPOLYLINETO;

class MRPOLYPOLYLINE : public MRBPP     /* mrppl */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPOLYPOLYLINE *PMRPOLYPOLYLINE;

class MRPOLYPOLYGON : public MRBPP      /* mrppg */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRPOLYPOLYGON *PMRPOLYPOLYGON;

class MRSETWINDOWEXTEX : public MRDD    /* mrswee */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETWINDOWEXTEX *PMRSETWINDOWEXTEX;

class MRSETWINDOWORGEX : public MRDD    /* mrswoe */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETWINDOWORGEX *PMRSETWINDOWORGEX;

class MRSETVIEWPORTEXTEX : public MRDD  /* mrsvee */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETVIEWPORTEXTEX *PMRSETVIEWPORTEXTEX;

class MRSETVIEWPORTORGEX : public MRDD  /* mrsvoe */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETVIEWPORTORGEX *PMRSETVIEWPORTORGEX;

class MRSETBRUSHORGEX : public MRDD     /* mrsboe */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETBRUSHORGEX *PMRSETBRUSHORGEX;

class MRSETMAPPERFLAGS : public MRD     /* mrsmf */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETMAPPERFLAGS *PMRSETMAPPERFLAGS;

class MRSETMAPMODE : public MRD         /* mrsmm */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETMAPMODE *PMRSETMAPMODE;

class MRSETLAYOUT : public MRD         /* mrslo */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETLAYOUT *PMRSETLAYOUT;

class MRSETBKMODE : public MRD          /* mrsbm */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

class MRSETICMMODE : public MRD          /* mrsbm */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

class MRSETCOLORSPACE : public MRD          /* mrsbm */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETBKMODE *PMRSETBKMODE;

class MRSETPOLYFILLMODE : public MRD    /* mrspfm */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETPOLYFILLMODE *PMRSETPOLYFILLMODE;

class MRSETROP2 : public MRD            /* mrsr2 */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETROP2 *PMRSETROP2;

class MRSETSTRETCHBLTMODE : public MRD  /* mrssbm */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETSTRETCHBLTMODE *PMRSETSTRETCHBLTMODE;

class MRSETTEXTALIGN : public MRD       /* mrsta */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETTEXTALIGN *PMRSETTEXTALIGN;

class MRSETTEXTCOLOR : public MRD       /* mrstc */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETTEXTCOLOR *PMRSETTEXTCOLOR;

class MRSETBKCOLOR : public MRD         /* mrsbc */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETBKCOLOR *PMRSETBKCOLOR;

class MRSETARCDIRECTION : public MRD    /* mrsad */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETARCDIRECTION *PMRSETARCDIRECTION;

class MRSETMITERLIMIT : public MRD      /* mrsml */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETMITERLIMIT *PMRSETMITERLIMIT;

class MROFFSETCLIPRGN : public MRDD     /* mrocr */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MROFFSETCLIPRGN *PMROFFSETCLIPRGN;

class MRMOVETOEX : public MRDD          /* mrmte */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRMOVETOEX *PMRMOVETOEX;

class MRLINETO : public MRDD            /* mrlt */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRLINETO *PMRLINETO;

class MRSETTEXTJUSTIFICATION : public MRDD
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETTEXTJUSTIFICATION *PMRSETTEXTJUST;

class MREXCLUDECLIPRECT : public MRDDDD /* mrecr */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MREXCLUDECLIPRECT *PMREXCLUDECLIPRECT;

class MRINTERSECTCLIPRECT : public MRDDDD       /* mricr */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRINTERSECTCLIPRECT *PMRINTERSECTCLIPRECT;

class MRSCALEVIEWPORTEXTEX : public MRDDDD      /* mrsvee */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSCALEVIEWPORTEXTEX *PMRSCALEVIEWPORTEXTEX;

class MRSCALEWINDOWEXTEX : public MRDDDD        /* mrswee */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSCALEWINDOWEXTEX *PMRSCALEWINDOWEXTEX;

class MRSAVEDC : public MR              /* mrsdc */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSAVEDC *PMRSAVEDC;

class MRRESTOREDC : public MRD          /* mrrdc */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRRESTOREDC *PMRRESTOREDC;

class MRSETWORLDTRANSFORM : public MRX  /* mrswt */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETWORLDTRANSFORM *PMRSETWORLDTRANSFORM;

class MRMODIFYWORLDTRANSFORM : public MRXD      /* mrmwt */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRMODIFYWORLDTRANSFORM *PMRMODIFYWORLDTRANSFORM;

class MRSELECTPALETTE : public MRD      /* mrsp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSELECTPALETTE *PMRSELECTPALETTE;

class MRCOLORCORRECTPALETTE : public MRDDDD      /* mrsp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRCOLORCORRECTPALETTE *PMRCOLORCORRECTPALETTE;

class MRREALIZEPALETTE : public MR      /* mrrp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRREALIZEPALETTE *PMRREALIZEPALETTE;

class MRSELECTOBJECT : public MRD       /* mrso */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSELECTOBJECT *PMRSELECTOBJECT;

class MRDELETEOBJECT : public MRD       /* mrdo */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRDELETEOBJECT *PMRDELETEOBJECT;

class MRBEGINPATH : public MR           /* mrbp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRBEGINPATH *PMRBEGINPATH;

class MRENDPATH : public MR             /* mrep */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRENDPATH *PMRENDPATH;

class MRCLOSEFIGURE : public MR         /* mrcf */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRCLOSEFIGURE *PMRCLOSEFIGURE;

class MRFLATTENPATH : public MR         /* mrfp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRFLATTENPATH *PMRFLATTENPATH;

class MRWIDENPATH : public MR           /* mrwp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRWIDENPATH *PMRWIDENPATH;

class MRFILLPATH : public MRB           /* mrfp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRFILLPATH *PMRFILLPATH;

class MRSTROKEANDFILLPATH : public MRB  /* mrsafp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSTROKEANDFILLPATH *PMRSTROKEANDFILLPATH;

class MRSTROKEPATH : public MRB         /* mrsp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSTROKEPATH *PMRSTROKEPATH;

class MRSELECTCLIPPATH : public MRD     /* mrscp */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSELECTCLIPPATH *PMRSELECTCLIPPATH;

class MRABORTPATH : public MR           /* mrap */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRABORTPATH *PMRABORTPATH;

class MRSETMETARGN : public MR          /* mrsmr */
{
public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSETMETARGN *PMRSETMETARGN;

class MRESCAPE : public MR         /* mrescape */
{
protected:
    INT iEscape;
    INT cjIn;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        DWORD  iType1,
        INT    iEscape1,
        INT    cjIn1,
        LPCSTR pvIn
    )
    {


        MFD1("MRESCAPE::vInit\n");

        MR::vInit(iType1);

        RtlCopyMemory((PBYTE)this+sizeof(MRESCAPE), (PBYTE) pvIn, cjIn1 );
        iEscape = iEscape1;
        cjIn = cjIn1;

    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht)
    {
        // Cant use the cjIn for app compat reasons. Some records out there
        // put garbage for cjIn and if we check this with the record size
        // we will fail a once valid metafile.
        if (/*nSize == ((sizeof(*this)+cjIn+3)&~3) && */bValidSize(pht, nSize))
            return(TRUE);
        vMarkFoundBad(pht);
        EMFVALFAIL(("MRESCAPE::bCheckRecord(%08x) failed\n", cjIn));
        return(FALSE);
    }
};

typedef MRESCAPE *PMRESCAPE;


class MRNAMEDESCAPE : public MR         /* mrescape */
{
protected:
    INT iEscape;
    INT cjDriver;
    INT cjIn;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        DWORD  iType1,
        INT    iEscape1,
        LPWSTR pwszDriver,
        LPCSTR pvIn,
        INT    cjIn1
    )
    {

        MFD1("MRNAMEDESCAPE::vInit\n");

        MR::vInit(iType1);
        cjDriver = (wcslen(pwszDriver)+1) * sizeof(WCHAR);

        RtlCopyMemory((PBYTE)this+sizeof(MRNAMEDESCAPE),(PBYTE)pwszDriver, cjDriver);

        RtlCopyMemory((PBYTE)this+sizeof(MRNAMEDESCAPE)+cjDriver,(PBYTE) pvIn, cjIn1);

        iEscape = iEscape1;
        cjIn = cjIn1;

    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht)
    {
        if (nSize == ((sizeof(*this) + cjIn + cjDriver + 3)&~3) && bValidSize(pht, nSize))
            return(TRUE);
        vMarkFoundBad(pht);
        EMFVALFAIL(("MRNAMEDESCAPE::bCheckRecord(%08x,%08x) failed\n", cjIn, cjDriver));
        return(FALSE);
    }
};

typedef MRNAMEDESCAPE *PMRNAMEDESCAPE;


class MRSTARTDOC : public MR /* mrstartdoc */
{
protected:
   DOCINFOW doi;
public:

   VOID vInit
   (
        DWORD    iType1,
        CONST DOCINFOW *pdoi
   )
   {
        PUTS("MRSTARTDOC::vInit\n");
        PBYTE pj;
    #if DBG
        DbgPrint("MR::vInit\n");
    #endif
        MR::vInit(iType1);

        *((DOCINFOW*)&doi) = *pdoi;

        pj = (PBYTE) this + sizeof(MRSTARTDOC);

        if( pdoi->lpszDocName != NULL )
        {
           lstrcpyW( (LPWSTR) pj, pdoi->lpszDocName );

           pj += ( ((lstrlenW( pdoi->lpszDocName )+1) * sizeof(WCHAR) ) + 4 ) & ~(0x3);

        }

        if( pdoi->lpszOutput != NULL )
        {
           lstrcpyW( (LPWSTR) pj, pdoi->lpszOutput );
        }
   }

// bPlay -- Play the record.

   BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

   BOOL bCheckRecord(PHANDLETABLE pht)
   {
       if (nSize >= sizeof(*this) && bValidSize(pht, nSize))
           return(TRUE);
       vMarkFoundBad(pht);
       EMFVALFAIL(("MRSTARTDOC::bCheckRecord() failed \n"));
       return(FALSE);
   }
};

typedef MRSTARTDOC *PMRSTARTDOC;



class MRSTARTPAGE : public MR   /* mrstartpage */
{
protected:

public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};


typedef MRSTARTPAGE *PMRSTARTPAGE;

class MRENDPAGE : public MR   /* mrendpage */
{
protected:

public:

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};


typedef MRENDPAGE *PMRENDPAGE;

#define ETO_NO_RECT     0x0100
#define ETO_SMALL_CHARS 0x0200

class MRSMALLTEXTOUT : public MR         /* mrescape */
{
private:
   INT          x;
   INT          y;
   UINT         cChars;
   UINT         fuOptions;
   DWORD        iGraphicsMode;
   FLOAT        exScale;
   FLOAT        eyScale;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        HDC          hdc1,
        PMDC         pmdc1,
        DWORD        iType1,
        int          x1,
        int          y1,
        UINT         fuOptions1,
        RECT         *pRect,
        UINT         cChars1,
        WCHAR        *pwc,
        BOOL         bSmallChars

    )
    {
        MFD1("MRSMALLTEXTOUT::vInit\n");
        MR::vInit(iType1);

        iGraphicsMode = GetGraphicsMode(hdc1);
        exScale = 0.0f;
        eyScale = 0.0f;

        if(iGraphicsMode == GM_COMPATIBLE)
        {
            XFORM xform;

            if(GetTransform(hdc1, XFORM_PAGE_TO_DEVICE, &xform))
            {
                exScale = xform.eM11 * 100.0f * (FLOAT) (pmdc1->cxMillimeters()) /
                  (FLOAT) (pmdc1->cxDevice)();
                eyScale = xform.eM22 * 100.0f * (FLOAT) (pmdc1->cyMillimeters()) /
                  (FLOAT) (pmdc1->cyDevice());
            }
            else
            {
                WARNING("GDI32:MRSMALLTEXTOUT: GetTransform failed");
            }
        }

#if DBG
        if( fuOptions1 & ( ETO_NO_RECT | ETO_SMALL_CHARS ) )
        {
           DbgPrint("MRSMALLTEXTOUT:vInit: warning fuOptions conflict\n");
        }
#endif
        fuOptions = fuOptions1 & ~(ETO_NO_RECT | ETO_SMALL_CHARS);
        fuOptions |= ( bSmallChars ) ? ETO_SMALL_CHARS : 0;
        fuOptions |= ( pRect == NULL ) ? ETO_NO_RECT : 0;

        x = x1;
        y = y1;
        cChars = cChars1;

        BYTE *pjThis = (PBYTE) this + sizeof(MRSMALLTEXTOUT);

        if( pRect )
        {
           RtlCopyMemory( pjThis, (PBYTE) pRect, sizeof(RECT) );
           pjThis += sizeof(RECT);
        }

        if( bSmallChars )
        {
           while(cChars1 --)
           {
              *pjThis++ = (BYTE) *pwc++;
           }
        }
        else
        {
           RtlCopyMemory( pjThis, pwc, cChars * sizeof(WCHAR) );
        }
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht)
    {
        //Review by Mleonov
        BOOL bNoRect =  fuOptions & ETO_NO_RECT;
        BOOL bSmallChar = fuOptions & ETO_SMALL_CHARS;

        DWORD sizeMustBe = sizeof(*this);
        sizeMustBe += bNoRect ? 0 : sizeof(RECT); 
        sizeMustBe += bSmallChar ? cChars * sizeof(char) : cChars * sizeof(WCHAR);
        sizeMustBe = (sizeMustBe + 3) & ~3;

        if (nSize == sizeMustBe && bValidSize(pht, nSize))
            return(TRUE);
        vMarkFoundBad(pht);
        EMFVALFAIL(("MRSMALLTEXTOUT::bCheckRecord failed\n"));
        return(FALSE);
    }
};

typedef MRSMALLTEXTOUT *PMRSMALLTEXTOUT;

class MRFORCEUFIMAPPING : public MR         /* mrescape */
{
private:
   UNIVERSAL_FONT_ID ufi;

public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        DWORD                iType1,
        PUNIVERSAL_FONT_ID   pufi
    )
    {
        MFD1("MRFORCEUFIMAPPING::vInit\n");
        MR::vInit(iType1);
        *(&ufi) = *pufi;
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht)
    {
        //Review by Mleonov
        if (nSize == sizeof(MRFORCEUFIMAPPING) && bValidSize(pht, nSize))
            return(TRUE);
        vMarkFoundBad(pht);
        EMFVALFAIL(("MRFORCEUFIMAPPING::bCheckRecord failed\n"));
        return(FALSE);
    }
};

typedef MRFORCEUFIMAPPING *PMRFORCEUFIMAPPING;


class MRSETLINKEDUFIS : public MR
{
private:
   UINT uNumLinkedUFIs;
   UNIVERSAL_FONT_ID pufiList[1];
public:
// Initializer -- Initialize the metafile record.

    VOID vInit
    (
        UINT _uNumLinkedUFIs,
        PUNIVERSAL_FONT_ID pufis
    )
    {
        MFD1("MRSETLINKEDUFIS::vInit\n");
        MR::vInit(EMR_SETLINKEDUFIS);
        uNumLinkedUFIs = _uNumLinkedUFIs;
        RtlCopyMemory(pufiList, pufis, sizeof(UNIVERSAL_FONT_ID) * uNumLinkedUFIs);
    }

// bPlay -- Play the record.

    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    BOOL bCheckRecord(PHANDLETABLE pht)
    {
        //Review by Mleonov
        if ((nSize == sizeof(MRSETLINKEDUFIS) + sizeof(UNIVERSAL_FONT_ID)*uNumLinkedUFIs) && bValidSize(pht, nSize))
            return(TRUE);
        vMarkFoundBad(pht);
        EMFVALFAIL(("MRSETLINKEDUFIS::bCheckRecord failed\n"));
        return(FALSE);
    }
};

typedef MRSETLINKEDUFIS *PMRSETLINKEDUFIS;


// typedef BOOL (MR::*FNBMRPLAY)(HDC, PHANDLETABLE, UINT);
// extern  FNBMRPLAY afnbMRPlay[EMR_MAX-EMR_MIN+1];

extern BOOL (MR::*afnbMRPlay[EMR_MAX-EMR_MIN+1])(HDC, PHANDLETABLE, UINT);

// typedef BOOL (MR::*FNBMRCHK)(PHANDLETABLE);
// extern  FNBMRCHECK afnbMRCheck[EMR_MAX-EMR_MIN+1];

extern BOOL (MR::*afnbMRCheck[EMR_MAX-EMR_MIN+1])(PHANDLETABLE);