Travailler avec l'API KOMPAS-3D → Leçon 16 → Contrôler les caractères

Nous continuons la série d'articles sur l'utilisation de l'API CAD COMPASS-3D. Les personnages de contrôle ont déjà été vus plusieurs fois dans les leçons précédentes du cycle. Ensuite, à chaque fois, il a été dit que les lignes de sortie ne devraient pas les contenir, car COMPAS les traite de manière spéciale. Il est maintenant temps de mieux les connaître.

Après avoir maîtrisé le travail avec eux, vous comprendrez que la création de chaînes composées complexes est une tâche triviale, dans la plupart des cas, ne nécessitant pas d'écrire une grande quantité de code.

Dans la leçon, nous verrons comment utiliser des caractères spéciaux et des caractères de police avec des caractères de contrôle, parlerons de la façon de créer des fractions et des écarts avec leur aide, et envisagerons également leur utilisation conjointement avec les paragraphes.

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
16. Caractères de contrôle

Examen du cursus

Les caractères de contrôle sont: @, $, &,;, ~, ^ et #. Malheureusement, le SDK KOMPAS contient très peu d'informations sur la façon de les utiliser. Pour plus d'informations, consultez l'aide de KOMPAS, dans la section «9. Paramètres KOMPAS-3D / Stockage des paramètres système / Fichiers de service / Fichier de menu utilisateur / Syntaxe de fichier . ”



Tous les caractères de contrôle peuvent être conditionnellement divisés en deux groupes: principal et auxiliaire. Les symboles auxiliaires ne sont utilisés qu'en conjonction avec les principaux et, en eux-mêmes, ne décrivent aucun composant. Le tableau ci-dessous fournit une brève description des caractères de contrôle.



Examinons-les plus en détail.

Insérer des caractères spéciaux

Nous avons déjà considéré les caractères spéciaux (voir les leçons 4 et 10 ). Ensuite, pour insérer un caractère spécial, une instance distincte de l'interface ksTextItemParam a été utilisée . À l'aide de caractères de contrôle, vous pouvez insérer autant de caractères spéciaux que vous le souhaitez sans réutiliser l' interface ksTextItemParam dans la chaîne .
La syntaxe d'insertion de caractères spéciaux est la suivante:

AA @ YXXXX ~ BB

où
AA - une chaîne située avant un caractère spécial,
Y - modificateur pour la représentation du code de caractère spécial,
XXXX - code du caractère spécial inséré.
BB - une ligne située après le caractère spécial.

Le code du caractère spécial inséré est spécifié entre @ et ~ . De plus, selon la valeur du modificateur Y , il peut être spécifié en notation décimale ou hexadécimale. Les valeurs valides du modificateur Y sont indiquées dans le tableau ci-dessous.



Remarque: comme mes expériences le montrent, COMPASS traite normalement l'absence du caractère ~ . Dans ce cas, des caractères spéciaux sont insérés au besoin. Cependant, je recommande fortement de ne pas compter sur ce comportement et de toujours terminer l'opération d'insertion avec le caractère ~ .

Ce qui suit est un exemple de programme démontrant la sortie de caractères spéciaux.

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); 

Dans cet exemple, le même caractère (α alpha) s'affiche deux fois. La première fois que son code est spécifié en décimal, la deuxième fois en hexadécimal. La figure ci-dessous montre le résultat du programme.



Les caractères de contrôle vous permettent d'afficher plusieurs caractères spéciaux sur la même ligne. Ainsi, dans l'exemple suivant, les trois premières lettres de l'alphabet grec sont affichées dans un appel à la méthode ksText .

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

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



Modifier + est le modificateur par défaut. Par conséquent, la ligne ci-dessus peut être écrite comme ceci:

"@ 51 ~ @ 52 ~ @ 53 ~"

Dans ce cas, le résultat du programme restera le même.

Si un @ n'est pas un caractère valide, la ligne entre @ et ~ s'affiche telle quelle. Les caractères @ et ~ sont omis. Par exemple, avec la ligne:

