Trabalhar com a API KOMPAS-3D → Lição 11 → Rótulos de texto simples

Nas lições anteriores do ciclo, aprendemos a exibir o texto no bloco de título. Hoje falaremos sobre como enviar texto para o próprio documento. Vamos considerar os exemplos mais simples e mostrar truques mais complexos nas lições a seguir.

O conteúdo da série de lições “Trabalhando com a API COMPASS-3D”

1. O básico
2. Desenho de desenho
3. Conexão correta com o KOMPAS
4. Inscrição principal
5. Primitivas gráficas
6. Salvando um documento em vários formatos
7. Conhecendo as configurações
8. Métodos de escrita mais sofisticados no bloco de título
9. Lendo células de legenda
10. Caracteres especiais, incluindo uma sequência
11. Etiquetas de texto simples

Ponto de ancoragem do texto

O texto no KOMPAS é sempre exibido em relação a algum ponto, chamado de ponto de ancoragem. O texto pode ser posicionado de maneira diferente em relação a ele. Para saber a localização do texto em relação ao ponto de ancoragem, o método de interface ksGetTextAlign ksDocument2D. O seguinte é o seu protótipo.

long ksGetTextAlign ( long pText //   ); 

Como único parâmetro, ele leva um ponteiro inteiro para um objeto de texto . O método retorna o tipo de ligação , ou -1 em caso de erro. Tipos de ligação válidos são mostrados na tabela abaixo.


A tabela de tipos de ligação válidos

Para alterar a ligação do texto, use o método ksSetTextAlign da interface ksDocument2D . O seguinte é o seu protótipo.

 long ksSetTextAlign ( long pText, //   «» long align //  ); 

Se for bem-sucedido, esse método retornará 1 e, em caso de erro, retornará zero .

Saída de texto

Para saída de texto simples, use o método ksText da interface ksDocument2D . A seguir, é apresentado um protótipo desse método.

 long ksText ( double x, //   double y, double ang, //   double hStr, //    double ksuStr, //  long bitVector, //  BSTR s //  ); 

Vamos analisar os parâmetros do método ksText . Discutimos o ponto de ancoragem na seção anterior.

O parâmetro ang define o ângulo em graus entre uma linha de texto e uma linha horizontal. O ângulo é contado no sentido anti-horário. A imagem abaixo mostra uma linha desenhada em um ângulo de 45 ° .


Corda de 45 °

O parâmetro hStr define o tamanho dos caracteres da sequência em milímetros. Se o valor desse parâmetro for zero , o tamanho padrão será usado.

O parâmetro ksuStr especifica o alongamento (restrição) do texto. A figura abaixo mostra várias linhas com valores diferentes do parâmetro ksuStr .


Várias linhas com diferentes valores de alongamento

A partir desta figura, pode-se observar que “alongamento 0” é equivalente a “alongamento 1”, ou seja, a ausência de qualquer alongamento.

O parâmetro bitVector contém um conjunto de sinalizadores que determinam o estilo de caractere. Os sinalizadores válidos estão listados na tabela abaixo.


Tabela de sinalizadores de caracteres

De fato, existem outros sinalizadores válidos, mas o trabalho deles só aparece na construção de cadeias compostas complexas. Vamos considerar alguns deles na próxima lição.
Lembre-se - a sequência de saída não deve conter os caracteres @ , $ , & , ~ , ^ e # , pois são caracteres de controle. Falaremos sobre como trabalhar com eles nas próximas lições do nosso ciclo.
Se for bem-sucedido, o método ksText retorna um ponteiro inteiro para o texto. Esse ponteiro pode ser passado, por exemplo, para o método ksSetTextAlign para alterar a posição do texto em relação ao ponto de ancoragem. Em caso de erro, o método ksText retorna zero .

Exemplo

A seguir, é apresentado um exemplo de programa que demonstra a saída da string usando o método ksText .

 //  BSTR str = SysAllocString(L""); long itext; itext = Document2D->ksText(100, 100, //  0, //  11, //  0, // 0, //  str); SysFreeString(str); //    Document2D->ksSetTextAlign(itext, txta_Left); Document2D.Unbind(); //   kompas->Visible = true; kompas.Unbind(); 

Por simplicidade, o código responsável pela criação e execução do documento é omitido neste exemplo. Como resultado deste programa, o texto "String" é exibido no documento.

Tamanho do texto

Ao exibir texto em um documento, é útil saber quanto espaço é necessário. A altura do texto é definida pelo parâmetro hStr do método ksText . Mas seu comprimento depende diretamente da sequência de saída.

Para determiná-lo, use o método ksGetTextLengthFromReference da interface ksDocument2D . Este método possui apenas um parâmetro - um ponteiro inteiro para o texto. Retorna o comprimento do texto em milímetros.

O método ksGetTextLengthFromReference é inconveniente, pois não permite determinar o comprimento da linha antes de ser enviada ao documento. Para determinar o comprimento de uma sequência que ainda não foi impressa no documento, você precisa usar o método ksGetTextLength . Mas antes de considerar, vamos falar sobre estilos.

Estilos de texto

O sistema KOMPAS pré-define vários estilos para os textos exibidos nos documentos. Cada estilo tem um número inteiro. Os estilos mais usados ​​estão na tabela abaixo.


Estilos de texto comumente usados

Nem todos os estilos são apresentados nesta tabela: apenas uma parte deles. Uma lista completa das constantes disponíveis pode ser encontrada na página "Estruturas e constantes de parâmetros \ Constantes \ Constantes de texto \ Estilos de texto do sistema" na documentação do KOMPAS.

Método KsGetTextLength

O método ksGetTextLength da interface ksDocument2D permite determinar o comprimento de uma sequência antes de ser enviada ao documento. Abaixo está um protótipo deste método.

 double ksGetTextLength ( BSTR text, // long style //  ); 

O método retorna o comprimento da string em milímetros. Observe: o método aceita a própria string como parâmetro, e não como ponteiro para o objeto "texto". Isso permite avaliar o tamanho da linha antes que ela seja impressa no documento.

Exemplo

Considere um exemplo de uso do método ksGetTextLength . Suponha que tenhamos uma linha e precisamos colocá-la em um retângulo de um determinado comprimento (essa tarefa é muito mais fácil de resolver com a ajuda de parágrafos, mas sobre eles nas próximas lições). Se a linha couber nela, é exibida na íntegra. Caso contrário, ele será cortado e uma elipse será colocada no final. Abaixo está o código fonte do programa que resolve esse problema.

 const wchar_t FULLSTR[] = L"  !   !   !"; const wchar_t DOTS[] = L"..."; const long STYLE = 1; double maxSize = 100.0; BSTR str = SysAllocString(FULLSTR); if(Document2D->ksGetTextLength(str, STYLE) > maxSize) { //   BSTR str_dots = SysAllocString(DOTS); double size_dots = Document2D->ksGetTextLength(str_dots, STYLE); SysFreeString(str_dots); //     maxSize -= size_dots; SysReAllocStringLen(&str, str, SysStringLen(str) - 4); // ,     while(Document2D->ksGetTextLength(str, STYLE) > maxSize) SysReAllocStringLen(&str, str, SysStringLen(str) - 1); //    size_t len = SysStringLen(str); SysFreeString(str); //     wchar_t *p = new wchar_t[len + wcslen(DOTS) + 1]; wcsncpy(p, FULLSTR, len); p[len] = L'\0'; wcscat(p, DOTS); str = SysAllocString(p); delete [] p; } //    Document2D->ksText(100, 100, //  0, //  0, //  0, // 0, //  str); //  SysFreeString(str); Document2D.Unbind(); //   kompas->Visible = true; kompas.Unbind(); 

A cadeia de origem é especificada na constante FULLSTR . A variável maxSize define o comprimento do retângulo no qual você deseja inserir a sequência. Posteriormente esse valor é especificado, o tamanho das reticências é subtraído dele, que é armazenado na variável size_dots . Se a linha não couber, um caractere será cortado até que caiba no retângulo do tamanho especificado. Isso acontece em um loop while .

Preste atenção a um ponto muito importante: ao emitir uma string, todos os parâmetros do método ksText (exceto as coordenadas do ponto de ancoragem) têm um valor zero . O fato é que o método ksGetTextLength não sabe nada sobre esses parâmetros, portanto, não pode levá-los em consideração ao calcular o comprimento da string. Portanto, se a saída de uma string usar valores diferentes de zero dos parâmetros do método ksText , o comprimento da string resultante poderá diferir daquele obtido pelo método ksGetTextLength .

Conclusão

Nesta lição, aprendemos como exibir rótulos de texto simples usando o método ksText . Esta não é a única maneira de exibir texto, mas talvez a mais fácil. Na próxima lição, veremos como essa linha composta pode ser impressa usando esse método. E a seguir, consideraremos métodos de saída de texto mais complexos.

Para continuar, acompanhe as notícias do blog.

Sergey Norseev, Ph.D., autor do livro "Application Development for COMPAS in Delphi".