Come caricare i font? | Aspose.Font per .NET

Panoramica

Per rispondere alla domanda su come caricare i font, dobbiamo innanzitutto comprendere che ogni font è fisicamente un array di byte in cui i dati sono rappresentati in un determinato formato. Pertanto, per un corretto caricamento del font è necessario conoscere due parametri chiave:

Formato del font: i font possono avere formati diversi come TrueType, Type1, ecc.
Archiviazione (Storage): dove vengono conservati i dati binari che rappresentano il font. Sebbene ogni font sia rappresentato come dati binari, il modo in cui questi dati sono archiviati può variare. Nella maggior parte dei casi, il font è archiviato come file su un disco rigido. Tuttavia, a volte i dati binari del font possono essere inseriti in un file differente, come i documenti creati da Microsoft Word (.docx) o Adobe Acrobat (.pdf), che possono includere diversi font al loro interno.

Oggetti e parametri richiesti per il caricamento del font

Aspose.Font per .NET fornisce l’oggetto FontDefinition per specificare i due parametri chiave richiesti per il caricamento del font. Dopo aver creato e inizializzato l’oggetto FontDefinition, è sufficiente chiamare il metodo statico Aspose.Font.Font.Open() passando l’oggetto appena configurato come parametro per caricare il font desiderato e ottenerne un riferimento.

Descriviamolo con dello pseudocodice:

1 
2using Aspose.Font;
3    ...
4
5    // Inizializza l'oggetto FontDefinition con le proprietà appropriate
6    FontDefinition fontDef = new FontDefinition(); 
7    Font desiredFont = Font.Open(fontDef);

Il risultato finale del caricamento del font è l’ottenimento di un oggetto di tipo Aspose.Font.Font. La classe Aspose.Font.Font è la classe base per i font nella libreria Aspose.Font per .NET e rappresenta la funzionalità principale per lavorare con essi.

Una volta caricato un font in un oggetto di tipo Aspose.Font.Font, sarai in grado di eseguire il rendering del testo con quel font, ottenere dati di codifica e metriche del font, oltre a poterlo modificare, salvare e molto altro.

Per inizializzare correttamente l’oggetto FontDefinition, come menzionato in precedenza, dobbiamo fornirgli 2 parametri: il tipo di formato e l’oggetto che descrive l’archiviazione per i dati binari del font. Il primo parametro viene specificato tramite l’enumerazione FontType.

Per semplificare il lavoro con il secondo parametro, Aspose.Font offre una serie di oggetti che forniscono un accesso universale ai dati binari del font, indipendentemente da dove esso sia posizionato.

Questo accesso universale è basato sul concetto di flusso di byte (byte stream). Quindi, sia che il font si trovi in un file su disco, all’interno di un altro file o in un array di byte in memoria, gli oggetti speciali di Aspose.Font forniranno l’accesso al flusso di byte relativo al font desiderato.

Descriviamo questi oggetti:

Classe StreamSource: Questa classe base astratta definisce le proprietà e i metodi che danno accesso al flusso di byte del font. Il metodo GetFontStream() di questa classe restituisce un flusso relativo ai dati binari del font. La proprietà Offset punta alla posizione nel flusso da cui iniziare la lettura dei dati.
Due delle classi più utilizzate ereditate da StreamSource:
- FileSystemStreamSource: progettata per fornire accesso al flusso basato sul file system. La proprietà FileName restituisce il nome del file del font. Il metodo GetFontStream() restituisce il flusso di byte relativo al file.
- ByteContentStreamSource: fornisce accesso al flusso basato su un array di byte.

Come inizializzare le classi?

Ecco alcuni esempi di inizializzazione di queste classi:

Supponiamo che il font si trovi nel file Lora.ttf. In questo caso, per accedere al flusso di byte di questo font, dobbiamo creare un oggetto di tipo FileSystemStreamSource utilizzando il suo costruttore:

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

