Trabalhando com 'Nome' Tabela | C ++
TrueType Font Table ‘Name’ é armazenamento para seqüências de texto relacionadas a essa fonte. Essas cordas podem ser escritas em diferentes idiomas e podem representar várias entidades, como nomes de fontes, nomes de família, nomes de designers, informações de licença, avisos de direitos autorais e assim por diante. Em suma, as linhas que são mantidas na tabela ’nome’ descrevem os metadados da fonte.
Esquema da tabela ‘Nome’.
Existem 2 formatos para uma tabela de ’nome’ com números 0 e 1 correspondentemente. Em termos da tabela ‘Nome’, esses números de formato são nomeados como versão, portanto o formato 0 é designado como *versão 0 *e formato 1 - como *versão 1 *.
O formato 1 difere do formato 0 na identificação da linguagem. Qualquer entrada na tabela ‘Name’ possui um identificador de idioma, usado para detectar o idioma dessa string. E a diferença entre o formato 0 e o formato 1 está na forma como esses identificadores de idioma são interpretados.
Os identificadores de idiomas para o formato 0 têm interpretação específica da plataforma, mas os identificadores de idiomas para o formato 1 estão associados a seqüências de caracteres de margem de idiomas, que identificam idiomas, independentemente da plataforma.
Para obter mais precisão, o formato 1 permite manter os identificadores de linguagem de ambos os tipos-identificadores com interpretação específica da plataforma e identificadores associados a seqüências de caracteres (ou seja, independentes de uma plataforma).
A biblioteca Aspose.Font suporta o formato 0 da tabela ’nome’. O suporte ao formato 1 está planejado para futuras lançamentos.
Independentemente do formato que a tabela ’nome’ possui, qualquer entrada nesta tabela é baseada em um componente específico - a estrutura namerecord.
Os quatro parâmetros principais dessa estrutura são:
- Identificador de plataforma (PlatformId),
- Identificador específico da plataforma (PlatformSpecificid),
- identificador de nome (nameId),
- e identificador de idiomas (idioma).
Parâmetros plataformid, plataformspecificid e idiomaID são usados para definir o idioma da string de maneira específica da plataforma. Os valores dos parâmetros plataformspecificid e `idioma ‘são importantes apenas no contexto do parâmetro PlatformID.
Por exemplo, PlatformSpecificid igual 0 define o script romano para a plataforma Mac e, ao mesmo tempo ‘, plataformspecificid define o script romano para a plataforma Windows.
De uma maneira semelhante, o valor do idioma é importante apenas no contexto do parâmetro PlatformID usado.
Por exemplo, idioma definindo os EUA em inglês é igual a 0 para plataformID = 1 (MAC) e 0x0409 para plataformid = 3 (Windows).
As exclusões são apenas “idiomas” para o formato de tabela de nomes 1, associado a uma sequência de idiomas, que identifica idiomas, independentemente da plataforma.
O parâmetro nameid é um número, que identifica uma categoria de string lógica, como nome da fonte, nome da família e outros. Existe um
conjunto predefinido dos identificadores de nome, que é o mesmo para todas as plataformas e idiomas.
Portanto, cada entrada da tabela ’nome’ condicionalmente pode ser dividida em 3 partes:
- categoria de sequência lógica,
- linguagem de string,
- a própria corda.
O parâmetro nameId está relacionado à primeira parte, os parâmetros plataformid, plataformSpecificid eidiomaID estão relacionados à segunda parte.
Como trabalhar com os registros da tabela ‘Name’ usando aspose.font?
O suporte para a tabela ‘Nome’ é fornecido pela classe ttfninetable. Além disso, consideramos a funcionalidade desse objeto. Primeiro, vamos descrever as enumerações necessárias para trabalhar com a funcionalidade da classe * ttfnametable *.
- As enumerações nameId e plataformid estão relacionadas a esses parâmetros descritos acima como nameId e plataformID.
- As enumerações unicodePlatformSpecificid, MacplatformSpecificid estão relacionadas ao parâmetro plataformpecificid.
Como foi mencionado acima, “os valores dos parâmetros específicos da plataforma e do idioma são importantes apenas no contexto do parâmetro PlatformID”. Portanto, quando o PlatformID é 0, e isso define a plataforma Unicode, use UnicodePlatformSpecificid Enumeração, quando o PlatformId é 1 (plataforma Macintosh), use MacplatformSpecificid Enumeração e quando o PlatformID é 3 (plataforma Windows), use msplatformpecificid Enumeration.
As enumerações msLanguageId e macLanguageId estão relacionadas ao parâmetro do idioma. Use MsLanguageId Enumeração, quando o PlatformID é 3 (plataforma Windows) e use MacLanguageId Enumeração quando o PlatformID é 1 (plataforma Macintosh).
Agora vamos prosseguir com a questão de obter e atualizações de entradas da tabela de nomes.
Como obter registros da tabela ‘Nome’?
Vamos começar a partir do método getAllnameRecords (). Este método, como segue de seu nome, retorna todas as entradas sem exclusões da tabela ’nome’. Na prática, o método não é chamado com frequência, pois na maioria dos casos não precisa de todas as entradas; portanto, para obter a entrada necessária, a lista de entradas deve ser completamente filtrada.
O assunto é que, mesmo em uma categoria lógica, Fontfamily, por exemplo, os dados da string dessa categoria podem estar em diferentes idiomas. Portanto, cada idioma precisa de uma entrada separada na tabela ’nome’ para esta categoria lógica. Como se os dados da categoria Fontfamily existam em inglês, francês e alemão, a categoria Fontfamily incluiria 3 entradas.
Além disso, a entrada do idioma pode ser dividida em algumas entradas que coincidem com os valores dos dados da string e o valor idiomaID, mas diferem por valores dos parâmetros plataformid e plataformspecificid.
Para simplificar a amostragem de dados da tabela ‘Nome’ Aspose.Font Library oferece os próximos métodos:
- GetNeReRecordsByNameId ()- Retorna a lista de entradas para o conjunto pela categoria lógica do usuário, definida pelo parâmetro
nameid. - GetMultilanguagenameById () - Retorna todas as entradas, relevantes para a categoria lógica aprovada NameId como um objeto de MultilanguageSring Tipo. Por meio do objeto do tipo - MultilanguageString, podemos descobrir todos os idiomas dessa categoria e obter os dados da string para o idioma definido. Você pode obter a lista de todos os idiomas chamando o método getAllLanguageIds () do tipomultilanguagestring. Depois de receber a lista dos idiomas, podemos chamar o método getStringForLanguageId () para cada idioma. Este método retorna a sequência de dados escrita neste idioma.
Classe multilanguagestring também oferece os próximos métodos:
- Contémstring (string str)- verifica se uma string passada está presente dentro de todas as seqüências de idiomas do objeto.
- GetenglishString () - Retorna uma sequência escrita em inglês, se encontrada. Ele retorna a primeira string, idioma que é msLanguageid.english_united_states, mslanguageid.english_australia, mslanguageid.english_united_kingdom, msLanguageid.english_canada, ou msLanguageid.english_new_zealand. Se não houver strings com o identificador de idioma relevante, o método retornará a primeira string da lista.
- GetAllStrings () - Retorna todas as cordas de todos os idiomas que o objeto inclui.
- O método mais simples de usar de classe ttfninetable é getNameById (), que foi projetado para casos em que você precisa apenas obter o valor da categoria definida em inglês. Este método procura um registro, que corresponde a 2 critérios:
- Este registro foi escrito em inglês, por isso possui o valor msLanguageId.english_united_states ou msLanguageId.english_united_kingdom para o parâmetro LanguageId.
- Este registro possui plataformid com o valor igual a fontenvironment.current.currentplatformid (3 na implementação atual, que declara a plataforma Microsoft).
Como adicionar/atualizar registros na tabela ’nome’?
Classe ttfninetable fornece um método
addName para adicionar ou atualizar registros na tabela ’nome’.
Este método cria a estrutura do tipo
namerecord e a insere na tabela ’nome’. Se o registro coincidir com o adicionado por parâmetros platafortId, plataformspecificid, idioma e nameid já existe, o método não adiciona um novo registro, mas atualiza os dados da string no registro existente usando o valor, definido pelo parâmetro name.
Parâmetro nameId define a categoria de sequência lógica para um registro. Parâmetros plataformid, plataformspecificid e idiomaID são usados para definir o idioma da string. E o último parâmetro name é usado para definir dados de string para um registro.
Exemplos de uso de funções do objeto * ttfninetable *.
Adicionar inclui e usando namespaces:
1#include <system/text/string_builder.h>
2#include <system/enum.h>
3#include <System/Console.h>
4#include <system/coletções/list.h>
5#include <aspose.font.cpp/src/ttftables/ttfninetable.h>
6#include <aspose.font.cpp/src/ttftables/ttftableRepository.h>
7#include <aspose.font.cpp/src/ttf/ttffont.h>
8#include <aspose.font.cpp/src/multilanguagestring.h>
9#include <aspose.font.cpp/src/fonttype.h>
10#include <aspose.font.cpp/src/font.h>
11
12using namespace System;
13using namespace Aspose::Font::Ttf;
14using namespace Aspose::Font::TtfTables;Declarando e inicializando uma variável de fonte.
1 System::SharedPtr<Aspose::Font::Ttf::TtfFont> _font;Próximos 2 trechos de impressão Valor para categoria * Nome completo da fonte * e produza o mesmo resultado para a font lora-regulate
1 //1
2 String fullFontName = _font->get_TtfTables()->get_NameTable()->GetNameById(TtfNameTable::NameId::FullName);
3 Console::WriteLine(String::Format(u"Full font name: {0}", fullFontName));
4 //2
5 String fullFontName = _font->get_TtfTables()->get_NameTable()->GetMultiLanguageNameById(TtfNameTable::NameId::FullName)->GetEnglishString();
6 Console::WriteLine(String::Format(u"Full font name: {0}", fullFontName));Imprimindo todo o conteúdo da tabela ’nome’.
O trecho abaixo mostra como cumprir esta operação.
1System::ArrayPtr<TtfNameTable::NameId> ids = System::Enum<TtfNameTable::NameId>::GetValues();
2
3 for (TtfNameTable::NameId nameId : ids)
4 {
5 System::SharedPtr<MultiLanguageString> mlString = _font->get_TtfTables()->get_NameTable()->GetMultiLanguageNameById(nameId);
6 if (mlString == nullptr)
7 {
8 continue;
9 }
10 System::Console::WriteLine(System::String::Format(u"{0}: {1}", nameId, GetMultiLanguageStringValue(mlString)));
11 }
12
13 //Using of this method has no sense when strings from 'name' table have only single language, but it can be useful when font
14 //'name' table include multilingual strings
15 System::String MetadataExamples::GetMultiLanguageStringValue(System::SharedPtr<MultiLanguageString> mlString)
16 {
17 System::ArrayPtr<int32_t> languages = mlString->GetAllLanguageIds();
18 if (languages->get_Length() == 1)
19 {
20 return mlString->GetEnglishString();
21 }
22
23 System::SharedPtr<System::Text::StringBuilder> sb = System::MakeObject<System::Text::StringBuilder>();
24
25 for (int32_t i = 0; i < languages->get_Length(); i++)
26 {
27 int32_t langId = languages[i];
28 sb->Append(System::String::Format(u"{0}: {1}", System::Enum<TtfNameTable::MSLanguageId>::GetName((TtfNameTable::MSLanguageId)langId), mlString->GetStringForLanguageId(langId)));
29 if (i != (languages->get_Length() - 1))
30 {
31 sb->Append(u", ");
32 }
33 }
34
35 return sb->ToString();
36 }Atualizando valores para categorias “Nome da subfamília da fonte” e “Descrição”
Para adicionar ou atualizar a entrada na tabela ‘Nome’ corretamente, precisamos passar os valores dos parâmetros PlatformID, PlatformSpecidid e LanguageID que coincidem com aqueles que já estão presentes na tabela ‘Name’. Para isso, antes de atualizar os dados, leremos os registros existentes do tipo Namerecord relevante para a categoria lógica refrescante, definida pelo identificador de nome.
1 //Struct for update operations
2 struct UpdateData
3 {
4 private:
5 TtfNameTable::NameId _nameId;
6 System::String _data;
7
8 public:
9 UpdateData(TtfNameTable::NameId nameId, String data)
10 {
11 this->_nameId = nameId;
12 this->_data = data;
13 }
14
15 TtfNameTable::NameId get_NameId() const
16 {
17 return this->_nameId;
18 }
19
20 String get_StringData() const
21 {
22 return this->_data;
23 }
24 };
25
26 UpdateData recordsToUpdate[] = {
27 UpdateData(TtfNameTable::NameId::FontSubfamily, String(u"Italic")),
28 UpdateData(TtfNameTable::NameId::Description, String(u"New description"))};
29
30 SharedPtr<TtfNameTable::NameRecord> firstRecord = nullptr;
31
32 for(UpdateData updateData : recordsToUpdate)
33 {
34 //Declare variable for NameRecord structure to use for update operations
35 SharedPtr<TtfNameTable::NameRecord> record = nullptr;
36
37 System::ArrayPtr<System::SharedPtr<TtfNameTable::NameRecord>> records = _font->get_TtfTables()->get_NameTable()->GetNameRecordsByNameId(updateData.get_NameId());
38
39 //In this example we will use only info from the first NameRecord structure returned to update font metadata.
40 //Many actual fonts require serious analyze of all NameRecords returned to update metadata correctly
41
42 //Initialize just created variables
43 if (records->get_Length() == 0)
44 {
45 //If no any record was found for current name identifer,
46 //we will use first found record for any name identifier
47 if (firstRecord == nullptr)
48 {
49 firstRecord = GetFirstExistingRecord(_font->get_TtfTables()->get_NameTable());
50 }
51 record = firstRecord;
52 }
53 else
54 {
55 record = records[0];
56 }
57
58 //Add or update record in 'name' table
59 _font->get_TtfTables()->get_NameTable()->AddName(updateData.get_NameId(), StaticCast<TtfNameTable::PlatformId>(record->get_PlatformId()), record->get_PlatformSpecificId(), record->get_LanguageId(), updateData.get_StringData());
60 }
61
62 System::SharedPtr<Aspose::Font::TtfTables::TtfNameTable::NameRecord> MetadataExamples::GetFirstExistingRecord(System::SharedPtr<Aspose::Font::TtfTables::TtfNameTable> table)
63 {
64 System::ArrayPtr<System::SharedPtr<TtfNameTable::NameRecord>> records;
65 for (TtfNameTable::NameId nameId : System::Enum<TtfNameTable::NameId>::GetValues())
66 {
67 records = table->GetNameRecordsByNameId(nameId);
68 if (records->get_Length() != 0)
69 {
70 return records[0];
71 }
72 }
73
74 return table->GetAllNameRecords()->idx_get(0);
75 }Outros exemplos para refrescar a tabela ‘Nome’ que você pode encontrar no teste Solução metadataexamples.cpp.