Comment charger les polices ? | Solution API pour C++

Aperçu

Pour répondre à la question de savoir comment charger les polices, nous devons d’abord apprendre que toute police est physiquement un tableau d’octets dans lequel les données sont représentées dans un certain format. Par conséquent, pour un chargement correct des polices, vous devez connaître deux paramètres clés :

Format de police. Les polices peuvent avoir différents formats comme « TrueType », « Type1 », etc.
Stockage, où sont conservées les données binaires qui représentent la police. Chaque police est représentée sous forme de données binaires mais la manière dont ces données sont stockées peut différer. Dans la plupart des cas, la police est stockée sous forme de fichier sur un disque dur. Mais parfois, les données binaires des polices peuvent être placées dans un fichier différent qui n’est pas une police en soi. Par exemple, les fichiers créés par Microsoft Word ou Adobe Acrobat. Ce sont des fichiers avec les extensions .docx, .pdf. Ils peuvent inclure différentes polices.

Objets et paramètres requis pour le chargement des polices

Aspose.Font pour C++ donne un objet FontDefiniton pour notifier deux paramètres clés requis pour le chargement de la police.

Après avoir créé et lancé l’objet FontDefiniton, il vous suffit d’appeler la méthode statique Aspose.Font.Font.Open() et de transmettre l’objet simplement initialisé FontDefiniton comme un paramètre pour charger la police souhaitée et obtenir une référence dessus.

Décrivons-le avec le pseudocode :

1using Aspose::Font;
2    ...
3
4    // Initialize object FontDefinition with appropriate properties
5    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>();
6    System::SharedPtr<Font> desiredFont = Aspose::Font::Font::Open(fd);

Le résultat final du chargement de la police est d’obtenir un objet de type Aspose.Font.Font. La classe Aspose.Font.Font est une classe de police de base de Aspose.Font pour la bibliothèque C++. Il représente la fonctionnalité principale du travail avec les polices.

En chargeant une police dans un objet de type Aspose.Font.Font, vous pourrez restituer le texte avec cette police, obtenir des données d’encodage et des métriques de police. Vous pourrez également modifier ou enregistrer cette police et bien d’autres.

Pour lancer l’objet FontDefiniton, nous devons donner à FontDefinition() 2 paramètres de police, - le type de format et l’objet qui décrit le stockage des données binaires de police. Le premier paramètre est notifié avec l’énumération FontType.

Pour simplifier le travail avec le deuxième paramètre, Aspose.Font propose une série d’objets qui donnent un accès universel aux données binaires de la police indépendamment de l’endroit où la police est placée.h

Cet accès universel est lié à un flux d’octets. Ainsi, indépendamment de l’endroit où la police est placée - dans un fichier sur un disque, dans un autre fichier, dans un tableau d’octets en mémoire - dans tous les cas, des objets spéciaux Aspose.Font fourniront un accès au flux d’octets. , lié à la police souhaitée.

Décrivons ces objets :

Classe StreamSource. Cette classe de base abstraite définit les propriétés et méthodes qui donnent accès au flux d’octets de police.

La méthode GetFontStream() de cette classe renvoie un flux lié aux données de police binaires. La propriété Offset pointe sur la position au niveau de ce flux, à partir de laquelle nous devons commencer à lire les données.

Deux classes les plus utilisées héritées de la base StreamSource :
- FileSystemStreamSource - conçu pour fournir un accès au flux, en fonction du système de fichiers. La propriété FileName renvoie le nom du fichier de police. La méthode GetFontStream() renvoie un flux d’octets lié à ce fichier.
- ByteContentStreamSource - permet d’accéder au flux, en fonction du tableau d’octets.

Comment initier les cours ?

Voici des exemples d’initiation de ces cours.1. Supposons que la police se trouve dans le fichier nommé Lora.ttf. Dans ce cas, pour accéder au flux d’octets de cette police, nous devons créer l’objet de type FileSystemStreamSource en utilisant ce constructeur unique :

1    System::SharedPtr<FileSystemStreamSource> fontSource = System::MakeObject<FileSystemStreamSource>("Lora.ttf");

Si les données binaires de la police sont situées dans un tableau binaire défini par la variable byte [] fontArray, alors un objet de type ByteContentStreamSource fournira un accès au flux de données de la police, basé sur la variable fontArray. . Pour accéder au flux d’octets de police, nous devons créer un objet de type ByteContentStreamSource pour accéder au flux, lié au tableau d’octets de police en utilisant un code comme celui-ci :

1    System::SharedPtr<ByteContentStreamSource> fontSource = System::MakeObject<ByteContentStreamSource>(fontArray);

Ainsi, pour donner accès aux données binaires des polices, utilisez des objets hérités de la classe de base StreamSource. De plus, nous appellerons ces objets sources de flux de polices.

Objet FontFileDefinition

