Fiche technique | |
---|---|
Type | Metafichier |
Méthode de compression | Aucune |
Nombre maximum de couleurs | 24 bits |
Taille maximum de l'image | Aucune |
Supporte plusieurs images | Oui, plusieurs images peuvent être présente dans un même fichier |
Format des nombres | Little-endian |
Date de conception | 1990 |
Auteur | Microsoft |
Plateforme | Windows |
Introduction
L'extension de fichier .WMF (abréviation de l'anglicisme Windows Metafile Format) est format d'image développé par les entreprises Microsoft utilisés pour entreposer des données graphiques au format vectoriel et bitmap en mémoire ou dans des fichiers disque. Les données vectorielles entreposées dans les fichiers WMF sont décrites comme des commandes GDI (Microsoft Windows Graphics Device Interface). Dans l'environnement Windows, ces commandes sont interprétées et lues sur un périphérique de sortie à l'aide de la fonction PlayMetaFile() de l'API de Windows. Les données bitmap entreposées dans un fichier WMF peuvent être entreposées sous le format DDB (Microsoft Device Dependent Bitmap) ou d'un DIB (Device Independent Bitmap).
Dans l'environnement Windows, les métafichiers sont généralement créés et lus en mémoire. Si les données du métafichier deviennent trop volumineuses pour être entreposées en mémoire, ou doivent être enregistrées avant la fin d'une application, les données peuvent être écrites sur le disque sous la forme d'un fichier WMF ou EMF et lues à partir du disque. La taille maximale d'un métafichier Windows est de quatre gigaoctets. Le WMF est le format de métafichier Windows de 16 bits d'origine étant apparu avec Windows 2.0. Les fichiers EMF sont la révision 32 bits du format WMF. Les fichiers EMF ont des fonctionnalités étendues sur les fichiers WMF, y compris une palette de couleurs et une prise en charge complète de toutes les commandes GDI en 32 bits. L'API de Win32 (Windows 95 et Windows NT) et OLE en 32 bits prennent en charge les fichiers WMF et EMF. Les API de Win16 et Win32s (Windows 3.x) et OLE en 16 bits ne prennent en charge que les fichiers WMF.
Bien que le format du métafichier Windows soit spécifique à Microsoft Windows, de nombreuses applications non basées sur Windows prennent en charge ce format comme méthode pour échanger des données graphiques avec des applications Windows. En raison de la popularité généralisée de l'interface graphique Microsoft Windows, le format de fichier de métafichier Windows est devenu un format de base pour les applications graphiques et est donc pris en charge sur la plupart des plates-formes. Par exemple, le EPS (Encapsulated PostScript) d'Adobe prend en charge l'utilisation d'un métafichier Windows inclus lorsque cela est nécessaire pour entreposer des données vectorielles.
Si vous utilisez des métafichiers dans les systèmes d'exploitation Windows ou OS/2, vous n'écrirez pas de code pour les analyser directement, mais appelez plutôt un ensemble de fonctions API de Windows utilisées pour manipuler les métafichiers. Si vous avez accès à un SDK (ensemble de développement logiciel) de Win16, vous trouverez toutes les structures de données et définitions de type de données associées aux fichiers WMF dans le fichier d'entête WINDOWS.H. Pour le SDK de Win32, vous trouverez les définitions WMF et EMF dans les fichiers d'entête WINUSER.H et WINGDI.H. Ces deux ensembles SDK sont disponibles avec tous les compilateurs C et C++ prenant en charge le développement d'applications Windows.
Organisation des fichiers
Un métafichier est composé d'un ou deux entêtes d'informations et d'un tableau d'enregistrements de longueur variable entreposant les informations d'appel de fonction GDI. Il existe quatre types de métafichiers Windows : standard, placable, presse-papiers et amélioré. Un métafichier standard contient un entête WMF de 18 octets suivi d'un ou plusieurs enregistrements de commandes GDI. Un métafichier placable contient un entête de 22 octets suivi de l'entête WMF de 18 octets standard et des enregistrements de commande GDI. Les métafichiers du presse-papiers contiennent un entête de 8 octets (Win16) ou 16 octets (Win32) précédant l'entête de métafichier standard. Les métafichiers améliorés contiennent uniquement des enregistrements EMF, le premier enregistrement entreposant les informations d'entête. Les fichiers EMF ne sont pas compatibles dans leur conception avec les autres types de métafichiers WMF.
Les métafichiers Windows contiennent un entête, suivi d'un ou plusieurs enregistrements de données. L'entête contient une description des données d'enregistrement entreposées dans le métafichier. Chaque enregistrement est un appel de fonction GDI (Graphics Device Interface) de Microsoft Windows codé en binaire. Le GDI est utilisé par Windows pour effectuer toutes les sorties vers une fenêtre, une imprimante ou un autre périphérique de sortie. Lorsque les données de métafichier sont rendues (ou lues, dans la terminologie Microsoft), les données de chaque enregistrement sont utilisées pour effectuer l'appel de fonction GDI approprié pour rendre chaque objet entreposé dans le fichier. Le dernier enregistrement du fichier contient des informations indiquant que la fin des données d'enregistrement a été atteinte.
Les métafichiers placables sont des fichiers WMF avec un entête de 18 octets ajouté. Cet entête contient des informations utilisées pour décrire la position du dessin de métafichier sur la page affichée (ce à quoi les concepteurs de fichiers WMF d'origine n'ont pas pensé).
Les métafichiers du presse-papiers sont similaires aux métafichiers placables en ce qu'ils contiennent également un entête supplémentaire ajouté au début d'un fichier WMF. Le pré-entête du presse-papiers contient des informations utilisées pour décrire la position du métafichier dans le presse-papiers Windows et le mode de cartographie utilisé pour lire les données.
Les métafichiers améliorés ont le même format de base que les fichiers WMF : un entête suivi d'un ou plusieurs enregistrements d'objets de dessin entreposés sous forme de commandes GDI. Contrairement à WMF, l'entête est également entreposé dans un enregistrement apparaissant comme le premier enregistrement dans chaque fichier EMF. L'entête EMF contient désormais des informations supplémentaires, notamment les informations de position et de cartographie entreposées dans les pré-entêtes de métafichier placable et presse-papiers. Le EMF ajoute également les fonctionnalités d'une chaîne de description de fichier et d'une palette de couleurs programmable au format de métafichier.
Détails du fichier
L'entête de métafichier Windows standard a une longueur de 18 octets et est structuré comme suit :
- typedef struct _WindowsMetaHeader
- {
- WORD FileType; /* Type de métafichier (0 = mémoire, 1 = disque) */
- WORD HeaderSize; /* Taille de l'entête en mots (toujours 9) */
- WORD Version; /* Version de Microsoft Windows utilisée */
- DWORD FileSize; /* Taille totale du métafichier dans WORD */
- WORD NumOfObjects; /* Nombre d'objets dans le fichier */
- DWORD MaxRecordSize; /* La taille du plus grand enregistrement en WORD */
- WORD NumOfParams; /* Non utilisé (toujours 0) */
- } WMFHEAD;
Le champ FileType contient une valeur indiquant l'emplacement des données du métafichier. Une valeur de 0 indique que le métafichier est entreposé en mémoire, tandis qu'un 1 indique qu'il est entreposé sur le disque. Le champ HeaderSize contient la taille de l'entête du métafichier dans les mots 16 bits. Cette valeur est toujours 9. Le champ Version entrepose le numéro de version de Microsoft Windows ayant créé le métafichier. Cette valeur est toujours lue au format hexadécimal. Par exemple, dans un métafichier créé par Windows 3.0 et Windows 3.1, cet élément aurait la valeur 0x0300. Le champ FileSize spécifie la taille totale du métafichier dans les mots 16 bits. Le champ NumOfObjects spécifie le nombre d'objets se trouvant dans le métafichier. Le champ MaxRecordSize spécifie la taille du plus grand enregistrement du métafichier en WORD. Le champ NumOfParams n'est pas utilisé et a la valeur 0.
Métafichiers placables Aldus
Les métafichiers placables (extension de fichier .APM) ont été créés par Aldus Corporation comme un moyen non standard de spécifier comment un métafichier est cartographié et mis à l'échelle sur un périphérique de sortie. Les métafichiers placables sont assez répandus, mais ne sont pas directement pris en charge par l'API de Windows. Pour lire un métafichier placable à l'aide de l'API de Windows, vous devez d'abord supprimer l'entête du métafichier placable du fichier. Cela est généralement effectué en copiant le métafichier dans un fichier temporaire à partir du déplacement de fichier 0x16. Le contenu du fichier temporaire peut ensuite être utilisé comme entrée pour les fonctions GetMetaFile(), PlayMetaFile(), CopyMetaFile(),... du GDI de Windows Les métafichiers placables sont limités à 64 Ko de longueur. Chaque métafichier placable commence par un entête de 22 octets suivi d'un métafichier standard :
- typedef struct _PlaceableMetaHeader
- {
- DWORD Key; /* Numéro magique (toujours 9AC6CDD7h) */
- WORD Handle; /* Numéro HANDLE du métafichier (toujours 0) */
- SHORT Left; /* Coordonnée gauche en unités de métafichier */
- SHORT Top; /* Coordonnée supérieure dans les unités de métafichier */
- SHORT Right; /* Coordonnée droite dans les unités de métafichier */
- SHORT Bottom; /* Coordonnée inférieure en unités de métafichier */
- WORD Inch; /* Nombre d'unités de métafichier par pouce */
- DWORD Reserved; /* Réservé (toujours 0) */
- WORD Checksum; /* Valeur de la somme de contrôle des 10 WORD précédents */
- } PLACEABLEMETAHEADER;
Le champ Key contient une valeur d'identification spéciale indiquant la présence d'un entête de métafichier placable et étant toujours 9AC6CDD7h. Le champ Handle est utilisé pour entreposer l'identificateur de descripteur du métafichier en mémoire. Lorsqu'il est écrit sur le disque, ce champ n'est pas utilisé et contiendra toujours la valeur 0. Les champs Left, Top, Right et Bottom contiennent les coordonnées des coins supérieur gauche et inférieur droit de l'image sur le périphérique de sortie. Celles-ci sont mesurées en twips (un twip (signifiant «vingtième de point») est l'unité logique de mesure utilisée dans les métafichiers Windows; un twip est égal à 1/1440 de pouce. Ainsi 720 twips équivalent à 1/2 pouce, tandis que 32768 twips équivaut à 22,75 pouces). Ces quatre champs correspondent également à la structure RECT utilisée dans Microsoft Windows et définie dans le fichier WINDOWS.H. Inch contient le nombre de twips par pouce utilisé pour représenter l'image. Normalement, il y a 1440 twips par pouce; cependant, ce nombre peut être modifié pour mettre l'image à l'échelle. Une valeur de 720 indique que l'image est le double de sa taille normale ou mise à l'échelle à un facteur de 2:1. Une valeur de 360 indique une échelle de 4:1, tandis qu'une valeur de 2880 indique que la taille de l'image est réduite par un facteur de deux. Une valeur de 1440 indique un rapport d'échelle 1:1. Le champ Reserved n'est pas utilisé et est toujours mis à 0. Le champ Checksum contient une valeur de somme de contrôle pour les 10 WORD précédents dans l'entête. Cette valeur peut être dans une tentative de détecter si le métafichier est corrompu. La somme de contrôle est calculée en XOR chaque valeur WORD à une valeur initiale de 0 :
- PLACEABLEMETAHEADER pmh;
- pmh.Checksum = 0;
- pmh.Checksum ^= (pmh.Key & 0x0000FFFFUL);
- pmh.Checksum ^= ((pmh.Key & 0xFFFF0000UL) >> 16);
- pmh.Checksum ^= pmh.Handle;
- pmh.Checksum ^= pmh.Left;
- pmh.Checksum ^= pmh.Top;
- pmh.Checksum ^= pmh.Right;
- pmh.Checksum ^= pmh.Bottom;
- pmh.Checksum ^= pmh.Inch;
- pmh.Checksum ^= (pmh.Reserved & 0x0000FFFFUL);
- pmh.Checksum ^= ((pmh.Reserved & 0xFFFF0000UL) >> 16);
Une autre façon de parcourir la structure d'entête un mot à la fois consiste à utiliser un pointeur comme indiqué ci-dessous :
- PLACEABLEMETAHEADER *pmh;
- WORD *ptr;
- pmh->Checksum = 0;
- for (ptr = (WORD *) pmh; ptr < (WORD *)pmh->Checksum; ptr++) pmh->Checksum ^= *ptr;
Métafichier du presse-papiers
Les métafichiers du presse-papiers sont entreposés dans des fichiers Microsoft Clipboard Viewer (extension de fichier .CLP) et des fichiers Microsoft Windows Write (extension de fichier .WRI). Les métafichiers du presse-papiers sont également basés sur le format de métafichier standard, mais sont précédés d'un entête supplémentaire de 8 ou 16 octets permettant la position du métafichier dans la visionneuse du presse-papiers. Si le métafichier de presse-papiers a été créé à l'aide d'une version 16 bits de Windows (Windows et Windows for Workgroups), cet entête contiendra des champs de 2 octets organisés dans la structure suivante :
- typedef struct _Clipboard16MetaHeader
- {
- SHORT MappingMode; /* Unités utilisées pour lire le métafichier */
- SHORT Width; /* Largeur du métafichier */
- SHORT Height; /* Hauteur du métafichier */
- WORD Handle; /* Identificateur de descripteur de métafichier en mémoire */
- } CLIPBOARD16METAHEADER;
Le champ MappingMode spécifie le type d'unités de cartographie de coordonnées Windows utilisées pour entreposer et lire les données de métafichier. Ce champ contiendra l'une des valeurs suivantes :
Valeur | Mode de cartographie | Une unité correspond à |
---|---|---|
1 | Texte | Un pixel |
2 | Métrique faible | 0,1 millimètre |
3 | Haute métrique | 0,01 millimètre |
4 | Bas anglais | 0,01 pouce |
5 | Haut anglais | 0,001 pouce |
6 | Twips | 1/1440e de pouce |
7 | Isotrope | Spécifique à l'application (rapport hauteur / largeur préservé). |
8 | Anisotrope | Spécifique à l'application (rapport hauteur / largeur non conservé). |
Les champs Width et Height correspondent à la taille du métafichier dans les unités spécifiées dans le champ MappingMode. Le champ Handle est utilisé pour entreposer l'identificateur de descripteur du métafichier en mémoire. Lorsqu'il est écrit sur le disque, ce champ n'est pas utilisé et contiendra toujours la valeur 0. Si le métafichier du presse-papiers a été créé sous un environnement Windows en 32 bits (Windows NT et Windows 95), cet entête contiendra les mêmes champs que l'entête WMF de Win16, mais les champs ont une longueur de 32 octets :
- typedef struct _Clipboard32MetaHeader
- {
- LONG MappingMode; /* Unités utilisées pour lire le métafichier */
- LONG Width; /* Largeur du métafichier */
- LONG Height; /* Hauteur du métafichier */
- DWORD Handle; /* Identificateur de descripteur de métafichier en mémoire */
- } CLIPBOARD32METAHEADER;
Métafichiers améliorés
Les fichiers de métafichier améliorés sont une révision 32 bits de nouvelle et amélioration du métafichier standard. Seule l'API de Windows en 32 bits (Win32) prend en charge les fichiers EMF et les API de Windows en 16 bits (Win16 et Win32s) ne le font pas. Il est également recommandé de ne pas utiliser les fichiers WMF par les applications exécutant les environnements Windows en 32 bits (Windows 95 et Windows NT). Les métafichiers améliorés sont généralement enregistrés sur le disque en utilisant l'extension de fichier «.EMF». Les données de chaîne de caractères trouvées dans les fichiers EMF utilisent l'ensemble de caractères Unicode. Chaque caractère Unicode a une taille de 2 octets. Les 256 premiers caractères (sur plus de 36 000) de l'ensemble de caractères Unicode sont également les 256 caractères de l'ensemble de caractères ANSI utilisé par Windows. L'octet de poids faible de chaque caractère Unicode contiendra la valeur du caractère ANSI et l'octet de poids fort sera zéro. Vous reconnaîtrez les chaînes de caratères Unicode dans les vidages de données lorsque vous verrez un modèle d'octet tel que "S u m m a r y I n f o" plutôt que le modèle ANSI ou ASCII plus courant de "SummaryInfo". Les fichiers EMF ont un entête de 80 octets et contient les mêmes fonctionnalités que celles des métafichiers placables et du presse-papiers. Bien que l'entête soit considéré comme juste un autre enregistrement EMF, il doit apparaître comme le premier enregistrement dans chaque fichier EMF.
- typedef struct _EnhancedMetaHeader
- {
- DWORD RecordType; /* Type d'enregistrement */
- DWORD RecordSize; /* Taille de l'enregistrement en octets */
- LONG BoundsLeft; /* Limites inclusives à gauche */
- LONG BoundsRight; /* Bonnes limites inclusives */
- LONG BoundsTop; /* Limites inclusives supérieures */
- LONG BoundsBottom; /* Limites inclusives inférieures */
- LONG FrameLeft; /* Côté gauche du cadre photo inclus */
- LONG FrameRight; /* Côté droit du cadre photo inclus */
- LONG FrameTop; /* Face supérieure du cadre photo inclusif */
- LONG FrameBottom; /* Face inférieure du cadre photo inclus */
- DWORD Signature; /* Identificateur de signature (toujours 0x464D4520) */
- DWORD Version; /* Version du métafichier */
- DWORD Size; /* Taille du métafichier en octets */
- DWORD NumOfRecords; /* Nombre d'enregistrements dans le métafichier */
- WORD NumOfHandles; /* Nombre d'identificateur de descripteur dans le tableau d'identificateurs de descripteurs */
- WORD Reserved; /* Non utilisé (toujours 0) */
- DWORD SizeOfDescrip; /* Taille de la chaîne de description dans WORD */
- DWORD OffsOfDescrip; /* Déplacement de la chaîne de caractères de description dans le métafichier */
- DWORD NumPalEntries; /* Nombre d'entrées de palette de couleurs */
- LONG WidthDevPixels; /* Largeur du périphérique de référence en pixels */
- LONG HeightDevPixels; /* Hauteur de l'appareil de référence en pixels */
- LONG WidthDevMM; /* Largeur du périphérique de référence en millimètres */
- LONG HeightDevMM; /* Hauteur du périphérique de référence en millimètres */
- } ENHANCEDMETAHEADER;
Le champ RecordType identifie le type d'enregistrement EMF. Pour l'enregistrement d'entête EMF, cette valeur est toujours 00000001h. Le champ RecordSize est la taille de l'entête en octets. Les champs BoundsLeft, BoundsRight, BoundsTop et BoundsBottom spécifient la taille du dessin de métafichier à l'aide du système de coordonnées X, Y, largeur et longueur. Les champs BoundsTop et BoundsBottom doivent avoir des valeurs supérieures à BoundsLeft et BoundsRight. Les champs FrameLeft, FrameRight, FrameTop et FrameBottom spécifient la taille du cadre ou de la bordure entourant le métafichier à l'aide du système de coordonnées X, Y, largeur et longueur. Les champs FrameTop et FrameBottom doivent avoir des valeurs supérieures à FrameLeft et FrameRight. Le champ Signature est une valeur d'identification de fichier et est toujours définie sur la valeur 0x464D4520. Le champ Version est le numéro de version du format de fichier EMF. La version actuelle est 1.0 et est entreposée sous la valeur 0x00000100. Le champ Size est la taille de l'ensemble du métafichier en octets. Le champ NumOfRecords est le nombre total d'enregistrements dans le métafichier, y compris l'enregistrement d'entête. Le champ NumOfHandles est le nombre de descripteurs actuellement entreposés dans la table de descripteurs de mémoire. Cette valeur est toujours 0 pour les données de métafichier entreposées sur le disque. Le champ Reserved n'est pas utilisé et vaut toujours zéro. Le champ SizeOfDescrip est le nombre de caractères Unicode de 16 bits contenus dans la chaîne de caractères de description, y compris tous les caractères NULL. Si cette valeur est 0, aucune chaîne de caractères de description n'est présente dans le fichier. Le champ OffsOfDescrip est l'emplacement de la chaîne de caractères de description calculé comme le nombre d'octets depuis le début du fichier. Si cette valeur est 0, aucune chaîne de description n'est présente dans le fichier. Le champ NumPalEntries indique le nombre d'entrées dans la palette de couleurs. La palette de couleurs, si elle est présente, sera située dans les enregistrements de fin de fichier. Si cette valeur est 0, aucune palette de couleurs n'est présente. Le champ WidthDevPixels et HeightDevPixels sont la largeur et la hauteur du périphérique d'affichage en pixels. Le champ WidthDevMM et HeightDevMM sont la largeur et la hauteur du périphérique d'affichage en millimètres.
Chaîne de caractères description EMF
Une chaîne de caractères de description Unicode peut être entreposée dans un fichier EMF. Si les champs d'entête SizeOfDescrip et OffsOfDescrip ne sont pas égaux à zéro, une chaîne de caractères de description est présente dans le fichier. Il sera localisé dans les octets OffsOfDescrip depuis le début du fichier et contiendra des caractères Unicode de SizeOfDescrip. Bien qu'elle ne soit pas limitée en taille pratique (à moins que vous ne souhaitiez une description de plus de deux milliards de caractères), la chaîne de caractères description devrait avoir un format spécifique. Le format est le nom de l'application ayant créé l'image, un NULL, le nom ou la description de l'image, et enfin deux NULL. Une chaîne de caractères de description Unicode de créateur/titre EMF typique peut donc apparaître comme telle :
"Peintres 1.5\0Peinture de gladir.com\0\0" |
Le respect de ce format à double terminaison NULL garantit que les informations standard peuvent être obtenues à partir d'un fichier EMF et permet également de lire facilement la chaîne de caractères de description à l'aide des appels de fonction GDI de Windows.
Enregistrements de métafichiers standard
Une série d'enregistrements de données suit l'entête standard de tous les métafichiers WMF. Cet enregistrement est défini par la définition du type de données METARECORD dans WINDOWS.H et a le format suivant :
- typedef struct _StandardMetaRecord {
- DWORD Size; /* Taille totale de l'enregistrement en mots */
- WORD Function; /* Numéro de fonction (défini dans WINDOWS.H) */
- WORD Parameters[]; /* Valeurs des paramètres transmises à la fonction */
- } WMFRECORD;
Le champ Size est la taille totale des enregistrements dans les mots 16 bits, y compris le champ Size lui-même. La taille minimale possible pour un enregistrement est de 3. Le champ Function est le numéro GDI de la fonction appelée pour lire cet enregistrement. L'octet de poids faible de cette valeur identifie la fonction GDI spécifique à appeler. L'octet de poids fort est le nombre de mots passés à cette fonction, ainsi que le nombre d'éléments dans le tableau Parameters. Par exemple, une valeur de 0x0213 indique la fonction LineTo() (0x13) et que cette fonction reçoit deux valeurs WORD. Le Parameters est un tableau des paramètres utilisés par la fonction GDI spécifiée par cet enregistrement. Les paramètres sont entreposés dans l'ordre inverse dans lequel ils sont passés à la fonction. Par exemple, les deux valeurs de paramètre de l'enregistrement LineTo sont transmises à la fonction LineTo() dans l'ordre X et Y, mais entreposées dans l'enregistrement sous la forme Y et X. Bien que chaque paramètre d'enregistrement soit entreposé en tant que WORD, le type de données exact du paramètre est déterminé par la fonction à laquelle il est passé. Les valeurs de paramètre changeant, telles que les identificateurs de descripteurs de contexte de périphérique, ne sont jamais entreposées dans les enregistrements de métafichier. Le dernier enregistrement de chaque métafichier a toujours un numéro de fonction de 0000h, une taille de 0003h et aucun tableau de paramètres. Cet enregistrement est utilisé pour indiquer la fin des données d'enregistrement dans le métafichier. L'utilisation de cet enregistrement de terminaison est absente de la description WMF d'origine trouvée dans le SDK de Windows et est désormais documentée dans l'article Q99334 de la base de connaissances Microsoft. Lorsqu'un fichier au format métafichier Windows est lu dans l'environnement Windows, chaque enregistrement est lu et l'appel de fonction qu'il contient est exécuté dans l'ordre dans lequel il est entreposé dans le fichier. Le système d'exploitation Windows crée une table des descripteurs d'objets utilisés par les fonctions appelées dans les enregistrements de métafichier. La taille maximale de cette table de descripteurs d'objets est indiquée par la valeur du champ NumOfObjects dans l'entête. Le système d'exploitation Windows insère de nouveaux objets dans la table à l'aide de l'appel SelectObject() de l'API. La table de descripteurs d'objets est créée et utilisée uniquement lors de l'accès au métafichier en mémoire et n'est jamais entreposée dans un fichier WMF. Il existe plusieurs considérations importantes à prendre en compte lors de la lecture des données d'enregistrement de métafichier. Tous les enregistrements d'un métafichier Windows n'ont pas le format ci-dessus, bien que la plupart le soient. Les enregistrements de métafichier suivant ce format d'enregistrement de base sont les suivants :
Nom de l'enregistrement | Numéro de fonction |
---|---|
AbortDoc | 0x0052 |
Arc | 0x0817 |
Chord | 0x0830 |
DeleteObject | 0x01f0 |
Ellipse | 0x0418 |
EndDoc | 0x005E |
EndPage | 0x0050 |
ExcludeClipRect | 0x0415 |
ExtFloodFill | 0x0548 |
FillRegion | 0x0228 |
FloodFill | 0x0419 |
FrameRegion | 0x0429 |
IntersectClipRect | 0x0416 |
InvertRegion | 0x012A |
LineTo | 0x0213 |
MoveTo | 0x0214 |
OffsetClipRgn | 0x0220 |
OffsetViewportOrg | 0x0211 |
OffsetWindowOrg | 0x020F |
PaintRegion | 0x012B |
PatBlt | 0x061D |
Pie | 0x081A |
RealizePalette | 0x0035 |
Rectangle | 0x041B |
ResetDc | 0x014C |
ResizePalette | 0x0139 |
RestoreDC | 0x0127 |
RoundRect | 0x061C |
SaveDC | 0x001E |
ScaleViewportExt | 0x0412 |
ScaleWindowExt | 0x0410 |
SelectClipRegion | 0x012C |
SelectObject | 0x012D |
SelectPalette | 0x0234 |
SetTextAlign | 0x012E |
SetBkColor | 0x0201 |
SetBkMode | 0x0102 |
SetDibToDev | 0x0d33 |
SetMapMode | 0x0103 |
SetMapperFlags | 0x0231 |
SetPalEntries | 0x0037 |
SetPixel | 0x041F |
SetPolyFillMode | 0x0106 |
SetRelabs | 0x0105 |
SetROP2 | 0x0104 |
SetStretchBltMode | 0x0107 |
SetTextAlign | 0x012E |
SetTextCharExtra | 0x0108 |
SetTextColor | 0x0209 |
SetTextJustification | 0x020A |
SetViewportExt | 0x020E |
SetViewportOrg | 0x020D |
SetWindowExt | 0x020C |
SetWindowOrg | 0x020B |
StartDoc | 0x014D |
StartPage | 0x004F |
Par exemple, l'enregistrement LineTo entrepose les informations transmises à la fonction LineTo() du GDI. La fonction LineTo() trace une ligne entre le point actuel et les coordonnées spécifiées dans les données d'enregistrement. En supposant que la ligne doit être tracée à l'emplacement 100,50, les données de l'enregistrement LineTo apparaissent comme suit :
- Size 5 /* Cinq WORD dans le fichier */
- Function 0x0213 /* Numéro de fonction LineTo */
- Parameters[0] 50 /* Coordonnée Y */
- Parameters[1] 100 /* Coordonnée X */
Ces données seraient lues à partir du métafichier et transmises aux fonctions LineTo() de GDI en tant que telles (l'identificateur de descripteur hDC n'est pas entreposé dans le métafichier) :
- LineTo(hDC, 100, 5);
Plusieurs formats d'enregistrement s'écartent du format d'enregistrement de base en contenant une structure de données, plutôt qu'un tableau de données, dans le champ Paramètres. Ces enregistrements sont :
Nom de l'enregistrement | Numéro de fonction |
---|---|
AnimatePalette | 0x0436 |
BitBlt | 0x0922 |
CreateBitmap | 0x06FE |
CreateBitmapIndirect | 0x02FD |
CreateBrush | 0x00F8 |
CreateBrushIndirect | 0x02FC |
CreateFontIndirect | 0x02FB |
CreatePalette | 0x00F7 |
CreatePatternBrush | 0x01F9 |
CreatePenIndirect | 0x02FA |
CreateRegion | 0x06FF |
DeleteObject | 0x01F0 |
DibBitblt | 0x0940 |
DibCreatePatternBrush | 0x0142 |
DibStretchBlt | 0x0B41 |
DrawText | 0x062F |
Escape | 0x0626 |
ExtTextOut | 0x0A32 |
Polygon | 0x0324 |
PolyPolygon | 0x0538 |
Polyline | 0x0325 |
TextOut | 0x0521 |
StretchBlt | 0x0B23 |
StretchDIBits | 0x0F43 |
Par exemple, l'enregistrement BitBlt est utilisé pour stocker des données bitmap dans un métafichier. L'enregistrement BitBlt entrepose un bitmap dépendant du périphérique (DDB) dans son champ Paramètres. Un DDB est un simple entête suivi de données bitmap non compressées. L'enregistrement BitBlt entier dans un métafichier Windows 2.x aura le format suivant :
- typedef struct _BitBltRecord {
- DWORD Size; /* Taille totale de l'enregistrement en mots */
- WORD Function; /* Numéro de fonction (0x0922) */
- WORD RasterOp; /* Mot de poids fort pour l'opération raster */
- WORD YSrcOrigin; /* Coordonnée Y de l'origine source */
- WORD XSrcOrigin; /* Coordonnée X de l'origine source */
- WORD YDest; /* Largeur de la destination */
- WORD XDest; /* Hauteur de la destination */
- WORD YDestOrigin; /* Y-coordinate of the destination origin */
- WORD XDestOrigin; /* X-coordinate of the destination origin */
- /* DDB Bitmap */
- DWORD Width; /* Largeur du bitmap en pixels */
- DWORD Height; /* Hauteur du bitmap dans les lignes de balayage */
- DWORD BytesPerLine; /* Nombre d'octets dans chaque ligne de balayage */
- WORD NumColorPlanes; /* Nombre de plans de couleur dans le bitmap */
- WORD BitsPerPixel; /* Nombre de bits dans chaque pixel */
- RGBTRIPLE Bitmap[]; /* Données bitmap */
- } BITBLTRECORD;
Les données Bitmap elles-mêmes sont entreposées sous forme de tableau de structures RGBTRIPLE :
- typedef struct _RGBTriple {
- BYTE Red;
- BYTE Green;
- BYTE Blue;
- } RGBTRIPLE;
Notez que le bitmap DDB trouvé dans les enregistrements BitBlt du WMF de Windows 2.x n'est pas compatible avec Windows 3.0 et versions ultérieures. Le Windows 3.0 a créé l'enregistrement DibBitBlt pour entreposer un bitmap indépendant du périphérique (DIB) plutôt qu'un DDB. Un enregistrement DibBitBlt a le format suivant :
- typedef struct _DibBitBltRecord {
- DWORD Size; /* Taille totale de l'enregistrement en mots */
- WORD Function; /* Numéro de fonction (0x0940) */
- WORD RasterOp; /* Mot de poids fort pour l'opération raster */
- WORD YSrcOrigin; /* Coordonnée Y de l'origine source */
- WORD XSrcOrigin; /* Coordonnée X de l'origine source */
- WORD YDest; /* Largeur de la destination */
- WORD XDest; /* Hauteur de destination */
- WORD YDestOrigin; /* Coordonnée Y de l'origine de la destination */
- WORD XDestOrigin; /* Coordonnée X de l'origine de la destination */
- /* DIB Bitmap */
- DWORD Width; /* Largeur du bitmap en pixels */
- DWORD Height; /* Hauteur du bitmap dans les lignes de balayage */
- DWORD BytesPerLine; /* Nombre d'octets dans chaque ligne de balayage */
- WORD NumColorPlanes; /* Nombre de plans de couleur dans le bitmap */
- WORD BitsPerPixel; /* Nombre de bits dans chaque pixel */
- DWORD Compression; /* Type de compression */
- DWORD SizeImage; /* Taille du bitmap en octets */
- LONG XPelsPerMeter; /* Largeur de l'image en pixels par mètre */
- LONG YPelsPerMeter; /* Hauteur de l'image en pixels par mètre */
- DWORD ClrUsed; /* Nombre de couleurs utilisées */
- DWORD ClrImportant; /* Nombre de couleurs importantes */
- RGBQUAD Bitmap[]; /* Données bitmap */
- } DIBBITBLTRECORD;
Les données bitmap elles-mêmes sont entreposées sous forme de tableau de structures RGBQUAD :
- typedef struct _RGBQuad {
- BYTE Red;
- BYTE Green;
- BYTE Blue;
- BYTE Reserved;
- } RGBQUAD;
Un autre enregistrement de métafichier spécifique à une fonction méritant l'attention est Escape. L'API de Windows 3.x prend en charge 64 séquences d'échappement d'imprimante différentes pouvant être incorporées dans un métafichier WMF. Les séquences réelles disponibles varient en fonction du ou des pilotes d'imprimante actuellement installés dans l'environnement Windows. L'utilisation d'échappements d'imprimante est déconseillée, car l'inclusion d'un ou plusieurs enregistrements d'échappement dans le fichier WMF rend le métafichier dépendant du périphérique. L'un des enregistrements Escape les plus courants est MFCOMMENT. Le format WMF ne prend pas directement en charge l'insertion de texte lisible par l'homme. La séquence d'imprimante MFCOMMENT est par conséquent utilisée pour insérer une chaîne de caractères (ou d'autres données privées) jusqu'à 32 Ko de taille dans un métafichier. Il peut y avoir plusieurs enregistrements Escape entreposés dans un métafichier. Plusieurs appels de fonction GDI ont été ajoutés ou leurs paramètres ont été modifiés avec la sortie de Microsoft Windows 3.0. Les appels de fonction GDI dans cette catégorie incluent :
- AnimatePalette
- BitBlt
- CreatePalette
- CreatePatternBrush
- DeleteObject
- DibBitBlt
- DibCreatePatternBrush
- DibStretchBlt
- RealizePalette
- ResizePalette
- StretchBlt
Notez que tous les appels de fonction GDI ne peuvent pas apparaître dans un métafichier. Les seuls appels valides sont ceux prenant un identificateur de descripteur vers un contexte de périphérique comme premier paramètre. Ils se trouvent dans le fichier d'entête WINDOWS.H. Ces appels de fonction GDI sont les directives commençant par les caractères META. Il existe plus de 70 appels de fonction GDI différents définis pour Windows 3.x.
Enregistrements de métafichiers améliorés
Les métafichiers améliorés ont également une structure d'enregistrement de métafichiers améliorée. Par rapport aux enregistrements de métafichier standard, vous verrez que les trois champs sont désormais des DWORD de 32 bits et que les positions des champs Size et Function sont échangées :
Le champ Function est le numéro GDI de la fonction appelée pour lire cet enregistrement. Dans le SDK de Win32, ces valeurs identifiées par les définitions EMR_* dans le fichier d'entête WINDOWS.H. Le champ Size est la taille totale des enregistrements en BYTE, y compris les champs Size et Function. La taille minimale possible pour un enregistrement est de 8. Le champ Parameters est un tableau des paramètres utilisés par la fonction GDI spécifiée par cet enregistrement. Les paramètres sont entreposés dans l'ordre inverse dans lequel ils sont passés à la fonction. Par exemple, les deux valeurs de paramètre de l'enregistrement LineTo sont transmises à la fonction LineTo() dans l'ordre X et Y, mais entreposées dans l'enregistrement en tant que Y et X. Un fichier EMF est entièrement composé d'enregistrements EMF. Sur les 97 types d'enregistrements actuellement définis pour les fichiers EMF, au moins deux enregistrements doivent être présents dans chaque fichier. Il s'agit de l'enregistrement d'entête (type d'enregistrement 1) et de l'enregistrement de fin de fichier (type d'enregistrement 14). Voici les identificateurs de fonction pour les 97 enregistrements EMF. Si vous devez ajouter la capacité de fichier EMF à votre logiciel, vous devez obtenir une copie des documents Microsoft décrivant ces fonctions de l'API de Win32.
Enregistrement | Valeur |
---|---|
EMR_ABORTPATH | 68 |
EMR_ANGLEARC | 41 |
EMR_ARC | 45 |
EMR_ARCTO | 55 |
EMR_BEGINPATH | 59 |
EMR_BITBLT | 76 |
EMR_CHORD | 46 |
EMR_CLOSEFIGURE | 61 |
EMR_CREATEBRUSHINDIRECT | 39 |
EMR_CREATEDIBPATTERNBRUSHPT | 94 |
EMR_CREATEMONOBRUSH | 93 |
EMR_CREATEPALETTE | 49 |
EMR_CREATEPEN | 38 |
EMR_DELETEOBJECT | 40 |
EMR_ELLIPSE | 42 |
EMR_ENDPATH | 60 |
EMR_EOF | 14 |
EMR_EXCLUDECLIPRECT | 29 |
EMR_EXTCREATEFONTINDIRECTW | 82 |
EMR_EXTCREATEPEN | 95 |
EMR_EXTFLOODFILL | 53 |
EMR_EXTSELECTCLIPRGN | 75 |
EMR_EXTTEXTOUTA | 83 |
EMR_EXTTEXTOUTW | 84 |
EMR_FILLPATH | 62 |
EMR_FILLRGN | 71 |
EMR_FLATTENPATH | 65 |
EMR_FRAMERGN | 72 |
EMR_GDICOMMENT | 70 |
EMR_HEADER | 1 |
EMR_INTERSECTCLIPRECT | 30 |
EMR_INVERTRGN | 73 |
EMR_LINETO | 54 |
EMR_MASKBLT | 78 |
EMR_MODIFYWORLDTRANSFORM | 36 |
EMR_MOVETOEX | 27 |
EMR_OFFSETCLIPRGN | 26 |
EMR_PAINTRGN | 74 |
EMR_PIE | 47 |
EMR_PLGBLT | 79 |
EMR_POLYBEZIER | 2 |
EMR_POLYBEZIER16 | 85 |
EMR_POLYBEZIERTO | 5 |
EMR_POLYBEZIERTO16 | 88 |
EMR_POLYDRAW | 56 |
EMR_POLYDRAW16 | 92 |
EMR_POLYGON | 3 |
EMR_POLYGON16 | 86 |
EMR_POLYLINE | 4 |
EMR_POLYLINE16 | 87 |
EMR_POLYLINETO | 6 |
EMR_POLYLINETO16 | 89 |
EMR_POLYPOLYGON | 8 |
EMR_POLYPOLYGON16 | 91 |
EMR_POLYPOLYLINE | 7 |
EMR_POLYPOLYLINE16 | 90 |
EMR_POLYTEXTOUTA | 96 |
EMR_POLYTEXTOUTW | 97 |
EMR_REALIZEPALETTE | 52 |
EMR_RECTANGLE | 43 |
EMR_RESIZEPALETTE | 51 |
EMR_RESTOREDC | 34 |
EMR_ROUNDRECT | 44 |
EMR_SAVEDC | 33 |
EMR_SCALEVIEWPORTEXTEX | 31 |
EMR_SCALEWINDOWEXTEX | 32 |
EMR_SELECTCLIPPATH | 67 |
EMR_SELECTOBJECT | 37 |
EMR_SELECTPALETTE | 48 |
EMR_SETARCDIRECTION | 57 |
EMR_SETBKCOLOR | 25 |
EMR_SETBKMODE | 18 |
EMR_SETBRUSHORGEX | 13 |
EMR_SETCOLORADJUSTMENT | 23 |
EMR_SETDIBITSTODEVICE | 80 |
EMR_SETMAPMODE | 17 |
EMR_SETMAPPERFLAGS | 16 |
EMR_SETMETARGN | 28 |
EMR_SETPALETTEENTRIES | 50 |
EMR_SETPIXELV | 15 |
EMR_SETPOLYFILLMODE | 19 |
EMR_SETROP2 | 20 |
EMR_SETSTRETCHBLTMODE | 21 |
EMR_SETTEXTALIGN | 22 |
EMR_SETTEXTCOLOR | 24 |
EMR_SETVIEWPORTEXTEX | 11 |
EMR_SETVIEWPORTORGEX | 12 |
EMR_SETWINDOWEXTEX | 9 |
EMR_SETWINDOWORGEX | 10 |
EMR_SETWORLDTRANSFORM | 35 |
EMR_STRETCHBLT | 77 |
EMR_STRETCHDIBITS | 81 |
EMR_STROKEANDFILLPATH | 63 |
EMR_STROKEPATH | 64 |
EMR_WIDENPATH | 66 |
Palette de couleurs
Les fichiers EMF peuvent également contenir une palette de couleurs facultative utilisée pour rendre le dessin EMF. Par comparaison, les fichiers WMF n'entreposent pas de palette de couleurs et utilisent à la place la palette de premier plan Windows par défaut. Le champ NumPalEntries dans l'entête EMF indiquera le nombre d'entrées dans la palette et aura une valeur de zéro si aucune palette n'est présente. La palette de couleurs, si elle est présente, sera entreposée dans l'enregistrement de fin de fichier. L'enregistrement EOF est toujours le dernier enregistrement dans un fichier EMF et a le format suivant :
- typedef struct _EndOfRecord {
- DWORD Function; /* Identificateur de fin d'enregistrement (14) */
- DWORD Size; /* Taille totale de l'enregistrement en mots */
- DWORD NumPalEntries; /* Nombre d'entrées de palette de couleurs */
- DWORD OffPalEntries; /* Déplacement des entrées de la palette de couleurs */
- PALENT Palette[]; /* Les données de la palette de couleurs */
- DWORD OffToEOF; /* Déplacement au début de cet enregistrement */
- } ENDOFRECORD;
Le champ Function est le numéro de fonction de cet enregistrement. Pour les enregistrements EOF, cette valeur est toujours de 14. Le champ Size est la taille totale de cet enregistrement en octets. Pour un enregistrement EOF ne contenant pas de palette de couleurs, cette valeur sera 20. Le champ NumPalEntries est le nombre d'entrées de la palette de couleurs. Cette valeur correspondra à la valeur du champ NumPalEntries dans l'entête EMF. Une valeur de zéro indique qu'aucune palette de couleurs n'est présente. Le champ OffPalEntries indique la position de la première entrée de palette de couleurs. Le déplacement est mesuré à partir du début de l'enregistrement EOF. Le champ Palette est les données de la palette de couleurs entreposées sous forme de tableau de structures PALENT. Ce champ n'est pas présent dans l'enregistrement EOF si une palette de couleurs n'est pas présente. Le champ OffToEOF indique le déplacement d'octet par rapport au début de l'enregistrement EOF. Ce champ est situé après les données de la palette de couleurs (le cas échéant) et contient toujours la même valeur que le champ Taille. Chaque entrée de la palette de couleurs a une taille de quatre octets et a le format suivant :
- typedef struct _PaletteEntry {
- BYTE Red; /* Valeur du composante rouge */
- BYTE Green; /* Valeur du composante vert */
- BYTE Blue; /* Valeur du composante bleu */
- BYTE Flags; /* Valeurs du drapeau */
- } PALENT;
Les champs Red, Green et Blue contiennent les valeurs des composantes de couleur pour l'entrée de la palette de couleurs 24 bits. Les drapeaux contiennent un champ de bits d'indicateurs utilisés pour indiquer l'utilisation de l'entrée de palette. Les valeurs de ce champ sont :
Valeur | Description |
---|---|
0x01 | Index de palette utilisé pour l'animation. |
0x02 | Index de la palette est explicite pour le périphérique. |
0x04 | Ne pas faire correspondre la couleur à la palette système. |
Commentaire GDI
Une fonctionnalité très intéressante du format EMF est la possibilité d'intégrer des données privées dans un fichier EMF. Contrairement au commentaire d'échappement de l'imprimante WMF, le commentaire GDI peut contenir n'importe quel type de données et est totalement indépendant du périphérique. L'enregistrement GDICOMMENT a le format suivant :
Le champ Function est le numéro de fonction de cet enregistrement. Pour les enregistrements de commentaires GDI, cette valeur est toujours de 70. Le champ Size est la taille totale de cet enregistrement en octets. Pour un enregistrement de commentaire GDI ne contenant aucune donnée, cette valeur sera 12. Le champ SizeOfData est le nombre d'octets dans le champ Data. Le champ Data sont les données de commentaire GDI. Les données peuvent être des chaînes de caractères, du Encapsulated PostScipt ou un métafichier amélioré. Chaque enregistrement de commentaire GDI peut entreposer un ou plusieurs types de données de commentaire. Le commentaire Metafile entrepose un seul métafichier. Les commentaires BeginGroup et EndGroup entreposent une collection d'objets de métafichier améliorés et de chaînes de caractères de description. Et le commentaire Multiformats entrepose plusieurs métafichiers améliorés et des données Encapsulated PostScipt. Les commentaires GDI ne doivent jamais contenir de données spécifiques à l'application, car cela rendrait le périphérique de métafichier amélioré dépendant. Les données de commentaire ne doivent pas non plus entreposer la position de déplacement des autres données du fichier. Il est possible que des enregistrements soient ajoutés ou supprimés dans le métafichier, ce qui rend les valeurs de déplacement invalides. Le commentaire du métafichier est un entête suivi d'un métafichier amélioré. L'entête a le format suivant :
- typedef struct _GdiCommentMetafile {
- DWORD Identifier; /* Identificateur de commentaire (0x43494447) */
- DWORD Comment; /* Identificateur de métafichier (0x80000001) */
- DWORD Version; /* Version du métafichier */
- DWORD Checksum; /* Valeur de somme de contrôle du métafichier */
- DWORD Flags; /* Drapeaux (toujours 0) */
- DWORD Size; /* Taille des données du métafichier en octets */
- } GDICOMMENTMETAFILE;
Le champ Identifier contient une valeur de 0x43494447 identifiant cette structure en tant que commentaire public GDI. Le champ Comment contient une valeur de 0x80000001 identifiant cette structure comme un commentaire de métafichier. Le champ Version est la version du métafichier. Cette valeur est généralement 0x00000001. Le champ Checksum est la valeur de la somme de contrôle des données du métafichier. Le champ Flags ne sont pas actuellement utilisés et sont toujours à 0. Le champ Size est le nombre d'octets dans les données du métafichier. Les commentaires BeginGroup et EndGroup contiennent un ou plusieurs objets de dessin EMF. Le commentaire BeginGroup démarre la liste, suivi de tous les enregistrements EMF et se termine par le commentaire EndGroup. Ces groupes peuvent être imbriqués. Le format de l'entête BeginGroup est le suivant :
- typedef struct _GdiCommentBeginGroup {
- DWORD Identifier; /* Identificateur du commentaire (0x43494447) */
- DWORD Comment; /* Identificateur du BeginGroup (0x00000002) */
- LONG BoundsLeft; /* Côté gauche du rectangle de délimitation */
- LONG BoundsRight; /* Côté droit du rectangle de délimitation */
- LONG BoundsTop; /* Côté supérieur du rectangle de délimitation */
- LONG BoundsBottom; /* Côté inférieur du rectangle de délimitation */
- DWORD SizeOfDescrip; /* Nombre de caractères dans la description */
- } GDICOMMENTBEGINGROUP;
Le champ Identifier contient une valeur de 0x43494447 identifiant cette structure en tant que commentaire public GDI. Le champ Comment contient une valeur de 0x00000002 identifiant cette structure en tant que commentaire BeginGroup. Les champs BoundsLeft, BoundsRight, BoundsTop et BoundsBottom définissent le rectangle englobant de l'image. Le champ SizeOfDescrip est le nombre de caractères Unicode dans la chaîne de caractères de description. Cette chaîne de caractères, si elle est présente, suivra toujours immédiatement cet entête. Si cette valeur est égale à zéro, aucune chaîne de caractères de description n'est présente. Le commentaire EndGroup contient uniquement un entête et aucune donnée. L'entête a le format suivant :
Le champ Identifier contient une valeur de 0x43494447 identifiant cette structure en tant que commentaire public GDI. Le champ Comment contient une valeur de 0x00000003 identifiant cette structure en tant que commentaire EndGroup. Le commentaire multiformats est utilisé pour entreposer des métafichiers et des données d'image EPS (Encapsulated PostScript). Ce commentaire commence par un entête suivi d'une ou plusieurs images. Le format d'un entête de commentaires multiformats est le suivant :
- typedef struct _GdiCommentMultiFormats {
- DWORD Identifier; /* Identificateur de commentaire (0x43494447) */
- DWORD Comment; /* Identificateur multiformats (0x40000004) */
- LONG BoundsLeft; /* Côté gauche du rectangle de délimitation */
- LONG BoundsRight; /* Côté droit du rectangle de délimitation */
- LONG BoundsTop; /* Côté supérieur du rectangle de délimitation */
- LONG BoundsBottom; /* Côté inférieur du rectangle de délimitation */
- DWORD NumFormats; /* Nombre de formats dans le commentaire */
- EMRFORMAT Data[]; /* Tableau de données de commentaires */
- } GDICOMMENTMULTIFORMATS
Le champ Identifier contient une valeur de 0x43494447 identifiant cette structure en tant que commentaire public GDI. Le champ Comment contient une valeur de 0x40000004 identifiant cette structure comme un commentaire multiformats. Les champs BoundsLeft, BoundsRight, BoundsTop et BoundsBottom définissent le rectangle englobant de l'image. Le champ NumFormats est le nombre de structures EMRFORMAT dans les données. Les données contiennent une ou plusieurs structures EMRFORMAT suivies de leurs données associées. Chaque structure identifie le type de données de commentaire, sa taille et son emplacement dans l'enregistrement.
Le champ Signature est l'identifiant du format de données. Une valeur de 0x464D4520 indique un métafichier amélioré et une valeur de 0x46535045 indique un fichier Encapsulated PostScript. Le champ Version est le niveau de version des données. Pour les données EPS, ce champ contiendra le numéro de version EPS. Pour un métafichier amélioré, cette valeur de ce champ sera 0x00000001. Les données correspondent à la taille des données associées à cette structure en octets. Le champ OffsetToData est le déplacement d'octet du début des données. Le déplacement est mesuré à partir du début du champ Comments dans la structure d'enregistrement GDICOMMENTMULTIFORMATS.