Se i dati binari del font si trovano in un array definito dalla variabile byte[] fontArray, l’oggetto di tipo ByteContentStreamSource fornirà l’accesso al flusso di dati basato su tale variabile:

1 
2    ByteContentStreamSource fontSource = new ByteContentStreamSource(fontArray);

Pertanto, per fornire l’accesso ai dati binari del font, si utilizzano oggetti ereditati dalla classe base StreamSource, che chiameremo Font Stream Sources.

Oggetto FontFileDefinition

La maggior parte dei font si trova in file comuni, ma alcuni possono avere origini dati differenti. Per unire in un unico oggetto i concetti di file e flusso binario del font, la libreria Aspose.Font fornisce l’oggetto speciale FontFileDefinition.

Questo oggetto ha le seguenti proprietà:

FileName: nome del file del font.
FileExtension: estensione del file del font.
StreamSource: sorgente del flusso del font (Font Stream Source).
Offset: offset all’interno del flusso di byte del font.

Uno dei costruttori più utilizzati di questo oggetto ha la firma FontFileDefinition(FileInfo fontFile); usalo quando il font desiderato si trova in un file su disco.

Ecco un esempio di inizializzazione di tale oggetto per il font Montserrat situato in C:\Windows\Fonts\Montserrat.ttf:

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

Inoltre, FontFileDefinition può fare riferimento al font Montserrat utilizzando i seguenti costruttori:

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

Il parametro FileExtension deve corrispondere all’estensione standard del formato del font. Ad esempio, se il formato è TrueType, il valore può essere ttf o ttc (se il file è una raccolta di font TrueType). Se il formato è Embedded OpenType, il valore deve essere eot.

La tabella seguente mostra i formati di file font più utilizzati in Aspose.Font per .NET, con i relativi valori per il parametro FileExtension.

Formato file font	FileExtension
`TrueType`, font singolo	`ttf`
Raccolta di font `TrueType`	`ttc`
`Web Open Font Format`	`woff`
`Web Open Font Format versione 2.0`	`woff2`
`Embedded OpenType`	`eot`
Font Adobe `Type 1`	`pfa`, `pfb`, `afm`, `pfm`
`Compact Font Format`	`cff` (può essere nullo)

Se i dati del font non iniziano dalla posizione 0 del flusso di byte, utilizza il costruttore con il parametro Offset:

1 
2    FontFileDefinition(string fileExtension, StreamSource streamSource, long offset);

Come inizializzare l’oggetto FontDefinition?

Ora che conosci gli oggetti ereditati da StreamSource e l’oggetto FontFileDefinition, spiegheremo come inizializzare correttamente FontDefinition in diverse situazioni.

L’oggetto FontDefinition fornisce molti costruttori sovraccarichi. La caratteristica comune è il parametro FontType, che descrive il tipo di formato del font. Oltre a [FontType], [FontDefinition] deve essere inizializzato con un riferimento ai dati binari del font.

In questo caso possono essere utilizzati i seguenti parametri nei costruttori di [FontDefinition]:

Perché passare [fileExtension] se specifichiamo già [FontType]? Il motivo è che [FontType] definisce il formato comune, ma non quello specifico del file. Alcuni font di un unico formato possono avere estensioni diverse. Ad esempio, TrueType (FontType.TTF) include formati con estensioni ttf, eot, ttc, ecc. Se passiamo solo FontType.TTF per un font in formato EOT, l’oggetto non saprebbe come gestirlo correttamente. Lo stesso vale per Type 1 (FontType.Type1), che può avere estensioni .pfa, .pfb, .afm, .pfm. Pertanto, per una corretta rilevazione, è necessario specificare sia [FontType] che [fileExtension].

Di seguito sono riportati esempi di inizializzazione di [FontDefinition] e del caricamento dei font per vari casi.

In tutti gli esempi, il risultato finale viene inserito in una variabile di tipo Aspose.Font.Font. Questa è la classe base della libreria Aspose.Font e fornisce le funzionalità comuni. Una volta caricato, potrai eseguire il rendering del testo, ottenere metriche, informazioni di codifica, ecc.

