Travailler avec la table 'name' | .NET

La table de polices TrueType « nom » est le stockage des chaînes de texte liées à cette police. Ces chaînes peuvent être écrites dans différentes langues et représenter diverses entités, telles que des noms de polices, des noms de famille, des noms de concepteurs, des informations de licence, des avis de droits d’auteur, etc. En bref, les lignes contenues dans la table « nom » décrivent les métadonnées de police.

Schéma de la table ’name'.

The detailed specification for ’name’ table is accessible in Microsoft and Apple documentations.

Il existe 2 formats pour une table « nom » avec les numéros 0 et 1 respectivement. En termes de table ’name’, ces numéros de format sont nommés comme version, donc le format 0 est désigné comme version 0 et le format 1 comme version 1.

Le format 1 diffère du format 0 dans l’identification de la langue. Toute entrée de la table ’name’ possède un identifiant de langue, qui est utilisé pour détecter la langue de cette chaîne. Et la différence entre le format 0 et le format 1 réside dans la manière dont ces identifiants de langue sont interprétés.

Les identifiants de langue pour le format 0 ont une interprétation spécifique à la plate-forme, mais les identifiants de langue pour le format 1 sont associés à des chaînes de balises de langue, qui identifient les langues quelle que soit la plate-forme.

Pour plus de précision, le format 1 permet de conserver les identifiants de langue des deux types : les identifiants avec une interprétation spécifique à la plate-forme et les identifiants associés aux chaînes de balises de langue (c’est-à-dire indépendants d’une plate-forme).

La bibliothèque Aspose.Font prend en charge le format 0 de la table ’name’. La prise en charge du format 1 est prévue pour les prochaines versions.

Indépendamment du format de la table ’name’, toute entrée de cette table est basée sur un composant particulier - la structure NameRecord.

Les quatre paramètres principaux de cette structure sont :

identifiant de plateforme(platformID),
identifiant spécifique à la plateforme (platformSpecificID),
identifiant de nom (nameID),
et l’identifiant de langue (langageID).

Les paramètres platformID, platformSpecificID et languageID sont utilisés pour définir la langue de la chaîne d’une manière spécifique à la plate-forme. Les valeurs des paramètres platformSpecificID et languageID n’ont d’importance que dans le contexte du paramètre platformID.

Par exemple, platformSpecificID égal à 0 définit le script romain pour la plate-forme Mac, et en même temps, platformSpecificID définit le script romain pour la plate-forme Windows.

De la même manière, la valeur de languageID n’a d’importance que dans le contexte du paramètre platformID utilisé.

Par exemple, languageID définissant l’anglais USA est égal à 0 pour platformID = 1 (Mac) et 0x0409 pour platformID = 3 (Windows).

Les exclusions sont uniquement langageID pour le format de table de noms 1, associé à une chaîne de balise de langue, qui identifie les langues quelle que soit la plateforme.

Le paramètre nameID est un nombre qui identifie une catégorie de chaîne logique, telle que le nom de la police, le nom de famille et autres. Il existe un ensemble prédéfini d’identifiants de nom, qui est le même pour toutes les plates-formes et toutes les langues.

Ainsi, chaque entrée de la table ’nom’ peut être conditionnellement divisée en 3 parties :

catégorie de chaîne logique,
langage de chaînes,
la chaîne elle-même.

Le paramètre nameID est lié à la première partie, les paramètres platformID, platformSpecificID et langageID sont liés à la deuxième partie.

Comment travailler avec les enregistrements de la table « nom » à l’aide d’Aspose.Font ?

La prise en charge de la table ’name’ est fournie par la classe TtfNameTable. De plus, nous considérons la fonctionnalité de cet objet.

Tout d’abord, décrivons les énumérations nécessaires pour utiliser les fonctionnalités de la classe TtfNameTable.

Les énumérations NameID et PlatformId sont liées aux paramètres décrits ci-dessus comme nameID et platformID.
Les énumérations UnicodePlatformSpecificId, MacPlatformSpecificId, MSPlatformSpecificId sont liées au paramètre platformSpecificID.

Comme mentionné ci-dessus, “les valeurs des paramètres platformSpecificID et languageID n’ont d’importance que dans le contexte du paramètre platformID”. Ainsi, lorsque platformID est 0 et que cela définit la plate-forme Unicode, utilisez l’énumération UnicodePlatformSpecificId, lorsque platformID est 1 (plate-forme Macintosh), utilisez l’énumération MacPlatformSpecificId et lorsque platformID est 3 (plate-forme Windows), utilisez l’énumération MSPlatformSpecificId. .

Les énumérations MSLanguageId et MacLanguageId sont liées au paramètre LanguageID. Utilisez l’énumération MSLanguageId lorsque platformID est 3 (plate-forme Windows) et utilisez l’énumération MacLanguageId lorsque platformID est 1 (plate-forme Macintosh).

