Section courante

A propos

Section administrative du site

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 :

  1. typedef struct _WindowsMetaHeader
  2. {
  3.   WORD  FileType;       /* Type de métafichier (0 = mémoire, 1 = disque) */
  4.   WORD  HeaderSize;     /* Taille de l'entête en mots (toujours 9) */
  5.   WORD  Version;        /* Version de Microsoft Windows utilisée */
  6.   DWORD FileSize;       /* Taille totale du métafichier dans WORD */
  7.   WORD  NumOfObjects;   /* Nombre d'objets dans le fichier */
  8.   DWORD MaxRecordSize;  /* La taille du plus grand enregistrement en WORD */
  9.   WORD  NumOfParams;    /* Non utilisé (toujours 0) */
  10. } 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 :

  1. typedef struct _PlaceableMetaHeader
  2. {
  3.   DWORD Key;           /* Numéro magique (toujours 9AC6CDD7h) */
  4.   WORD  Handle;        /* Numéro HANDLE du métafichier (toujours 0) */
  5.   SHORT Left;          /* Coordonnée gauche en unités de métafichier */
  6.   SHORT Top;           /* Coordonnée supérieure dans les unités de métafichier */
  7.   SHORT Right;         /* Coordonnée droite dans les unités de métafichier */
  8.   SHORT Bottom;        /* Coordonnée inférieure en unités de métafichier */
  9.   WORD  Inch;          /* Nombre d'unités de métafichier par pouce */
  10.   DWORD Reserved;      /* Réservé (toujours 0) */
  11.   WORD  Checksum;      /* Valeur de la somme de contrôle des 10 WORD précédents */
  12. } 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 :

  1. PLACEABLEMETAHEADER pmh; 
  2. pmh.Checksum = 0;
  3. pmh.Checksum ^= (pmh.Key & 0x0000FFFFUL);
  4. pmh.Checksum ^= ((pmh.Key & 0xFFFF0000UL) >> 16);
  5. pmh.Checksum ^= pmh.Handle; 
  6. pmh.Checksum ^= pmh.Left;
  7. pmh.Checksum ^= pmh.Top; 
  8. pmh.Checksum ^= pmh.Right;
  9. pmh.Checksum ^= pmh.Bottom; 
  10. pmh.Checksum ^= pmh.Inch;
  11. pmh.Checksum ^= (pmh.Reserved & 0x0000FFFFUL);
  12. 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 :

  1. PLACEABLEMETAHEADER *pmh; 
  2. WORD *ptr;
  3. pmh->Checksum = 0;
  4. 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 :

  1. typedef struct _Clipboard16MetaHeader
  2. {
  3.   SHORT MappingMode; /* Unités utilisées pour lire le métafichier */
  4.   SHORT Width;       /* Largeur du métafichier */
  5.   SHORT Height;      /* Hauteur du métafichier */
  6.   WORD  Handle;      /* Identificateur de descripteur de métafichier en mémoire */
  7. } 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 :

  1. typedef struct _Clipboard32MetaHeader
  2. {
  3.   LONG  MappingMode; /* Unités utilisées pour lire le métafichier */
  4.   LONG  Width;       /* Largeur du métafichier */
  5.   LONG  Height;      /* Hauteur du métafichier */
  6.   DWORD Handle;      /* Identificateur de descripteur de métafichier en mémoire */
  7. } 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.

  1. typedef struct _EnhancedMetaHeader
  2. {
  3.     DWORD RecordType;       /* Type d'enregistrement */
  4.     DWORD RecordSize;       /* Taille de l'enregistrement en octets */
  5.     LONG  BoundsLeft;       /* Limites inclusives à gauche */
  6.     LONG  BoundsRight;      /* Bonnes limites inclusives */
  7.     LONG  BoundsTop;        /* Limites inclusives supérieures */
  8.     LONG  BoundsBottom;     /* Limites inclusives inférieures */
  9.     LONG  FrameLeft;        /* Côté gauche du cadre photo inclus */
  10.     LONG  FrameRight;       /* Côté droit du cadre photo inclus */
  11.     LONG  FrameTop;         /* Face supérieure du cadre photo inclusif */
  12.     LONG  FrameBottom;      /* Face inférieure du cadre photo inclus */
  13.     DWORD Signature;        /* Identificateur de signature (toujours 0x464D4520) */
  14.     DWORD Version;          /* Version du métafichier */
  15.     DWORD Size;             /* Taille du métafichier en octets */
  16.     DWORD NumOfRecords;     /* Nombre d'enregistrements dans le métafichier */
  17.     WORD  NumOfHandles;     /* Nombre d'identificateur de descripteur dans le tableau d'identificateurs de descripteurs */
  18.     WORD  Reserved;         /* Non utilisé (toujours 0) */
  19.     DWORD SizeOfDescrip;    /* Taille de la chaîne de description dans WORD */
  20.     DWORD OffsOfDescrip;    /* Déplacement de la chaîne de caractères de description dans le métafichier */
  21.     DWORD NumPalEntries;    /* Nombre d'entrées de palette de couleurs */
  22.     LONG  WidthDevPixels;   /* Largeur du périphérique de référence en pixels */
  23.     LONG  HeightDevPixels;  /* Hauteur de l'appareil de référence en pixels */
  24.     LONG  WidthDevMM;       /* Largeur du périphérique de référence en millimètres */
  25.     LONG  HeightDevMM;      /* Hauteur du périphérique de référence en millimètres */
  26. } 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 :

  1. typedef struct _StandardMetaRecord {
  2.     DWORD Size;          /* Taille totale de l'enregistrement en mots */
  3.     WORD  Function;      /* Numéro de fonction (défini dans WINDOWS.H) */
  4.     WORD  Parameters[];  /* Valeurs des paramètres transmises à la fonction */
  5. } 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 :

  1. Size           5       /* Cinq WORD dans le fichier */
  2. Function       0x0213  /* Numéro de fonction LineTo */
  3. Parameters[0]  50      /* Coordonnée Y */
  4. 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) :

  1. 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 :

  1. typedef struct _BitBltRecord {
  2.     DWORD     Size;             /* Taille totale de l'enregistrement en mots */
  3.     WORD      Function;         /* Numéro de fonction (0x0922) */
  4.     WORD      RasterOp;         /* Mot de poids fort pour l'opération raster */
  5.     WORD      YSrcOrigin;       /* Coordonnée Y de l'origine source */
  6.     WORD      XSrcOrigin;       /* Coordonnée X de l'origine source */
  7.     WORD      YDest;            /* Largeur de la destination */
  8.     WORD      XDest;            /* Hauteur de la destination */
  9.     WORD      YDestOrigin;      /* Y-coordinate of the destination origin */
  10.     WORD      XDestOrigin;      /* X-coordinate of the destination origin */
  11.     /* DDB Bitmap */
  12.     DWORD     Width;            /* Largeur du bitmap en pixels */
  13.     DWORD     Height;           /* Hauteur du bitmap dans les lignes de balayage */
  14.     DWORD     BytesPerLine;     /* Nombre d'octets dans chaque ligne de balayage */
  15.     WORD      NumColorPlanes;   /* Nombre de plans de couleur dans le bitmap */
  16.     WORD      BitsPerPixel;     /* Nombre de bits dans chaque pixel */
  17.     RGBTRIPLE Bitmap[];         /* Données bitmap */
  18. } BITBLTRECORD;

