Geekly articles weekly

Utilisation de l'API KOMPAS-3D → Leçon 15 → Lignes composées basées sur le paragraphe

Dans la leçon 12, nous avons présenté les lignes composées et examiné une manière non documentée de les créer. Dans la leçon 13 , des paragraphes ont été présentés. Aujourd'hui, nous allons voir comment les utiliser pour créer des chaînes composées. Pour commencer, prenons des lignes qui incluent des écarts et des fractions, et familiarisons-nous avec des composants de lignes composées comme un exposant, une sous-chaîne et des caractères spéciaux.



Le contenu de la série de leçons «Travailler avec l'API KOMPAS-3D»


  1. Les bases
  2. Conception de dessin
  3. Connexion correcte à KOMPAS
  4. Inscription principale
  5. Primitives graphiques
  6. Enregistrement d'un document dans différents formats
  7. Connaître les paramètres
  8. Méthodes d'écriture plus sophistiquées dans le cartouche
  9. Lecture des cellules de légende
  10. Caractères spéciaux dont une chaîne
  11. Étiquettes de texte simples
  12. Chaînes composées
  13. Paragraphes
  14. Texte multiligne
  15. Lignes composées basées sur des paragraphes

Écarts supérieurs et inférieurs


Ce qui suit est un fragment d'un programme qui illustre la sortie d'une ligne avec des écarts supérieurs et inférieurs à l'aide de paragraphes. Pour cela, les drapeaux END_DEVIAT , LOWER_DEVIAT et UPPER_DEVIAT , mentionnés dans la leçon 12, sont utilisés .

Extrait de code de programme
//     DynamicArrayPtr items; items = static_cast<DynamicArrayPtr>(kompas->GetDynamicArray(TEXT_ITEM_ARR)); items->ksClearArray(); TextItemParamPtr itemParam; itemParam = static_cast<TextItemParamPtr>(kompas->GetParamStruct(ko_TextItemParam)); itemParam->Init(); TextItemFontPtr itemFont; itemFont = static_cast<TextItemFontPtr>(itemParam->GetItemFont()); //   BSTR str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(UPPER_DEVIAT); str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(LOWER_DEVIAT); str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(END_DEVIAT); str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); // ,     itemFont.Unbind(); itemParam.Unbind(); //  ksTextLineParam TextLineParamPtr lineParam; lineParam = static_cast<TextLineParamPtr>(kompas->GetParamStruct(ko_TextLineParam)); lineParam->Init(); lineParam->SetTextItemArr(items); //  ksParagraphParam ParagraphParamPtr paragraphParam; paragraphParam= static_cast<ParagraphParamPtr>(kompas->GetParamStruct(ko_ParagraphParam)); paragraphParam->Init(); paragraphParam->set_x(30.0); paragraphParam->set_y(100.0); //  Document2D->ksParagraph(paragraphParam); Document2D->ksTextLine(lineParam); Document2D->ksEndObj(); //  items->ksDeleteArray(); items.Unbind(); lineParam.Unbind(); paragraphParam.Unbind();


Comparé à l'exemple de la construction d'écarts par rapport à la leçon 12, le programme actuel présente deux avantages importants:

  1. Il utilise les capacités documentées du système COMPASS.
  2. Pas besoin de recalculer la position des rangées. KOMPAS détermine lui-même tous les décalages nécessaires.

Notez l'utilisation de l'indicateur END_DEVIAT . Il termine la génération de l'écart et annule les indicateurs LOWER_DEVIAT et UPPER_DEVIAT . Si nous ne l'avions pas utilisé, la ligne «Texte après écarts» serait affichée comme l'écart le plus faible.

Les drapeaux LOWER_DEVIAT et UPPER_DEVIAT s'annulent. Lorsqu'elle est utilisée simultanément, la chaîne est sortie comme elle serait affichée sans spécifier ces drapeaux.

Étant donné que l'indicateur NEW_LINE n'est pas utilisé dans notre exemple, toutes les lignes peuvent être affichées avec un seul appel à la méthode ksTextLine . Pour ce faire, ils sont préformés sous la forme de l'interface ksTextLineParam .

Le résultat du programme est illustré dans la figure ci-dessous.



Fraction


Voici un exemple de programme qui illustre la sortie d'une chaîne qui comprend une fraction.

