meta.hpp

WinCE5.0部分核心源码

        // Copy dib info if given.

        if (cbBitsInfoDib1)
        {
        // Copy BitmapInfoHeader and color table
        memcpy((PBYTE) this + offBitsInfoDib1,(PBYTE) pBitsInfoDib1,cbBitsInfoDib1);       
        memcpy((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 iUsageDib1
    )
    {
        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),   // after bitmap info header and
            cbBitsDib1,
            pBitsDib1,
            iUsageDib1
        );
    }

// bPlay -- Play the record.

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

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

/*********************************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 rop1
    )
    {
        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        
            cbBitsDib1,
            pBitsDib1,
            iUsageDib1
        );

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

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



#define ETO_NO_RECT     0x0100
#define ETO_SMALL_CHARS 0x0200

class MRSMALLTEXTOUT : public MR         /* mrescape */
{
private:
   INT          x;
   INT          y;
   UINT         cChars;
   UINT         fuOptions;

public:
    //
    // Initializer -- Initialize the metafile record.
    //
    VOID vInit
    (
        HDC          hdc1,
        PMDC         pmdc1,
        DWORD        iType1,
        int          x1,
        int          y1,
        UINT         fuOptions1,
        RECT         *pRect,
        UINT         cChars1,
        const WCHAR        *pwc,
        BOOL         bSmallChars
    )
    {
        MR::vInit(iType1);

#ifdef DEBUG
        if (fuOptions1 & (ETO_NO_RECT | ETO_SMALL_CHARS))
        {
//           WARNING(TEXT("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)
        {
           memcpy(pjThis, (PBYTE) pRect, sizeof(RECT));
           pjThis += sizeof(RECT);
        }

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

    //
    // bPlay -- Play the record.
    //
    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);
};

typedef MRSMALLTEXTOUT *PMRSMALLTEXTOUT;


class MRMOVETOEX : public MRDD          
{
public:

// bPlay -- Play the record.

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

typedef MRMOVETOEX *PMRMOVETOEX;

/*********************************Class************************************\
* class MRALPHABLEND : public MRBB
*
* ALPHABLEND record.
*
\**************************************************************************/

class MRALPHABLEND : public MRBB        /* mrab */
{
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,      // BLENDFUNCTION for AlphaBlend (rop would always be SRCCOPY
        LONG     cxSrc1,
        LONG     cySrc1,
        COLORREF clrBkSrc1,
        HBITMAP  hbitmap1
    )
    {
        cxSrc = cxSrc1;
        cySrc = cySrc1;

        return MRBB::bInit(
                EMR_ALPHABLEND,
                pmdc1,
                xDst1,
                yDst1,
                cxDst1,
                cyDst1,
                rop1,
                clrBkSrc1,
                hbitmap1);
    }

    //
    // bPlay -- Play the record.
    //
    BOOL bPlay(HDC hdc, PHANDLETABLE pht, UINT cht);

    void Cleanup() { MRBB::Cleanup(); };
};

typedef MRALPHABLEND *PMRALPHABLEND;
#define SIZEOF_MRALPHABLEND  sizeof(MRALPHABLEND)

/*********************************Class************************************\
* class MRGRADFILL : public MRBB
*
* GRADIENTFILL record.
*
\**************************************************************************/

class MRGRADFILL : public MR
{
protected:
	PTRIVERTEX     m_pVertex;
	PGRADIENT_RECT m_pRect;
	ULONG          m_nVertex;
	ULONG          m_nRect;
	ULONG          m_ulMode;
	
public:
	//
	// Initializer -- Initialize the metafile record.
	//
	BOOL
	bInit(
		PMDC pmdc,
		PTRIVERTEX pVertex,
		ULONG nVertex,
		PVOID pMesh,
		ULONG nCount,
		ULONG ulMode
		);

