metafile.c File Reference

#include <stdarg.h>
#include <math.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "wine/unicode.h"
#include "objbase.h"
#include "ocidl.h"
#include "olectl.h"
#include "ole2.h"
#include "winreg.h"
#include "shlwapi.h"
#include "gdiplus.h"
#include "gdiplus_private.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for metafile.c:

Go to the source code of this file.

Classes
struct	EmfPlusRecordHeader
struct	EmfPlusHeader
struct	EmfPlusClear
struct	EmfPlusFillRects
struct	EmfPlusSetClipRect
struct	EmfPlusSetPageTransform
struct	EmfPlusRect
struct	EmfPlusSetWorldTransform
struct	EmfPlusScaleWorldTransform
struct	EmfPlusMultiplyWorldTransform
struct	EmfPlusRotateWorldTransform
struct	EmfPlusTranslateWorldTransform
struct	EmfPlusBeginContainer
struct	EmfPlusContainerRecord
struct	container
struct	EmfPlusTransformMatrix
struct	EmfPlusDashedLineData
struct	EmfPlusCompoundLineData
struct	EmfPlusCustomStartCapData
struct	EmfPlusCustomEndCapData
struct	EmfPlusPenData
struct	EmfPlusSolidBrushData
struct	EmfPlusHatchBrushData
struct	EmfPlusTextureBrushData
struct	EmfPlusRectF
struct	EmfPlusLinearGradientBrushData
struct	EmfPlusBrush
struct	EmfPlusPen
struct	EmfPlusPath
struct	EmfPlusRegionNodePath
struct	EmfPlusRegion
struct	EmfPlusPalette
struct	EmfPlusBitmap
struct	EmfPlusMetafile
struct	EmfPlusImage
struct	EmfPlusImageAttributes
struct	EmfPlusObject
struct	EmfPlusPointR7
struct	EmfPlusPoint
struct	EmfPlusPointF
struct	EmfPlusDrawImage
struct	EmfPlusDrawImagePoints
struct	EmfPlusDrawPath
struct	EmfPlusDrawArc
struct	EmfPlusDrawEllipse
struct	EmfPlusDrawPie
struct	EmfPlusDrawRects
struct	EmfPlusFillPath
struct	EmfPlusFillClosedCurve
struct	EmfPlusFillEllipse
struct	EmfPlusFillPie
struct	EmfPlusFont
struct	enum_metafile_data

Macros
#define	NONAMELESSUNION
#define	COBJMACROS

Typedefs
typedef ARGB	EmfPlusARGB
typedef struct EmfPlusRecordHeader	EmfPlusRecordHeader
typedef struct EmfPlusHeader	EmfPlusHeader
typedef struct EmfPlusClear	EmfPlusClear
typedef struct EmfPlusFillRects	EmfPlusFillRects
typedef struct EmfPlusSetClipRect	EmfPlusSetClipRect
typedef struct EmfPlusSetPageTransform	EmfPlusSetPageTransform
typedef struct EmfPlusRect	EmfPlusRect
typedef struct EmfPlusSetWorldTransform	EmfPlusSetWorldTransform
typedef struct EmfPlusScaleWorldTransform	EmfPlusScaleWorldTransform
typedef struct EmfPlusMultiplyWorldTransform	EmfPlusMultiplyWorldTransform
typedef struct EmfPlusRotateWorldTransform	EmfPlusRotateWorldTransform
typedef struct EmfPlusTranslateWorldTransform	EmfPlusTranslateWorldTransform
typedef struct EmfPlusBeginContainer	EmfPlusBeginContainer
typedef struct EmfPlusContainerRecord	EmfPlusContainerRecord
typedef struct container	container
typedef struct EmfPlusTransformMatrix	EmfPlusTransformMatrix
typedef struct EmfPlusDashedLineData	EmfPlusDashedLineData
typedef struct EmfPlusCompoundLineData	EmfPlusCompoundLineData
typedef struct EmfPlusCustomStartCapData	EmfPlusCustomStartCapData
typedef struct EmfPlusCustomEndCapData	EmfPlusCustomEndCapData
typedef struct EmfPlusPenData	EmfPlusPenData
typedef struct EmfPlusSolidBrushData	EmfPlusSolidBrushData
typedef struct EmfPlusHatchBrushData	EmfPlusHatchBrushData
typedef struct EmfPlusTextureBrushData	EmfPlusTextureBrushData
typedef struct EmfPlusRectF	EmfPlusRectF
typedef struct EmfPlusLinearGradientBrushData	EmfPlusLinearGradientBrushData
typedef struct EmfPlusBrush	EmfPlusBrush
typedef struct EmfPlusPen	EmfPlusPen
typedef struct EmfPlusPath	EmfPlusPath
typedef struct EmfPlusRegionNodePath	EmfPlusRegionNodePath
typedef struct EmfPlusRegion	EmfPlusRegion
typedef struct EmfPlusPalette	EmfPlusPalette
typedef struct EmfPlusBitmap	EmfPlusBitmap
typedef struct EmfPlusMetafile	EmfPlusMetafile
typedef enum ImageDataType	ImageDataType
typedef struct EmfPlusImage	EmfPlusImage
typedef struct EmfPlusImageAttributes	EmfPlusImageAttributes
typedef struct EmfPlusObject	EmfPlusObject
typedef struct EmfPlusPointR7	EmfPlusPointR7
typedef struct EmfPlusPoint	EmfPlusPoint
typedef struct EmfPlusPointF	EmfPlusPointF
typedef struct EmfPlusDrawImage	EmfPlusDrawImage
typedef struct EmfPlusDrawImagePoints	EmfPlusDrawImagePoints
typedef struct EmfPlusDrawPath	EmfPlusDrawPath
typedef struct EmfPlusDrawArc	EmfPlusDrawArc
typedef struct EmfPlusDrawEllipse	EmfPlusDrawEllipse
typedef struct EmfPlusDrawPie	EmfPlusDrawPie
typedef struct EmfPlusDrawRects	EmfPlusDrawRects
typedef struct EmfPlusFillPath	EmfPlusFillPath
typedef struct EmfPlusFillClosedCurve	EmfPlusFillClosedCurve
typedef struct EmfPlusFillEllipse	EmfPlusFillEllipse
typedef struct EmfPlusFillPie	EmfPlusFillPie
typedef struct EmfPlusFont	EmfPlusFont