Exemple de programme
 //     DynamicArrayPtr items; items = static_cast<DynamicArrayPtr>(kompas->GetDynamicArray(TEXT_ITEM_ARR)); items->ksClearArray(); TextItemParamPtr itemParam; itemParam = static_cast<TextItemParamPtr>(kompas->GetParamStruct(ko_TextItemParam)); itemParam->Init(); TextItemFontPtr itemFont; itemFont = static_cast<TextItemFontPtr>(itemParam->GetItemFont()); //   BSTR str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(NUMERATOR); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(DENOMINATOR); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(END_FRACTION); str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); // ,     itemFont.Unbind(); itemParam.Unbind(); //  ksTextLineParam TextLineParamPtr lineParam; lineParam = static_cast<TextLineParamPtr>(kompas->GetParamStruct(ko_TextLineParam)); lineParam->Init(); lineParam->SetTextItemArr(items); //  ksParagraphParam ParagraphParamPtr paragraphParam; paragraphParam= static_cast<ParagraphParamPtr>(kompas->GetParamStruct(ko_ParagraphParam)); paragraphParam->Init(); paragraphParam->set_x(30.0); paragraphParam->set_y(100.0); //  Document2D->ksParagraph(paragraphParam); Document2D->ksTextLine(lineParam); Document2D->ksEndObj(); //  items->ksDeleteArray(); items.Unbind(); lineParam.Unbind(); paragraphParam.Unbind();


La construction d'une fraction diffère peu de la construction des écarts. La seule différence est les drapeaux utilisés. L'indicateur END_FRACTION annule les indicateurs NUMERATOR et DENOMINATOR et agit de la même manière que l'indicateur END_DEVIAT en ce qui concerne les écarts.
La figure ci-dessous montre le résultat de ce programme.



Cette ligne semble plus nette par rapport au même texte de la leçon 12 .

Contrôle de la taille des fractions


La fraction affichée peut avoir une taille différente, qui est contrôlée à l'aide de l'interface ksTextItemParam . Si sa propriété type est FRACTION_TYPE , cette interface, entre autres, définit la taille de la fraction. La taille elle-même est spécifiée dans la propriété iSNumb . Ses valeurs valides sont indiquées dans le tableau ci-dessous.



Si la propriété iSNumb spécifie une valeur non valide, alors KOMPAS utilise la hauteur par défaut.

Voici un exemple d'utilisation de l'indicateur FRACTION_TYPE .

Exemple d'utilisation d'indicateur
 //   DynamicArrayPtr items; items = static_cast<DynamicArrayPtr>(kompas->GetDynamicArray(TEXT_ITEM_ARR)); items->ksClearArray(); TextItemParamPtr itemParam; itemParam = static_cast<TextItemParamPtr>(kompas->GetParamStruct(ko_TextItemParam)); itemParam->Init(); TextItemFontPtr itemFont; itemFont = static_cast<TextItemFontPtr>(itemParam->GetItemFont()); //   BSTR str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(NUMERATOR); itemParam->set_type(FRACTION_TYPE); itemParam->set_iSNumb(3); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(DENOMINATOR); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(END_FRACTION); str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); // ,     itemFont.Unbind(); itemParam.Unbind(); //  ksTextLineParam TextLineParamPtr lineParam; lineParam = static_cast<TextLineParamPtr>(kompas->GetParamStruct(ko_TextLineParam)); lineParam->Init(); lineParam->SetTextItemArr(items); //  ksParagraphParam ParagraphParamPtr paragraphParam; paragraphParam= static_cast<ParagraphParamPtr>(kompas->GetParamStruct(ko_ParagraphParam)); paragraphParam->Init(); paragraphParam->set_x(30.0); paragraphParam->set_y(100.0); //  Document2D->ksParagraph(paragraphParam); Document2D->ksTextLine(lineParam); Document2D->ksEndObj(); //  items->ksDeleteArray(); items.Unbind(); lineParam.Unbind(); paragraphParam.Unbind();


Cet exemple diffère du précédent uniquement en définissant le type FRACTION_TYPE dans la propriété type de l'interface ksTextItemParam lors de la sortie du numérateur. Cependant, cela suffit pour redimensionner la fraction. La figure ci-dessous montre le résultat de ce programme (comparez-le avec le résultat de l' exemple précédent ).



Remarque: la taille de la fraction est définie lorsque le numérateur est affiché. Comme mes expériences le montrent, la taille de fraction spécifiée lorsque le dénominateur est affiché est ignorée.

Exposant et sous-chaîne



La construction d'une sous-chaîne et d'une sous-chaîne est contrôlée par les indicateurs répertoriés dans le tableau ci-dessous.



Voici un exemple de programme qui illustre la sortie d'une chaîne avec une sous-chaîne et une sous-chaîne.