La plupart des polices se trouvent dans des fichiers normaux, mais en même temps, certaines polices peuvent avoir des sources de données différentes. Pour joindre en un seul objet les termes fichier et flux binaire de polices, la bibliothèque Aspose.Font fournit un objet spécial FontFileDefinition.

Cet objet a les propriétés suivantes :

FileName - nom du fichier de police.
FileExtension - extension d’un fichier de police.
StreamSource - source du flux de polices.
Offset - décalage à l’intérieur du flux d’octets de la police.

Le constructeur le plus simple et l’un des plus utilisés de cet objet est le constructeur avec la signature suivante : FontFileDefinition (System::SharedPtr System::IO::FileInfo fontFile), utilisez ce constructeur pour les cas lorsque la police souhaitée se trouve dans un fichier sur le disque dur.

Voici un exemple d’initialisation d’un tel objet pour la police Montserrat qui se trouve dans le fichier C:\Windows\Fonts\Montserrat.ttf :

1    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(System::MakeObject<System::IO::FileInfo>(u"C:\\Windows\\Fonts\\Montserrat.ttf"));

De plus, FontFileDefinition peut référencer la police Montserrat en utilisant les constructeurs suivants :

1    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(System::MakeObject<FileSystemStreamSource>(u"C:\\Windows\\Fonts\\Montserrat.ttf"));
2
3    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(u"ttf", System::MakeObject<FileSystemStreamSource>(u"C:\\Windows\\Fonts\\Montserrat.ttf"));

Le paramètre fileExtension doit correspondre à l’extension standard pour le format de police. Par exemple, si le format de police est « TrueType », alors la valeur du paramètre fileExtension peut être « ttf » ou « ttc » (si le fichier de police est une collection de polices « TrueType »). Si le format de police est « Embedded Open Type », alors la valeur du paramètre fileExtension doit être « eot ».

Le tableau ci-dessous présente les formats de fichier de polices les plus souvent utilisés dans Aspose.Font pour C++. Les voilà avec les valeurs correspondantes que le paramètre fileExtension devrait prendre.

Format du fichier de police	Extension de fichier
`TrueType`, police unique	`ttf`
`Collection de polices TrueType`	`ttc`
`Web Open Font Format`	`woff`
`Web Open Font Format version 2.0`	`woff2`
`Embedded OpenType`	`eot`
Police Adobe `Type 1`	`pfa`, `pfb`, `afm`, `pfm`
`Compact Font Format`	`cff`, peut être null

Si les données de police ne démarrent pas à partir de la position 0 du flux d’octets, utilisez le constructeur suivant avec le paramètre offset :

1    FontFileDefinition(System::String fileExtension, System::SharedPtr<Aspose::Font::Sources::StreamSource> streamSource, int64_t offset).

Comment lancer l’objet FontDefinition ?

Maintenant, lorsque vous aurez une idée des objets hérités de la classe StreamSource et donnant accès au flux d’octets de police, et de l’objet FontFileDefinition, nous expliquerons à vous explique comment lancer correctement l’objet FontDefiniton avec ces objets pour différentes situations.

L’objet FontDefiniton vous fournit de nombreux constructeurs surchargés. La caractéristique commune à tous les constructeurs existants est le paramètre FontType. Il décrit le type de format de police.

Comme cela a été mentionné précédemment, outre la valeur FontType, l’objet FontDefiniton doit être initialisé en référence aux données binaires de la police.

Les paramètres suivants des constructeurs FontDefiniton peuvent être utilisés dans ce cas :

Vous avez peut-être une question. Pourquoi passerions-nous le paramètre fileExtension à l’objet FontDefiniton ou FontFileDefinition, alors que nous passons toujours le paramètre FontType qui semble coïncider par sa valeur avec fileExtension ?

Le problème est que FontType ne coïncide pas toujours avec la valeur de fileExtension. FontType définit le format de police commun mais pas le format de police d’un fichier spécifique. Certaines polices d’un même format peuvent avoir des formats de fichiers différents.