Enumerations
enum	container_type { BEGIN_CONTAINER , SAVE_GRAPHICS }
enum	PenDataFlags {   PenDataTransform = 0x0001 , PenDataStartCap = 0x0002 , PenDataEndCap = 0x0004 , PenDataJoin = 0x0008 ,   PenDataMiterLimit = 0x0010 , PenDataLineStyle = 0x0020 , PenDataDashedLineCap = 0x0040 , PenDataDashedLineOffset = 0x0080 ,   PenDataDashedLine = 0x0100 , PenDataNonCenter = 0x0200 , PenDataCompoundLine = 0x0400 , PenDataCustomStartCap = 0x0800 ,   PenDataCustomEndCap = 0x1000 }
enum	LineStyle {   LineStyleSolid , LineStyleDash , LineStyleDot , LineStyleDashDot ,   LineStyleDashDotDot , LineStyleCustom }
enum	BrushDataFlags {   BrushDataPath = 1 << 0 , BrushDataTransform = 1 << 1 , BrushDataPresetColors = 1 << 2 , BrushDataBlendFactorsH = 1 << 3 ,   BrushDataBlendFactorsV = 1 << 4 , BrushDataFocusScales = 1 << 6 , BrushDataIsGammaCorrected = 1 << 7 , BrushDataDoNotTransform = 1 << 8 }
enum	BitmapDataType { BitmapDataTypePixel , BitmapDataTypeCompressed }
enum	ImageDataType {   ImageDataTypeUnknown , ImageDataTypeBitmap , ImageDataTypeMetafile , ImageDataTypeUnknown ,   ImageDataTypeBitmap , ImageDataTypeMetafile }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (gdiplus)
HRESULT WINAPI	WICCreateImagingFactory_Proxy (UINT, IWICImagingFactory **)
static void	metafile_free_object_table_entry (GpMetafile *metafile, BYTE id)
void	METAFILE_Free (GpMetafile *metafile)
static DWORD	METAFILE_AddObjectId (GpMetafile *metafile)
static GpStatus	METAFILE_AllocateRecord (GpMetafile *metafile, DWORD size, void **result)
static void	METAFILE_RemoveLastRecord (GpMetafile *metafile, EmfPlusRecordHeader *record)
static void	METAFILE_WriteRecords (GpMetafile *metafile)
static GpStatus	METAFILE_WriteHeader (GpMetafile *metafile, HDC hdc)
static GpStatus	METAFILE_WriteEndOfFile (GpMetafile *metafile)
GpStatus WINGDIPAPI	GdipRecordMetafile (HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipRecordMetafileI (HDC hdc, EmfType type, GDIPCONST GpRect *frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipRecordMetafileStream (IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
static void	METAFILE_AdjustFrame (GpMetafile *metafile, const GpPointF *points, UINT num_points)
GpStatus	METAFILE_GetGraphicsContext (GpMetafile *metafile, GpGraphics **result)
GpStatus	METAFILE_GetDC (GpMetafile *metafile, HDC *hdc)
GpStatus	METAFILE_GraphicsClear (GpMetafile *metafile, ARGB color)
static BOOL	is_integer_rect (const GpRectF *rect)
static GpStatus	METAFILE_PrepareBrushData (GpBrush *brush, DWORD *size)
static void	METAFILE_FillBrushData (GpBrush *brush, EmfPlusBrush *data)
static GpStatus	METAFILE_AddBrushObject (GpMetafile *metafile, GpBrush *brush, DWORD *id)
GpStatus	METAFILE_FillRectangles (GpMetafile *metafile, GpBrush *brush, GDIPCONST GpRectF *rects, INT count)
GpStatus	METAFILE_SetClipRect (GpMetafile *metafile, REAL x, REAL y, REAL width, REAL height, CombineMode mode)
static GpStatus	METAFILE_AddRegionObject (GpMetafile *metafile, GpRegion *region, DWORD *id)
GpStatus	METAFILE_SetClipRegion (GpMetafile *metafile, GpRegion *region, CombineMode mode)
GpStatus	METAFILE_SetPageTransform (GpMetafile *metafile, GpUnit unit, REAL scale)
GpStatus	METAFILE_SetWorldTransform (GpMetafile *metafile, GDIPCONST GpMatrix *transform)
GpStatus	METAFILE_ScaleWorldTransform (GpMetafile *metafile, REAL sx, REAL sy, MatrixOrder order)
GpStatus	METAFILE_MultiplyWorldTransform (GpMetafile *metafile, GDIPCONST GpMatrix *matrix, MatrixOrder order)
GpStatus	METAFILE_RotateWorldTransform (GpMetafile *metafile, REAL angle, MatrixOrder order)
GpStatus	METAFILE_TranslateWorldTransform (GpMetafile *metafile, REAL dx, REAL dy, MatrixOrder order)
GpStatus	METAFILE_ResetWorldTransform (GpMetafile *metafile)
GpStatus	METAFILE_BeginContainer (GpMetafile *metafile, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, DWORD StackIndex)
GpStatus	METAFILE_BeginContainerNoParams (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_EndContainer (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_SaveGraphics (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_RestoreGraphics (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_ReleaseDC (GpMetafile *metafile, HDC hdc)
GpStatus	METAFILE_GraphicsDeleted (GpMetafile *metafile)
GpStatus WINGDIPAPI	GdipGetHemfFromMetafile (GpMetafile *metafile, HENHMETAFILE *hEmf)
static void	METAFILE_GetFinalGdiTransform (const GpMetafile *metafile, XFORM *result)
static GpStatus	METAFILE_PlaybackUpdateGdiTransform (GpMetafile *metafile)
static GpStatus	METAFILE_PlaybackGetDC (GpMetafile *metafile)
static void	METAFILE_PlaybackReleaseDC (GpMetafile *metafile)
static GpStatus	METAFILE_PlaybackUpdateClip (GpMetafile *metafile)
static GpStatus	METAFILE_PlaybackUpdateWorldTransform (GpMetafile *metafile)
static void	metafile_set_object_table_entry (GpMetafile *metafile, BYTE id, BYTE type, void *object)
static GpStatus	metafile_deserialize_image (const BYTE *record_data, UINT data_size, GpImage **image)
static GpStatus	metafile_deserialize_path (const BYTE *record_data, UINT data_size, GpPath **path)
static GpStatus	metafile_read_region_node (struct memory_buffer *mbuf, GpRegion *region, region_element *node, UINT *count)
static GpStatus	metafile_deserialize_region (const BYTE *record_data, UINT data_size, GpRegion **region)
static GpStatus	metafile_deserialize_brush (const BYTE *record_data, UINT data_size, GpBrush **brush)
static GpStatus	metafile_get_pen_brush_data_offset (EmfPlusPen *data, UINT data_size, DWORD *ret)
static GpStatus	METAFILE_PlaybackObject (GpMetafile *metafile, UINT flags, UINT data_size, const BYTE *record_data)
static GpStatus	metafile_set_clip_region (GpMetafile *metafile, GpRegion *region, CombineMode mode)
GpStatus WINGDIPAPI	GdipPlayMetafileRecord (GDIPCONST GpMetafile *metafile, EmfPlusRecordType recordType, UINT flags, UINT dataSize, GDIPCONST BYTE *data)
static int CALLBACK	enum_metafile_proc (HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR, int nObj, LPARAM lpData)
GpStatus WINGDIPAPI	GdipEnumerateMetafileSrcRectDestPoints (GpGraphics *graphics, GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *destPoints, INT count, GDIPCONST GpRectF *srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, GDIPCONST GpImageAttributes *imageAttributes)
GpStatus WINGDIPAPI	GdipEnumerateMetafileDestRect (GpGraphics *graphics, GDIPCONST GpMetafile *metafile, GDIPCONST GpRectF *dest, EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
GpStatus WINGDIPAPI	GdipEnumerateMetafileDestRectI (GpGraphics *graphics, GDIPCONST GpMetafile *metafile, GDIPCONST GpRect *dest, EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
GpStatus WINGDIPAPI	GdipEnumerateMetafileDestPoint (GpGraphics *graphics, GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *dest, EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
GpStatus WINGDIPAPI	GdipEnumerateMetafileDestPointI (GpGraphics *graphics, GDIPCONST GpMetafile *metafile, GDIPCONST GpPoint *dest, EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromMetafile (GpMetafile *metafile, MetafileHeader *header)
static int CALLBACK	get_emfplus_header_proc (HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR, int nObj, LPARAM lpData)
GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromEmf (HENHMETAFILE hemf, MetafileHeader *header)
GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromWmf (HMETAFILE hwmf, GDIPCONST WmfPlaceableFileHeader *placeable, MetafileHeader *header)
GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromFile (GDIPCONST WCHAR *filename, MetafileHeader *header)
GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromStream (IStream *stream, MetafileHeader *header)
GpStatus WINGDIPAPI	GdipCreateMetafileFromEmf (HENHMETAFILE hemf, BOOL delete, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipCreateMetafileFromWmf (HMETAFILE hwmf, BOOL delete, GDIPCONST WmfPlaceableFileHeader *placeable, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipCreateMetafileFromWmfFile (GDIPCONST WCHAR *file, GDIPCONST WmfPlaceableFileHeader *placeable, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipCreateMetafileFromFile (GDIPCONST WCHAR *file, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipCreateMetafileFromStream (IStream *stream, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipSetMetafileDownLevelRasterizationLimit (GpMetafile *metafile, UINT limitDpi)
GpStatus WINGDIPAPI	GdipConvertToEmfPlus (const GpGraphics *ref, GpMetafile *metafile, BOOL *succ, EmfType emfType, const WCHAR *description, GpMetafile **out_metafile)
GpStatus WINGDIPAPI	GdipEmfToWmfBits (HENHMETAFILE hemf, UINT cbData16, LPBYTE pData16, INT iMapMode, INT eFlags)
GpStatus WINGDIPAPI	GdipRecordMetafileFileName (GDIPCONST WCHAR *fileName, HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipRecordMetafileFileNameI (GDIPCONST WCHAR *fileName, HDC hdc, EmfType type, GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
GpStatus WINGDIPAPI	GdipConvertToEmfPlusToFile (const GpGraphics *refGraphics, GpMetafile *metafile, BOOL *conversionSuccess, const WCHAR *filename, EmfType emfType, const WCHAR *description, GpMetafile **out_metafile)
static GpStatus	METAFILE_CreateCompressedImageStream (GpImage *image, IStream **stream, DWORD *size)
static GpStatus	METAFILE_FillEmfPlusBitmap (EmfPlusBitmap *record, IStream *stream, DWORD size)
static GpStatus	METAFILE_AddImageObject (GpMetafile *metafile, GpImage *image, DWORD *id)
static GpStatus	METAFILE_AddImageAttributesObject (GpMetafile *metafile, const GpImageAttributes *attrs, DWORD *id)
GpStatus	METAFILE_DrawImagePointsRect (GpMetafile *metafile, GpImage *image, GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
GpStatus	METAFILE_AddSimpleProperty (GpMetafile *metafile, SHORT prop, SHORT val)
static GpStatus	METAFILE_AddPathObject (GpMetafile *metafile, GpPath *path, DWORD *id)
static GpStatus	METAFILE_AddPenObject (GpMetafile *metafile, GpPen *pen, DWORD *id)
GpStatus	METAFILE_DrawPath (GpMetafile *metafile, GpPen *pen, GpPath *path)
GpStatus	METAFILE_FillPath (GpMetafile *metafile, GpBrush *brush, GpPath *path)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 30 of file metafile.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 23 of file metafile.c.

Typedef Documentation

container

typedef struct container container

EmfPlusARGB

typedef ARGB EmfPlusARGB

Definition at line 48 of file metafile.c.

EmfPlusBeginContainer

typedef struct EmfPlusBeginContainer EmfPlusBeginContainer

EmfPlusBitmap

typedef struct EmfPlusBitmap EmfPlusBitmap

EmfPlusBrush

typedef struct EmfPlusBrush EmfPlusBrush

EmfPlusClear

typedef struct EmfPlusClear EmfPlusClear

EmfPlusCompoundLineData

typedef struct EmfPlusCompoundLineData EmfPlusCompoundLineData

EmfPlusContainerRecord

typedef struct EmfPlusContainerRecord EmfPlusContainerRecord

EmfPlusCustomEndCapData

typedef struct EmfPlusCustomEndCapData EmfPlusCustomEndCapData

EmfPlusCustomStartCapData

typedef struct EmfPlusCustomStartCapData EmfPlusCustomStartCapData

EmfPlusDashedLineData

typedef struct EmfPlusDashedLineData EmfPlusDashedLineData

EmfPlusDrawArc

typedef struct EmfPlusDrawArc EmfPlusDrawArc

EmfPlusDrawEllipse

typedef struct EmfPlusDrawEllipse EmfPlusDrawEllipse

EmfPlusDrawImage

typedef struct EmfPlusDrawImage EmfPlusDrawImage

EmfPlusDrawImagePoints

typedef struct EmfPlusDrawImagePoints EmfPlusDrawImagePoints

EmfPlusDrawPath

typedef struct EmfPlusDrawPath EmfPlusDrawPath

EmfPlusDrawPie

typedef struct EmfPlusDrawPie EmfPlusDrawPie

EmfPlusDrawRects

typedef struct EmfPlusDrawRects EmfPlusDrawRects

EmfPlusFillClosedCurve

typedef struct EmfPlusFillClosedCurve EmfPlusFillClosedCurve

EmfPlusFillEllipse

typedef struct EmfPlusFillEllipse EmfPlusFillEllipse

EmfPlusFillPath

typedef struct EmfPlusFillPath EmfPlusFillPath

EmfPlusFillPie

typedef struct EmfPlusFillPie EmfPlusFillPie

EmfPlusFillRects

typedef struct EmfPlusFillRects EmfPlusFillRects

EmfPlusFont

typedef struct EmfPlusFont EmfPlusFont

EmfPlusHatchBrushData

typedef struct EmfPlusHatchBrushData EmfPlusHatchBrushData

EmfPlusHeader

typedef struct EmfPlusHeader EmfPlusHeader

EmfPlusImage

typedef struct EmfPlusImage EmfPlusImage

EmfPlusImageAttributes

typedef struct EmfPlusImageAttributes EmfPlusImageAttributes

EmfPlusLinearGradientBrushData

typedef struct EmfPlusLinearGradientBrushData EmfPlusLinearGradientBrushData

EmfPlusMetafile

typedef struct EmfPlusMetafile EmfPlusMetafile

EmfPlusMultiplyWorldTransform

typedef struct EmfPlusMultiplyWorldTransform EmfPlusMultiplyWorldTransform

EmfPlusObject

typedef struct EmfPlusObject EmfPlusObject

EmfPlusPalette

typedef struct EmfPlusPalette EmfPlusPalette

EmfPlusPath

typedef struct EmfPlusPath EmfPlusPath

EmfPlusPen

typedef struct EmfPlusPen EmfPlusPen

EmfPlusPenData

typedef struct EmfPlusPenData EmfPlusPenData

EmfPlusPoint

typedef struct EmfPlusPoint EmfPlusPoint

EmfPlusPointF

typedef struct EmfPlusPointF EmfPlusPointF

EmfPlusPointR7

typedef struct EmfPlusPointR7 EmfPlusPointR7

EmfPlusRecordHeader

typedef struct EmfPlusRecordHeader EmfPlusRecordHeader

EmfPlusRect

typedef struct EmfPlusRect EmfPlusRect

EmfPlusRectF

typedef struct EmfPlusRectF EmfPlusRectF

EmfPlusRegion

typedef struct EmfPlusRegion EmfPlusRegion

EmfPlusRegionNodePath

typedef struct EmfPlusRegionNodePath EmfPlusRegionNodePath

EmfPlusRotateWorldTransform

typedef struct EmfPlusRotateWorldTransform EmfPlusRotateWorldTransform

EmfPlusScaleWorldTransform

typedef struct EmfPlusScaleWorldTransform EmfPlusScaleWorldTransform

EmfPlusSetClipRect

typedef struct EmfPlusSetClipRect EmfPlusSetClipRect

EmfPlusSetPageTransform

typedef struct EmfPlusSetPageTransform EmfPlusSetPageTransform

EmfPlusSetWorldTransform

typedef struct EmfPlusSetWorldTransform EmfPlusSetWorldTransform

EmfPlusSolidBrushData

typedef struct EmfPlusSolidBrushData EmfPlusSolidBrushData

EmfPlusTextureBrushData

typedef struct EmfPlusTextureBrushData EmfPlusTextureBrushData

EmfPlusTransformMatrix

typedef struct EmfPlusTransformMatrix EmfPlusTransformMatrix

EmfPlusTranslateWorldTransform

typedef struct EmfPlusTranslateWorldTransform EmfPlusTranslateWorldTransform

ImageDataType

typedef enum ImageDataType ImageDataType

Enumeration Type Documentation

BitmapDataType

enum BitmapDataType

Enumerator
BitmapDataTypePixel
BitmapDataTypeCompressed

Definition at line 331 of file metafile.c.

{
    BitmapDataTypePixel,
    BitmapDataTypeCompressed,
} BitmapDataType;

BrushDataFlags

enum BrushDataFlags

Enumerator
BrushDataPath
BrushDataTransform
BrushDataPresetColors
BrushDataBlendFactorsH
BrushDataBlendFactorsV
BrushDataFocusScales
BrushDataIsGammaCorrected
BrushDataDoNotTransform

Definition at line 228 of file metafile.c.

{
    BrushDataPath             = 1 << 0,
    BrushDataTransform        = 1 << 1,
    BrushDataPresetColors     = 1 << 2,
    BrushDataBlendFactorsH    = 1 << 3,
    BrushDataBlendFactorsV    = 1 << 4,
    BrushDataFocusScales      = 1 << 6,
    BrushDataIsGammaCorrected = 1 << 7,
    BrushDataDoNotTransform   = 1 << 8,
};

container_type

enum container_type

Enumerator
BEGIN_CONTAINER
SAVE_GRAPHICS

Definition at line 146 of file metafile.c.

{
    BEGIN_CONTAINER,
    SAVE_GRAPHICS
};

ImageDataType

enum ImageDataType

Enumerator
ImageDataTypeUnknown
ImageDataTypeBitmap
ImageDataTypeMetafile
ImageDataTypeUnknown
ImageDataTypeBitmap
ImageDataTypeMetafile

Definition at line 354 of file metafile.c.

{
    ImageDataTypeUnknown,
    ImageDataTypeBitmap,
    ImageDataTypeMetafile,
} ImageDataType;

LineStyle

enum LineStyle

Enumerator
LineStyleSolid
LineStyleDash
LineStyleDot
LineStyleDashDot
LineStyleDashDotDot
LineStyleCustom

Definition at line 186 of file metafile.c.

{
    LineStyleSolid,
    LineStyleDash,
    LineStyleDot,
    LineStyleDashDot,
    LineStyleDashDotDot,
    LineStyleCustom
};

PenDataFlags

enum PenDataFlags

Enumerator
PenDataTransform
PenDataStartCap
PenDataEndCap
PenDataJoin
PenDataMiterLimit
PenDataLineStyle
PenDataDashedLineCap
PenDataDashedLineOffset
PenDataDashedLine
PenDataNonCenter
PenDataCompoundLine
PenDataCustomStartCap
PenDataCustomEndCap

Definition at line 164 of file metafile.c.

{
    PenDataTransform        = 0x0001,
    PenDataStartCap         = 0x0002,
    PenDataEndCap           = 0x0004,
    PenDataJoin             = 0x0008,
    PenDataMiterLimit       = 0x0010,
    PenDataLineStyle        = 0x0020,
    PenDataDashedLineCap    = 0x0040,
    PenDataDashedLineOffset = 0x0080,
    PenDataDashedLine       = 0x0100,
    PenDataNonCenter        = 0x0200,
    PenDataCompoundLine     = 0x0400,
    PenDataCustomStartCap   = 0x0800,
    PenDataCustomEndCap     = 0x1000
};

Function Documentation

enum_metafile_proc()

static int CALLBACK enum_metafile_proc ( HDC  hDC, HANDLETABLE *  lpHTable, const ENHMETARECORD *  lpEMFR, int  nObj, LPARAM  lpData  )

static

Definition at line 3385 of file metafile.c.

{
    BOOL ret;
    struct enum_metafile_data *data = (struct enum_metafile_data*)lpData;
    const BYTE* pStr;
 
    data->metafile->handle_table = lpHTable;
    data->metafile->handle_count = nObj;
 
    /* First check for an EMF+ record. */
    if (lpEMFR->iType == EMR_GDICOMMENT)
    {
        const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
 
        if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
        {
            int offset = 4;
 
            while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
            {
                const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
 
                if (record->DataSize)
                    pStr = (const BYTE*)(record+1);
                else
                    pStr = NULL;
 
                ret = data->callback(record->Type, record->Flags, record->DataSize,
                    pStr, data->callback_data);
 
                if (!ret)
                    return 0;
 
                offset += record->Size;
            }
 
            return 1;
        }
    }
 
    if (lpEMFR->nSize != 8)
        pStr = (const BYTE*)lpEMFR->dParm;
    else
        pStr = NULL;
 
    return data->callback(lpEMFR->iType, 0, lpEMFR->nSize-8,
        pStr, data->callback_data);
}

Referenced by check_metafile(), and GdipEnumerateMetafileSrcRectDestPoints().

GdipConvertToEmfPlus()

GpStatus WINGDIPAPI GdipConvertToEmfPlus	(	const GpGraphics *	ref,
		GpMetafile *	metafile,
		BOOL *	succ,
		EmfType	emfType,
		const WCHAR *	description,
		GpMetafile **	out_metafile
	)

Definition at line 3964 of file metafile.c.

{
    static int calls;
 
    TRACE("(%p,%p,%p,%u,%s,%p)\n", ref, metafile, succ, emfType,
        debugstr_w(description), out_metafile);
 
    if(!ref || !metafile || !out_metafile || emfType < EmfTypeEmfOnly || emfType > EmfTypeEmfPlusDual)
        return InvalidParameter;
 
    if(succ)
        *succ = FALSE;
    *out_metafile = NULL;
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

GdipConvertToEmfPlusToFile()

GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile	(	const GpGraphics *	refGraphics,
		GpMetafile *	metafile,
		BOOL *	conversionSuccess,
		const WCHAR *	filename,
		EmfType	emfType,
		const WCHAR *	description,
		GpMetafile **	out_metafile
	)

Definition at line 4018 of file metafile.c.

{
    FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
    return NotImplemented;
}

GdipCreateMetafileFromEmf()

GpStatus WINGDIPAPI GdipCreateMetafileFromEmf	(	HENHMETAFILE	hemf,
		BOOL	delete,
		GpMetafile **	metafile
	)

Definition at line 3804 of file metafile.c.

{
    GpStatus stat;
    MetafileHeader header;
 
    TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
 
    if(!hemf || !metafile)
        return InvalidParameter;
 
    stat = GdipGetMetafileHeaderFromEmf(hemf, &header);
    if (stat != Ok)
        return stat;
 
    *metafile = heap_alloc_zero(sizeof(GpMetafile));
    if (!*metafile)
        return OutOfMemory;
 
    (*metafile)->image.type = ImageTypeMetafile;
    (*metafile)->image.format = ImageFormatEMF;
    (*metafile)->image.frame_count = 1;
    (*metafile)->image.xres = header.DpiX;
    (*metafile)->image.yres = header.DpiY;
    (*metafile)->bounds.X = (REAL)header.u.EmfHeader.rclFrame.left / 2540.0 * header.DpiX;
    (*metafile)->bounds.Y = (REAL)header.u.EmfHeader.rclFrame.top / 2540.0 * header.DpiY;
    (*metafile)->bounds.Width = (REAL)(header.u.EmfHeader.rclFrame.right - header.u.EmfHeader.rclFrame.left)
                                / 2540.0 * header.DpiX;
    (*metafile)->bounds.Height = (REAL)(header.u.EmfHeader.rclFrame.bottom - header.u.EmfHeader.rclFrame.top)
                                 / 2540.0 * header.DpiY;
    (*metafile)->unit = UnitPixel;
    (*metafile)->metafile_type = header.Type;
    (*metafile)->hemf = hemf;
    (*metafile)->preserve_hemf = !delete;
    list_init(&(*metafile)->containers);
 
    TRACE("<-- %p\n", *metafile);
 
    return Ok;
}

Referenced by GdipCreateMetafileFromWmf(), GdipCreateMetafileFromWmfFile(), load_emf(), sync_metafile(), test_drawimage(), test_emfonly(), and test_empty().

GdipCreateMetafileFromFile()

GpStatus WINGDIPAPI GdipCreateMetafileFromFile	(	GDIPCONST WCHAR *	file,
		GpMetafile **	metafile
	)

Definition at line 3915 of file metafile.c.

{
    GpStatus status;
    IStream *stream;
 
    TRACE("(%p, %p)\n", file, metafile);
 
    if (!file || !metafile) return InvalidParameter;
 
    *metafile = NULL;
 
    status = GdipCreateStreamOnFile(file, GENERIC_READ, &stream);
    if (status == Ok)
    {
        status = GdipCreateMetafileFromStream(stream, metafile);
        IStream_Release(stream);
    }
    return status;
}

Referenced by GdipGetMetafileHeaderFromFile().

GdipCreateMetafileFromStream()

GpStatus WINGDIPAPI GdipCreateMetafileFromStream	(	IStream *	stream,
		GpMetafile **	metafile
	)

Definition at line 3936 of file metafile.c.

{
    GpStatus stat;
 
    TRACE("%p %p\n", stream, metafile);
 
    stat = GdipLoadImageFromStream(stream, (GpImage **)metafile);
    if (stat != Ok) return stat;
 
    if ((*metafile)->image.type != ImageTypeMetafile)
    {
        GdipDisposeImage(&(*metafile)->image);
        *metafile = NULL;
        return GenericError;
    }
 
    return Ok;
}

Referenced by GdipCreateMetafileFromFile(), and GdipGetMetafileHeaderFromStream().

GdipCreateMetafileFromWmf()

GpStatus WINGDIPAPI GdipCreateMetafileFromWmf	(	HMETAFILE	hwmf,
		BOOL	delete,
		GDIPCONST WmfPlaceableFileHeader *	placeable,
		GpMetafile **	metafile
	)

Definition at line 3845 of file metafile.c.

{
    UINT read;
    BYTE *copy;
    HENHMETAFILE hemf;
    GpStatus retval = Ok;
 
    TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
 
    if(!hwmf || !metafile)
        return InvalidParameter;
 
    *metafile = NULL;
    read = GetMetaFileBitsEx(hwmf, 0, NULL);
    if(!read)
        return GenericError;
    copy = heap_alloc_zero(read);
    GetMetaFileBitsEx(hwmf, read, copy);
 
    hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
    heap_free(copy);
 
    /* FIXME: We should store and use hwmf instead of converting to hemf */
    retval = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
 
    if (retval == Ok)
    {
        if (placeable)
        {
            (*metafile)->image.xres = (REAL)placeable->Inch;
            (*metafile)->image.yres = (REAL)placeable->Inch;
            (*metafile)->bounds.X = ((REAL)placeable->BoundingBox.Left) / ((REAL)placeable->Inch);
            (*metafile)->bounds.Y = ((REAL)placeable->BoundingBox.Top) / ((REAL)placeable->Inch);
            (*metafile)->bounds.Width = (REAL)(placeable->BoundingBox.Right -
                                               placeable->BoundingBox.Left);
            (*metafile)->bounds.Height = (REAL)(placeable->BoundingBox.Bottom -
                                                placeable->BoundingBox.Top);
            (*metafile)->metafile_type = MetafileTypeWmfPlaceable;
        }
        else
            (*metafile)->metafile_type = MetafileTypeWmf;
        (*metafile)->image.format = ImageFormatWMF;
 
        if (delete) DeleteMetaFile(hwmf);
    }
    else
        DeleteEnhMetaFile(hemf);
    return retval;
}

Referenced by GdipCreateMetafileFromWmfFile(), GdipGetMetafileHeaderFromWmf(), load_wmf(), test_createfromwmf(), and test_createfromwmf_noplaceable().

GdipCreateMetafileFromWmfFile()

GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile	(	GDIPCONST WCHAR *	file,
		GDIPCONST WmfPlaceableFileHeader *	placeable,
		GpMetafile **	metafile
	)

Definition at line 3896 of file metafile.c.

{
    HMETAFILE hmf;
    HENHMETAFILE emf;
 
    TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
 
    hmf = GetMetaFileW(file);
    if(hmf)
        return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
 
    emf = GetEnhMetaFileW(file);
    if(emf)
        return GdipCreateMetafileFromEmf(emf, TRUE, metafile);
 
    return GenericError;
}

Referenced by test_fillpath().

GdipEmfToWmfBits()

GpStatus WINGDIPAPI GdipEmfToWmfBits	(	HENHMETAFILE	hemf,
		UINT	cbData16,
		LPBYTE	pData16,
		INT	iMapMode,
		INT	eFlags
	)

Definition at line 3986 of file metafile.c.

{
    FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
    return NotImplemented;
}

GdipEnumerateMetafileDestPoint()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpPointF *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3602 of file metafile.c.

{
    GpRectF destf;
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    destf.X = dest->X;
    destf.Y = dest->Y;
    destf.Width = units_to_pixels(metafile->bounds.Width, metafile->unit, metafile->image.xres);
    destf.Height = units_to_pixels(metafile->bounds.Height, metafile->unit, metafile->image.yres);
 
    return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
}

Referenced by GdipEnumerateMetafileDestPointI().

GdipEnumerateMetafileDestPointI()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpPoint *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3618 of file metafile.c.

{
    GpPointF ptf;
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    ptf.X = dest->X;
    ptf.Y = dest->Y;
 
    return GdipEnumerateMetafileDestPoint(graphics, metafile, &ptf, callback, cb_data, attrs);
}

GdipEnumerateMetafileDestRect()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpRectF *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3569 of file metafile.c.

{
    GpPointF points[3];
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    points[0].X = points[2].X = dest->X;
    points[0].Y = points[1].Y = dest->Y;
    points[1].X = dest->X + dest->Width;
    points[2].Y = dest->Y + dest->Height;
 
    return GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, points, 3,
        &metafile->bounds, metafile->unit, callback, cb_data, attrs);
}

Referenced by GdipEnumerateMetafileDestPoint(), and GdipEnumerateMetafileDestRectI().

GdipEnumerateMetafileDestRectI()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpRect *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3586 of file metafile.c.

{
    GpRectF destf;
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    destf.X = dest->X;
    destf.Y = dest->Y;
    destf.Width = dest->Width;
    destf.Height = dest->Height;
 
    return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
}

GdipEnumerateMetafileSrcRectDestPoints()

GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpPointF *	destPoints,
		INT	count,
		GDIPCONST GpRectF *	srcRect,
		Unit	srcUnit,
		EnumerateMetafileProc	callback,
		VOID *	callbackData,
		GDIPCONST GpImageAttributes *	imageAttributes
	)

Definition at line 3435 of file metafile.c.

{
    struct enum_metafile_data data;
    GpStatus stat;
    GpMetafile *real_metafile = (GpMetafile*)metafile; /* whoever made this const was joking */
    GraphicsContainer state;
    GpPath *dst_path;
 
    TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics, metafile,
        destPoints, count, srcRect, srcUnit, callback, callbackData,
        imageAttributes);
 
    if (!graphics || !metafile || !destPoints || count != 3 || !srcRect)
        return InvalidParameter;
 
    if (!metafile->hemf)
        return InvalidParameter;
 
    if (metafile->playback_graphics)
        return ObjectBusy;
 
    TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect), srcUnit,
        debugstr_pointf(&destPoints[0]), debugstr_pointf(&destPoints[1]),
        debugstr_pointf(&destPoints[2]));
 
    data.callback = callback;
    data.callback_data = callbackData;
    data.metafile = real_metafile;
 
    real_metafile->playback_graphics = graphics;
    real_metafile->playback_dc = NULL;
    real_metafile->src_rect = *srcRect;
 
    memcpy(real_metafile->playback_points, destPoints, sizeof(PointF) * 3);
    stat = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, real_metafile->playback_points, 3);
 
    if (stat == Ok)
        stat = GdipBeginContainer2(graphics, &state);
 
    if (stat == Ok)
    {
        stat = GdipSetPageScale(graphics, 1.0);
 
        if (stat == Ok)
            stat = GdipSetPageUnit(graphics, UnitPixel);
 
        if (stat == Ok)
            stat = GdipResetWorldTransform(graphics);
 
        if (stat == Ok)
            stat = GdipCreateRegion(&real_metafile->base_clip);
 
        if (stat == Ok)
            stat = GdipGetClip(graphics, real_metafile->base_clip);
 
        if (stat == Ok)
            stat = GdipCreateRegion(&real_metafile->clip);
 
        if (stat == Ok)
            stat = GdipCreatePath(FillModeAlternate, &dst_path);
 
        if (stat == Ok)
        {
            GpPointF clip_points[4];
 
            clip_points[0] = real_metafile->playback_points[0];
            clip_points[1] = real_metafile->playback_points[1];
            clip_points[2].X = real_metafile->playback_points[1].X + real_metafile->playback_points[2].X
                - real_metafile->playback_points[0].X;
            clip_points[2].Y = real_metafile->playback_points[1].Y + real_metafile->playback_points[2].Y
                - real_metafile->playback_points[0].Y;
            clip_points[3] = real_metafile->playback_points[2];
 
            stat = GdipAddPathPolygon(dst_path, clip_points, 4);
 
            if (stat == Ok)
                stat = GdipCombineRegionPath(real_metafile->base_clip, dst_path, CombineModeIntersect);
 
            GdipDeletePath(dst_path);
        }
 
        if (stat == Ok)
            stat = GdipCreateMatrix(&real_metafile->world_transform);
 
        if (stat == Ok)
        {
            real_metafile->page_unit = UnitDisplay;
            real_metafile->page_scale = 1.0;
            stat = METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
 
        if (stat == Ok)
        {
            stat = METAFILE_PlaybackUpdateClip(real_metafile);
        }
 
        if (stat == Ok && (metafile->metafile_type == MetafileTypeEmf ||
            metafile->metafile_type == MetafileTypeWmfPlaceable ||
            metafile->metafile_type == MetafileTypeWmf))
            stat = METAFILE_PlaybackGetDC(real_metafile);
 
        if (stat == Ok)
            EnumEnhMetaFile(0, metafile->hemf, enum_metafile_proc, &data, NULL);
 
        METAFILE_PlaybackReleaseDC(real_metafile);
 
        GdipDeleteMatrix(real_metafile->world_transform);
        real_metafile->world_transform = NULL;
 
        GdipDeleteRegion(real_metafile->base_clip);
        real_metafile->base_clip = NULL;
 
        GdipDeleteRegion(real_metafile->clip);
        real_metafile->clip = NULL;
 
        while (list_head(&real_metafile->containers))
        {
            container* cont = LIST_ENTRY(list_head(&real_metafile->containers), container, entry);
            list_remove(&cont->entry);
            GdipDeleteRegion(cont->clip);
            heap_free(cont);
        }
 
        GdipEndContainer(graphics, state);
    }
 
    real_metafile->playback_graphics = NULL;
 
    return stat;
}

Referenced by check_metafile(), GdipDrawImagePointsRect(), GdipEnumerateMetafileDestRect(), and play_metafile().

GdipGetHemfFromMetafile()

GpStatus WINGDIPAPI GdipGetHemfFromMetafile	(	GpMetafile *	metafile,
		HENHMETAFILE *	hEmf
	)

Definition at line 1613 of file metafile.c.

{
    TRACE("(%p,%p)\n", metafile, hEmf);
 
    if (!metafile || !hEmf || !metafile->hemf)
        return InvalidParameter;
 
    *hEmf = metafile->hemf;
    metafile->hemf = NULL;
 
    return Ok;
}

Referenced by sync_metafile(), test_clear(), test_drawimage(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_gditransform(), test_getdc(), and test_properties().

GdipGetMetafileHeaderFromEmf()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf	(	HENHMETAFILE	hemf,
		MetafileHeader *	header
	)

Definition at line 3688 of file metafile.c.

{
    ENHMETAHEADER3 emfheader;
    EmfPlusHeader emfplusheader;
    MetafileType metafile_type;
 
    TRACE("(%p,%p)\n", hemf, header);
 
    if(!hemf || !header)
        return InvalidParameter;
 
    if (GetEnhMetaFileHeader(hemf, sizeof(emfheader), (ENHMETAHEADER*)&emfheader) == 0)
        return GenericError;
 
    emfplusheader.Header.Type = 0;
 
    EnumEnhMetaFile(NULL, hemf, get_emfplus_header_proc, &emfplusheader, NULL);
 
    if (emfplusheader.Header.Type == EmfPlusRecordTypeHeader)
    {
        if ((emfplusheader.Header.Flags & 1) == 1)
            metafile_type = MetafileTypeEmfPlusDual;
        else
            metafile_type = MetafileTypeEmfPlusOnly;
    }
    else
        metafile_type = MetafileTypeEmf;
 
    header->Type = metafile_type;
    header->Size = emfheader.nBytes;
    header->DpiX = (REAL)emfheader.szlDevice.cx * 25.4 / emfheader.szlMillimeters.cx;
    header->DpiY = (REAL)emfheader.szlDevice.cy * 25.4 / emfheader.szlMillimeters.cy;
    header->X = gdip_round((REAL)emfheader.rclFrame.left / 2540.0 * header->DpiX);
    header->Y = gdip_round((REAL)emfheader.rclFrame.top / 2540.0 * header->DpiY);
    header->Width = gdip_round((REAL)(emfheader.rclFrame.right - emfheader.rclFrame.left) / 2540.0 * header->DpiX);
    header->Height = gdip_round((REAL)(emfheader.rclFrame.bottom - emfheader.rclFrame.top) / 2540.0 * header->DpiY);
    header->u.EmfHeader = emfheader;
 
    if (metafile_type == MetafileTypeEmfPlusDual || metafile_type == MetafileTypeEmfPlusOnly)
    {
        header->Version = emfplusheader.Version;
        header->EmfPlusFlags = emfplusheader.EmfPlusFlags;
        header->EmfPlusHeaderSize = emfplusheader.Header.Size;
        header->LogicalDpiX = emfplusheader.LogicalDpiX;
        header->LogicalDpiY = emfplusheader.LogicalDpiY;
    }
    else
    {
        header->Version = emfheader.nVersion;
        header->EmfPlusFlags = 0;
        header->EmfPlusHeaderSize = 0;
        header->LogicalDpiX = 0;
        header->LogicalDpiY = 0;
    }
 
    return Ok;
}

Referenced by GdipCreateMetafileFromEmf(), GdipGetMetafileHeaderFromMetafile(), METAFILE_GraphicsDeleted(), test_emfonly(), and test_empty().

GdipGetMetafileHeaderFromFile()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile	(	GDIPCONST WCHAR *	filename,
		MetafileHeader *	header
	)

Definition at line 3764 of file metafile.c.

{
    GpStatus status;
    GpMetafile *metafile;
 
    TRACE("(%s,%p)\n", debugstr_w(filename), header);
 
    if (!filename || !header)
        return InvalidParameter;
 
    status = GdipCreateMetafileFromFile(filename, &metafile);
    if (status == Ok)
    {
        status = GdipGetMetafileHeaderFromMetafile(metafile, header);
        GdipDisposeImage(&metafile->image);
    }
    return status;
}

GdipGetMetafileHeaderFromMetafile()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile	(	GpMetafile *	metafile,
		MetafileHeader *	header
	)

Definition at line 3632 of file metafile.c.

{
    GpStatus status;
 
    TRACE("(%p, %p)\n", metafile, header);
 
    if(!metafile || !header)
        return InvalidParameter;
 
    if (metafile->hemf)
    {
        status = GdipGetMetafileHeaderFromEmf(metafile->hemf, header);
        if (status != Ok) return status;
    }
    else
    {
        memset(header, 0, sizeof(*header));
        header->Version = VERSION_MAGIC2;
    }
 
    header->Type = metafile->metafile_type;
    header->DpiX = metafile->image.xres;
    header->DpiY = metafile->image.yres;
    header->Width = gdip_round(metafile->bounds.Width);
    header->Height = gdip_round(metafile->bounds.Height);
 
    return Ok;
}

Referenced by GdipGetMetafileHeaderFromFile(), GdipGetMetafileHeaderFromStream(), GdipGetMetafileHeaderFromWmf(), test_createfromwmf(), test_emfonly(), test_empty(), test_gditransform(), and test_loadwmf().

GdipGetMetafileHeaderFromStream()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream	(	IStream *	stream,
		MetafileHeader *	header
	)

Definition at line 3784 of file metafile.c.

{
    GpStatus status;
    GpMetafile *metafile;
 
    TRACE("(%p,%p)\n", stream, header);
 
    if (!stream || !header)
        return InvalidParameter;
 
    status = GdipCreateMetafileFromStream(stream, &metafile);
    if (status == Ok)
    {
        status = GdipGetMetafileHeaderFromMetafile(metafile, header);
        GdipDisposeImage(&metafile->image);
    }
    return status;
}

GdipGetMetafileHeaderFromWmf()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromWmf	(	HMETAFILE	hwmf,
		GDIPCONST WmfPlaceableFileHeader *	placeable,
		MetafileHeader *	header
	)

Definition at line 3747 of file metafile.c.

{
    GpStatus status;
    GpMetafile *metafile;
 
    TRACE("(%p,%p,%p)\n", hwmf, placeable, header);
 
    status = GdipCreateMetafileFromWmf(hwmf, FALSE, placeable, &metafile);
    if (status == Ok)
    {
        status = GdipGetMetafileHeaderFromMetafile(metafile, header);
        GdipDisposeImage(&metafile->image);
    }
    return status;
}

GdipPlayMetafileRecord()

GpStatus WINGDIPAPI GdipPlayMetafileRecord	(	GDIPCONST GpMetafile *	metafile,
		EmfPlusRecordType	recordType,
		UINT	flags,
		UINT	dataSize,
		GDIPCONST BYTE *	data
	)

Definition at line 2461 of file metafile.c.

{
    GpStatus stat;
    GpMetafile *real_metafile = (GpMetafile*)metafile;
 
    TRACE("(%p,%x,%x,%d,%p)\n", metafile, recordType, flags, dataSize, data);
 
    if (!metafile || (dataSize && !data) || !metafile->playback_graphics)
        return InvalidParameter;
 
    if (recordType >= 1 && recordType <= 0x7a)
    {
        /* regular EMF record */
        if (metafile->playback_dc)
        {
            switch (recordType)
            {
            case EMR_SETMAPMODE:
            case EMR_SAVEDC:
            case EMR_RESTOREDC:
            case EMR_SETWINDOWORGEX:
            case EMR_SETWINDOWEXTEX:
            case EMR_SETVIEWPORTORGEX:
            case EMR_SETVIEWPORTEXTEX:
            case EMR_SCALEVIEWPORTEXTEX:
            case EMR_SCALEWINDOWEXTEX:
            case EMR_MODIFYWORLDTRANSFORM:
                FIXME("not implemented for record type %x\n", recordType);
                break;
            case EMR_SETWORLDTRANSFORM:
            {
                const XFORM* xform = (void*)data;
                real_metafile->gdiworldtransform = *xform;
                METAFILE_PlaybackUpdateGdiTransform(real_metafile);
                break;
            }
            case EMR_EXTSELECTCLIPRGN:
            {
                DWORD rgndatasize = *(DWORD*)data;
                DWORD mode = *(DWORD*)(data + 4);
                const RGNDATA *rgndata = (const RGNDATA*)(data + 8);
                HRGN hrgn = NULL;
 
                if (dataSize > 8)
                {
                    XFORM final;
 
                    METAFILE_GetFinalGdiTransform(metafile, &final);
 
                    hrgn = ExtCreateRegion(&final, rgndatasize, rgndata);
                }
 
                ExtSelectClipRgn(metafile->playback_dc, hrgn, mode);
 
                DeleteObject(hrgn);
 
                return Ok;
            }
            default:
            {
                ENHMETARECORD *record = heap_alloc_zero(dataSize + 8);
 
                if (record)
                {
                    record->iType = recordType;
                    record->nSize = dataSize + 8;
                    memcpy(record->dParm, data, dataSize);
 
                    if(PlayEnhMetaFileRecord(metafile->playback_dc, metafile->handle_table,
                            record, metafile->handle_count) == 0)
                        ERR("PlayEnhMetaFileRecord failed\n");
 
                    heap_free(record);
                }
                else
                    return OutOfMemory;
 
                break;
            }
            }
        }
    }
    else
    {
        EmfPlusRecordHeader *header = (EmfPlusRecordHeader*)(data)-1;
 
        METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
 
        switch(recordType)
        {
        case EmfPlusRecordTypeHeader:
        case EmfPlusRecordTypeEndOfFile:
            break;
        case EmfPlusRecordTypeGetDC:
            METAFILE_PlaybackGetDC((GpMetafile*)metafile);
            break;
        case EmfPlusRecordTypeClear:
        {
            EmfPlusClear *record = (EmfPlusClear*)header;
 
            if (dataSize != sizeof(record->Color))
                return InvalidParameter;
 
            return GdipGraphicsClear(metafile->playback_graphics, record->Color);
        }
        case EmfPlusRecordTypeFillRects:
        {
            EmfPlusFillRects *record = (EmfPlusFillRects*)header;
            GpBrush *brush, *temp_brush=NULL;
            GpRectF *rects, *temp_rects=NULL;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects))
                return InvalidParameter;
 
            if (flags & 0x4000)
            {
                if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(EmfPlusRect) * record->Count)
                    return InvalidParameter;
            }
            else
            {
                if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(GpRectF) * record->Count)
                    return InvalidParameter;
            }
 
            if (flags & 0x8000)
            {
                stat = GdipCreateSolidFill(record->BrushID, (GpSolidFill **)&temp_brush);
                brush = temp_brush;
            }
            else
            {
                if (record->BrushID >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[record->BrushID].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[record->BrushID].u.brush;
                stat = Ok;
            }
 
            if (stat == Ok)
            {
                if (flags & 0x4000)
                {
                    EmfPlusRect *int_rects = (EmfPlusRect*)(record+1);
                    int i;
 
                    rects = temp_rects = heap_alloc_zero(sizeof(GpRectF) * record->Count);
                    if (rects)
                    {
                        for (i=0; i<record->Count; i++)
                        {
                            rects[i].X = int_rects[i].X;
                            rects[i].Y = int_rects[i].Y;
                            rects[i].Width = int_rects[i].Width;
                            rects[i].Height = int_rects[i].Height;
                        }
                    }
                    else
                        stat = OutOfMemory;
                }
                else
                    rects = (GpRectF*)(record+1);
            }
 
            if (stat == Ok)
            {
                stat = GdipFillRectangles(metafile->playback_graphics, brush, rects, record->Count);
            }
 
            GdipDeleteBrush(temp_brush);
            heap_free(temp_rects);
 
            return stat;
        }
        case EmfPlusRecordTypeSetClipRect:
        {
            EmfPlusSetClipRect *record = (EmfPlusSetClipRect*)header;
            CombineMode mode = (CombineMode)((flags >> 8) & 0xf);
            GpRegion *region;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(*record))
                return InvalidParameter;
 
            stat = GdipCreateRegionRect(&record->ClipRect, &region);
 
            if (stat == Ok)
            {
                stat = metafile_set_clip_region(real_metafile, region, mode);
                GdipDeleteRegion(region);
            }
 
            return stat;
        }
        case EmfPlusRecordTypeSetClipRegion:
        {
            CombineMode mode = (flags >> 8) & 0xf;
            BYTE regionid = flags & 0xff;
            GpRegion *region;
 
            if (dataSize != 0)
                return InvalidParameter;
 
            if (regionid >= EmfPlusObjectTableSize || real_metafile->objtable[regionid].type != ObjectTypeRegion)
                return InvalidParameter;
 
            stat = GdipCloneRegion(real_metafile->objtable[regionid].u.region, &region);
            if (stat == Ok)
            {
                stat = metafile_set_clip_region(real_metafile, region, mode);
                GdipDeleteRegion(region);
            }
 
            return stat;
        }
        case EmfPlusRecordTypeSetClipPath:
        {
            CombineMode mode = (flags >> 8) & 0xf;
            BYTE pathid = flags & 0xff;
            GpRegion *region;
 
            if (dataSize != 0)
                return InvalidParameter;
 
            if (pathid >= EmfPlusObjectTableSize || real_metafile->objtable[pathid].type != ObjectTypePath)
                return InvalidParameter;
 
            stat = GdipCreateRegionPath(real_metafile->objtable[pathid].u.path, &region);
            if (stat == Ok)
            {
                stat = metafile_set_clip_region(real_metafile, region, mode);
                GdipDeleteRegion(region);
            }
 
            return stat;
        }
        case EmfPlusRecordTypeSetPageTransform:
        {
            EmfPlusSetPageTransform *record = (EmfPlusSetPageTransform*)header;
            GpUnit unit = (GpUnit)flags;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetPageTransform))
                return InvalidParameter;
 
            real_metafile->page_unit = unit;
            real_metafile->page_scale = record->PageScale;
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeSetWorldTransform:
        {
            EmfPlusSetWorldTransform *record = (EmfPlusSetWorldTransform*)header;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetWorldTransform))
                return InvalidParameter;
 
            memcpy(real_metafile->world_transform->matrix, record->MatrixData, sizeof(record->MatrixData));
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeScaleWorldTransform:
        {
            EmfPlusScaleWorldTransform *record = (EmfPlusScaleWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusScaleWorldTransform))
                return InvalidParameter;
 
            GdipScaleMatrix(real_metafile->world_transform, record->Sx, record->Sy, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeMultiplyWorldTransform:
        {
            EmfPlusMultiplyWorldTransform *record = (EmfPlusMultiplyWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
            GpMatrix matrix;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusMultiplyWorldTransform))
                return InvalidParameter;
 
            memcpy(matrix.matrix, record->MatrixData, sizeof(matrix.matrix));
 
            GdipMultiplyMatrix(real_metafile->world_transform, &matrix, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeRotateWorldTransform:
        {
            EmfPlusRotateWorldTransform *record = (EmfPlusRotateWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusRotateWorldTransform))
                return InvalidParameter;
 
            GdipRotateMatrix(real_metafile->world_transform, record->Angle, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeTranslateWorldTransform:
        {
            EmfPlusTranslateWorldTransform *record = (EmfPlusTranslateWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusTranslateWorldTransform))
                return InvalidParameter;
 
            GdipTranslateMatrix(real_metafile->world_transform, record->dx, record->dy, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeResetWorldTransform:
        {
            GdipSetMatrixElements(real_metafile->world_transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeBeginContainer:
        {
            EmfPlusBeginContainer *record = (EmfPlusBeginContainer*)header;
            container* cont;
            GpUnit unit;
            REAL scale_x, scale_y;
            GpRectF scaled_srcrect;
            GpMatrix transform;
 
            cont = heap_alloc_zero(sizeof(*cont));
            if (!cont)
                return OutOfMemory;
 
            stat = GdipCloneRegion(metafile->clip, &cont->clip);
            if (stat != Ok)
            {
                heap_free(cont);
                return stat;
            }
 
            stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
 
            if (stat != Ok)
            {
                GdipDeleteRegion(cont->clip);
                heap_free(cont);
                return stat;
            }
 
            cont->id = record->StackIndex;
            cont->type = BEGIN_CONTAINER;
            cont->world_transform = *metafile->world_transform;
            cont->page_unit = metafile->page_unit;
            cont->page_scale = metafile->page_scale;
            list_add_head(&real_metafile->containers, &cont->entry);
 
            unit = record->Header.Flags & 0xff;
 
            scale_x = units_to_pixels(1.0, unit, metafile->image.xres);
            scale_y = units_to_pixels(1.0, unit, metafile->image.yres);
 
            scaled_srcrect.X = scale_x * record->SrcRect.X;
            scaled_srcrect.Y = scale_y * record->SrcRect.Y;
            scaled_srcrect.Width = scale_x * record->SrcRect.Width;
            scaled_srcrect.Height = scale_y * record->SrcRect.Height;
 
            transform.matrix[0] = record->DestRect.Width / scaled_srcrect.Width;
            transform.matrix[1] = 0.0;
            transform.matrix[2] = 0.0;
            transform.matrix[3] = record->DestRect.Height / scaled_srcrect.Height;
            transform.matrix[4] = record->DestRect.X - scaled_srcrect.X;
            transform.matrix[5] = record->DestRect.Y - scaled_srcrect.Y;
 
            GdipMultiplyMatrix(real_metafile->world_transform, &transform, MatrixOrderPrepend);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeBeginContainerNoParams:
        case EmfPlusRecordTypeSave:
        {
            EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
            container* cont;
 
            cont = heap_alloc_zero(sizeof(*cont));
            if (!cont)
                return OutOfMemory;
 
            stat = GdipCloneRegion(metafile->clip, &cont->clip);
            if (stat != Ok)
            {
                heap_free(cont);
                return stat;
            }
 
            if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
                stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
            else
                stat = GdipSaveGraphics(metafile->playback_graphics, &cont->state);
 
            if (stat != Ok)
            {
                GdipDeleteRegion(cont->clip);
                heap_free(cont);
                return stat;
            }
 
            cont->id = record->StackIndex;
            if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
                cont->type = BEGIN_CONTAINER;
            else
                cont->type = SAVE_GRAPHICS;
            cont->world_transform = *metafile->world_transform;
            cont->page_unit = metafile->page_unit;
            cont->page_scale = metafile->page_scale;
            list_add_head(&real_metafile->containers, &cont->entry);
 
            break;
        }
        case EmfPlusRecordTypeEndContainer:
        case EmfPlusRecordTypeRestore:
        {
            EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
            container* cont;
            enum container_type type;
            BOOL found=FALSE;
 
            if (recordType == EmfPlusRecordTypeEndContainer)
                type = BEGIN_CONTAINER;
            else
                type = SAVE_GRAPHICS;
 
            LIST_FOR_EACH_ENTRY(cont, &real_metafile->containers, container, entry)
            {
                if (cont->id == record->StackIndex && cont->type == type)
                {
                    found = TRUE;
                    break;
                }
            }
 
            if (found)
            {
                container* cont2;
 
                /* pop any newer items on the stack */
                while ((cont2 = LIST_ENTRY(list_head(&real_metafile->containers), container, entry)) != cont)
                {
                    list_remove(&cont2->entry);
                    GdipDeleteRegion(cont2->clip);
                    heap_free(cont2);
                }
 
                if (type == BEGIN_CONTAINER)
                    GdipEndContainer(real_metafile->playback_graphics, cont->state);
                else
                    GdipRestoreGraphics(real_metafile->playback_graphics, cont->state);
 
                *real_metafile->world_transform = cont->world_transform;
                real_metafile->page_unit = cont->page_unit;
                real_metafile->page_scale = cont->page_scale;
                GdipCombineRegionRegion(real_metafile->clip, cont->clip, CombineModeReplace);
 
                list_remove(&cont->entry);
                GdipDeleteRegion(cont->clip);
                heap_free(cont);
            }
 
            break;
        }
        case EmfPlusRecordTypeSetPixelOffsetMode:
        {
            return GdipSetPixelOffsetMode(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetCompositingQuality:
        {
            return GdipSetCompositingQuality(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetInterpolationMode:
        {
            return GdipSetInterpolationMode(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetTextRenderingHint:
        {
            return GdipSetTextRenderingHint(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetAntiAliasMode:
        {
            return GdipSetSmoothingMode(real_metafile->playback_graphics, (flags >> 1) & 0xff);
        }
        case EmfPlusRecordTypeSetCompositingMode:
        {
            return GdipSetCompositingMode(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeObject:
        {
            return METAFILE_PlaybackObject(real_metafile, flags, dataSize, data);
        }
        case EmfPlusRecordTypeDrawImage:
        {
            EmfPlusDrawImage *draw = (EmfPlusDrawImage *)header;
            BYTE image = flags & 0xff;
            GpPointF points[3];
 
            if (image >= EmfPlusObjectTableSize || real_metafile->objtable[image].type != ObjectTypeImage)
                return InvalidParameter;
 
            if (dataSize != FIELD_OFFSET(EmfPlusDrawImage, RectData) - sizeof(EmfPlusRecordHeader) +
                    (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (draw->ImageAttributesID >= EmfPlusObjectTableSize ||
                    real_metafile->objtable[draw->ImageAttributesID].type != ObjectTypeImageAttributes)
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
            {
                points[0].X = draw->RectData.rect.X;
                points[0].Y = draw->RectData.rect.Y;
                points[1].X = points[0].X + draw->RectData.rect.Width;
                points[1].Y = points[0].Y;
                points[2].X = points[1].X;
                points[2].Y = points[1].Y + draw->RectData.rect.Height;
            }
            else
            {
                points[0].X = draw->RectData.rectF.X;
                points[0].Y = draw->RectData.rectF.Y;
                points[1].X = points[0].X + draw->RectData.rectF.Width;
                points[1].Y = points[0].Y;
                points[2].X = points[1].X;
                points[2].Y = points[1].Y + draw->RectData.rectF.Height;
            }
 
            return GdipDrawImagePointsRect(real_metafile->playback_graphics, real_metafile->objtable[image].u.image,
                points, 3, draw->SrcRect.X, draw->SrcRect.Y, draw->SrcRect.Width, draw->SrcRect.Height, draw->SrcUnit,
                real_metafile->objtable[draw->ImageAttributesID].u.image_attributes, NULL, NULL);
        }
        case EmfPlusRecordTypeDrawImagePoints:
        {
            EmfPlusDrawImagePoints *draw = (EmfPlusDrawImagePoints *)header;
            static const UINT fixed_part_size = FIELD_OFFSET(EmfPlusDrawImagePoints, PointData) -
                FIELD_OFFSET(EmfPlusDrawImagePoints, ImageAttributesID);
            BYTE image = flags & 0xff;
            GpPointF points[3];
            unsigned int i;
            UINT size;
 
            if (image >= EmfPlusObjectTableSize || real_metafile->objtable[image].type != ObjectTypeImage)
                return InvalidParameter;
 
            if (dataSize <= fixed_part_size)
                return InvalidParameter;
            dataSize -= fixed_part_size;
 
            if (draw->ImageAttributesID >= EmfPlusObjectTableSize ||
                    real_metafile->objtable[draw->ImageAttributesID].type != ObjectTypeImageAttributes)
                return InvalidParameter;
 
            if (draw->count != 3)
                return InvalidParameter;
 
            if ((flags >> 13) & 1) /* E */
                FIXME("image effects are not supported.\n");
 
            if ((flags >> 11) & 1) /* P */
                size = sizeof(EmfPlusPointR7) * draw->count;
            else if ((flags >> 14) & 1) /* C */
                size = sizeof(EmfPlusPoint) * draw->count;
            else
                size = sizeof(EmfPlusPointF) * draw->count;
 
            if (dataSize != size)
                return InvalidParameter;
 
            if ((flags >> 11) & 1) /* P */
            {
                points[0].X = draw->PointData.pointsR[0].X;
                points[0].Y = draw->PointData.pointsR[0].Y;
                for (i = 1; i < 3; i++)
                {
                    points[i].X = points[i-1].X + draw->PointData.pointsR[i].X;
                    points[i].Y = points[i-1].Y + draw->PointData.pointsR[i].Y;
                }
            }
            else if ((flags >> 14) & 1) /* C */
            {
                for (i = 0; i < 3; i++)
                {
                    points[i].X = draw->PointData.points[i].X;
                    points[i].Y = draw->PointData.points[i].Y;
                }
            }
            else
                memcpy(points, draw->PointData.pointsF, sizeof(points));
 
            return GdipDrawImagePointsRect(real_metafile->playback_graphics, real_metafile->objtable[image].u.image,
                points, 3, draw->SrcRect.X, draw->SrcRect.Y, draw->SrcRect.Width, draw->SrcRect.Height, draw->SrcUnit,
                real_metafile->objtable[draw->ImageAttributesID].u.image_attributes, NULL, NULL);
        }
        case EmfPlusRecordTypeFillPath:
        {
            EmfPlusFillPath *fill = (EmfPlusFillPath *)header;
            GpSolidFill *solidfill = NULL;
            BYTE path = flags & 0xff;
            GpBrush *brush;
 
            if (path >= EmfPlusObjectTableSize || real_metafile->objtable[path].type != ObjectTypePath)
                return InvalidParameter;
 
            if (dataSize != sizeof(fill->data.BrushId))
                return InvalidParameter;
 
            if (flags & 0x8000)
            {
                stat = GdipCreateSolidFill(fill->data.Color, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->data.BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->data.BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->data.BrushId].u.brush;
            }
 
            stat = GdipFillPath(real_metafile->playback_graphics, brush, real_metafile->objtable[path].u.path);
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeFillClosedCurve:
        {
            static const UINT fixed_part_size = FIELD_OFFSET(EmfPlusFillClosedCurve, PointData) -
                sizeof(EmfPlusRecordHeader);
            EmfPlusFillClosedCurve *fill = (EmfPlusFillClosedCurve *)header;
            GpSolidFill *solidfill = NULL;
            GpFillMode mode;
            GpBrush *brush;
            UINT size, i;
 
            if (dataSize <= fixed_part_size)
                return InvalidParameter;
 
            if (fill->Count == 0)
                return InvalidParameter;
 
            if (flags & 0x800) /* P */
                size = (fixed_part_size + sizeof(EmfPlusPointR7) * fill->Count + 3) & ~3;
            else if (flags & 0x4000) /* C */
                size = fixed_part_size + sizeof(EmfPlusPoint) * fill->Count;
            else
                size = fixed_part_size + sizeof(EmfPlusPointF) * fill->Count;
 
            if (dataSize != size)
                return InvalidParameter;
 
            mode = flags & 0x200 ? FillModeWinding : FillModeAlternate; /* W */
 
            if (flags & 0x8000) /* S */
            {
                stat = GdipCreateSolidFill(fill->BrushId, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->BrushId].u.brush;
            }
 
            if (flags & (0x800 | 0x4000))
            {
                GpPointF *points = GdipAlloc(fill->Count * sizeof(*points));
                if (points)
                {
                    if (flags & 0x800) /* P */
                    {
                        for (i = 1; i < fill->Count; i++)
                        {
                            points[i].X = points[i - 1].X + fill->PointData.pointsR[i].X;
                            points[i].Y = points[i - 1].Y + fill->PointData.pointsR[i].Y;
                        }
                    }
                    else
                    {
                        for (i = 0; i < fill->Count; i++)
                        {
                            points[i].X = fill->PointData.points[i].X;
                            points[i].Y = fill->PointData.points[i].Y;
                        }
                    }
 
                    stat = GdipFillClosedCurve2(real_metafile->playback_graphics, brush,
                        points, fill->Count, fill->Tension, mode);
                    GdipFree(points);
                }
                else
                    stat = OutOfMemory;
            }
            else
                stat = GdipFillClosedCurve2(real_metafile->playback_graphics, brush,
                    (const GpPointF *)fill->PointData.pointsF, fill->Count, fill->Tension, mode);
 
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeFillEllipse:
        {
            EmfPlusFillEllipse *fill = (EmfPlusFillEllipse *)header;
            GpSolidFill *solidfill = NULL;
            GpBrush *brush;
 
            if (dataSize <= FIELD_OFFSET(EmfPlusFillEllipse, RectData) - sizeof(EmfPlusRecordHeader))
                return InvalidParameter;
            dataSize -= FIELD_OFFSET(EmfPlusFillEllipse, RectData) - sizeof(EmfPlusRecordHeader);
 
            if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x8000)
            {
                stat = GdipCreateSolidFill(fill->BrushId, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->BrushId].u.brush;
            }
 
            if (flags & 0x4000)
                stat = GdipFillEllipseI(real_metafile->playback_graphics, brush, fill->RectData.rect.X,
                    fill->RectData.rect.Y, fill->RectData.rect.Width, fill->RectData.rect.Height);
            else
                stat = GdipFillEllipse(real_metafile->playback_graphics, brush, fill->RectData.rectF.X,
                    fill->RectData.rectF.Y, fill->RectData.rectF.Width, fill->RectData.rectF.Height);
 
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeFillPie:
        {
            EmfPlusFillPie *fill = (EmfPlusFillPie *)header;
            GpSolidFill *solidfill = NULL;
            GpBrush *brush;
 
            if (dataSize <= FIELD_OFFSET(EmfPlusFillPie, RectData) - sizeof(EmfPlusRecordHeader))
                return InvalidParameter;
            dataSize -= FIELD_OFFSET(EmfPlusFillPie, RectData) - sizeof(EmfPlusRecordHeader);
 
            if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x8000) /* S */
            {
                stat = GdipCreateSolidFill(fill->BrushId, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->BrushId].u.brush;
            }
 
            if (flags & 0x4000) /* C */
                stat = GdipFillPieI(real_metafile->playback_graphics, brush, fill->RectData.rect.X,
                    fill->RectData.rect.Y, fill->RectData.rect.Width, fill->RectData.rect.Height,
                    fill->StartAngle, fill->SweepAngle);
            else
                stat = GdipFillPie(real_metafile->playback_graphics, brush, fill->RectData.rectF.X,
                    fill->RectData.rectF.Y, fill->RectData.rectF.Width, fill->RectData.rectF.Height,
                    fill->StartAngle, fill->SweepAngle);
 
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeDrawPath:
        {
            EmfPlusDrawPath *draw = (EmfPlusDrawPath *)header;
            BYTE path = flags & 0xff;
 
            if (dataSize != sizeof(draw->PenId))
                return InvalidParameter;
 
            if (path >= EmfPlusObjectTableSize || draw->PenId >= EmfPlusObjectTableSize)
                return InvalidParameter;
 
            if (real_metafile->objtable[path].type != ObjectTypePath ||
                    real_metafile->objtable[draw->PenId].type != ObjectTypePen)
                return InvalidParameter;
 
            return GdipDrawPath(real_metafile->playback_graphics, real_metafile->objtable[draw->PenId].u.pen,
                real_metafile->objtable[path].u.path);
        }
        case EmfPlusRecordTypeDrawArc:
        {
            EmfPlusDrawArc *draw = (EmfPlusDrawArc *)header;
            BYTE pen = flags & 0xff;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize != FIELD_OFFSET(EmfPlusDrawArc, RectData) - sizeof(EmfPlusRecordHeader) +
                    (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
                return GdipDrawArcI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
                    draw->RectData.rect.Height, draw->StartAngle, draw->SweepAngle);
            else
                return GdipDrawArc(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
                    draw->RectData.rectF.Height, draw->StartAngle, draw->SweepAngle);
        }
        case EmfPlusRecordTypeDrawEllipse:
        {
            EmfPlusDrawEllipse *draw = (EmfPlusDrawEllipse *)header;
            BYTE pen = flags & 0xff;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
                return GdipDrawEllipseI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
                    draw->RectData.rect.Height);
            else
                return GdipDrawEllipse(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
                    draw->RectData.rectF.Height);
        }
        case EmfPlusRecordTypeDrawPie:
        {
            EmfPlusDrawPie *draw = (EmfPlusDrawPie *)header;
            BYTE pen = flags & 0xff;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize != FIELD_OFFSET(EmfPlusDrawPie, RectData) - sizeof(EmfPlusRecordHeader) +
                    (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
                return GdipDrawPieI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
                    draw->RectData.rect.Height, draw->StartAngle, draw->SweepAngle);
            else
                return GdipDrawPie(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
                    draw->RectData.rectF.Height, draw->StartAngle, draw->SweepAngle);
        }
        case EmfPlusRecordTypeDrawRects:
        {
            EmfPlusDrawRects *draw = (EmfPlusDrawRects *)header;
            BYTE pen = flags & 0xff;
            GpRectF *rects = NULL;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize <= FIELD_OFFSET(EmfPlusDrawRects, RectData) - sizeof(EmfPlusRecordHeader))
                return InvalidParameter;
            dataSize -= FIELD_OFFSET(EmfPlusDrawRects, RectData) - sizeof(EmfPlusRecordHeader);
 
            if (dataSize != draw->Count * (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000)
            {
                DWORD i;
 
                rects = GdipAlloc(draw->Count * sizeof(*rects));
                if (!rects)
                    return OutOfMemory;
 
                for (i = 0; i < draw->Count; i++)
                {
                    rects[i].X = draw->RectData.rect[i].X;
                    rects[i].Y = draw->RectData.rect[i].Y;
                    rects[i].Width = draw->RectData.rect[i].Width;
                    rects[i].Height = draw->RectData.rect[i].Height;
                }
            }
 
            stat = GdipDrawRectangles(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    rects ? rects : (GpRectF *)draw->RectData.rectF, draw->Count);
            GdipFree(rects);
            return stat;
        }
        default:
            FIXME("Not implemented for record type %x\n", recordType);
            return NotImplemented;
        }
    }
 
    return Ok;
}

Referenced by play_metafile_proc(), and test_gditransform_cb().

GdipRecordMetafile()

GpStatus WINGDIPAPI GdipRecordMetafile	(	HDC	hdc,
		EmfType	type,
		GDIPCONST GpRectF *	frameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 735 of file metafile.c.

{
    HDC record_dc;
    REAL dpix, dpiy;
    REAL framerect_factor_x, framerect_factor_y;
    RECT rc, *lprc;
    GpStatus stat;
 
    TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (!hdc || type < EmfTypeEmfOnly || type > EmfTypeEmfPlusDual || !metafile)
        return InvalidParameter;
 
    dpix = (REAL)GetDeviceCaps(hdc, HORZRES) / GetDeviceCaps(hdc, HORZSIZE) * 25.4;
    dpiy = (REAL)GetDeviceCaps(hdc, VERTRES) / GetDeviceCaps(hdc, VERTSIZE) * 25.4;
 
    if (frameRect)
    {
        switch (frameUnit)
        {
        case MetafileFrameUnitPixel:
            framerect_factor_x = 2540.0 / dpix;
            framerect_factor_y = 2540.0 / dpiy;
            break;
        case MetafileFrameUnitPoint:
            framerect_factor_x = framerect_factor_y = 2540.0 / 72.0;
            break;
        case MetafileFrameUnitInch:
            framerect_factor_x = framerect_factor_y = 2540.0;
            break;
        case MetafileFrameUnitDocument:
            framerect_factor_x = framerect_factor_y = 2540.0 / 300.0;
            break;
        case MetafileFrameUnitMillimeter:
            framerect_factor_x = framerect_factor_y = 100.0;
            break;
        case MetafileFrameUnitGdi:
            framerect_factor_x = framerect_factor_y = 1.0;
            break;
        default:
            return InvalidParameter;
        }
 
        rc.left = framerect_factor_x * frameRect->X;
        rc.top = framerect_factor_y * frameRect->Y;
        rc.right = rc.left + framerect_factor_x * frameRect->Width;
        rc.bottom = rc.top + framerect_factor_y * frameRect->Height;
 
        lprc = &rc;
    }
    else
        lprc = NULL;
 
    record_dc = CreateEnhMetaFileW(hdc, NULL, lprc, desc);
 
    if (!record_dc)
        return GenericError;
 
    *metafile = heap_alloc_zero(sizeof(GpMetafile));
    if(!*metafile)
    {
        DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
        return OutOfMemory;
    }
 
    (*metafile)->image.type = ImageTypeMetafile;
    (*metafile)->image.flags   = ImageFlagsNone;
    (*metafile)->image.palette = NULL;
    (*metafile)->image.xres = dpix;
    (*metafile)->image.yres = dpiy;
    (*metafile)->bounds.X = (*metafile)->bounds.Y = 0.0;
    (*metafile)->bounds.Width = (*metafile)->bounds.Height = 1.0;
    (*metafile)->unit = UnitPixel;
    (*metafile)->metafile_type = type;
    (*metafile)->record_dc = record_dc;
    (*metafile)->comment_data = NULL;
    (*metafile)->comment_data_size = 0;
    (*metafile)->comment_data_length = 0;
    (*metafile)->hemf = NULL;
    list_init(&(*metafile)->containers);
 
    if (!frameRect)
    {
        (*metafile)->auto_frame = TRUE;
        (*metafile)->auto_frame_min.X = 0;
        (*metafile)->auto_frame_min.Y = 0;
        (*metafile)->auto_frame_max.X = -1;
        (*metafile)->auto_frame_max.Y = -1;
    }
 
    stat = METAFILE_WriteHeader(*metafile, hdc);
 
    if (stat != Ok)
    {
        DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
        heap_free(*metafile);
        *metafile = NULL;
        return OutOfMemory;
    }
 
    return stat;
}

Referenced by GdipRecordMetafileI(), GdipRecordMetafileStream(), test_clear(), test_clipping(), test_containers(), test_converttoemfplus(), test_drawimage(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_frameunit(), test_gditransform(), test_getdc(), test_nullframerect(), test_pagetransform(), test_properties(), and test_worldtransform().

GdipRecordMetafileFileName()

GpStatus WINGDIPAPI GdipRecordMetafileFileName	(	GDIPCONST WCHAR *	fileName,
		HDC	hdc,
		EmfType	type,
		GDIPCONST GpRectF *	pFrameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 3993 of file metafile.c.

{
    FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
                                 frameUnit, debugstr_w(desc), metafile);
 
    return NotImplemented;
}

GdipRecordMetafileFileNameI()

GpStatus WINGDIPAPI GdipRecordMetafileFileNameI	(	GDIPCONST WCHAR *	fileName,
		HDC	hdc,
		EmfType	type,
		GDIPCONST GpRect *	pFrameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 4004 of file metafile.c.

{
    FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
                                 frameUnit, debugstr_w(desc), metafile);
 
    return NotImplemented;
}

GdipRecordMetafileI()

GpStatus WINGDIPAPI GdipRecordMetafileI	(	HDC	hdc,
		EmfType	type,
		GDIPCONST GpRect *	frameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 842 of file metafile.c.

{
    GpRectF frameRectF, *pFrameRectF;
 
    TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (frameRect)
    {
        frameRectF.X = frameRect->X;
        frameRectF.Y = frameRect->Y;
        frameRectF.Width = frameRect->Width;
        frameRectF.Height = frameRect->Height;
        pFrameRectF = &frameRectF;
    }
    else
        pFrameRectF = NULL;
 
    return GdipRecordMetafile(hdc, type, pFrameRectF, frameUnit, desc, metafile);
}

GdipRecordMetafileStream()

GpStatus WINGDIPAPI GdipRecordMetafileStream	(	IStream *	stream,
		HDC	hdc,
		EmfType	type,
		GDIPCONST GpRectF *	frameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 863 of file metafile.c.

{
    GpStatus stat;
 
    TRACE("(%p %p %d %p %d %p %p)\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (!stream)
        return InvalidParameter;
 
    stat = GdipRecordMetafile(hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (stat == Ok)
    {
        (*metafile)->record_stream = stream;
        IStream_AddRef(stream);
    }
 
    return stat;
}

GdipSetMetafileDownLevelRasterizationLimit()

GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit	(	GpMetafile *	metafile,
		UINT	limitDpi
	)

Definition at line 3956 of file metafile.c.

{
    TRACE("(%p,%u)\n", metafile, limitDpi);
 
    return Ok;
}

get_emfplus_header_proc()

static int CALLBACK get_emfplus_header_proc ( HDC  hDC, HANDLETABLE *  lpHTable, const ENHMETARECORD *  lpEMFR, int  nObj, LPARAM  lpData  )

static

Definition at line 3662 of file metafile.c.

{
    EmfPlusHeader *dst_header = (EmfPlusHeader*)lpData;
 
    if (lpEMFR->iType == EMR_GDICOMMENT)
    {
        const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
 
        if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
        {
            const EmfPlusRecordHeader *header = (const EmfPlusRecordHeader*)&comment->Data[4];
 
            if (4 + sizeof(EmfPlusHeader) <= comment->cbData &&
                header->Type == EmfPlusRecordTypeHeader)
            {
                memcpy(dst_header, header, sizeof(*dst_header));
            }
        }
    }
    else if (lpEMFR->iType == EMR_HEADER)
        return TRUE;
 
    return FALSE;
}

Referenced by GdipGetMetafileHeaderFromEmf().

is_integer_rect()

static BOOL is_integer_rect ( const GpRectF *  rect )

static

Definition at line 970 of file metafile.c.

{
    SHORT x, y, width, height;
    x = rect->X;
    y = rect->Y;
    width = rect->Width;
    height = rect->Height;
    if (rect->X != (REAL)x || rect->Y != (REAL)y ||
        rect->Width != (REAL)width || rect->Height != (REAL)height)
        return FALSE;
    return TRUE;
}

Referenced by METAFILE_FillRectangles().

METAFILE_AddBrushObject()

static GpStatus METAFILE_AddBrushObject ( GpMetafile *  metafile, GpBrush *  brush, DWORD *  id  )

static

Definition at line 1027 of file metafile.c.

{
    EmfPlusObject *object_record;
    GpStatus stat;
    DWORD size;
 
    *id = -1;
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    stat = METAFILE_PrepareBrushData(brush, &size);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AllocateRecord(metafile,
        FIELD_OFFSET(EmfPlusObject, ObjectData) + size, (void**)&object_record);
    if (stat != Ok) return stat;
 
    *id = METAFILE_AddObjectId(metafile);
    object_record->Header.Type = EmfPlusRecordTypeObject;
    object_record->Header.Flags = *id | ObjectTypeBrush << 8;
    METAFILE_FillBrushData(brush, &object_record->ObjectData.brush);
    return Ok;
}

Referenced by METAFILE_FillPath(), and METAFILE_FillRectangles().

METAFILE_AddImageAttributesObject()

static GpStatus METAFILE_AddImageAttributesObject ( GpMetafile *  metafile, const GpImageAttributes *  attrs, DWORD *  id  )

static

Definition at line 4158 of file metafile.c.

{
    EmfPlusObject *object_record;
    EmfPlusImageAttributes *attrs_record;
    GpStatus stat;
 
    *id = -1;
 
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    if (!attrs)
        return Ok;
 
    stat = METAFILE_AllocateRecord(metafile,
            FIELD_OFFSET(EmfPlusObject, ObjectData.image_attributes) + sizeof(EmfPlusImageAttributes),
            (void**)&object_record);
    if (stat != Ok) return stat;
 
    *id = METAFILE_AddObjectId(metafile);
    object_record->Header.Type = EmfPlusRecordTypeObject;
    object_record->Header.Flags = *id | (ObjectTypeImageAttributes << 8);
    attrs_record = &object_record->ObjectData.image_attributes;
    attrs_record->Version = VERSION_MAGIC2;
    attrs_record->Reserved1 = 0;
    attrs_record->WrapMode = attrs->wrap;
    attrs_record->ClampColor = attrs->outside_color;
    attrs_record->ObjectClamp = attrs->clamp;
    attrs_record->Reserved2 = 0;
    return Ok;
}

Referenced by METAFILE_DrawImagePointsRect().

METAFILE_AddImageObject()

static GpStatus METAFILE_AddImageObject ( GpMetafile *  metafile, GpImage *  image, DWORD *  id  )

static

Definition at line 4080 of file metafile.c.

{
    EmfPlusObject *object_record;
    GpStatus stat;
    DWORD size;
 
    *id = -1;
 
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    if (image->type == ImageTypeBitmap)
    {
        IStream *stream;
        DWORD aligned_size;
 
        stat = METAFILE_CreateCompressedImageStream(image, &stream, &size);
        if (stat != Ok) return stat;
        aligned_size = (size + 3) & ~3;
 
        stat = METAFILE_AllocateRecord(metafile,
                FIELD_OFFSET(EmfPlusObject, ObjectData.image.ImageData.bitmap.BitmapData[aligned_size]),
                (void**)&object_record);
        if (stat != Ok)
        {
            IStream_Release(stream);
            return stat;
        }
        memset(object_record->ObjectData.image.ImageData.bitmap.BitmapData + size, 0, aligned_size - size);
 
        *id = METAFILE_AddObjectId(metafile);
        object_record->Header.Type = EmfPlusRecordTypeObject;
        object_record->Header.Flags = *id | ObjectTypeImage << 8;
        object_record->ObjectData.image.Version = VERSION_MAGIC2;
        object_record->ObjectData.image.Type = ImageDataTypeBitmap;
 
        stat = METAFILE_FillEmfPlusBitmap(&object_record->ObjectData.image.ImageData.bitmap, stream, size);
        IStream_Release(stream);
        if (stat != Ok) METAFILE_RemoveLastRecord(metafile, &object_record->Header);
        return stat;
    }
    else if (image->type == ImageTypeMetafile)
    {
        HENHMETAFILE hemf = ((GpMetafile*)image)->hemf;
        EmfPlusMetafile *metafile_record;
 
        if (!hemf) return InvalidParameter;
 
        size = GetEnhMetaFileBits(hemf, 0, NULL);
        if (!size) return GenericError;
 
        stat  = METAFILE_AllocateRecord(metafile,
                FIELD_OFFSET(EmfPlusObject, ObjectData.image.ImageData.metafile.MetafileData[size]),
                (void**)&object_record);
        if (stat != Ok) return stat;
 
        *id = METAFILE_AddObjectId(metafile);
        object_record->Header.Type = EmfPlusRecordTypeObject;
        object_record->Header.Flags = *id | ObjectTypeImage << 8;
        object_record->ObjectData.image.Version = VERSION_MAGIC2;
        object_record->ObjectData.image.Type = ImageDataTypeMetafile;
        metafile_record = &object_record->ObjectData.image.ImageData.metafile;
        metafile_record->Type = ((GpMetafile*)image)->metafile_type;
        metafile_record->MetafileDataSize = size;
        if (GetEnhMetaFileBits(hemf, size, metafile_record->MetafileData) != size)
        {
            METAFILE_RemoveLastRecord(metafile, &object_record->Header);
            return GenericError;
        }
        return Ok;
    }
    else
    {
        FIXME("not supported image type (%d)\n", image->type);
        return NotImplemented;
    }
}

Referenced by METAFILE_DrawImagePointsRect().

METAFILE_AddObjectId()

static DWORD METAFILE_AddObjectId ( GpMetafile *  metafile )

static

Definition at line 613 of file metafile.c.

{
    return (metafile->next_object_id++) % EmfPlusObjectTableSize;
}

Referenced by METAFILE_AddBrushObject(), METAFILE_AddImageAttributesObject(), METAFILE_AddImageObject(), METAFILE_AddPathObject(), METAFILE_AddPenObject(), and METAFILE_AddRegionObject().

METAFILE_AddPathObject()

static GpStatus METAFILE_AddPathObject ( GpMetafile *  metafile, GpPath *  path, DWORD *  id  )

static

Definition at line 4287 of file metafile.c.

{
    EmfPlusObject *object_record;
    GpStatus stat;
    DWORD size;
 
    *id = -1;
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    size = write_path_data(path, NULL);
    stat = METAFILE_AllocateRecord(metafile,
            FIELD_OFFSET(EmfPlusObject, ObjectData.path) + size,
            (void**)&object_record);
    if (stat != Ok) return stat;
 
    *id = METAFILE_AddObjectId(metafile);
    object_record->Header.Type = EmfPlusRecordTypeObject;
    object_record->Header.Flags = *id | ObjectTypePath << 8;
    write_path_data(path, &object_record->ObjectData.path);
    return Ok;
}

Referenced by METAFILE_DrawPath(), and METAFILE_FillPath().

METAFILE_AddPenObject()

static GpStatus METAFILE_AddPenObject ( GpMetafile *  metafile, GpPen *  pen, DWORD *  id  )

static

Definition at line 4310 of file metafile.c.

{
    DWORD i, data_flags, pen_data_size, brush_size;
    EmfPlusObject *object_record;
    EmfPlusPenData *pen_data;
    GpStatus stat;
    BOOL result;
 
    *id = -1;
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    data_flags = 0;
    pen_data_size = FIELD_OFFSET(EmfPlusPenData, OptionalData);
 
    GdipIsMatrixIdentity(&pen->transform, &result);
    if (!result)
    {
        data_flags |= PenDataTransform;
        pen_data_size += sizeof(EmfPlusTransformMatrix);
    }
    if (pen->startcap != LineCapFlat)
    {
        data_flags |= PenDataStartCap;
        pen_data_size += sizeof(DWORD);
    }
    if (pen->endcap != LineCapFlat)
    {
        data_flags |= PenDataEndCap;
        pen_data_size += sizeof(DWORD);
    }
    if (pen->join != LineJoinMiter)
    {
        data_flags |= PenDataJoin;
        pen_data_size += sizeof(DWORD);
    }
    if (pen->miterlimit != 10.0)
    {
        data_flags |= PenDataMiterLimit;
        pen_data_size += sizeof(REAL);
    }
    if (pen->style != GP_DEFAULT_PENSTYLE)
    {
        data_flags |= PenDataLineStyle;
        pen_data_size += sizeof(DWORD);
    }
    if (pen->dashcap != DashCapFlat)
    {
        data_flags |= PenDataDashedLineCap;
        pen_data_size += sizeof(DWORD);
    }
    data_flags |= PenDataDashedLineOffset;
    pen_data_size += sizeof(REAL);
    if (pen->numdashes)
    {
        data_flags |= PenDataDashedLine;
        pen_data_size += sizeof(DWORD) + pen->numdashes*sizeof(REAL);
    }
    if (pen->align != PenAlignmentCenter)
    {
        data_flags |= PenDataNonCenter;
        pen_data_size += sizeof(DWORD);
    }
    /* TODO: Add support for PenDataCompoundLine */
    if (pen->customstart)
    {
        FIXME("ignoring custom start cup\n");
    }
    if (pen->customend)
    {
        FIXME("ignoring custom end cup\n");
    }
 
    stat = METAFILE_PrepareBrushData(pen->brush, &brush_size);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AllocateRecord(metafile,
            FIELD_OFFSET(EmfPlusObject, ObjectData.pen.data) + pen_data_size + brush_size,
            (void**)&object_record);
    if (stat != Ok) return stat;
 
    *id = METAFILE_AddObjectId(metafile);
    object_record->Header.Type = EmfPlusRecordTypeObject;
    object_record->Header.Flags = *id | ObjectTypePen << 8;
    object_record->ObjectData.pen.Version = VERSION_MAGIC2;
    object_record->ObjectData.pen.Type = 0;
 
    pen_data = (EmfPlusPenData*)object_record->ObjectData.pen.data;
    pen_data->PenDataFlags = data_flags;
    pen_data->PenUnit = pen->unit;
    pen_data->PenWidth = pen->width;
 
    i = 0;
    if (data_flags & PenDataTransform)
    {
        EmfPlusTransformMatrix *m = (EmfPlusTransformMatrix*)(pen_data->OptionalData + i);
        memcpy(m, &pen->transform, sizeof(*m));
        i += sizeof(EmfPlusTransformMatrix);
    }
    if (data_flags & PenDataStartCap)
    {
        *(DWORD*)(pen_data->OptionalData + i) = pen->startcap;
        i += sizeof(DWORD);
    }
    if (data_flags & PenDataEndCap)
    {
        *(DWORD*)(pen_data->OptionalData + i) = pen->endcap;
        i += sizeof(DWORD);
    }
    if (data_flags & PenDataJoin)
    {
        *(DWORD*)(pen_data->OptionalData + i) = pen->join;
        i += sizeof(DWORD);
    }
    if (data_flags & PenDataMiterLimit)
    {
        *(REAL*)(pen_data->OptionalData + i) = pen->miterlimit;
        i += sizeof(REAL);
    }
    if (data_flags & PenDataLineStyle)
    {
        switch (pen->style & PS_STYLE_MASK)
        {
        case PS_SOLID: *(DWORD*)(pen_data->OptionalData + i) = LineStyleSolid; break;
        case PS_DASH: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDash; break;
        case PS_DOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDot; break;
        case PS_DASHDOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDashDot; break;
        case PS_DASHDOTDOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDashDotDot; break;
        default: *(DWORD*)(pen_data->OptionalData + i) = LineStyleCustom; break;
        }
        i += sizeof(DWORD);
    }
    if (data_flags & PenDataDashedLineCap)
    {
        *(DWORD*)(pen_data->OptionalData + i) = pen->dashcap;
        i += sizeof(DWORD);
    }
    if (data_flags & PenDataDashedLineOffset)
    {
        *(REAL*)(pen_data->OptionalData + i) = pen->offset;
        i += sizeof(REAL);
    }
    if (data_flags & PenDataDashedLine)
    {
        int j;
 
        *(DWORD*)(pen_data->OptionalData + i) = pen->numdashes;
        i += sizeof(DWORD);
 
        for (j=0; j<pen->numdashes; j++)
        {
            *(REAL*)(pen_data->OptionalData + i) = pen->dashes[j];
            i += sizeof(REAL);
        }
    }
    if (data_flags & PenDataNonCenter)
    {
        *(REAL*)(pen_data->OptionalData + i) = pen->align;
        i += sizeof(DWORD);
    }
 
    METAFILE_FillBrushData(pen->brush,
            (EmfPlusBrush*)(object_record->ObjectData.pen.data + pen_data_size));
    return Ok;
}

Referenced by METAFILE_DrawPath().

METAFILE_AddRegionObject()

static GpStatus METAFILE_AddRegionObject ( GpMetafile *  metafile, GpRegion *  region, DWORD *  id  )

static

Definition at line 1167 of file metafile.c.

{
    EmfPlusObject *object_record;
    DWORD size;
    GpStatus stat;
 
    *id = -1;
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    size = write_region_data(region, NULL);
    stat = METAFILE_AllocateRecord(metafile,
            FIELD_OFFSET(EmfPlusObject, ObjectData.region) + size, (void**)&object_record);
    if (stat != Ok) return stat;
 
    *id = METAFILE_AddObjectId(metafile);
    object_record->Header.Type = EmfPlusRecordTypeObject;
    object_record->Header.Flags = *id | ObjectTypeRegion << 8;
    write_region_data(region, &object_record->ObjectData.region);
    return Ok;
}

Referenced by METAFILE_SetClipRegion().

METAFILE_AddSimpleProperty()

GpStatus METAFILE_AddSimpleProperty

(

GpMetafil