Geekly articles weekly

Trabalhar com a API KOMPAS-3D → Lição 10 → Caracteres especiais, incluindo uma sequência

Já nos familiarizamos com caracteres especiais na quarta lição do nosso ciclo. Seu uso mais simples foi mostrado lá. Ele também disse que se a interface ksTextItemParam especificar um caractere especial e uma sequência, a sequência será localizada imediatamente após o caractere especial. No entanto, existem caracteres especiais que violam essa regra. Hoje falaremos sobre eles.




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


Caracteres especiais, incluindo uma sequência



A tabela de sinais especiais encontra-se no apêndice V da ajuda principal do KOMPAS.

Caracteres especiais com os números 78-80 , 83 , 93-99 , 171 e 172 incluem a sequência. Nesse caso, a sequência s da interface ksTextItemParam não está localizada após o caractere especial, mas dentro dele. Por exemplo, um caractere especial com o número 80 exibe o texto no quadro. A seguir, é apresentado um exemplo de um programa que demonstra o trabalho com um caractere tão especial.

//    TextItemParamPtr TextItemParam; TextItemParam=(TextItemParamPtr)kompas->GetParamStruct(ko_TextItemParam); //  TextItemParam->set_type(SPECIAL_SYMBOL); TextItemParam->set_iSNumb(98); BSTR str = SysAllocString(L""); TextItemParam->set_s(str); SysFreeString(str); //    StampPtr Stamp; Stamp=(StampPtr)Document2D->GetStamp(); //     Stamp->ksOpenStamp(); Stamp->ksColumnNumber(1); Stamp->ksTextLine(TextItemParam); //     Stamp->ksCloseStamp(); Stamp.Unbind(); TextItemParam.Unbind(); Document2D.Unbind(); //   kompas->Visible = true; kompas.Unbind();

Por simplicidade, este exemplo omite o código responsável pela criação e execução do documento (este tópico foi discutido nas lições anteriores do ciclo). A figura abaixo mostra o rótulo principal formado por este programa.



Para simplificar, preenchemos apenas uma célula. O caractere especial com o número 98 define o sinal da raiz quadrada. Observe que o valor da propriedade s da interface ksTextItemParam está completamente sob o sinal de raiz. Outros caracteres especiais, incluindo a string, funcionam exatamente da mesma maneira.

Caracteres especiais e ksTextLineParam


A ação de caracteres especiais não se limita à interface ksTextItemParam . Considere o exemplo abaixo.

 //     TextItemParamPtr TextItemParam; TextItemParam=(TextItemParamPtr)kompas->GetParamStruct(ko_TextItemParam); //     DynamicArrayPtr DynamicArray; DynamicArray=(DynamicArrayPtr)kompas->GetDynamicArray(TEXT_ITEM_ARR); //   TextItemParam->set_type(SPECIAL_SYMBOL); TextItemParam->set_iSNumb(98); BSTR str = SysAllocString(L"1 "); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); //   TextItemParam->Init(); TextItemParam->set_type(SPECIAL_SYMBOL); TextItemParam->set_iSNumb(169); str = SysAllocString(L"2 "); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); //   TextItemParam->Init(); TextItemParam->set_type(0); str = SysAllocString(L" 3"); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); //   ksTextLineParam TextLineParamPtr TextLineParam; TextLineParam=(TextLineParamPtr)kompas->GetParamStruct(ko_TextLineParam); TextLineParam->SetTextItemArr(DynamicArray); //    StampPtr Stamp; Stamp=(StampPtr)Document2D->GetStamp(); //     Stamp->ksOpenStamp(); Stamp->ksColumnNumber(1); Stamp->ksTextLine(TextLineParam); //     Stamp->ksCloseStamp(); Stamp.Unbind(); TextItemParam.Unbind(); TextLineParam.Unbind(); DynamicArray->ksDeleteArray(); DynamicArray.Unbind(); Document2D.Unbind(); //   kompas->Visible = true; kompas.Unbind();

Neste exemplo, uma linha composta por três componentes é inserida no bloco de título. Os dois primeiros contêm um caractere especial e uma string. O terceiro componente contém apenas uma sequência, sem um caractere especial. Vejamos o resultado do programa (a figura abaixo mostra apenas a linha gerada sem a inscrição principal).



Observe que a linha “Página 2” e a linha “Página 3” foram incluídas no segundo caractere especial, que planejamos exibir fora do caractere especial. Além disso, ambas as linhas foram incluídas no primeiro caractere especial (também não planejamos isso). Este exemplo demonstra dois pontos importantes:

  • caracteres especiais podem incluir outros caracteres especiais;
  • a ação do caractere especial se estende a todos os componentes que compõem a interface ksTextLineParam .

Uma pergunta razoável surge - existe uma maneira de limitar a ação do personagem especial? Sim existe. Mas, para entendê-lo, primeiro você precisa se familiarizar com a interface ksTextItemFont .