Par exemple, la valeur FontType.TTF définit le format « TrueType ». Mais en même temps, TrueType inclut quelques formats de police et il existe des fichiers de polices avec les extensions ttf, eot, ttc, etc. Et si, par exemple, pour la police au format EOT nous passons à FontDefiniton uniquement la valeur FontType.TTF, alors comment cet objet comprendra-t-il que la police appartient au format EOT et non à ` TTF ?

De la même manière, la valeur de FontType.Type1 est la définition courante des polices de ce format. Dans le même temps, les fichiers de polices au format Type1 ont les extensions .pfa, .pfb, .afm, .pfm. Vous ne pouvez donc pas définir correctement le format de fichier de police en vous basant uniquement sur la valeur FonType.Type1. Par conséquent, pour définir correctement le format de police, nous devons spécifier le paramètre FontType avec la valeur du paramètre fileExtension.

Ci-dessous, vous pouvez découvrir des exemples d’initialisation d’objet FontDefiniton et de chargement de police suivant pour différents cas.

Dans tous les cas, le résultat final du chargement de la police est mis dans la variable de type Aspose.Font.Font. Ce type est la classe de police de base de la bibliothèque Aspose.Font et les objets de ce type fournissent des fonctionnalités de base communes pour travailler avec les polices.

En chargeant la police dans cet objet, vous pourrez restituer le texte avec cette police, obtenir des informations de codage, des métriques de police, etc.

Exemples de chargement de polices

Prenons comme exemple le chargement de la police Montserrat à partir du fichier C:\Windows\Fonts\Montserrat.ttf

Ajoutez les espaces de noms suivants en tête du fichier :

1using Aspose::Font;
2using Aspose::Font::Sources;
3using System::IO;

Vous pouvez charger cette police à l’aide des objets FontDefiniton et FontFileDefinition de différentes manières :

Chargement à l’aide de l’objet System::IO::FileInfo

Pour effectuer le chargement, procédez comme suit :

Construisez le chemin d’accès au fichier.
Initiez l’objet FontDefiniton en passant TTF comme valeur FontType.
Obtenez la valeur calculée automatiquement fileExtension.
Chargez la police.

 1    // Construct path to the file
 2    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";
 3
 4    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
 5    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(System::MakeObject<System::IO::FileInfo>(fontPath));
 6
 7    // Based on FileInfo object, fileExtension value is calculated automatically from FileInfo fields.
 8    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, fileDef);
 9	
10    // Load font
11    System::SharedPtr<Font> font = Font::Open(fontDef);

Chargement à l’aide d’un objet de type FileSystemStreamSource

Suivez les étapes suivantes pour réaliser l’opération :

Construisez le chemin d’accès au fichier.
Initiez l’objet FontDefiniton.
Définissez fileExtension sur ttf.
Chargez la police.

 1    // Construct path to the file
 2    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";
 3
 4    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
 5    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(u"ttf", System::MakeObject<FileSystemStreamSource>(fontPath));
 6
 7    // Based on FileSystemStreamSource object, set fileExtension to "ttf"
 8    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, fileDef);
 9		
10    // Load font   
11    System::SharedPtr<Font> font = Font::Open(fontDef);

Chargement de polices sans objet FontFileDefinition, en passant FileSystemStreamSource directement à FontDefinition

Les actions suivantes doivent être entreprises pour charger la police de cette façon :

Construisez le chemin d’accès au fichier.
Initiez l’objet FontDefiniton en passant TTF comme valeur FontType, ttf comme valeur fileExtension et l’objet FileSystemStreamSource . Le paramètre fileExtension n’est pas ici une valeur en double pour le paramètre FontType.
Chargez la police.

 1    // Construct path to the file
 2    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";
 3
 4    // Initialize FontDefinition object passing TTF as FontType value, "ttf" as fileExtension value, 
 5    // and FileSystemStreamSource object. Parameter 'fileExtension' here is not duplicate value 
 6    // for parameter 'FontType' and it's needed for correct font format detection
 7    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, u"ttf", System::MakeObject<FileSystemStreamSource>(fontPath));
 8
 9    // Load font	
10    System::SharedPtr<Font> font = Font::Open(fontDef);

Chargement de police avec la variable de type byte[] et avec l’utilisation de l’objet de type ByteContentStreamSource

Pour charger une police à partir du tableau d’octets, vous devez :

Construisez le chemin d’accès au fichier.
Chargez les données binaires de la police dans le tableau d’octets
Initialisez l’objet FontDefiniton en passant TTF comme valeur FontType, ttf comme valeur fileExtension et ByteContentStreamSource objet basé sur le tableau fontBytes.
Chargez la police.

 1    // Construct path to the file
 2    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";
 3
 4    // Load font binary data into byte array
 5    System::ArrayPtr<uint8_t> fontBytes;
 6
 7    // Initialize FontDefinition object  passing TTF as FontType value, "ttf" as fileExtension value, 
 8    // and ByteContentStreamSource object based on fontBytes array
 9    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, u"ttf", System::MakeObject<ByteContentStreamSource>(fontBytes));
10	
11    // Load font	
12    System::SharedPtr<Font> font = Font::Open(fontDef);

Pour obtenir plus d’exemples d’utilisation d’Aspose.Font, accédez à la solution Aspose.Font.Examples.CPP.sln, dans les cpp-examples de la documentation Aspose.Font.

S’il vous reste des problèmes ou des questions, vous pouvez les publier dans la section Aspose.Font.Product Family du Free Support Forum et dans quelques heures, notre équipe d’assistance vous répondra. clarifie tout pour toi.

Guide du développeur Charger une police à partir d'un fichier TTF