Come caricare i caratteri? | Soluzione API per Java

Panoramica

Per rispondere alla domanda, come caricare i caratteri, prima dobbiamo apprendere che qualsiasi carattere è fisicamente una serie di byte in cui i dati sono rappresentati in un formato. Pertanto, per il caricamento del carattere corretto è necessario conoscere due parametri chiave:

Formato di carattere. I caratteri possono avere formati diversi come truetype, type1, ecc.
Archiviazione, in cui vengono tenuti i dati binari che rappresentano il carattere. Ogni carattere è rappresentato come dati binari ma il modo in cui questi dati sono archiviati può differire. Nella maggior parte dei casi, il carattere viene archiviato come file su un disco rigido. Ma a volte i dati binari di carattere possono essere inseriti in un file diverso che non è un carattere stesso. Ad esempio, i file creati da Microsoft Word o Adobe Acrobat. Questi sono file con estensioni .docx, .pdf. Possono includere caratteri diversi.

Oggetti e parametri richiesti per il caricamento del carattere

Aspose.Font per java dà oggetto FontDefiniton per la notifica di due parametri chiave richiesti per il caricamento del carattere.

Dopo aver creato e avviatoFontDefinitonoggetto, devi solo chiamare il metodo statico com.aspose.font.Font.open() e passare oggetto appena inizializzatoFontDefinitoncome parametro per caricare il carattere desiderato e ottenere un riferimento su di esso.

Descriviamolo con lo pseudocodice:

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

Il risultato finale del caricamento del carattere sta ottenendo un oggetto di tipo com.aspose.font.font. Classe com.aspose.font.font è una classe di carattere base del pacchetto com.aspose.font per la libreria Java. Rappresenta la principale funzionalità del lavoro con i caratteri.

Essere caricato un carattere in com.aspose.font.font Digitare oggetto che sarai in grado di rendere il testo con questo carattere, ottenere dati di codifica e metriche di carattere. Sarai anche in grado di modificare o salvare questo carattere e molti altri.

Per avviare l’oggetto FontDefiniton di cui abbiamo bisogno, come menzionato in precedenza, per dargli 2 parametri di carattere, - il tipo di formato e l’oggetto che descrive l’archiviazione per i dati binari del carattere. Il primo parametro viene avvisato con enumerazione fontttype.

Per semplificare il lavoro con il secondo parametro, com.aspose.font offre una serie di oggetti che danno accesso universale ai dati binari del carattere indipendentemente da dove viene posizionato il carattere.

Questo accesso universale è collegato a una cosa come un flusso di byte. Quindi, indipendentemente da dove viene inserito il carattere - in un file su un disco, all’interno di un altro file, array di byte in memoria - in ogni caso, gli oggetti speciali com.aspose.font forniranno un accesso al flusso di byte, relativo al carattere desiderato.

Descriviamo questi oggetti:

StreamSource classe. Questa classe di base astratta definisce le proprietà e i metodi che danno accesso al flusso di byte di carattere. getFontstream() Il metodo di questa classe restituisce un flusso, relativo ai dati del carattere binario. Proprietà offset punti sulla posizione in questo flusso, da dove dobbiamo iniziare a leggere i dati.
Due classi più usate ereditate dalla base *StreamSource *:
- FilesystemStreamSource - Progettato per fornire l’accesso al flusso, in base al file system. Proprietà nome file Restituisce il nome del file font. getfontstream() il metodo restituisce un flusso di byte, relativo a questo file.
- ByteContentstreamSource - fornisce accesso al flusso, in base all’array di byte.

Come iniziare le lezioni?

Ecco esempi dell’iniziazione di queste classi. 1.Supponiamo che il carattere sia nel file chiamato lora.ttf. In questo caso, per ottenere l’accesso al flusso di byte di questo carattere dobbiamo creare l’oggetto di tipo FilesystemStreamSource usando questo singolo costruttore:

1 
2    FilesystemStreamSource fonsource = new FilesystemStreamSource ("LORA.TTF");

