Trabalhar com a API KOMPAS-3D → Lição 16 → Caracteres de controle

Continuamos a série de artigos sobre como trabalhar com a API CAD COMPASS-3D. Os caracteres de controle já foram vistos várias vezes nas lições anteriores do ciclo. Cada vez que se dizia que as linhas de saída não deveriam contê-las, uma vez que o COMPAS as processa de maneira especial. Agora é hora de conhecê-los melhor.

Depois de dominar o trabalho com eles, você entenderá que criar seqüências compostas complexas é uma tarefa trivial, na maioria dos casos, não exigindo a gravação de uma grande quantidade de código.

Na lição, veremos como usar caracteres especiais e caracteres de fonte com caracteres de controle, falaremos sobre como criar frações e desvios com sua ajuda e também consideraremos seu uso em conjunto com parágrafos.

O conteúdo da série de lições “Trabalhando com a API KOMPAS-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
12. Cordas compostas
13. Parágrafos
14. Texto de várias linhas
15. Linhas compostas baseadas em parágrafos
16. Caracteres de controle

Revisão superficial

Os caracteres de controle são: @, $, &,;, ~, ^ e #. Infelizmente, o KOMPAS SDK tem muito pouca informação sobre como usá-los. Para mais informações, consulte a ajuda do KOMPAS, na seção “9. Configurações do KOMPAS-3D / Armazenamento das configurações do sistema / Arquivos de serviço / Arquivo de menu do usuário / Sintaxe do arquivo . ”



Todos os caracteres de controle podem ser divididos condicionalmente em dois grupos: principal e auxiliar. Os símbolos auxiliares são usados ​​apenas em conjunto com os principais e, por si só, não descrevem nenhum componente. A tabela abaixo fornece uma breve descrição dos caracteres de controle.



Vamos considerá-los com mais detalhes.

Inserir caracteres especiais

Já consideramos caracteres especiais (ver lições 4 e 10 ). Em seguida, para inserir um caractere especial, uma instância separada da interface ksTextItemParam foi usada . Usando caracteres de controle, você pode inserir tantos caracteres especiais em uma sequência de caracteres que desejar, sem reutilizar a interface ksTextItemParam .
A sintaxe para inserir caracteres especiais é:

AA @ YXXXX ~ BB

onde
AA - uma sequência localizada antes de um caractere especial,
Y - modificador para a representação do código de caractere especial,
XXXX - código do caractere especial inserido.
BB - uma linha localizada após o caractere especial.

O código para o caractere especial inserido é especificado entre @ e ~ . Além disso, dependendo do valor do modificador Y , ele pode ser especificado em notação decimal ou hexadecimal. Os valores válidos do modificador Y são mostrados na tabela abaixo.



Nota: como mostram meus experimentos, o COMPASS normalmente processa a ausência do caractere ~ . Nesse caso, caracteres especiais são inseridos conforme necessário. No entanto, eu recomendo não confiar nesse comportamento e sempre conclua a operação de inserção com o caractere ~ .

A seguir, é apresentado um exemplo de um programa que demonstra a saída de caracteres especiais.