Exemple de programme
 //   DynamicArrayPtr items; items = static_cast<DynamicArrayPtr>(kompas->GetDynamicArray(TEXT_ITEM_ARR)); items->ksClearArray(); TextItemParamPtr itemParam; itemParam = static_cast<TextItemParamPtr>(kompas->GetParamStruct(ko_TextItemParam)); itemParam->Init(); TextItemFontPtr itemFont; itemFont = static_cast<TextItemFontPtr>(itemParam->GetItemFont()); //   BSTR str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_BASE); str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_UPPER_INDEX); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_LOWER_INDEX); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_END); str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); // ,     itemFont.Unbind(); itemParam.Unbind(); //  ksTextLineParam TextLineParamPtr lineParam; lineParam = static_cast<TextLineParamPtr>(kompas->GetParamStruct(ko_TextLineParam)); lineParam->Init(); lineParam->SetTextItemArr(items); //  ksParagraphParam ParagraphParamPtr paragraphParam; paragraphParam= static_cast<ParagraphParamPtr>(kompas->GetParamStruct(ko_ParagraphParam)); paragraphParam->Init(); paragraphParam->set_x(30.0); paragraphParam->set_y(100.0); //  Document2D->ksParagraph(paragraphParam); Document2D->ksTextLine(lineParam); Document2D->ksEndObj(); //  items->ksDeleteArray(); items.Unbind(); lineParam.Unbind(); paragraphParam.Unbind();


La figure ci-dessous montre le résultat de ce programme.



Vous ne pouvez pas créer une sous-chaîne et une sous-chaîne à l'aide de la méthode ksDocument2D :: ksText .

Contrôle de la taille de la ligne principale


La ligne principale peut avoir une taille différente, qui est modifiée à l'aide de l'interface ksTextItemParam . Pour cela, la constante SUM_TYPE est spécifiée dans sa propriété type et la taille requise de la ligne principale dans la propriété iSNumb . Les valeurs valides sont indiquées dans le tableau ci-dessous:



Si la propriété iSNumb contient une valeur non valide, KOMPAS utilise la valeur par défaut.

Voici un extrait d'un programme démontrant l'utilisation de la constante SUM_TYPE .

Extrait de programme
 //   DynamicArrayPtr items; items = static_cast<DynamicArrayPtr>(kompas->GetDynamicArray(TEXT_ITEM_ARR)); items->ksClearArray(); TextItemParamPtr itemParam; itemParam = static_cast<TextItemParamPtr>(kompas->GetParamStruct(ko_TextItemParam)); itemParam->Init(); TextItemFontPtr itemFont; itemFont = static_cast<TextItemFontPtr>(itemParam->GetItemFont()); //   BSTR str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_BASE); itemParam->set_type(SUM_TYPE); itemParam->set_iSNumb(2); str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_UPPER_INDEX); itemParam->set_type(0); itemParam->set_iSNumb(0); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_LOWER_INDEX); str = SysAllocString(OLESTR("")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); itemFont->set_bitVector(S_END); str = SysAllocString(OLESTR("  ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); // ,     itemFont.Unbind(); itemParam.Unbind(); //  ksTextLineParam TextLineParamPtr lineParam; lineParam = static_cast<TextLineParamPtr>(kompas->GetParamStruct(ko_TextLineParam)); lineParam->Init(); lineParam->SetTextItemArr(items); //  ksParagraphParam ParagraphParamPtr paragraphParam; paragraphParam= static_cast<ParagraphParamPtr>(kompas->GetParamStruct(ko_ParagraphParam)); paragraphParam->Init(); paragraphParam->set_x(30.0); paragraphParam->set_y(100.0); //  Document2D->ksParagraph(paragraphParam); Document2D->ksTextLine(lineParam); Document2D->ksEndObj(); //  items->ksDeleteArray(); items.Unbind(); lineParam.Unbind(); paragraphParam.Unbind();



La constante SUM_TYPE est entrée dans la propriété type de l'interface ksTextItemParam lorsque la ligne principale est affichée . Avant la sortie du complément , l'interface ksTextItemParam est restaurée à son état initial. C'est la seule différence entre cet exemple et le précédent.