«Avant @ T51 ~ Après»

Le document affichera:

Avant T51 Après

Remarque: ce comportement de KOMPAS n'est pas documenté et peut varier selon les différentes versions du programme.

Remarque: les caractères de contrôle ne conviennent pas pour insérer des caractères spéciaux contenant une chaîne. Le fait est que pour limiter leur action, vous devez utiliser le drapeau SPECIAL_SYMBOL_END (pour plus de détails, voir 10 leçon du cycle), mais les caractères de contrôle ne permettent pas l'utilisation de drapeaux.

Insérer des caractères de police

En plus des caractères spéciaux, vous pouvez insérer des caractères ordinaires par leur code. Les caractères de contrôle ^ et ~ sont utilisés pour cela. Leur syntaxe est donnée ci-dessous.

AA ^ ( FNAME ) YXXXX ~ BB

où
AA - une chaîne située avant le caractère inséré,
FNAME - le nom de la police dont le caractère est tiré,
Y - modificateur pour la représentation du code de caractère (similaire à @),
XXXX - code numérique du caractère inséré,
BB - une ligne située après le caractère inséré.

De par sa fonction, le caractère de contrôle ^ est similaire à @ . Ils ont même une syntaxe similaire. Mais il y a deux différences importantes entre eux:

1. ^ insère non pas un caractère spécial, mais un caractère de police par son code;
2. pour le caractère à insérer, vous pouvez définir la police dans le champ FNAME (@ ne le permet pas).

Les codes de symboles peuvent être consultés à l'aide de l'application charmap (Symbol Table), qui fait partie du système d'exploitation Windows.

Si aucune police n'est spécifiée, la police par défaut est utilisée. Voici un exemple utilisant le caractère ^ .

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

Dans cet exemple, deux caractères sont insérés dans la chaîne résultante, pour le premier nous sélectionnons la police Arial , pour le second nous laissons la police par défaut. La figure ci-dessous montre la ligne qui est sortie dans le document.



Remarque: la police est définie uniquement pour le caractère affiché. Comme mes expériences le montrent, KOMPAS traite normalement l'absence de terminateur. Cependant, je ne recommande pas de compter sur ce comportement et de toujours définir un finaliseur.

Si un caractère non valide (ou un code non valide) est spécifié après ^ , alors ^ et ~ sont omis et la ligne entre eux est affichée telle quelle en utilisant la police par défaut. Par exemple, avec la ligne

"Avant ^ Q (Arial) * B1 ~ Après"

Le document affichera:

"Avant Q (Arial) * B1 Après"

Si un nom de police incorrect est indiqué dans le champ FNAME , KOMPAS sélectionnera la police et affichera le caractère qu'il contient.

S'il n'y a pas de parenthèse fermante dans la ligne, alors une telle ligne ne sera pas entièrement affichée. Par exemple, avec la ligne:

"Avant ^ Q (Arial * B1 ~ Après"

Le document n'affichera que

"Jusqu'à"

Remarque: le comportement ci-dessus avec une syntaxe de caractères de contrôle incorrecte est valide pour KOMPAS-3D V17 et n'est pas documenté. Dans d'autres versions, cela peut être différent.

Autres moyens d'insérer des caractères

Les caractères @ et ^ ont respectivement des analogues - & et # . Ils ont une syntaxe similaire:

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

où

AA - une chaîne affichée avant le caractère inséré,
XX - code du caractère inséré (pour & - caractère spécial, pour # - caractère de police),
BB - une chaîne affichée après le caractère inséré,
FNAME - le nom de la police.

Il n'y a que deux différences entre les caractères @ et ^ et leurs homologues:

1. Les caractères & et # n'ont pas de modificateur Y. Le code de caractère est toujours spécifié en notation décimale.
2. Le code du caractère à insérer est spécifié par un maximum de deux chiffres.

Ce qui suit est le code source d'un programme montrant comment utiliser les caractères & et # .

 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); 

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

