Come caricare i caratteri? | Soluzione API per C ++

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 C ++ fornisce oggetto FontDefiniton per avvisare due parametri chiave richiesti per il caricamento del carattere.

Dopo aver creato e avviato FontDefiniton Oggetto, devi solo chiamare il metodo statico Aspose.Font.Font.Open() e passare oggetto appena inizializzato FontDefiniton come parametro per caricare il carattere desiderato e ottenere un riferimento su di esso.

Descriviamolo con lo pseudocodice:

using Aspose::Font;
    ...

    // Initialize object FontDefinition with appropriate properties
    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>();
    System::SharedPtr<Font> desiredFont = Aspose::Font::Font::Open(fd);

Il risultato finale del caricamento del carattere sta ottenendo un tipo di tipo Aspose.Font.Font. Class Aspose.Font.Font è una classe di carattere di base di Aspose.Font per la libreria C ++. Rappresenta la principale funzionalità del lavoro con i caratteri.

Essere caricato un carattere in 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 dobbiamo fornire FontDefinition() 2 parametri di font, - il tipo di formato e l’oggetto che descrive l’archiviazione per i dati binari del carattere. Il primo parametro viene avvisato con enumerazione FontType.

Per semplificare il lavoro con il secondo parametro, 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 Aspose.Font forniranno un accesso al flusso di byte, relativi al carattere desiderato.

Descriviamo questi oggetti:

1. StreamSource classe. Questa classe di base astratta definisce le proprietà e i metodi che danno accesso al flusso di byte di carattere. GetFontstream() 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.

2. 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:

    System::SharedPtr<FileSystemStreamSource> fontSource = System::MakeObject<FileSystemStreamSource>("Lora.ttf");

2. 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 Fontarray. 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:

    System::SharedPtr<ByteContentStreamSource> fontSource = System::MakeObject<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, Aspose.Font Library fornisce oggetto speciale FontFileDefinition.

Questo oggetto ha tali proprietà:

• Nome file - Nome del file di carattere.
• FileExtension - Estensione di un file di carattere.
• StreamSource - Font Stream Fonte.
• 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 (System::SharedPtr System::IO::FileInfo fontFile), usa questo costruttore per i casi in cui il font desiderato è in un file sul rigido disco.

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

    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(System::MakeObject<System::IO::FileInfo>(u"C:\\Windows\\Fonts\\Montserrat.ttf"));

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

    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(System::MakeObject<FileSystemStreamSource>(u"C:\\Windows\\Fonts\\Montserrat.ttf"));

    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(u"ttf", System::MakeObject<FileSystemStreamSource>(u"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 deve essere eot.

La tabella seguente mostra la più spesso utilizzata in Aspose.Font per i formati di file di carattere C ++. Ci sono con i valori di corrispondenza che dovrebbe assumere il parametro fileextension.

Formato file font	Estensionefile
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 carattere non iniziano dalla posizione 0 del flusso di byte, utilizzare il seguente costruttore con il parametro offset:

    FontFileDefinition(System::String fileExtension, System::SharedPtr<Aspose::Font::Sources::StreamSource> streamSource, int64_t 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 avviare FontDefiniton oggetto con questi oggetti correttamente per le 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 FontType, oggetto FontDefiniton dovrebbe essere inizializzato con riferimento ai dati binari del carattere.

I parametri successivi 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 al FontDefiniton o l’oggetto fontfiledefinition, quando passiamo sempre il parametro FontType che sembra con coincidenza con il suo valore con fileetensions? Il problema è che FontType non coincide sempre con il valore di fileextension. Fontttype definisce il formato di carattere comune ma non il formato di carattere di un file specifico. Alcuni caratteri di un formato possono avere diversi formati di file.

Ad esempio, il valore FontType.TTF definisce il formato TrueType. Ma allo stesso tempo TrueType include alcuni formati di font e contiene file di 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 del fontttype.Type1 è la definizione comune per i caratteri di questo formato. Allo stesso tempo, i file di caratteri in formato type1 hanno estensioni .pfa, .pfb, .afm, .pfm. Quindi non è possibile definire il formato del file di carattere correttamente basandosi solo sul valore fonte.type1. Quindi, per definire correttamente il formato del carattere dobbiamo specificare il parametro FontType con il valore del parametro fileextension.

Di seguito puoi imparare esempi di FontDefiniton Inizializzazione dell’oggetto e seguendo il caricamento del carattere per diversi casi.

In tutti i casi il risultato del caricamento del carattere finale viene inserito nella variabile di tipo Aspose.Font.Font. Questo tipo è la classe di caratteri di base di Aspose.Font Documentation e oggetti di questo tipo forniscono funzionalità di base comuni per funzionare con i caratteri.

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

Aggiungi gli spazi dei nomi successivi alla testa del file:

using Aspose::Font;
using Aspose::Font::Sources;
using System::IO;

È possibile caricare questo carattere usando FontDefiniton e fontFileDefinition oggetti in diversi modi:

Caricamento con l’aiuto di System::IO::FileInfo Oggetto

Per soddisfare il caricamento fai il prossimo:

1. Costruisci percorso al file.
2. Inizia FontDefiniton Passando ttf as FontType valore.
3. Ottenere valore calcolato automaticamente fileextension.
4. Carica il carattere.

    // Construct path to the file
    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";

    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(System::MakeObject<System::IO::FileInfo>(fontPath));

    // Based on FileInfo object, fileExtension value is calculated automatically from FileInfo fields.
    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, fileDef);
	
    // Load font
    System::SharedPtr<Font> font = Font::Open(fontDef);

Caricamento con l’aiuto di FilesystemStreamSource Type Object

Prendi i passaggi successivi per eseguire l’operazione:

1. Costruisci percorso al file.
2. Inizia FontDefiniton.
3. Imposta fileextension su ttf.
4. Carica il carattere.

    // Construct path to the file
    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";

    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
    System::SharedPtr<FontFileDefinition> fileDef = System::MakeObject<FontFileDefinition>(u"ttf", System::MakeObject<FileSystemStreamSource>(fontPath));

    // Based on FileSystemStreamSource object, set fileExtension to "ttf"
    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, fileDef);
		
    // Load font   
    System::SharedPtr<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:

1. Costruisci percorso al file.
2. 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 per il parametro FontType.
3. Carica il carattere.

    // Construct path to the file
    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";

    // Initialize FontDefinition object passing TTF as FontType value, "ttf" as fileExtension value, 
    // and FileSystemStreamSource object. Parameter 'fileExtension' here is not duplicate value 
    // for parameter 'FontType' and it's needed for correct font format detection
    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, u"ttf", System::MakeObject<FileSystemStreamSource>(fontPath));

    // Load font	
    System::SharedPtr<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:

1. Costruisci percorso al file.
2. Carica i dati binari del carattere nell’array di byte
3. Inizializza FontDefiniton Passando ``
4. Carica il carattere.

    // Construct path to the file
    System::String fontPath = u"C:\\Windows\\Fonts\\Montserrat.ttf";

    // Load font binary data into byte array
    System::ArrayPtr<uint8_t> fontBytes;

    // Initialize FontDefinition object  passing TTF as FontType value, "ttf" as fileExtension value, 
    // and ByteContentStreamSource object based on fontBytes array
    System::SharedPtr<FontDefinition> fontDef = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, u"ttf", System::MakeObject<ByteContentStreamSource>(fontBytes));
	
    // Load font	
    System::SharedPtr<Font> font = Font::Open(fontDef);

Per ottenere ulteriori esempi di utilizzo di Aspose.Font, vai su aspose.font.examples.cpp.sln Solution, nell’example CPP-Examples della asposa.font documentazione.

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