Les données Bitmap elles-mêmes sont entreposées sous forme de tableau de structures RGBTRIPLE :

  1. typedef struct _RGBTriple {
  2.     BYTE Red;
  3.     BYTE Green;
  4.     BYTE Blue;
  5. } 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 :

  1. typedef struct _DibBitBltRecord {
  2.     DWORD   Size;             /* Taille totale de l'enregistrement en mots */
  3.     WORD    Function;         /* Numéro de fonction (0x0940) */
  4.     WORD    RasterOp;         /* Mot de poids fort pour l'opération raster */
  5.     WORD    YSrcOrigin;       /* Coordonnée Y de l'origine source */
  6.     WORD    XSrcOrigin;       /* Coordonnée X de l'origine source */
  7.     WORD    YDest;            /* Largeur de la destination */
  8.     WORD    XDest;            /* Hauteur de destination */
  9.     WORD    YDestOrigin;      /* Coordonnée Y de l'origine de la destination */
  10.     WORD    XDestOrigin;      /* Coordonnée X de l'origine de la destination */
  11.     /* DIB Bitmap */
  12.     DWORD   Width;            /* Largeur du bitmap en pixels */
  13.     DWORD   Height;           /* Hauteur du bitmap dans les lignes de balayage */
  14.     DWORD   BytesPerLine;     /* Nombre d'octets dans chaque ligne de balayage */
  15.     WORD    NumColorPlanes;   /* Nombre de plans de couleur dans le bitmap */
  16.     WORD    BitsPerPixel;     /* Nombre de bits dans chaque pixel */
  17.     DWORD   Compression;      /* Type de compression */
  18.     DWORD   SizeImage;        /* Taille du bitmap en octets */
  19.     LONG    XPelsPerMeter;    /* Largeur de l'image en pixels par mètre */
  20.     LONG    YPelsPerMeter;    /* Hauteur de l'image en pixels par mètre */
  21.     DWORD   ClrUsed;          /* Nombre de couleurs utilisées */
  22.     DWORD   ClrImportant;     /* Nombre de couleurs importantes */
  23.     RGBQUAD Bitmap[];         /* Données bitmap */
  24. } DIBBITBLTRECORD;