BSTR str = SysAllocString(OLESTR(" @+51~ ")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); str = SysAllocString(OLESTR(" @*33~ ")); document2D->ksText(100.0,90.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

Neste exemplo, o mesmo caractere (α alfa) é exibido duas vezes. A primeira vez que seu código é especificado em decimal, a segunda vez em hexadecimal. A figura abaixo mostra o resultado do programa.



Os caracteres de controle permitem exibir vários caracteres especiais na mesma linha. Portanto, no exemplo a seguir, as três primeiras letras do alfabeto grego são exibidas em uma chamada para o método ksText .

 BSTR str = SysAllocString(OLESTR("@+51~ @+52~ @+53~")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

A figura abaixo mostra o resultado deste programa.



Modificador + é o modificador padrão. Portanto, a linha acima pode ser escrita assim:

“@ 51 ~ @ 52 ~ @ 53 ~”

Nesse caso, o resultado do programa permanecerá o mesmo.

Se @ for um caractere inválido, a linha entre @ e ~ será exibida como está. Os caracteres @ e ~ são omitidos. Por exemplo, com a linha:

“Antes @ T51 ~ Depois”

O documento exibirá:

Antes de T51 Depois

Nota: esse comportamento do KOMPAS não está documentado e pode variar em diferentes versões do programa.

Nota: os caracteres de controle não são adequados para inserir caracteres especiais contendo uma sequência. O fato é que, para limitar a ação deles, é necessário usar o sinalizador SPECIAL_SYMBOL_END (para obter mais detalhes, consulte a lição 10 do ciclo), mas os caracteres de controle não permitem o uso de sinalizadores.

Inserir caracteres de fonte

Além de caracteres especiais, você pode inserir caracteres comuns por seu código. Os caracteres de controle ^ e ~ são usados ​​para isso. Sua sintaxe é dada abaixo.

AA ^ ( FNAME ) YXXXX ~ BB

onde
AA - uma sequência localizada antes do caractere inserido,
FNAME - o nome da fonte da qual o caractere é retirado,
Y - modificador para a representação do código de caractere (semelhante a @),
XXXX - código numérico do caractere inserido,
BB - uma linha localizada após o caractere inserido.

Por seu propósito, o caractere de controle ^ é semelhante a @ . Eles ainda têm uma sintaxe semelhante. Mas existem duas diferenças importantes entre eles:

1. ^ insere não um caractere especial, mas um caractere de fonte por seu código;
2. para o caractere a ser inserido, você pode definir a fonte no campo FNAME (@ não permite isso).

Os códigos de símbolos podem ser visualizados usando o aplicativo charmap (Tabela de símbolos), que faz parte do sistema operacional Windows.

Se nenhuma fonte for especificada, a fonte padrão será usada. A seguir, um exemplo usando o caractere ^ .

 BSTR str = SysAllocString(OLESTR(" ^(Arial)*B1~  ^*39~ ")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

Neste exemplo, dois caracteres são inseridos na sequência resultante; no primeiro, selecionamos a fonte Arial ; no segundo, deixamos a fonte padrão. A figura abaixo mostra a linha que é impressa no documento.



Observe: a fonte está definida apenas para o caractere exibido. Como mostram meus experimentos, o KOMPAS normalmente processa a ausência de um terminador. No entanto, eu não recomendo confiar nesse comportamento e sempre definir um finalizador.

Se um caractere inválido (ou um código inválido) for especificado após ^ , ^ e ~ serão omitidos e a linha entre eles será exibida como se estivesse usando a fonte padrão. Por exemplo, com a linha

“Antes ^ Q (Arial) * B1 ~ Depois”

O documento exibirá:

“Antes de Q (Arial) * B1 Depois”

Se um nome de fonte incorreto for indicado no campo FNAME , o KOMPAS selecionará a fonte e exibirá o caractere.

Se não houver parênteses de fechamento na linha, essa linha não será exibida completamente. Por exemplo, com a linha:

“Antes ^ Q (Arial * B1 ~ Depois”

O documento será exibido apenas

"Até"

Nota: o comportamento acima com sintaxe incorreta de caractere de controle é válido para o KOMPAS-3D V17 e não está documentado. Em outras versões, pode ser diferente.

Maneiras adicionais de inserir caracteres

Os caracteres @ e ^ têm análogos - & e # respectivamente. Eles têm sintaxe semelhante:

AA e XX ~ BB
AA # ( FNAME ) XX ~ BB

onde

AA - uma sequência exibida antes do caractere inserido,
XX - código do caractere inserido (para & - caractere especial, para # - caractere de fonte),
BB - uma sequência exibida após o caractere inserido,
FNAME - o nome da fonte.

Existem apenas duas diferenças entre os caracteres @ e ^ e suas contrapartes:

1. Os caracteres & e # não possuem um modificador Y. O código do caractere é sempre especificado em notação decimal.
2. O código para o caractere a ser inserido é especificado por um máximo de dois dígitos.

A seguir está o código fonte de um programa que demonstra como usar os caracteres & e # .

 BSTR str = SysAllocString(OLESTR(" &51~ ")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); str = SysAllocString(OLESTR(" #(Arial)37~  #37~ ")); document2D->ksText(100.0,90.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

A figura abaixo mostra o resultado deste programa.

Texto de várias linhas

Usando caracteres de controle, o texto de várias linhas pode ser exibido. Para fazer isso, no local de transferência para uma nova linha, você precisa inserir a sequência: @ / . Nota: o caractere @ é usado sem um terminador ~ . A seguir está o código fonte de um programa que exibe texto de várias linhas usando caracteres de controle.

 BSTR str = SysAllocString(OLESTR(" @/ ")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

Observação: graças ao uso de caracteres de controle, exibimos texto de duas linhas com apenas uma chamada para o método ksText . A figura abaixo mostra o resultado deste programa.

Inserir caracteres de controle

Nós descobrimos como inserir caracteres especiais arbitrários e caracteres Unicode. Mas e se você quiser inserir o próprio caractere de controle? Aqui você pode ir de duas maneiras. A primeira maneira é usar o caractere ^ e colá-lo como caracteres de fonte regulares. Mas existe uma maneira mais fácil.

Símbolo ; é auxiliar e pode ser inserido diretamente no texto. Para inserir outros caracteres de controle, você precisa dobrá-los. Ou seja, um par de caracteres @@ insere um único caractere @ no texto. O mesmo vale para outros caracteres de controle.

A seguir, é apresentado um exemplo de programa que demonstra a inserção de caracteres de controle em uma seqüência de caracteres.

 BSTR str = SysAllocString(OLESTR(" : @@ $$ && ; ~~ ^^ ##")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

A figura abaixo mostra o resultado deste programa.

Desvios superiores e inferiores

A seguinte sintaxe é usada para inserir desvios:

AA $ XX ; AA $ BB

onde

AA - texto exibido antes dos desvios;
XX - desvio superior;
YY é o desvio mais baixo;
BB - texto exibido após os desvios.

Observe: toda a construção é limitada a $ caracteres e o " ; »Serve como separador entre os desvios superior e inferior.

Se não houver delimitador "entre os caracteres $ ; ", A linha inteira entre eles é interpretada como o desvio superior. Se o componente XX estiver ausente, ou seja, após o primeiro $ ir imediatamente " ; ", A linha subsequente inteira até o $ mais próximo é interpretada como o desvio mais baixo.

Nota: o texto do desvio superior não deve começar pelas letras b , d , s , m e l ( L minúsculo). A razão para isso será explicada um pouco mais tarde.

A seguir, é apresentado um exemplo de um programa que exibe a saída com desvios

 BSTR str = SysAllocString(OLESTR(" $;$ ")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

A figura abaixo mostra o resultado deste programa:



Observe que o KOMPAS processa apenas um caractere " ; " O segundo caractere é " ; "Pode ser interpretado como o finalizador de toda a estrutura. Por exemplo, com a linha " 11 $ 22; 33; 44 $ ", a tela exibirá:



Nota: esse comportamento do KOMPAS não está documentado, portanto você não pode confiar nele.

Fração

A sintaxe da fração é semelhante à sintaxe do desvio e possui duas opções equivalentes:

AA $ bXX ; AA $ BB
AA $ dXX ; AA $ BB

onde

AA - saída de texto para frações;
XX é o numerador;
YY é o denominador;
BB - texto exibido após a fração.

Observe: a única diferença entre a saída da fração e a saída dos desvios é a presença da letra d ou b imediatamente após o primeiro sinal de $ . Caso contrário, suas sintaxes são idênticas.

Se não houver " ; " entre os caracteres $ d ( $ b ) e $ ", A linha inteira entre eles será interpretada como um numerador. Se o componente XX estiver ausente, ou seja, depois que $ d ( $ b ) vier imediatamente " ; ", A linha subsequente inteira até o $ mais próximo é interpretada como o denominador.

Nota: o texto do numerador não deve começar pelas letras s , m ou l ( L minúsculo). A razão para isso será explicada um pouco mais tarde.

A seguir, é apresentado um exemplo de um programa que demonstra a saída da fração usando caracteres de controle.

 BSTR str = SysAllocString(OLESTR(" $d;$ ")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

A figura abaixo mostra o resultado deste programa.



Por favor, note que o KOMPAS processa os caracteres "extras" ; »Bem como no caso de desvios. Esse comportamento não é documentado e não pode ser invocado.

Controle de variação e tamanho de fração

No início da construção de desvios ou frações, uma das letras pode ser localizada: s , m ou l ( L minúsculo). Eles especificam o tamanho dos desvios e elementos da fração (numerador e denominador). Seu objetivo é descrito na tabela abaixo.



Se nenhuma dessas letras for especificada, l será usado para a fração e m será usado para desvios. A seguir, é apresentado um exemplo de programa que demonstra o uso dessas letras.

 BSTR str = SysAllocString(OLESTR(" $d;$ ")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); str = SysAllocString(OLESTR(" $dl;$ ")); document2D->ksText(100.0,85.0,0.0,0.0,0.0,0,str); SysFreeString(str); str = SysAllocString(OLESTR(" $dm;$ ")); document2D->ksText(100.0,70.0,0.0,0.0,0.0,0,str); SysFreeString(str); str = SysAllocString(OLESTR(" $ds;$ ")); document2D->ksText(100.0,60.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

A figura abaixo mostra o resultado deste programa.



Embora as letras s , me sejam usadas para frações neste exemplo, seu uso para desvios não é diferente.

Observe que se entre o início de uma fração ou desvio ( $ , $ d ou $ b ) e a letra s , m ou l houver pelo menos um caractere “estranho” (por exemplo, um espaço), o COMPAS não “verá” as letras e a fração ou O desvio será o tamanho padrão.

Caracteres de controle aninhados

Ao emitir frações e desvios, as linhas incluídas em sua composição são processadas recursivamente. Isso significa que, ao formar o numerador e o denominador, os caracteres de controle também podem ser usados. Essa abordagem é demonstrada no exemplo a seguir.

 BSTR str = SysAllocString(OLESTR("@54~$s2$ + $d@+51~;@+52~$ - ^(Symbol)*70~")); document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str); SysFreeString(str); 

A figura abaixo mostra o resultado deste programa.



Para inserir letras do alfabeto grego, usamos os caracteres de controle @ e ^ (para a letra  pi). O grau no primeiro termo é derivado usando desvios. A substring $ s2 $ a exibe. A letra s indica o tamanho pequeno do desvio, mas devido à ausência de um separador " ; »Apenas o desvio superior é exibido.

Para formar uma fração, a combinação $ d; $ é usada . Além disso, o numerador e o denominador incluem caracteres de controle que fornecem a saída das letras do alfabeto grego.

O último subtraído (π pi) é exibido como o símbolo da fonte Symbol usando os caracteres de controle ^ e ~ .

Infelizmente, as possibilidades de tal "recursão" são muito limitadas. Não podemos investir frações e desvios um no outro. O problema é que os dois são formados usando o caractere $ control. Por esse motivo, o COMPASS não pode analisar corretamente qual $ pertence a qual elemento.

Controlar caracteres no parágrafo

Você pode ignorar parcialmente a restrição com caracteres de controle aninhado usando parágrafos. O uso de caracteres e parágrafos de controle juntos permite criar estruturas ainda mais complexas. O exemplo abaixo demonstra a construção de uma fração de 4 níveis.


Neste exemplo, caracteres de controle são usados ​​para construir frações no numerador e denominador da fração principal, além de inserir letras do alfabeto grego. A figura abaixo mostra o resultado deste programa.

Conclusão

Nesta lição, encontramos os caracteres de controle e aprendemos como usá-los para exibir caracteres especiais e caracteres de fonte. Como você pode ver, eles fornecem uma sintaxe simples para criar strings que incluem caracteres especiais, frações e desvios. Infelizmente, eles não são adequados para inserir caracteres especiais contendo cadeias. Mas esses caracteres especiais são extremamente raros. Essa é uma das limitações dos caracteres de controle. Além disso, eles não podem ser usados ​​para criar substrings e substrings, e há limitações ao trabalhar com caracteres especiais que incluem strings. Mas isso não diminui seus méritos. Isso conclui nossa discussão sobre caracteres de controle.

Para continuar, acompanhe as notícias do blog.

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