Esempi di come caricare i font

Prendiamo come esempio il caricamento del font Montserrat dal file C:\Windows\Fonts\Montserrat.ttf.

Aggiungi i seguenti namespace all’inizio del file:

1    using System;
2    using Aspose.Font;
3    using Aspose.Font.Sources;
4    using System.IO;

Puoi caricare questo font utilizzando gli oggetti [FontDefinition] e [FontFileDefinition] in diversi modi:

Caricamento tramite l’oggetto System.IO.FileInfo

Per eseguire il caricamento, procedi come segue:

Costruisci il percorso del file.
Crea un oggetto [FontFileDefinition] basato su FileInfo.
Inizializza [FontDefinition] passando FontType.TTF. L’estensione verrà calcolata automaticamente.
Carica il font.

 1    // Costruisci il percorso del file
 2    string fontPath = @"C:\Windows\Fonts\Montserrat.ttf";
 3
 4    // Inizializza l'oggetto FontFileDefinition usando FileInfo
 5    FontFileDefinition fileDef = new FontFileDefinition(new FileInfo(fontPath));
 6
 7    // L'estensione viene calcolata automaticamente dai campi di FileInfo
 8    FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);
 9	
10    // Carica il font
11    Font font = Font.Open(fontDef);

Caricamento tramite l’oggetto FileSystemStreamSource

Segui questi passaggi:

Costruisci il percorso del file.
Inizializza [FontFileDefinition] specificando l’estensione “ttf” e la sorgente del flusso.
Inizializza [FontDefinition].
Carica il font.

 1    // Costruisci il percorso del file
 2    string fontPath = @"C:\Windows\Fonts\Montserrat.ttf";
 3
 4    // Inizializza FontFileDefinition specificando "ttf" e FileSystemStreamSource
 5    FontFileDefinition fileDef = new FontFileDefinition("ttf", new FileSystemStreamSource(fontPath));
 6
 7    // Crea la definizione del font basata sul fileDef
 8    FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);
 9		
10    // Carica il font   
11    Font font = Font.Open(fontDef);

Caricamento diretto tramite FileSystemStreamSource (senza FontFileDefinition)

Costruisci il percorso del file.
Inizializza [FontDefinition] passando direttamente la sorgente del flusso e l’estensione.
Carica il font.

1    // Costruisci il percorso del file
2    string fontPath = @"C:\Windows\Fonts\Montserrat.ttf";
3
4    // Inizializza FontDefinition passando FontType, estensione e sorgente del flusso
5    // Il parametro 'ttf' è necessario per la corretta rilevazione del formato
6    FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new FileSystemStreamSource(fontPath));
7
8    // Carica il font	
9    Font font = Font.Open(fontDef);

Caricamento tramite array di byte (ByteContentStreamSource)

Per caricare un font da un array di byte:

Carica i dati binari del font in un array byte[].
Inizializza [FontDefinition] usando [ByteContentStreamSource] basato sull’array.
Carica il font.

1    // Supponendo che fontBytes contenga i dati binari del font caricati in precedenza
2    byte[] fontBytes = File.ReadAllBytes(@"C:\Windows\Fonts\Montserrat.ttf");
3
4    // Inizializza FontDefinition passando FontType, estensione e ByteContentStreamSource
5    FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new ByteContentStreamSource(fontBytes));
6	
7    // Carica il font	
8    Font font = Font.Open(fontDef);

Per ulteriori esempi sull’utilizzo di Aspose.Font, consulta la soluzione Aspose.Font.Examples.sln nel repository della documentazione.

In caso di domande o problemi, puoi pubblicarli nella sezione Aspose.Font Product Family del nostro Forum di supporto gratuito: il nostro team ti risponderà in poche ore.

Guida per sviluppatori Carica un carattere dal file TTF