Passons maintenant à la question de l’obtention et de l’actualisation des entrées de la « table des noms ».

Comment récupérer les enregistrements de la table ’name’ ?

Commençons par la méthode GetAllNameRecords(). Cette méthode, comme son nom l’indique, renvoie toutes les entrées sans exclusions de la table ’name’. En pratique, la méthode n’est pas souvent appelée car dans la plupart des cas, les utilisateurs n’ont pas besoin de toutes les entrées, donc pour obtenir l’entrée nécessaire, la liste des entrées doit être soigneusement filtrée.

Le fait est que même dans une catégorie logique, FontFamily par exemple, les données de chaîne de cette catégorie peuvent être dans différentes langues. Ainsi, chaque langue a besoin d’une entrée distincte dans la table « nom » pour cette catégorie logique. Comme si les données de la catégorie FontFamily existaient en anglais, français et allemand, la catégorie FontFamily comprendrait 3 entrées.

De plus, l’entrée de langue peut elle-même être divisée en quelques entrées qui coïncident par les valeurs de données de chaîne et la valeur languageID, mais diffèrent par les valeurs des paramètres platformID et platformSpecificID.

Pour simplifier l’échantillonnage des données de la table ’name’, la bibliothèque Aspose.Font propose les méthodes suivantes :

GetNameRecordsByNameId()- renvoie la liste des entrées pour l’ensemble par la catégorie logique utilisateur, définie par le paramètre nameID.
GetMultiLanguageNameById() - renvoie toutes les entrées pertinentes pour le nameID de catégorie logique transmis en tant qu’objet de type MultiLanguageString. Grâce à l’objet de type - MultiLanguageString, nous pouvons connaître toutes les langues de cette catégorie et obtenir les données de chaîne pour la langue définie. Vous pouvez obtenir la liste de toutes les langues en appelant la méthode GetAllLanguageIds() de type MultiLanguageString. Après avoir reçu la liste des langues, nous pouvons appeler la méthode GetStringForLanguageId() pour chaque ID de langue. Cette méthode renvoie la chaîne de données écrite dans ce langage.

La classe MultiLanguageString propose également les méthodes suivantes :

ContainsString (string str)- vérifie si une chaîne passée est présente dans toutes les chaînes de langue de l’objet.
GetEnglishString() - renvoie une chaîne écrite en anglais si elle est trouvée. Il renvoie la première chaîne, dont l’ID langue est MSLanguageId.English_United_States, MSLanguageId.English_Australia, MSLanguageId.English_United_Kingdom, MSLanguageId.English_Canada ou MSLanguageId.English_New_Zealand. S’il n’existe aucune chaîne avec l’identifiant de langue pertinent, la méthode renvoie la première chaîne de la liste.
GetAllStrings() - renvoie toutes les chaînes de toutes les langues incluses dans l’objet.

La méthode la plus simple à utiliser de la classe TtfNameTable est GetNameById(), qui a été conçue pour les cas où vous n’avez besoin que d’obtenir la valeur de la catégorie définie en anglais. Cette méthode recherche un enregistrement qui correspond à 2 critères :

Cet enregistrement est rédigé en anglais, il a donc la valeur MSLanguageId.English_United_States ou MSLanguageId.English_United_Kingdom pour le paramètre LanguageID.
Cet enregistrement a platformID avec la valeur égale à FontEnvironment.Current.CurrentPlatformId (3 dans l’implémentation actuelle, qui déclare la plate-forme Microsoft).

Comment ajouter/mettre à jour des enregistrements dans la table ’name’ ?

La classe TtfNameTable fournit une méthode AddName pour ajouter ou mettre à jour des enregistrements dans la table ’name'.

Cette méthode crée la structure de type NameRecord et l’insère dans la table ’name’. Si l’enregistrement coïncide avec celui ajouté par les paramètres platformID, platformSpecificID, langueID et nameID existe déjà, la méthode n’ajoute pas de nouvel enregistrement, mais met à jour les données de chaîne dans l’enregistrement existant en utilisant la valeur , défini par le paramètre name.

Le paramètre nameId définit la catégorie de chaîne logique pour un enregistrement. Les paramètres platformId, platformSpecificId et lingualId sont utilisés pour définir la langue de la chaîne. Et le dernier paramètre « nom » est utilisé pour définir les données de chaîne pour un enregistrement.

Exemples d’utilisation des fonctions de l’objet TtfNameTable.

Incluez using pour les espaces de noms suivants :

1using System;
2using System.Text;
3using System.Collections.Generic;
4using Aspose.Font.Ttf;
5using Aspose.Font.TtfTables;

Déclaration et initialisation d’une variable de police.

1TtfFont font;

Les 2 extraits suivants impriment la valeur pour la catégorie Nom complet de la police et produisent le même résultat pour la police Lora-Regular

