diff options
Diffstat (limited to 'core/src/fxge/Microsoft SDK/include/GdiPlusMetaHeader.h')
| -rw-r--r-- | core/src/fxge/Microsoft SDK/include/GdiPlusMetaHeader.h | 213 |
1 files changed, 213 insertions, 0 deletions
diff --git a/core/src/fxge/Microsoft SDK/include/GdiPlusMetaHeader.h b/core/src/fxge/Microsoft SDK/include/GdiPlusMetaHeader.h new file mode 100644 index 0000000000..79b5bc9533 --- /dev/null +++ b/core/src/fxge/Microsoft SDK/include/GdiPlusMetaHeader.h @@ -0,0 +1,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
+
|