Texte multiligne

En utilisant des caractères de contrôle, du texte sur plusieurs lignes peut être affiché. Pour ce faire, au lieu du transfert vers une nouvelle ligne, vous devez insérer la séquence: @ / . Remarque: le caractère @ est utilisé sans terminateur ~ . Voici le code source d'un programme qui affiche du texte multiligne à l'aide de caractères de contrôle.

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

Remarque: grâce à l'utilisation de caractères de contrôle, nous affichons du texte sur deux lignes avec un seul appel à la méthode ksText . La figure ci-dessous montre le résultat de ce programme.

Insérer des caractères de contrôle

Nous avons compris comment insérer des caractères spéciaux arbitraires et des caractères Unicode. Mais que faire si vous souhaitez insérer le caractère de contrôle lui-même? Ici, vous pouvez procéder de deux manières. La première façon consiste à utiliser le caractère ^ et à les coller comme des caractères de police standard. Mais il existe un moyen plus simple.

Symbole ; est auxiliaire et peut être inséré directement dans le texte. Pour insérer d'autres caractères de contrôle, vous devez les doubler. Autrement dit, une paire de caractères @@ insère un seul caractère @ dans le texte. Il en va de même pour les autres caractères de contrôle.

Voici un exemple de programme qui illustre l'insertion de caractères de contrôle dans une chaîne.

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

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

Écarts supérieurs et inférieurs

La syntaxe suivante est utilisée pour insérer des écarts:

AA $ XX ; AA $ BB

où

AA - texte affiché avant les écarts;
XX - déviation supérieure;
YY est l'écart le plus faible;
BB - texte affiché après les écarts.

Veuillez noter: la construction entière est limitée à $ caractères, et le « ; »Sert de séparateur entre les écarts supérieurs et inférieurs.

S'il n'y a pas de délimiteur "entre les caractères $ ; ", Ensuite, la ligne entière entre eux est interprétée comme la déviation supérieure. Si le composant XX est absent, c'est-à-dire après que le premier $ aille immédiatement “ ; ", Ensuite, la ligne suivante entière au $ le plus proche est interprétée comme l'écart inférieur.

Remarque: le texte de l'écart supérieur ne doit pas commencer par les lettres b , d , s , m et l ( L minuscule). La raison de cela sera expliquée un peu plus tard.

Voici un exemple de programme qui affiche la sortie avec des écarts

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

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



Veuillez noter que KOMPAS ne traite qu’un seul caractère " ; ". Le deuxième caractère est " ; "Peut être interprété comme le finaliseur de toute la structure. Par exemple, avec la ligne " 11 $ 22; 33; 44 $ " l'écran affichera:



Remarque: ce comportement de KOMPAS n'est pas documenté, vous ne pouvez donc pas vous y fier.

Fraction

La syntaxe de fraction est similaire à la syntaxe de déviation et a deux options équivalentes:

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

où

AA - sortie de texte en fractions;
XX est le numérateur;
YY est le dénominateur;
BB - texte affiché après la fraction.

Remarque: la seule différence entre la sortie de la fraction et la sortie des écarts est la présence de la lettre d ou b immédiatement après le premier signe de $ . Sinon, leurs syntaxes sont identiques.

S'il n'y a pas de « ; » entre les caractères $ d ( $ b ) et $ ", Ensuite, la ligne entière entre eux sera interprétée comme un numérateur. Si le composant XX est absent, c'est-à-dire après que $ d ( $ b ) arrive immédiatement " ; ", Ensuite, la ligne suivante entière au $ le plus proche est interprétée comme le dénominateur.

Remarque: le texte du numérateur ne doit pas commencer par les lettres s , m ou l ( L minuscule). La raison de cela sera expliquée un peu plus tard.

Voici un exemple d'un programme qui illustre la sortie de fraction à l'aide de caractères de contrôle.

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

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