1    //1
2    string fullFontName = font.TtfTables.NameTable.GetNameById(TtfNameTable.NameId.FullName);
3    Console.WriteLine(String.Format("Full font name: {0}", fullFontName ));
4    //2
5    string fullFontName = font.TtfTables.NameTable.GetMultiLanguageNameById(TtfNameTable.NameId.FullName).GetEnglishString();
6    Console.WriteLine(String.Format("Full font name: {0}", fullFontName));

Impression de tout le contenu de la table ’name'.

L’extrait ci-dessous montre comment effectuer cette opération.

 1    TtfNameTable.NameId[] ids = Enum.GetValues<TtfNameTable.NameId>();
 2
 3    foreach (TtfNameTable.NameId nameId in ids)
 4    {
 5        MultiLanguageString mlString = font.TtfTables.NameTable.GetMultiLanguageNameById(nameId);
 6            if (mlString == null)
 7                continue;
 8        Console.WriteLine(string.Format("{0}: {1}", nameId, GetMultiLanguageStringValue(mlString)));
 9    }
10    //Using of this method has no sense when strings from 'name' table have only single language, but it can be useful when font
11    //'name' table include multilingual strings
12    string GetMultiLanguageStringValue(MultiLanguageString mlString)
13    {
14        int[] languages = mlString.GetAllLanguageIds();
15        if(languages.Length == 1)
16            return mlString.GetEnglishString();
17
18        StringBuilder sb = new StringBuilder();
19
20        for(int i = 0; i < languages.Length; i++) 
21        {
22            int langId = languages[i];
23            sb.Append(String.Format("{0}: {1}", Enum.GetName<TtfNameTable.MSLanguageId>(
24                (TtfNameTable.MSLanguageId)langId), mlString.GetStringForLanguageId(langId)));
25            if (i != (languages.Length - 1))
26                sb.Append(", ");
27        }
28
29        return sb.ToString();
30    }

Mise à jour des valeurs des catégories « Nom de la sous-famille de police » et « Description »

Pour ajouter ou actualiser correctement l’entrée dans la table ’name’, nous devons transmettre les valeurs des paramètres platformID, platformSpecificID et languageID qui coïncident avec celles déjà présentes dans la table ’name’. Pour cela, avant de rafraîchir les données, nous lirons les enregistrements existants de type NameRecord pertinents pour la catégorie logique de rafraîchissement, définie par identifiant de nom.

 1    //Struct for update operations
 2    struct UpdateData
 3    {
 4        private TtfNameTable.NameId _nameId;
 5        private string _data;
 6
 7        public UpdateData(TtfNameTable.NameId nameId, string data)
 8        {
 9            this._nameId = nameId;
10            this._data = data;
11        }
12
13        public TtfNameTable.NameId NameId => this._nameId;
14        public string StringData => this._data;
15    }
16		
17    UpdateData[] recordsToUpdate = new UpdateData[]
18    {
19        new UpdateData(TtfNameTable.NameId.FontSubfamily, "Italic"),
20        new UpdateData(TtfNameTable.NameId.Description, "New description")
21    };
22
23    TtfNameTable.NameRecord firstRecord = null;
24
25    foreach (UpdateData updateData in recordsToUpdate)
26    {
27        TtfNameTable.NameRecord[] records = font.TtfTables.NameTable.GetNameRecordsByNameId(updateData.NameId);
28
29        //Declare variable for NameRecord structure to use for update operations
30        TtfNameTable.NameRecord record = null;
31
32        //In this example we will use only info from the first NameRecord structure returned to update font metadata.
33        //Many actual fonts require serious analyze of all NameRecords returned to update metadata correctly
34
35        //Initialize just created variables
36        if (records.Length == 0)
37        {
38            //If no any record was found for current name identifer,
39            //we will use first found record for any name identifier
40            if (firstRecord == null)
41            {
42                firstRecord = GetFirstExistingRecord(font.TtfTables.NameTable);
43            }
44            record = firstRecord;
45        }
46        else
47        {
48            record = records[0];
49        }
50
51        //Add or update record in 'name' table
52        font.TtfTables.NameTable.AddName(updateData.NameId, (TtfNameTable.PlatformId)record PlatformId, 
53                        record.PlatformSpecificId, record.LanguageId, updateData.StringData);
54    }		
55
56		
57    TtfNameTable.NameRecord GetFirstExistingRecord(TtfNameTable table)
58    {
59        TtfNameTable.NameRecord[] records = null;
60        foreach (TtfNameTable.NameId nameId in Enum.GetValues<TtfNameTable.NameId>())
61        {
62            records = table.GetNameRecordsByNameId(nameId);
63            if (records.Length != 0)
64                return records[0];
65        }
66
67        return table.GetAllNameRecords()[0];
68    }

D’autres exemples pour actualiser la table ’name’ que vous pouvez trouver dans le test solution MetadataExamples.cs.

Travailler avec les glyphes et les mesures des polices TrueType Travailler avec les polices Type1