1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/**************************************************************************\
*
* Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved.
*
* Module Name:
*
* Metafile headers
*
* Abstract:
*
* Declarations for various metafile header structures.
*
\**************************************************************************/
#ifndef _GDIPLUSMETAHEADER_H
#define _GDIPLUSMETAHEADER_H
typedef struct
{
DWORD iType; // Record type EMR_HEADER
DWORD nSize; // Record size in bytes. This may be greater
// than the sizeof(ENHMETAHEADER).
RECTL rclBounds; // Inclusive-inclusive bounds in device units
RECTL rclFrame; // Inclusive-inclusive Picture Frame of metafile in .01 mm units
DWORD dSignature; // Signature. Must be ENHMETA_SIGNATURE.
DWORD nVersion; // Version number
DWORD nBytes; // Size of the metafile in bytes
DWORD nRecords; // Number of records in the metafile
WORD nHandles; // Number of handles in the handle table
// Handle index zero is reserved.
WORD sReserved; // Reserved. Must be zero.
DWORD nDescription; // Number of chars in the unicode description string
// This is 0 if there is no description string
DWORD offDescription; // Offset to the metafile description record.
// This is 0 if there is no description string
DWORD nPalEntries; // Number of entries in the metafile palette.
SIZEL szlDevice; // Size of the reference device in pels
SIZEL szlMillimeters; // Size of the reference device in millimeters
} ENHMETAHEADER3;
// Aldus Placeable Metafiles
// Placeable Metafiles were created by Aldus Corporation as a non-standard
// way of specifying how a metafile is mapped and scaled on an output device.
// Placeable metafiles are quite wide-spread, but not directly supported by
// the Windows API. To playback a placeable metafile using the Windows API,
// you will first need to strip the placeable metafile header from the file.
// This is typically performed by copying the metafile to a temporary file
// starting at file offset 22 (0x16). The contents of the temporary file may
// then be used as input to the Windows GetMetaFile(), PlayMetaFile(),
// CopyMetaFile(), etc. GDI functions.
// Each placeable metafile begins with a 22-byte header,
// followed by a standard metafile:
#include <pshpack2.h> // set structure packing to 2
typedef struct
{
INT16 Left;
INT16 Top;
INT16 Right;
INT16 Bottom;
} APMRect16;
typedef struct
{
UINT32 Key; // GDIP_WMF_ALDUSKEY
INT16 Hmf; // Metafile HANDLE number (always 0)
APMRect16 BoundingBox; // Coordinates in metafile units
INT16 Inch; // Number of metafile units per inch
UINT32 Reserved; // Reserved (always 0)
INT16 Checksum; // Checksum value for previous 10 WORDs
} APMFileHeader;
#include <poppack.h>
// Key contains a special identification value that indicates the presence
// of a placeable metafile header and is always 0x9AC6CDD7.
// Handle is used to stored the handle of the metafile in memory. When written
// to disk, this field is not used and will always contains the value 0.
// Left, Top, Right, and Bottom contain the coordinates of the upper-left
// and lower-right corners of the image on the output device. These are
// measured in twips.
// A twip (meaning "twentieth of a point") is the logical unit of measurement
// used in Windows Metafiles. A twip is equal to 1/1440 of an inch. Thus 720
// twips equal 1/2 inch, while 32,768 twips is 22.75 inches.
// Inch contains the number of twips per inch used to represent the image.
// Normally, there are 1440 twips per inch; however, this number may be
// changed to scale the image. A value of 720 indicates that the image is
// double its normal size, or scaled to a factor of 2:1. A value of 360
// indicates a scale of 4:1, while a value of 2880 indicates that the image
// is scaled down in size by a factor of two. A value of 1440 indicates
// a 1:1 scale ratio.
// Reserved is not used and is always set to 0.
// Checksum contains a checksum value for the previous 10 WORDs in the header.
// This value can be used in an attempt to detect if the metafile has become
// corrupted. The checksum is calculated by XORing each WORD value to an
// initial value of 0.
// If the metafile was recorded with a reference Hdc that was a display.
#define GDIP_EMFPLUSFLAGS_DISPLAY 0x00000001
class MetafileHeader
{
public:
MetafileType Type;
UINT Size; // Size of the metafile (in bytes)
UINT Version; // EMF+, EMF, or WMF version
UINT EmfPlusFlags;
REAL DpiX;
REAL DpiY;
INT X; // Bounds in device units
INT Y;
INT Width;
INT Height;
union
{
METAHEADER WmfHeader;
ENHMETAHEADER3 EmfHeader;
};
INT EmfPlusHeaderSize; // size of the EMF+ header in file
INT LogicalDpiX; // Logical Dpi of reference Hdc
INT LogicalDpiY; // usually valid only for EMF+ files
public:
// Get the metafile type
MetafileType GetType() const { return Type; }
// Get the size of the metafile in BYTEs
UINT GetMetafileSize() const { return Size; }
// If IsEmfPlus, this is the EMF+ version; else it is the WMF or EMF version
UINT GetVersion() const { return Version; }
// Get the EMF+ flags associated with the metafile
UINT GetEmfPlusFlags() const { return EmfPlusFlags; }
// Get the X Dpi of the metafile
REAL GetDpiX() const { return DpiX; }
// Get the Y Dpi of the metafile
REAL GetDpiY() const { return DpiY; }
// Get the bounds of the metafile in device units
VOID GetBounds (OUT Rect *rect) const
{
rect->X = X;
rect->Y = Y;
rect->Width = Width;
rect->Height = Height;
}
// Is it any type of WMF (standard or Aldus Placeable Metafile)?
BOOL IsWmf() const
{
return ((Type == MetafileTypeWmf) || (Type == MetafileTypeWmfAldus));
}
// Is this an Aldus Placeable Metafile?
BOOL IsWmfAldus() const { return (Type == MetafileTypeWmf); }
// Is this an EMF (not an EMF+)?
BOOL IsEmf() const { return (Type == MetafileTypeEmf); }
// Is this an EMF or EMF+ file?
BOOL IsEmfOrEmfPlus() const { return (Type >= MetafileTypeEmf); }
// Is this an EMF+ file?
BOOL IsEmfPlus() const { return (Type >= MetafileTypeEmfPlusOnly); }
// Is this an EMF+ dual (has dual, down-level records) file?
BOOL IsEmfPlusDual() const { return (Type == MetafileTypeEmfPlusDual); }
// Is this an EMF+ only (no dual records) file?
BOOL IsEmfPlusOnly() const { return (Type == MetafileTypeEmfPlusOnly); }
// If it's an EMF+ file, was it recorded against a display Hdc?
BOOL IsDisplay() const
{
return (IsEmfPlus() &&
((EmfPlusFlags & GDIP_EMFPLUSFLAGS_DISPLAY) != 0));
}
// Get the WMF header of the metafile (if it is a WMF)
const METAHEADER * GetWmfHeader() const
{
if (IsWmf())
{
return &WmfHeader;
}
return NULL;
}
// Get the EMF header of the metafile (if it is an EMF)
const ENHMETAHEADER3 * GetEmfHeader() const
{
if (IsEmfOrEmfPlus())
{
return &EmfHeader;
}
return NULL;
}
};
#endif
|