Les données bitmap elles-mêmes sont entreposées sous forme de tableau de structures RGBQUAD :

  1. typedef struct _RGBQuad {
  2.     BYTE Red;
  3.     BYTE Green;
  4.     BYTE Blue;
  5.     BYTE Reserved;
  6. } 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 :

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 :

  1. typedef struct _EnhancedMetaRecord {
  2.     DWORD Function;      /* Numéro de fonction (défini dans WINGDI.H) */
  3.     DWORD Size;          /* Taille totale de l'enregistrement en mots */
  4.     DWORD Parameters[];  /* Valeurs de paramètre transmises à la fonction GDI */
  5. } EMFRECORD;

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 :

  1. typedef struct _EndOfRecord {
  2.     DWORD  Function;        /* Identificateur de fin d'enregistrement (14) */
  3.     DWORD  Size;            /* Taille totale de l'enregistrement en mots */
  4.     DWORD  NumPalEntries;   /* Nombre d'entrées de palette de couleurs */
  5.     DWORD  OffPalEntries;   /* Déplacement des entrées de la palette de couleurs */
  6.     PALENT Palette[];       /* Les données de la palette de couleurs */
  7.     DWORD  OffToEOF;        /* Déplacement au début de cet enregistrement */
  8. } 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 :

  1. typedef struct _PaletteEntry {
  2.     BYTE Red;       /* Valeur du composante rouge */
  3.     BYTE Green;     /* Valeur du composante vert */
  4.     BYTE Blue;      /* Valeur du composante bleu */
  5.     BYTE Flags;     /* Valeurs du drapeau */
  6. } 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 :

  1. typedef struct _GdiCommentRecord {
  2.     DWORD   Function;      /* Identificateur de commentaire GDI (70) */
  3.     DWORD   Size;          /* Taille totale de l'enregistrement en mots */
  4.     DWORD   SizeOfData;    /* Taille des données de commentaire en octets */
  5.     BYTE    Data[];        /* Données de commentaire */
  6. } GDICOMMENTRECORD;

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 :

  1. typedef struct _GdiCommentMetafile {
  2.     DWORD Identifier;       /* Identificateur de commentaire (0x43494447) */
  3.     DWORD Comment;          /* Identificateur de métafichier (0x80000001) */
  4.     DWORD Version;          /* Version du métafichier */
  5.     DWORD Checksum;         /* Valeur de somme de contrôle du métafichier */
  6.     DWORD Flags;            /* Drapeaux (toujours 0) */
  7.     DWORD Size;             /* Taille des données du métafichier en octets */
  8. } 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 :

  1. typedef struct _GdiCommentBeginGroup {
  2.     DWORD Identifier;       /* Identificateur du commentaire (0x43494447) */
  3.     DWORD Comment;          /* Identificateur du BeginGroup (0x00000002) */
  4.     LONG  BoundsLeft;       /* Côté gauche du rectangle de délimitation */
  5.     LONG  BoundsRight;      /* Côté droit du rectangle de délimitation */
  6.     LONG  BoundsTop;        /* Côté supérieur du rectangle de délimitation */
  7.     LONG  BoundsBottom;     /* Côté inférieur du rectangle de délimitation */
  8.     DWORD SizeOfDescrip;    /* Nombre de caractères dans la description */     
  9. } 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 :

  1. typedef struct _GdiCommentEndGroup {
  2.     DWORD Identifier;       /* Identificateur de commentaire (0x43494447) */
  3.     DWORD Comment;          /* Identificateur de EndGroup (0x00000003) */
  4. } GDICOMMENTENDGROUP;

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 :

  1. typedef struct _GdiCommentMultiFormats {
  2.     DWORD Identifier;       /* Identificateur de commentaire (0x43494447) */
  3.     DWORD Comment;          /* Identificateur multiformats (0x40000004) */
  4.     LONG  BoundsLeft;       /* Côté gauche du rectangle de délimitation */
  5.     LONG  BoundsRight;      /* Côté droit du rectangle de délimitation */
  6.     LONG  BoundsTop;        /* Côté supérieur du rectangle de délimitation */
  7.     LONG  BoundsBottom;     /* Côté inférieur du rectangle de délimitation */
  8.     DWORD NumFormats;       /* Nombre de formats dans le commentaire */
  9.     EMRFORMAT Data[];       /* Tableau de données de commentaires */
  10. } 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.

  1. typedef struct _EmrFormat {
  2.     DWORD Signature;    /* Signature de format */
  3.     DWORD Version;      /* Numéro de version du format */
  4.     DWORD Data;         /* Taille des données en octets */
  5.     DWORD OffsetToData; /* Déplacement aux données */
  6. } EMRFORMAT;

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.



Dernière mise à jour : Dimanche, le 27 décembre 2020