Comment charger les polices ? | Solution API pour Java

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 Java 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 com.aspose.font.Font.open() et de transmettre l’objet FontDefiniton juste initialisé en tant que paramètre pour charger la police souhaitée et obtenez une référence là-dessus.

Décrivons-le avec le pseudocode :

1 
2    package com.aspose.font;
3
4    import com.aspose.font.FontDefinition;
5    ...
6
7    // Initialize object FontDefinition with appropriate properties
8    FontDefinition fontDef = new FontDefinition(); 
9    Font desiredFont = Font.open(fontDef);

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

En chargeant une police dans un objet de type com.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, comme mentionné précédemment, lui donner 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, com.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.

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 com.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 
2    FileSystemStreamSource fontSource = new FileSystemStreamSource("Lora.ttf");

Si les données binaires de la police se trouvent 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 
2    ByteContentStreamSource fontSource = new 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 com.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 (File fontFile), utilisez ce constructeur dans les cas où la police souhaitée est 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 
2    FontFileDefinition fileDef = new FontFileDefinition(new File("C:\\Windows\\Fonts\\Montserrat.ttf"));

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

1 
2    FontFileDefinition fileDef = new FontFileDefinition(new FileSystemStreamSource("C:\\Windows\\Fonts\\Montserrat.ttf"));
3
4    FontFileDefinition fileDef = new FontFileDefinition("ttf", new FileSystemStreamSource("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 police Aspose.Font les plus souvent utilisés. 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 
2    FontFileDefinition(String fileExtension, StreamSource streamSource, long 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 :

Nom de police;
fileExtension;
objet de type StreamSource ;
objet de type FontFileDefinition.

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 au 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 com.aspose.font.Font. Ce type est la classe de police de base de com.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 Montserrat-Regular.ttf.

Utilisez les instructions suivantes :

 1    package com.aspose.font;
 2
 3    import java.io.File;
 4    import java.io.IOException;
 5    import java.nio.file.Files;
 6    import java.nio.file.Paths;
 7
 8    import com.aspose.font.ByteContentStreamSource;
 9    import com.aspose.font.FileSystemStreamSource;
10    import com.aspose.font.Font;
11    import com.aspose.font.FontDefinition;
12    import com.aspose.font.FontFileDefinition;
13    import com.aspose.font.FontType;

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

Chargement à l’aide de l’objet java.io.File

Pour effectuer le chargement, procédez comme suit :

Construisez le chemin d’accès au fichier.
Lancez 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    String fontPath = Paths.get(getDataDir(), "Montserrat-Regular.ttf").toString();
 3
 4    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
 5    FontFileDefinition fileDef = new FontFileDefinition(new File(fontPath));
 6
 7    // Based on FileInfo object, fileExtension value is calculated automatically from FileInfo fields.
 8    FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);
 9
10    // Load the font 
11    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.
Lancez l’objet FontDefiniton.
Définissez fileExtension sur ttf.
Chargez la police.

 1    // Construct path to the file
 2    String fontPath = Paths.get(getDataDir(), "Montserrat-Regular.ttf").toString();
 3
 4    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
 5    FontFileDefinition fileDef = new FontFileDefinition("ttf", new FileSystemStreamSource(fontPath));
 6
 7    // Based on FileSystemStreamSource object, set fileExtension to "ttf"
 8    FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);
 9
10    // Load the font
11    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    String fontPath = Paths.get(getDataDir(), "Montserrat-Regular.ttf").toString();
 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    FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new FileSystemStreamSource(fontPath));
 8
 9    // Load the font
10    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 l’objet ByteContentStreamSource basé sur le tableau fontBytes.
Chargez la police.

 1    // Construct path to the file
 2    String fontPath = Paths.get(getDataDir(), "Montserrat-Regular.ttf").toString();
 3
 4    // Load font binary data into byte array
 5    byte[] fontBytes = Files.readAllBytes(Paths.get(fontPath));
 6
 7    // Initialize FontDefinition object  passing TTF as FontType value, "ttf" as fileExtension value, 
 8    // and ByteContentStreamSource object based on fontBytes array
 9    FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new ByteContentStreamSource(fontBytes));
10
11    // Load the font
12    Font font = Font.open(fontDef);

For getting more examples of using the Aspose.Font go to Aspose.Font.Examples.sln solution, in the java-examples of the Aspose.Font Documentation

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