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

Ü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 C++ 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 Objekts FontDefiniton müssen Sie nur noch die statische Methode Aspose.Font.Font.Open() aufrufen und das gerade initialisierte Objekt FontDefiniton als übergeben ein Parameter, um die gewünschte Schriftart zu laden und eine Referenz darauf zu erhalten.

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

Das Endergebnis des Ladens der Schriftart ist das Erhalten eines Objekts vom Typ Aspose.Font.Font. Die Klasse Aspose.Font.Font ist eine Basisschriftklasse von Aspose.Font für die C++-Bibliothek. Es stellt die Hauptfunktionalität der Arbeit mit Schriftarten dar.

Wenn Sie eine Schriftart in das Typobjekt 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 FontDefinition() zwei Schriftartparameter übergeben: den Formattyp und das Objekt, das die Speicherung für Schriftart-Binärdaten beschreibt. Der erste Parameter wird mit der Aufzählung FontType benachrichtigt.

Um die Arbeit mit dem zweiten Parameter zu vereinfachen, bietet 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.h

Dieser universelle Zugriff ist mit so etwas wie einem Bytestream verknüpft. Unabhängig davon, wo die Schriftart platziert wird – in einer Datei auf einer Festplatte, in einer anderen Datei, einem Byte-Array im Speicher – bieten spezielle Aspose.Font-Objekte in jedem Fall Zugriff auf den Byte-Stream , bezogen auf 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, geerbt von der Basis StreamSource:
- 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    System::SharedPtr<FileSystemStreamSource> fontSource = System::MakeObject<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 basierend auf der Variable „fontArray“ Zugriff auf den Schriftart-Datenstrom bereit.

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, der sich auf das Font-Byte-Array bezieht, indem wir Code wie diesen verwenden:

1    System::SharedPtr<ByteContentStreamSource> fontSource = System::MakeObject<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 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 (System::SharedPtr System::IO::FileInfo FontFile), verwenden Sie diesen Konstruktor für Fälle wenn 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    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(System::MakeObject<System::IO::FileInfo>(u"C:\\Windows\\Fonts\\Montserrat.ttf"));

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

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

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 für C++ 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    FontFileDefinition(System::String fileExtension, System::SharedPtr<Aspose::Font::Sources::StreamSource> streamSource, int64_t 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 Objekt FontDefiniton 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 Wert FontType auch das Objekt FontDefiniton mit Bezug auf die Schriftart-Binärdaten initialisiert werden.

In diesem Fall können die nächsten Parameter der Konstruktoren FontDefiniton verwendet werden:

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

Das Problem besteht darin, dass FontType nicht immer mit dem Wert von fileExtension übereinstimmt. FontType definiert das allgemeine Schriftartformat, aber nicht das Schriftartformat 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 soll dieses Objekt dann verstehen, dass die Schriftart zum „EOT“-Format gehört und nicht zu „ TTF`?

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 Objektinitialisierung von FontDefiniton 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 Aspose.Font.Font eingefügt. Dieser Typ ist die grundlegende Schriftartenklasse der Bibliothek Aspose.Font und Objekte dieses Typs bieten gemeinsame Basisfunktionen für die Arbeit mit Schriftarten.

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 C:\Windows\Fonts\Montserrat.ttf

Fügen Sie am Kopf der Datei die nächsten Namespaces hinzu:

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

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

Laden mit Hilfe des System::IO::FileInfo-Objekts

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

Pfad zur Datei erstellen.
Initiieren Sie das Objekt FontDefiniton 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    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);

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 Objekt FontDefiniton.
Setzen Sie fileExtension auf „ttf“.
Laden Sie die Schriftart.

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

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

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 Objekt FontDefiniton, indem Sie „TTF“ als FontType-Wert, „ttf“ als fileExtension-Wert und ByteContentStreamSource übergeben. Objekt basierend auf dem FontBytes-Array.
Laden Sie die Schriftart.

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

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

Wenn Sie noch Probleme oder Fragen haben, können Sie diese im Abschnitt Aspose.Font.Product Family des Free Support Forum 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