Opções de fonte do componente de texto ( ksTextItemFont )


De acordo com a documentação, a interface ksTextItemFont descreve os parâmetros de fonte do componente de texto. Mas, de fato, seus recursos excedem a descrição simples da fonte usada. Essa interface permite criar linhas compostas (sobre elas - nas próximas lições do ciclo).

Você pode obtê-lo de várias maneiras. Primeiro, usando o método GetParamStruct da interface KompasObject : para isso, a constante ko_TextItemFont deve ser passada para esse método como o único parâmetro. Em segundo lugar, usando o método GetItemFont da interface ksTextItemParam . Este método não possui parâmetros de entrada e retorna a interface ksTextItemFont já associada ao componente de texto.

Considere as propriedades da interface ksTextItemFont .
bitvector - um vetor de bits que define as características do texto (elas serão discutidas em detalhes nas próximas lições do ciclo).
color - cor dos caracteres no formato RGB.
fontName - uma string com o nome da fonte.
height - altura da fonte em milímetros.
ksu é o fator de extensão do texto.
Existem apenas três métodos para a interface ksTextItemFont .
Init () redefine todas as propriedades da interface. Não possui parâmetros de entrada. Se for bem-sucedido, retornará VERDADEIRO e, em caso de erro - FALSO .
GetBitVectorValue retorna o valor de um sinalizador individual do conjunto de vetores de bits . Como um único parâmetro, ele aceita uma flag cujo valor queremos determinar. Se estiver definido, o método retornará VERDADEIRO ; se redefinido, FALSO .
SetBitVectorValue altera o valor de um único sinalizador. A seguir está um protótipo desse método:

 BOOL SetBitVectorValue ( long bitVector, //  BOOL state //   );

Se o valor do parâmetro state for TRUE , o sinalizador bitVector será ativado , caso contrário, será redefinido.
Se for bem-sucedido, o método SetBitVectorValue retornará TRUE e, em caso de erro, FALSE .
Os métodos GetBitVectorValue e SetBitVectorValue permitem trabalhar com a propriedade bitvector sem acessá-la diretamente.

Limitação de caracteres especiais


Dois sinalizadores são projetados para controlar caracteres especiais. Eles estão listados na tabela abaixo.



O sinalizador SPECIAL_SYMBOL que já consideramos quando descrevemos a interface ksTextItemParam . É necessário para indicar - um caractere especial é exibido. O mesmo sinalizador é duplicado na propriedade bitVector da interface ksTextItemFont (como mostram minhas experiências, essa duplicação é opcional).

O segundo sinalizador ( SPECIAL_SYMBOL_END ) faz sentido apenas para caracteres especiais que incluem uma string. Cancela a ação do caractere especial. As linhas exibidas após esse sinalizador não são incluídas no caractere especial.

A ação combinada de ambas as bandeiras cancela a ação do caractere especial. Nesse caso, o caractere especial não será exibido no documento.

Exemplo


Abaixo está o código fonte do programa modificado. Usando os sinalizadores descritos acima, ele implementa a saída correta dos componentes.

 //     TextItemParamPtr TextItemParam; TextItemParam=(TextItemParamPtr)kompas->GetParamStruct(ko_TextItemParam); //     DynamicArrayPtr DynamicArray; DynamicArray=(DynamicArrayPtr)kompas->GetDynamicArray(TEXT_ITEM_ARR); //   TextItemParam->set_type(SPECIAL_SYMBOL); TextItemParam->set_iSNumb(98); BSTR str = SysAllocString(L"1 "); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); //   TextItemFontPtr TextItemFont; TextItemParam->Init(); TextItemFont=(TextItemFontPtr)TextItemParam->GetItemFont(); TextItemFont->set_bitVector(SPECIAL_SYMBOL_END); DynamicArray->ksAddArrayItem(-1, TextItemParam); TextItemFont->Init(); TextItemFont.Unbind(); //   TextItemParam->Init(); TextItemParam->set_type(SPECIAL_SYMBOL); TextItemParam->set_iSNumb(169); str = SysAllocString(L"2 "); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); //      TextItemParam->Init(); TextItemFont=(TextItemFontPtr)TextItemParam->GetItemFont(); TextItemFont->set_bitVector(SPECIAL_SYMBOL_END); TextItemParam->set_type(0); str = SysAllocString(L"  3"); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); TextItemFont.Unbind(); //   ksTextLineParam TextLineParamPtr TextLineParam; TextLineParam=(TextLineParamPtr)kompas->GetParamStruct(ko_TextLineParam); TextLineParam->SetTextItemArr(DynamicArray); //    StampPtr Stamp; Stamp=(StampPtr)Document2D->GetStamp(); //     Stamp->ksOpenStamp(); Stamp->ksColumnNumber(1); Stamp->ksTextLine(TextLineParam); //     Stamp->ksCloseStamp(); Stamp.Unbind(); TextItemParam.Unbind(); TextLineParam.Unbind(); DynamicArray->ksDeleteArray(); DynamicArray.Unbind(); Document2D.Unbind(); //   kompas->Visible = true; kompas.Unbind();

A única diferença entre este exemplo e o anterior é que, após cada caractere especial, um componente é exibido para o qual o sinalizador SPECIAL_SYMBOL_END é definido na interface ksTextItemFont . Seu único objetivo é cancelar a ação do personagem especial. No primeiro caso, ele não contém nenhum dado (exceto a bandeira, é claro). E no segundo caso, contém a string "Página 3" .

Você não pode combinar o sinalizador SPECIAL_SYMBOL_END com a saída do segundo caractere especial. Como nesse caso, esse sinalizador cancelará a ação dos dois caracteres especiais. A linha "Página 2" será exibida sem rasuras.

A figura abaixo mostra a linha exibida pelo programa no bloco de título.



Como você pode ver, agora a ação de caracteres especiais se aplica apenas ao componente "your".

Símbolos especiais aninhados


O primeiro exemplo da lição de hoje mostra claramente - caracteres especiais podem ser incorporados um no outro. O sinalizador SPECIAL_SYMBOL_END cancela a ação de um (último) caractere especial. Isso permite criar linhas complexas com caracteres especiais incorporados.

Abaixo está o código fonte do exemplo modificado, no qual a subcadeia “Página 2” também é incluída na expressão sob o sinal de raiz quadrada.

 //     TextItemParamPtr TextItemParam; TextItemParam=(TextItemParamPtr)kompas->GetParamStruct(ko_TextItemParam); //     DynamicArrayPtr DynamicArray; DynamicArray=(DynamicArrayPtr)kompas->GetDynamicArray(TEXT_ITEM_ARR); //   TextItemParam->set_type(SPECIAL_SYMBOL); TextItemParam->set_iSNumb(98); BSTR str = SysAllocString(L"1 "); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); //   TextItemParam->Init(); TextItemParam->set_type(SPECIAL_SYMBOL); TextItemParam->set_iSNumb(169); str = SysAllocString(L"2 "); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); //   TextItemFontPtr TextItemFont; TextItemParam->Init(); TextItemFont=(TextItemFontPtr)TextItemParam->GetItemFont(); TextItemFont->set_bitVector(SPECIAL_SYMBOL_END); DynamicArray->ksAddArrayItem(-1, TextItemParam); //      TextItemParam->set_type(0); str = SysAllocString(L"  3"); TextItemParam->set_s(str); SysFreeString(str); DynamicArray->ksAddArrayItem(-1, TextItemParam); TextItemFont.Unbind(); //   ksTextLineParam TextLineParamPtr TextLineParam; TextLineParam=(TextLineParamPtr)kompas->GetParamStruct(ko_TextLineParam); TextLineParam->SetTextItemArr(DynamicArray); //    StampPtr Stamp; Stamp=(StampPtr)Document2D->GetStamp(); //     Stamp->ksOpenStamp(); Stamp->ksColumnNumber(1); Stamp->ksTextLine(TextLineParam); //     Stamp->ksCloseStamp(); Stamp.Unbind(); TextItemParam.Unbind(); TextLineParam.Unbind(); DynamicArray->ksDeleteArray(); DynamicArray.Unbind(); Document2D.Unbind(); //   kompas->Visible = true; kompas.Unbind();

Observe que, após a substituição da string "Página 2", produzimos duas vezes o componente com o sinalizador SPECIAL_SYMBOL_END (a primeira vez - como parte de um componente vazio, o segundo - junto com a string "Página 3" ). Isso é necessário para cancelar a ação de caracteres especiais. A primeira vez que cancelamos o caractere especial 169 (tachado), a segunda vez - 98 (raiz quadrada). Se exibirmos apenas um componente com o sinalizador SPECIAL_SYMBOL_END , isso cancelará apenas o caractere especial 169 , mas não 98 . Nesse caso, a linha “Página 3” não seria riscada, mas seria incluída na expressão sob o sinal de raiz.
A figura abaixo mostra o resultado deste programa.



Conclusão

Como parte desta lição, encontramos caracteres especiais que incluem uma sequência. Como você viu, eles são significativamente diferentes dos caracteres especiais simples (por exemplo, letras do alfabeto grego). Embora tenhamos mostrado a eles no exemplo da inscrição principal, isso não deve confundi-lo. Esses caracteres podem ser usados ​​em outros métodos de saída de texto. Vamos considerar um desses métodos na próxima lição.

Para continuar, acompanhe as notícias do blog.

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

Source: https://habr.com/ru/post/pt414701/

More articles:


All Articles