	//
	// bPlay -- Play the record.
	//
	BOOL
	bPlay(
		HDC hdc,
		PHANDLETABLE pht,
		UINT cht
		);
};

typedef MRGRADFILL *PMRGRADFILL;
#define SIZEOF_MRGRADFILL(nVertex,nRect) (sizeof (MRGRADFILL) + (nVertex * sizeof (TRIVERTEX)) + (nRect * sizeof (GRADIENT_RECT)))

//
// afnbMRPlay is the metafile playback dispatch table.
//
typedef BOOL (MR::*MRPFN)(HDC, PHANDLETABLE, UINT);
extern const MRPFN afnbMRPlay[EMR_MAX-EMR_MIN+1];
//
// SaveDC
//
BOOL MF_Record(HDC hdc,DWORD mrType);

//
// Polygon
// Polyline
//
BOOL MF_Poly(HDC hdc, CONST POINT *pptl, DWORD cptl, DWORD mrType);

//
// SetBkMode
// SetTextColor
// SetBkColor
// RestoreDC
//
BOOL MF_SetD(HDC hdc,DWORD d1,DWORD mrType);

//
// SetBrushOrgEx
// SetViewportOrgEx
//
BOOL MF_SetDD(HDC hdc,DWORD d1,DWORD d2,DWORD mrType);

//
// ExcludeClipRect
// IntersectClipRect
//
BOOL MF_AnyClipRect(HDC hdc,int x1,int y1,int x2,int y2,DWORD mrType);

//
// SetPixel
//
BOOL MF_SetPixelV(HDC hdc,int x,int y,COLORREF color);

//
// CloseEnhMetaFile
//
BOOL MF_EOF(HDC hdc);

//
// SelectObject
// SelectPalette
//
BOOL MF_SelectAnyObject(HDC hdc,HANDLE h,DWORD mrType);

//
// CreatePen
// CreatePenIndirect
// CreateBrushIndirect
// CreateDIBPatternBrush
// CreateDIBPatternBrushPt
// CreateHatchBrush
// CreatePatternBrush
// CreatePalette
// CreateFont
// CreateFontIndirect
//
DWORD MF_InternalCreateObject(HDC hdc,HANDLE h);

//
// FillRect
//
BOOL MF_FillRect(HDC hdc,const RECTL * rc,HBRUSH hbr);

//
// Ellipse
// Rectangle
//
BOOL MF_EllipseRect(HDC hdc,int x1,int y1,int x2,int y2,DWORD mrType);

//
// SelectClipRgn
// ExtSelectClipRgn
// SelectObject(hdc,hrgn)
//
BOOL MF_ExtSelectClipRgn(HDC hdc,HRGN hrgn,int iMode);

//
// BitBlt
// PatBlt
// StretchBlt
// MaskBlt
// AlphaBlend
//
BOOL MF_AnyBitBlt(HDC hdcDst,int xDst,int yDst,int cxDst,int cyDst,
    CONST POINT *pptDst, HDC hdcSrc,int xSrc,int ySrc,int cxSrc,int cySrc,
    HBITMAP hbmMask,int xMask,int yMask,DWORD rop,DWORD mrType);


// SetDIBitsToDevice
// StretchDIBits
BOOL MF_AnyDIBits(HDC hdcDst,int xDst,int yDst,int cxDst,int cyDst,
    int xDib,int yDib,int cxDib,int cyDib,DWORD iStartScan,DWORD cScans,
    CONST VOID * pBitsDib, CONST BITMAPINFO *pBitsInfoDib,DWORD iUsageDib,DWORD rop,DWORD mrType);

BOOL
MF_ExtTextOut(
			HDC		hdc,
			int		x,
			int		y,
			UINT 	fl,
	const	RECT*	prcl,
	const	WCHAR*	psz,
			int		c,
	const	INT*	pdx,
			DWORD mrType
			);

//
// RoundRect
// DrawEdge
//
BOOL MF_RectDwDw(HDC hdc,DWORD iType,int x1,int y1,int x2,int y2,DWORD x3,DWORD y3);

//
// GradientFill
//
BOOL
MF_GradientFill(
	HDC hdc,
	PTRIVERTEX pVertex,
	ULONG nVertex,
	PVOID pMesh,
	ULONG nCount,
	ULONG ulMode
	);

//
// Obviously-named functions -- MF_XXX implements API XXX.
//
BOOL MF_RestoreDC(HDC hdc,int iLevel);
BOOL MF_DeleteObject(HANDLE h);
BOOL MF_RealizePalette(HPALETTE hpal);
BOOL MF_SetPaletteEntries(HPALETTE hpal, UINT iStart, UINT cEntries, CONST PALETTEENTRY *pPalEntries);
BOOL MF_FillRgn(HDC hdc,HRGN hrgn,HBRUSH hbrush);

//
// DO_METAFILE_THEN_CONTINUE is exactly li