Se i dati binari del carattere si trovano in un array binario definito dalla variabile Fontarray byte [], allora un oggetto di tipo ByteContentStreamSource fornirà un accesso al flusso di dati del carattere, in base alla variabile Fontaray.

Per ottenere l’accesso al flusso di byte di carattere, dobbiamo creare un oggetto di tipo ByteContentStreamSource per ottenere l’accesso al flusso, relativo all’array di byte di carattere usando codice come questo:

1 
2    ByteContentstreamSource fonsource = new ByteContentstreamSource (Fontarray);

Pertanto, per fornire l’accesso ai dati binari del carattere, utilizzare gli oggetti ereditati dalla classe Base StreamSource. Inoltre, chiameremo tali oggetti Font Stream Sources.

Oggetto FontFileDefinition

La maggior parte dei fronti si trova in file normali ma allo stesso tempo, parte dei caratteri può avere origini di dati diverse. Per unirsi a un oggetto Termini File e Font Binary Stream, com.aspose.font La libreria fornisce un oggetto speciale fontfiledefinition.

Questo oggetto ha tali proprietà:

Nome file - Nome del file di carattere.
FileExtension - Estensione di un file di carattere.
StreamSource - Fonte Font Stream.
Offset - Offset all’interno del flusso di byte di carattere.

Il più semplice e uno dei costruttori più utilizzati di questo oggetto è il costruttore con la seguente firma: FontFileDefinition (FONTFILE FILE), utilizzare questo costruttore per i casi in cui il carattere desiderato è in un file sul disco rigido.

Ecco un esempio di avvio di tale oggetto per il carattere Montserrat che si trova nel file C:\Windows\Fonts\Montserrat.ttf:

1 
2    FontFileDefinition filedef = new fontFileDefinition (nuovo file ("C:\\Windows\\Fonts\\Montserrat.ttf"));

Inoltre, FontFileDefinition può fare riferimento al carattere Montserrat usando i seguenti costruttori:

1 
2    FontFileDefinition FileDedef = 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 per il formato del font. Ad esempio, se il formato del font è TrueType, il valore del parametro fileExtension può essere ttf o ttc (se il file del font è una raccolta di font TrueType). Se il formato del font è Embedded Open Type, il valore del parametro fileExtension dovrebbe essere eot.

La tabella seguente mostra i più spesso utilizzati nei formati di file di font Aspy.Font. Eccoli con i valori di corrispondenza che dovrebbe prendere il parametro * fileextension *.

Formato file font	Estensionefile
`TrueType`, single font	`ttf`
`TrueType` font collection	`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`
`Compact Font Format`	`cff`, can be null

Se i dati del carattere non iniziano dalla posizione 0 del flusso di byte, utilizzare il seguente costruttore con il parametro offset:

1 
2    FontFileDefinition (String FileExtension, StreamSource StreamSource, Long Offset).

Come avviare l’oggetto FontDefinition?

Ora, quando hai un’idea degli oggetti ereditati dalla classe StreamSource e fornendo accesso al flusso di byte di carattere e dell’oggetto fontfiledefinition, ti spiegheremo come avviareFontDefinitonoggetto*con questi oggetti corretti per diverse situazioni.

FontDefiniton L’oggetto fornisce molti costruttori sovraccarichi. La caratteristica comune di tutti i costruttori esistenti è il parametro FontType. Descrive il tipo di formato carattere. Come accennato in precedenza, a parte il valore * fontttype *, oggetto * fontdefiniton * dovrebbe essere inizializzato con riferimento ai dati binari del carattere.

I prossimi parametri dei costruttori * fontdefiniton * possono essere utilizzati in questo caso:

FontName;
fileextension;- Oggetto del tipo StreamSource;
Oggetto del tipo FontFileDefinition.