La figure ci-dessous montre le résultat du programme (comparez-le avec le résultat de l'exemple précédent).



La constante SUM_TYPE vous permet de redimensionner la chaîne principale, mais pas les sous-chaînes et les sous-chaînes. La modification de leurs tailles dans KOMPAS n'est pas fournie.

Caractères spéciaux dont une sous-chaîne


Un paragraphe peut gérer des caractères spéciaux qui incluent une chaîne (ils ont été abordés dans la leçon 10 du cycle). Ce qui suit est un fragment d'un programme démontrant leur utilisation dans un paragraphe.

Extrait de programme
 //  DynamicArrayPtr items; items = static_cast<DynamicArrayPtr>(kompas->GetDynamicArray(TEXT_ITEM_ARR)); items->ksClearArray(); DynamicArrayPtr lines; lines = static_cast<DynamicArrayPtr>(kompas->GetDynamicArray(TEXT_LINE_ARR)); lines->ksClearArray(); //   TextLineParamPtr lineParam; lineParam = static_cast<TextLineParamPtr>(kompas->GetParamStruct(ko_TextLineParam)); lineParam->Init(); TextItemParamPtr itemParam; itemParam = static_cast<TextItemParamPtr>(kompas->GetParamStruct(ko_TextItemParam)); itemParam->Init(); TextItemFontPtr itemFont = static_cast<TextItemFontPtr>(itemParam->GetItemFont()); //   BSTR str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); items->ksAddArrayItem(-1, itemParam); lineParam->SetTextItemArr(items); lines->ksAddArrayItem(-1, lineParam); lineParam->Init(); SysFreeString(str); str = NULL; //     itemFont->set_bitVector(NEW_LINE | SPECIAL_SYMBOL); str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); itemParam->set_type(SPECIAL_SYMBOL); itemParam->set_iSNumb(169); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); str = NULL; //   itemFont->set_bitVector(SPECIAL_SYMBOL_END); itemParam->set_s(NULL); itemParam->set_type(0); itemParam->set_iSNumb(0); items->ksAddArrayItem(-1, itemParam); lineParam->SetTextItemArr(items); lines->ksAddArrayItem(-1, lineParam); lineParam->Init(); //     itemFont->set_bitVector(NEW_LINE | SPECIAL_SYMBOL); str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); itemParam->set_type(SPECIAL_SYMBOL); itemParam->set_iSNumb(96); items->ksAddArrayItem(-1, itemParam); SysFreeString(str); str = NULL; //   itemFont->set_bitVector(SPECIAL_SYMBOL_END); itemParam->set_s(NULL); itemParam->set_type(0); itemParam->set_iSNumb(0); items->ksAddArrayItem(-1, itemParam); lineParam->SetTextItemArr(items); lines->ksAddArrayItem(-1, lineParam); lineParam->Init(); //   itemFont->set_bitVector(NEW_LINE); str = SysAllocString(OLESTR(" ")); itemParam->set_s(str); itemParam->set_type(0); itemParam->set_iSNumb(0); items->ksAddArrayItem(-1, itemParam); lineParam->SetTextItemArr(items); lines->ksAddArrayItem(-1, lineParam); lineParam->Init(); SysFreeString(str); str = NULL; itemParam.Unbind(); lineParam.Unbind(); itemFont.Unbind(); items.Unbind(); //    ParagraphParamPtr paragraphParam; paragraphParam= static_cast<ParagraphParamPtr>(kompas->GetParamStruct(ko_ParagraphParam)); paragraphParam->Init(); paragraphParam->set_x(100.0); paragraphParam->set_y(100.0); paragraphParam->set_width(60.0); paragraphParam->set_hFormat(2); //    TextParamPtr textParam = static_cast<TextParamPtr>(kompas->GetParamStruct(ko_TextParam)); textParam->SetParagraphParam(paragraphParam); textParam->SetTextLineArr(lines); //  Document2D->ksTextEx(textParam, 1); lines->ksDeleteArray(); lines.Unbind(); paragraphParam.Unbind(); textParam.Unbind();


L'exemple semble très compliqué, mais si vous le regardez attentivement, vous pouvez voir qu'il consiste à répéter des morceaux. Dans celui-ci, à l'aide de caractères spéciaux, du texte barré et souligné est affiché. Après chacun de ces blocs, une ligne vide avec l'indicateur SPECIAL_SYMBOL_END s'affiche . Sa tâche est d'annuler l'action du personnage spécial. S'il n'est pas affiché, le paragraphe risque de ne pas être construit correctement. L'action du caractère spécial s'étend à l'ensemble du bloc ksTextLineParam , à toute sa longueur quel que soit son contenu réel (cette thèse est illustrée dans la figure ci-dessous).



La ligne d'annulation doit faire partie du bloc ksTextLineParam . Sinon, le paragraphe risque de ne pas être construit correctement. Le bloc ksTextLineParam peut contenir plusieurs caractères de contrôle. Chacun d'eux doit avoir sa propre ligne d'annulation.

L'indicateur SPECIAL_SYMBOL_END est utilisé uniquement pour les caractères spéciaux qui ont une sous-chaîne. Pour les caractères spéciaux ordinaires, il n'est pas nécessaire.

La figure ci-dessous montre le résultat de notre exemple.



Conclusion

Dans cette leçon, nous avons appris à utiliser des paragraphes pour créer des lignes composées, y compris les écarts et les fractions, et examiné les moyens documentés de créer des lignes composées à partir d'un paragraphe. Ce n'est pas la seule et loin de la façon la plus simple de les créer. Une autre manière, beaucoup plus simple, nous considérerons dans la prochaine leçon.

Pour continuer, suivez l'actualité du blog.

Sergey Norseev, Ph.D., auteur du livre "Application Development for COMPAS in Delphi".

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

More articles:


All Articles