Wie lade ich Schriftarten? | API-Lösung für Java

Überblick

Um die Frage zu beantworten, wie Schriftarten geladen werden, müssen wir zunächst lernen, dass jede Schriftart physisch ein Array von Bytes ist, in dem Daten in einem bestimmten Format dargestellt werden.

Daher müssen Sie für das korrekte Laden von Schriftarten zwei wichtige Parameter kennen:

Schriftartformat. Schriftarten können verschiedene Formate wie „TrueType“, „Type1“ usw. haben.
Speicher, in dem die Binärdaten gespeichert werden, die die Schriftart darstellen. Jede Schriftart wird als Binärdaten dargestellt, die Art und Weise, wie diese Daten gespeichert werden, kann jedoch unterschiedlich sein. In den meisten Fällen wird die Schriftart als Datei auf einer Festplatte gespeichert. Aber manchmal können Schriftart-Binärdaten in einer anderen Datei abgelegt werden, die selbst keine Schriftart ist. Zum Beispiel Dateien, die mit Microsoft Word oder Adobe Acrobat erstellt wurden. Dies sind Dateien mit den Erweiterungen „.docx“, „.pdf“. Sie können unterschiedliche Schriftarten enthalten.

Für das Laden von Schriftarten erforderliche Objekte und Parameter

Aspose.Font für Java stellt das Objekt FontDefiniton zur Benachrichtigung von zwei Schlüsselparametern bereit, die für das Laden von Schriftarten erforderlich sind.

Nach dem Erstellen und Initiieren des FontDefiniton-Objekts müssen Sie nur noch die statische Methode com.aspose.font.Font.open() aufrufen und das gerade initialisierte Objekt FontDefiniton als Parameter übergeben, um die gewünschte Schriftart zu laden Holen Sie sich eine Referenz dazu.

Beschreiben wir es mit dem 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);

Das Endergebnis des Ladens der Schriftart ist das Erhalten eines Objekts vom Typ com.aspose.font.Font. Die Klasse com.aspose.font.Font ist eine Basisschriftartklasse des com.aspose.font-Pakets für die Java-Bibliothek. Es stellt die Hauptfunktionalität der Arbeit mit Schriftarten dar.

Wenn Sie eine Schriftart in ein Objekt vom Typ com.aspose.font.Font laden, können Sie Text mit dieser Schriftart rendern, Codierungsdaten und Schriftartmetriken abrufen. Sie können diese und viele weitere Schriftarten auch ändern oder speichern.

Um das Objekt FontDefiniton zu initiieren, müssen wir ihm, wie bereits erwähnt, zwei Schriftartparameter geben: den Formattyp und das Objekt, das die Speicherung für Schriftartbinärdaten beschreibt.

Der erste Parameter wird mit der Aufzählung FontType benachrichtigt.

Um die Arbeit mit dem zweiten Parameter zu vereinfachen, bietet com.aspose.font eine Reihe von Objekten, die unabhängig davon, wo die Schriftart platziert ist, universellen Zugriff auf die Binärdaten der Schriftart ermöglichen.

Dieser universelle Zugriff ist mit so etwas wie einem Bytestream verknüpft. Unabhängig davon, wo die Schriftart platziert ist – in einer Datei auf einer Festplatte, in einer anderen Datei, einem Byte-Array im Speicher – bieten spezielle com.aspose.font-Objekte in jedem Fall Zugriff auf den zugehörigen Byte-Stream die gewünschte Schriftart.

Beschreiben wir diese Objekte:

StreamSource-Klasse. Diese abstrakte Basisklasse definiert die Eigenschaften und Methoden, die den Zugriff auf den Schriftart-Byte-Stream ermöglichen.

Die Methode getFontStream() dieser Klasse gibt einen Stream zurück, der sich auf binäre Schriftartdaten bezieht.

Die Eigenschaft Offset zeigt auf die Position an diesem Stream, von der aus wir mit dem Lesen der Daten beginnen müssen.

Zwei am häufigsten verwendete Klassen, die von der Basis StreamSource geerbt wurden:
- FileSystemStreamSource – Entwickelt, um Zugriff auf den Stream basierend auf dem Dateisystem bereitzustellen.
Die Eigenschaft FileName gibt den Namen der Schriftartdatei zurück. Die Methode getFontStream() gibt einen Byte-Stream zurück, der sich auf diese Datei bezieht.
- ByteContentStreamSource – bietet Zugriff auf den Stream, basierend auf dem Byte-Array.

Wie initiiere ich Kurse?

Hier finden Sie Beispiele für die Einführung dieser Kurse.1. Nehmen wir an, dass sich die Schriftart in der Datei Lora.ttf befindet. Um in diesem Fall Zugriff auf den Bytestream dieser Schriftart zu erhalten, müssen wir das Objekt vom Typ FileSystemStreamSource mit diesem einzelnen Konstruktor erstellen:

1 
2    FileSystemStreamSource fontSource = new FileSystemStreamSource("Lora.ttf");