Potresti avere una domanda. Perché dovremmo passare il parametro fileExtension all’oggetto FontDefiniton o FontFileDefinition, quando passiamo sempre il parametro FontType, il cui valore sembra coincidere con fileExtension? Il problema è che FontType non sempre coincide con il valore di fileExtension. FontType definisce il formato font comune, ma non il formato font di un file specifico. Alcuni font di un formato possono avere formati di file diversi. Ad esempio, il valore FontType.TTF definisce il formato TrueType. Ma allo stesso tempo TrueType include alcuni formati font e ci sono file font con estensioni ttf, eot, ttc, ecc. E se, ad esempio, per il font in formato EOT passiamo a FontDefiniton solo il valore FontType.TTF, come farà questo oggetto a capire che il font appartiene al formato EOT e non a TTF?

Allo stesso modo, il valore di FontType.Type1 è la definizione comune per i font di questo formato. Allo stesso tempo, i file di font in formato Type1 hanno estensioni .pfa, .pfb, .afm, .pfm. Pertanto, non è possibile definire correttamente il formato del file di font basandosi solo sul valore di FonType.Type1. Pertanto, per definire correttamente il formato del font, è necessario specificare il parametro FontType con il valore del parametro fileExtension.

Di seguito sono riportati esempi di inizializzazione dell’oggetto FontDefiniton e del successivo caricamento dei font in diversi casi.

In tutti i casi, il risultato finale del caricamento del font viene inserito nella variabile di tipo com.aspose.font.Font. Questo tipo è la classe di font base di com.aspose.font e gli oggetti di questo tipo forniscono funzionalità di base comuni per lavorare con i font.

Caricamento del carattere in questo oggetto sarai in grado di rendere il testo con questo carattere, ottenere informazioni di codifica, metriche di carattere, ecc.

Esempi di come caricare i caratteri

Facciamo come esempio, caricando il carattere Montserrat dal file Montserrat-Regular.ttf.

Usa le affermazioni successive:

 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;

Puoi caricare questo carattere usando FontDefiniton e FontFileDefinition Objects in diversi modi:

Caricamento con l’aiuto dell’oggetto java.io.file

Per soddisfare il caricamento fai il prossimo:

Costruisci il percorso del file.
Inizializza l’oggetto FontDefiniton passando a TTF un valore FontType.
Ottiene il valore fileExtension calcolato automaticamente.
Carica il font.

 1    // Costruisci percorso al 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);

Caricamento con l’aiuto di FilesystemStreamSource Type Object

Prendi i passaggi successivi per eseguire l’operazione:

Costruisci il percorso per il file.
Avvia l’oggetto FontDefiniton.
Imposta fileExtension a ttf.
Carica il font.

 1    // Costruisci percorso al 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);

Caricamento del carattere senza obiettivo FontFileDefinition, con il passaggio di FileSystemStreamSource direttamente a FontDefinition

Le prossime azioni devono essere intraprese per caricare il carattere in questo modo:

Costruisci il percorso del file.
Avvia l’oggetto FontDefiniton passando TTF come valore FontType, ttf come valore fileExtension e l’oggetto FileSystemStreamSource. Il parametro fileExtension qui non è un valore duplicato del parametro FontType.
Carica il font.

 1    // Costruisci percorso al 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);

Caricamento del carattere con la variabile Byte [] Digita e con l’utilizzo di ByTeContentstreamSource

Per caricare un carattere dall’array di byte è necessario:

Costruisci il percorso per il file.
Carica i dati binari del font nell’array di byte.
Inizializza l’oggetto FontDefiniton passando TTF come valore FontType, ttf come valore fileExtension e l’oggetto ByteContentStreamSource in base all’array fontBytes.
Carica il font.

 1    // Costruisci percorso al 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);

Per ottenere altri esempi di utilizzo di Aspose.Font, vai su aspose.font.examples.sln Solution, in java-examples della documentazione Aspose.Font

In caso di problemi o domande, puoi pubblicarli nella sezione Aspose.Font.Product del Forum di supporto libero e entro poche ore il nostro team di supporto chiarirà tutto per te.

Guida per sviluppatori Carica un carattere dal file TTF