Veuillez noter que KOMPAS traite les caractères "supplémentaires" " ; »Ainsi qu'en cas d'écarts. Ce comportement n'est pas documenté et ne peut pas être invoqué.

Contrôle de la variation et de la taille des fractions

Au tout début de la construction des écarts ou des fractions, l'une des lettres peut être localisée: s , m ou l ( L minuscule). Ils précisent la taille des écarts et des éléments de la fraction (numérateur et dénominateur). Leur objectif est décrit dans le tableau ci-dessous.



Si aucune de ces lettres n'est spécifiée, alors l est utilisé pour la fraction et m est utilisé pour les écarts. Voici un exemple de programme qui illustre l'utilisation de ces lettres.

 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); 

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



Bien que les lettres s , m et l soient utilisées pour les fractions dans cet exemple, leur utilisation pour les écarts n'est pas différente.

Notez que si entre le début d'une fraction ou d'un écart ( $ , $ d ou $ b ) et la lettre s , m ou l il y a au moins un caractère «étranger» (par exemple, un espace), alors COMPAS ne «verra» pas les lettres, et la fraction ou L'écart sera la taille par défaut.

Caractères de contrôle imbriqués

Lors de la sortie de fractions et d'écarts, les lignes incluses dans leur composition sont traitées de manière récursive. Cela signifie que lors de la formation du numérateur et du dénominateur, des caractères de contrôle peuvent également être utilisés. Cette approche est illustrée dans l'exemple suivant.

 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); 

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



Pour insérer des lettres de l'alphabet grec, nous utilisons les caractères de contrôle @ et ^ (pour la lettre  pi). Le degré dans le premier terme est dérivé en utilisant des écarts. La sous-chaîne $ s2 $ l' affiche. La lettre s indique la petite taille de l'écart, mais en raison de l'absence de séparateur " ; »Seul l'écart supérieur est affiché.

Pour former une fraction, la combinaison $ d; $ est utilisée . De plus, le numérateur et le dénominateur comprennent des caractères de contrôle qui fournissent la sortie des lettres de l'alphabet grec.

Le dernier soustrait (π pi) est affiché comme le symbole de la police Symbol en utilisant les caractères de contrôle ^ et ~ .

Malheureusement, les possibilités d'une telle "récursivité" sont très limitées. Nous ne pouvons pas investir les fractions et les écarts les uns dans les autres. Le problème est que les deux sont formés en utilisant le caractère $ control. Pour cette raison, COMPASS ne peut pas correctement analyser quel $ appartient à quel élément.

Contrôler les caractères dans le paragraphe

Vous pouvez contourner partiellement la restriction avec des caractères de contrôle imbriqués à l'aide de paragraphes. L'utilisation simultanée de caractères de contrôle et de paragraphes vous permet de créer des structures encore plus complexes. L'exemple ci-dessous montre la construction d'une fraction à 4 niveaux.


Dans cet exemple, les caractères de contrôle sont utilisés pour construire des fractions dans le numérateur et le dénominateur de la fraction principale, ainsi que pour insérer des lettres de l'alphabet grec. La figure ci-dessous montre le résultat de ce programme.

Conclusion

Dans cette leçon, nous avons rencontré des caractères de contrôle et appris à les utiliser pour afficher des caractères spéciaux et des caractères de police. Comme vous pouvez le voir, ils fournissent une syntaxe simple pour créer des chaînes qui incluent des caractères spéciaux, des fractions et des écarts. Malheureusement, ils ne sont pas bien adaptés pour insérer des caractères spéciaux contenant des chaînes. Mais ces caractères spéciaux sont extrêmement rares. C'est l'une des limitations des caractères de contrôle. En outre, ils ne peuvent pas être utilisés pour créer des sous-chaînes et des sous-chaînes, et il existe des limitations lorsque vous travaillez avec des caractères spéciaux qui incluent des chaînes. Mais cela n'enlève rien à leurs mérites. Ceci conclut notre discussion sur les caractères de contrôle.

Pour continuer, suivez l'actualité du blog.

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