Wenn sich die Schriftart-Binärdaten in einem binären Array befinden, das durch die Variable „byte [] FontArray“ definiert wird, dann stellt ein Objekt vom Typ ByteContentStreamSource einen Zugriff auf den Schriftart-Datenstrom bereit, basierend auf der Variable „fontArray“.

Um Zugriff auf den Font-Byte-Stream zu erhalten, müssen wir ein Objekt vom Typ ByteContentStreamSource erstellen, um Zugriff auf den Stream zu erhalten, das sich auf das Font-Byte-Array bezieht, indem wir Code wie diesen verwenden:

1 
2    ByteContentStreamSource fontSource = new ByteContentStreamSource(fontArray);

Um also Zugriff auf Schriftart-Binärdaten zu ermöglichen, verwenden Sie Objekte, die von der Basisklasse StreamSource geerbt wurden. Darüber hinaus nennen wir solche Objekte Font-Stream-Quellen.

FontFileDefinition-Objekt

Die meisten Schriftarten befinden sich in regulären Dateien, aber gleichzeitig können einige Schriftarten unterschiedliche Datenquellen haben. Um die Begriffe Datei und Binär-Schriftartstream zu einem Objekt zusammenzuführen, stellt die Bibliothek com.aspose.font das spezielle Objekt FontFileDefinition bereit.

Dieses Objekt hat folgende Eigenschaften:

FileName – Name der Schriftartdatei.
FileExtension – Erweiterung einer Schriftartdatei.
StreamSource – Font-Stream-Quelle.
Offset – Offset innerhalb des Font-Byte-Streams.

Der einfachste und einer der am häufigsten verwendeten Konstruktoren dieses Objekts ist der Konstruktor mit der folgenden Signatur: FontFileDefinition (Datei-Schriftartdatei). Verwenden Sie diesen Konstruktor für Fälle, in denen sich die gewünschte Schriftart in einer Datei auf der Festplatte befindet .

Hier ist ein Beispiel für die Initiierung eines solchen Objekts für die Schriftart „Montserrat“, die sich in der Datei C:\Windows\Fonts\Montserrat.ttf befindet:

1 
2    FontFileDefinition fileDef = new FontFileDefinition(new File("C:\\Windows\\Fonts\\Montserrat.ttf"));

Außerdem kann FontFileDefinition mithilfe der folgenden Konstruktoren auf die Schriftart „Montserrat“ verweisen:

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"));

Der Parameter fileExtension sollte dem Standard für das Schriftartformat und der Erweiterung entsprechen. Wenn das Schriftartformat beispielsweise „TrueType“ ist, kann der Wert des Parameters fileExtension „ttf“ oder „ttc“ sein (wenn die Schriftartdatei eine Sammlung von „TrueType“-Schriftarten ist). Wenn das Schriftartformat „Embedded Open Type“ ist, sollte der Wert des Parameters fileExtension „eot“ sein.

Die folgende Tabelle zeigt die am häufigsten in Aspose.Font verwendeten Schriftartdateiformate. Da sind sie mit den passenden Werten, die der Parameter fileExtension annehmen sollte.

Schriftdateiformat	Dateierweiterung
`TrueType`, einzelne Schriftart	`ttf`
`TrueType`-Schriftsammlung	`ttc`
`Web Open Font Format`	`woff`
`Web Open Font Format version 2.0`	`woff2`
`Embedded OpenType`	`eot`
Adobe `Type 1` font	`pfa`, `pfb`, `afm`, `pfm`
`Kompaktes Schriftformat`	`cff`, kann null sein

Wenn Schriftartdaten nicht an der Position 0 des Bytestreams beginnen, verwenden Sie den folgenden Konstruktor mit dem Parameter offset:

1 
2    FontFileDefinition(String fileExtension, StreamSource streamSource, long offset).

Wie initiiere ich ein FontDefinition-Objekt?

Wenn Sie nun eine Vorstellung von den Objekten haben, die von der Klasse StreamSource geerbt wurden und Zugriff auf den Font-Byte-Stream bieten, und vom Objekt FontFileDefinition, werden wir es erklären Sie erfahren, wie Sie das FontDefiniton-Objekt mit diesen Objekten für verschiedene Situationen richtig initiieren.

Das FontDefiniton-Objekt bietet Ihnen viele überladene Konstruktoren. Das gemeinsame Merkmal aller vorhandenen Konstruktoren ist der Parameter FontType. Es beschreibt die Art des Schriftformats. Wie bereits erwähnt, sollte neben dem FontType-Wert auch das Objekt FontDefiniton mit Bezug auf die Schriftart-Binärdaten initialisiert werden.

In diesem Fall können die folgenden Parameter der FontDefiniton-Konstruktoren verwendet werden:

fontName;
fileExtension;
Objekt vom Typ StreamSource;
Objekt vom Typ FontFileDefinition.

Möglicherweise haben Sie eine Frage. Warum sollten wir den Parameter fileExtension an das FontDefiniton- oder das FontFileDefinition-Objekt übergeben, wenn wir immer den Parameter FontType übergeben, der von seinem Wert her mit fileExtension übereinzustimmen scheint?

Das Problem besteht darin, dass FontType nicht immer mit dem Wert von fileExtension übereinstimmt. FontType definiert das allgemeine Schriftformat, aber nicht das Schriftformat einer bestimmten Datei. Einige Schriftarten eines Formats können unterschiedliche Dateiformate haben.

Der Wert FontType.TTF definiert beispielsweise das „TrueType“-Format. Aber gleichzeitig enthält „TrueType“ einige Schriftformate und es gibt Schriftdateien mit den Erweiterungen „ttf“, „eot“, „ttc“ usw. darin. Und wenn wir zum Beispiel für die Schriftart im „EOT“-Format an FontDefiniton nur den FontType.TTF-Wert übergeben, wie erkennt dieses Objekt dann, dass die Schriftart zum „EOT“-Format und nicht zu „TTF“ gehört?

Ebenso ist der Wert von FontType.Type1 die übliche Definition für Schriftarten dieses Formats. Gleichzeitig haben Schriftartdateien im „Type1“-Format die Erweiterungen „.pfa“, „.pfb“, „.afm“, „.pfm“. Daher können Sie das Schriftdateiformat nicht richtig definieren, indem Sie sich nur auf den Wert FonType.Type1 verlassen. Um das Schriftformat korrekt zu definieren, müssen wir daher den Parameter FontType mit dem Wert des Parameters fileExtension angeben.

Nachfolgend finden Sie Beispiele für die Initialisierung von FontDefiniton-Objekten und das anschließende Laden von Schriftarten für verschiedene Fälle.

In allen Fällen wird das endgültige Ergebnis beim Laden der Schriftart in die Variable vom Typ com.aspose.font.Font eingefügt. Dieser Typ ist die grundlegende Schriftartenklasse von com.aspose.font und Objekte dieses Typs stellen gemeinsame Basisfunktionen für die Arbeit mit Schriftarten bereit.

Wenn Sie die Schriftart in dieses Objekt laden, können Sie Text mit dieser Schriftart rendern, Codierungsinformationen, Schriftartmetriken usw. abrufen.

Beispiele zum Laden von Schriftarten

Nehmen wir als Beispiel das Laden der Schriftart „Montserrat“ aus der Datei Montserrat-Regular.ttf.

Verwenden Sie die nächsten Aussagen:

 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;

Sie können diese Schriftart mit den Objekten FontDefiniton und FontFileDefinition auf verschiedene Arten laden:

Laden mit Hilfe des java.io.File-Objekts

Um den Ladevorgang abzuschließen, gehen Sie wie folgt vor:

Pfad zur Datei erstellen.
Initiieren Sie das FontDefiniton-Objekt und übergeben Sie „TTF“ als FontType-Wert.
Rufen Sie den automatisch berechneten Wert fileExtension ab.
Laden Sie die Schriftart.

 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);

Laden mit Hilfe des Objekts vom Typ FileSystemStreamSource

Führen Sie die nächsten Schritte aus, um den Vorgang abzuschließen:

Pfad zur Datei erstellen.
Initiieren Sie das FontDefiniton-Objekt.
Setzen Sie fileExtension auf „ttf“.
Laden Sie die Schriftart.

 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);

Laden von Schriftarten ohne FontFileDefinition-Objekt, wobei FileSystemStreamSource direkt an FontDefinition übergeben wird

Um die Schriftart auf diese Weise zu laden, müssen die nächsten Schritte ausgeführt werden:

Pfad zur Datei erstellen.
Initiieren Sie das FontDefiniton-Objekt und übergeben Sie „TTF“ als FontType-Wert, „ttf“ als fileExtension-Wert und FileSystemStreamSource-Objekt. Der Parameter fileExtension ist hier kein doppelter Wert für den Parameter FontType.
Laden Sie die Schriftart.

 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);

Laden von Schriftarten mit der Variablen vom Typ byte[] und unter Verwendung des Objekts vom Typ ByteContentStreamSource

Um eine Schriftart aus dem Byte-Array zu laden, müssen Sie Folgendes tun:

Pfad zur Datei erstellen.
Laden Sie Schriftart-Binärdaten in das Byte-Array
Initialisieren Sie das FontDefiniton-Objekt und übergeben Sie „TTF“ als FontType-Wert, „ttf“ als fileExtension-Wert und ByteContentStreamSource-Objekt basierend auf dem FontBytes-Array.
Laden Sie die Schriftart.

 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);

Weitere Beispiele zur Verwendung von Aspose.Font finden Sie in der Aspose.Font.Examples.sln-Lösung in den Java-Examples der Aspose.Font-Dokumentation.

Wenn Sie noch Probleme oder Fragen haben, können Sie diese im Abschnitt Aspose.Font.Product Family des Kostenlosen Support-Forums posten und unser Support-Team wird sich innerhalb weniger Stunden darum kümmern klären Sie alles für Sie.

Entwicklerhandbuch Laden Sie eine Schriftart aus einer TTF-Datei