Trabajar con la API de KOMPAS-3D → Lección 16 → Caracteres de control

Continuamos la serie de artículos sobre cómo trabajar con CAD API COMPASS-3D. Los personajes de control ya se han visto varias veces en lecciones anteriores del ciclo. Luego, cada vez se decía que las líneas de salida no deberían contenerlas, ya que COMPAS las procesa de una manera especial. Ahora es el momento de conocerlos mejor.

Habiendo dominado el trabajo con ellos, comprenderá que crear cadenas compuestas complejas es una tarea trivial, en la mayoría de los casos no requiere escribir una gran cantidad de código.

En la lección, veremos cómo usar caracteres especiales y caracteres de fuente con caracteres de control, hablaremos sobre cómo crear fracciones y desviaciones con su ayuda, y también consideraremos su uso junto con los párrafos.

El contenido de la serie de lecciones "Trabajando con la API KOMPAS-3D"

1. Los fundamentos
2. Diseño de dibujo
3. Conexión correcta a KOMPAS
4. Inscripción principal
5. Primitivas gráficas
6. Guardar un documento en varios formatos
7. Conociendo la configuración
8. Métodos de escritura más sofisticados en el bloque de título
9. Lectura de celdas de subtítulos
10. Caracteres especiales que incluyen una cadena
11. Etiquetas de texto simple
12. Cuerdas compuestas
13. Los párrafos
14. Texto multilínea
15. Líneas compuestas basadas en párrafos
16. Personajes de control

Revisión cursiva

Los caracteres de control son: @, $, &,;, ~, ^ y #. Desafortunadamente, el SDK de KOMPAS tiene muy poca información sobre cómo usarlos. Para obtener más información, consulte la ayuda de KOMPAS, en la sección "9. Configuración de KOMPAS-3D / Almacenamiento de la configuración del sistema / Archivos de servicio / Archivo de menú de usuario / Sintaxis de archivo " .



Todos los caracteres de control se pueden dividir condicionalmente en dos grupos: principal y auxiliar. Los símbolos auxiliares se usan solo junto con los principales y, por sí mismos, no describen ningún componente. La siguiente tabla proporciona una breve descripción de los caracteres de control.



Consideremos con más detalle.

Insertar caracteres especiales

Ya hemos considerado personajes especiales (ver lecciones 4 y 10 ). Luego, para insertar un carácter especial, se utilizó una instancia separada de la interfaz ksTextItemParam . Usando caracteres de control, puede insertar tantos caracteres especiales en la cadena como mejor le parezca sin reutilizar la interfaz ksTextItemParam .
La sintaxis para insertar caracteres especiales es:

AA @ YXXXX ~ BB

donde
AA : una cadena ubicada antes de un carácter especial,
Y - modificador para la representación del código de caracteres especiales,
XXXX : código del carácter especial insertado.
BB : una línea ubicada después del carácter especial.

El código para el carácter especial insertado se especifica entre @ y ~ . Además, dependiendo del valor del modificador Y , se puede especificar en notación decimal o hexadecimal. Los valores válidos del modificador Y se muestran en la tabla a continuación.



Nota: como muestran mis experimentos, COMPASS normalmente procesa la ausencia del carácter ~ . En este caso, se insertan caracteres especiales según sea necesario. Sin embargo, recomiendo no depender de este comportamiento y completar siempre la operación de inserción con el carácter ~ .

El siguiente es un ejemplo de un programa que demuestra la salida de caracteres especiales.

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

En este ejemplo, el mismo carácter (α alfa) se muestra dos veces. La primera vez que su código se especifica en decimal, la segunda vez en hexadecimal. La siguiente figura muestra el resultado del programa.



Los caracteres de control le permiten mostrar varios caracteres especiales en la misma línea. Entonces, en el siguiente ejemplo, las primeras tres letras del alfabeto griego se muestran en una llamada al 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); 

La siguiente figura muestra el resultado de este programa.



Modificador + es el modificador predeterminado. Por lo tanto, la línea anterior se puede escribir así:

"@ 51 ~ @ 52 ~ @ 53 ~"

En este caso, el resultado del programa seguirá siendo el mismo.

Si una @ es un carácter no válido, la línea entre @ y ~ se muestra como está. Los caracteres @ y ~ se omiten. Por ejemplo, con la línea:

"Antes @ T51 ~ Después"

El documento mostrará:

Antes T51 Después

Nota: este comportamiento de KOMPAS no está documentado y puede variar en diferentes versiones del programa.

Nota: los caracteres de control no son adecuados para insertar caracteres especiales que contienen una cadena. El hecho es que para limitar su acción, debe usar el indicador SPECIAL_SYMBOL_END (para obtener más detalles, consulte la lección 10 del ciclo), pero los caracteres de control no permiten el uso de indicadores.

Insertar caracteres de fuente

Además de los caracteres especiales, puede insertar caracteres ordinarios por su código. Los caracteres de control ^ y ~ se utilizan para esto. Su sintaxis se da a continuación.

AA ^ ( FNAME ) YXXXX ~ BB

donde
AA : una cadena ubicada antes del carácter insertado,
FNAME : el nombre de la fuente de la que se toma el carácter,
Y - modificador para la representación del código de caracteres (similar a @),
XXXX : código numérico del carácter insertado,
BB : una línea ubicada después del carácter insertado.

Por su propósito, el carácter de control ^ es similar a @ . Incluso tienen una sintaxis similar. Pero hay dos diferencias importantes entre ellos:

1. ^ inserta no un carácter especial, sino un carácter de fuente por su código;
2. para que se inserte el carácter, puede establecer la fuente en el campo FNAME (@ no permite esto).

Los códigos de símbolos se pueden ver usando la aplicación charmap (Tabla de símbolos), que forma parte del sistema operativo Windows.

Si no se especifica ninguna fuente, se utiliza la fuente predeterminada. El siguiente es un ejemplo usando el carácter ^ .

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

En este ejemplo, se insertan dos caracteres en la cadena resultante, para el primero seleccionamos la fuente Arial , para el segundo dejamos la fuente predeterminada. La siguiente figura muestra la línea que se envía al documento.



Tenga en cuenta: la fuente se establece solo para el carácter que se muestra. Como muestran mis experimentos, KOMPAS normalmente procesa la ausencia de un terminador ~ . Sin embargo, no recomiendo confiar en este comportamiento y siempre configurar un finalizador.

Si se especifica un carácter no válido (o un código no válido) después de ^ , entonces se omiten ^ y ~ , y la línea entre ellos se muestra tal como está usando la fuente predeterminada. Por ejemplo, con la línea

"Antes ^ Q (Arial) * B1 ~ Después"

El documento mostrará:

"Antes de Q (Arial) * B1 Después"

Si se indica un nombre de fuente incorrecto en el campo FNAME , KOMPAS seleccionará la fuente y mostrará el carácter en ella.

Si no hay paréntesis de cierre en la línea, entonces dicha línea no se mostrará completamente. Por ejemplo, con la línea:

"Antes ^ Q (Arial * B1 ~ Después"

El documento solo mostrará

"Hasta"

Nota: el comportamiento anterior con una sintaxis de caracteres de control incorrecta es válido para KOMPAS-3D V17 y no está documentado. En otras versiones, puede ser diferente.

Formas adicionales de insertar caracteres

Los caracteres @ y ^ tienen análogos - & y # respectivamente. Tienen una sintaxis similar:

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

donde

AA : una cadena que se muestra antes del carácter insertado,
XX - código del carácter insertado (para & - carácter especial, para # - carácter de fuente),
BB : una cadena que se muestra después del carácter insertado,
FNAME : el nombre de la fuente.

Solo hay dos diferencias entre los caracteres @ y ^ y sus contrapartes:

1. Los caracteres & y # no tienen un modificador Y. El código de caracteres siempre se especifica en notación decimal.
2. El código para el carácter a insertar se especifica por un máximo de dos dígitos.

El siguiente es el código fuente de un programa que muestra cómo usar los caracteres & y # .

 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 siguiente figura muestra el resultado de este programa.

Texto multilínea

Usando caracteres de control, se puede mostrar texto de varias líneas. Para hacer esto, en el lugar de la transferencia a una nueva línea, debe insertar la secuencia: @ / . Nota: el carácter @ se usa sin un terminador ~ . El siguiente es el código fuente de un programa que muestra texto multilínea utilizando caracteres de control.

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

Tenga en cuenta: gracias al uso de caracteres de control, mostramos texto de dos líneas con una sola llamada al método ksText . La siguiente figura muestra el resultado de este programa.

Insertar caracteres de control

Descubrimos cómo insertar caracteres especiales arbitrarios y caracteres Unicode. Pero, ¿qué pasa si desea insertar el carácter de control en sí? Aquí puedes ir de dos maneras. La primera forma es usar el carácter ^ y pegarlo como caracteres de fuente normal. Pero hay una manera más fácil.

Símbolo ; es auxiliar y se puede insertar directamente en el texto. Para insertar otros caracteres de control, debe duplicarlos. Es decir, un par de caracteres @@ inserta un carácter @ en el texto. Lo mismo es cierto para otros personajes de control.

El siguiente es un programa de ejemplo que muestra la inserción de caracteres de control en una cadena.

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

La siguiente figura muestra el resultado de este programa.

Desviaciones superiores e inferiores

La siguiente sintaxis se utiliza para insertar desviaciones:

AA $ XX ; AA $ BB

donde

AA : texto que se muestra antes de las desviaciones;
XX - desviación superior;
YY es la desviación más baja;
BB : texto que se muestra después de las desviaciones.

Tenga en cuenta: toda la construcción está limitada a $ caracteres y el " ; »Sirve como separador entre las desviaciones superior e inferior.

Si no hay delimitador "entre los caracteres $ ; ", Entonces toda la línea entre ellos se interpreta como la desviación superior. Si el componente XX está ausente, es decir, después de que el primer $ se vaya inmediatamente " ; ", Entonces toda la línea subsiguiente al $ más cercano se interpreta como la desviación más baja.

Nota: el texto de la desviación superior no debe comenzar con las letras b , d , s , my l (minúscula L ). La razón de esto se explicará un poco más adelante.

El siguiente es un ejemplo de un programa que muestra resultados con desviaciones

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

La siguiente figura muestra el resultado de este programa:



Tenga en cuenta que KOMPAS procesa solo un carácter " ; ". El segundo personaje es " ; "Se puede interpretar como el finalizador de toda la estructura. Por ejemplo, con la línea " 11 $ 22; 33; 44 $ " la pantalla mostrará:



Nota: este comportamiento de KOMPAS no está documentado, por lo que no puede confiar en él.

Fracción

La sintaxis de fracción es similar a la sintaxis de desviación y tiene dos opciones equivalentes:

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

donde

AA - salida de texto a fracciones;
XX es el numerador;
YY es el denominador;
BB : texto que se muestra después de la fracción.

Tenga en cuenta: la única diferencia entre el resultado de la fracción y el resultado de las desviaciones es la presencia de la letra d o b inmediatamente después del primer signo $ . De lo contrario, sus sintaxis son idénticas.

Si no hay " ; " entre los caracteres $ d ( $ b ) y $ ", Entonces toda la línea entre ellos se interpretará como un numerador. Si el componente XX está ausente, es decir, después de que $ d ( $ b ) aparece inmediatamente " ; ", Entonces toda la línea subsiguiente al $ más cercano se interpreta como el denominador.

Nota: el texto del numerador no debe comenzar con las letras s , mo l (minúscula L ). La razón de esto se explicará un poco más adelante.

El siguiente es un ejemplo de un programa que muestra la salida de fracciones utilizando caracteres de control.

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

La siguiente figura muestra el resultado de este programa.



Tenga en cuenta que KOMPAS procesa los caracteres "extra" ; »Así como en el caso de desviaciones. Este comportamiento no está documentado y no se puede confiar en él.

Control de variación y tamaño de fracción

Al comienzo de la construcción de desviaciones o fracciones, se puede ubicar una de las letras: s , mo l (minúscula L ). Especifican el tamaño de las desviaciones y los elementos de la fracción (numerador y denominador). Su propósito se describe en la tabla a continuación.



Si no se especifica ninguna de estas letras, entonces l se usa para la fracción, ym se usa para las desviaciones. El siguiente es un programa de ejemplo que demuestra el uso de estas 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); 

La siguiente figura muestra el resultado de este programa.



Aunque las letras s , myl se usan para fracciones en este ejemplo, su uso para las desviaciones no es diferente.

Tenga en cuenta que si entre el comienzo de una fracción o desviación ( $ , $ do $ b ) y la letra s , mo l hay al menos un carácter "extraño" (por ejemplo, un espacio), entonces COMPAS no "verá" las letras y la fracción o La desviación será el tamaño predeterminado.

Personajes de control anidados

Al generar fracciones y desviaciones, las líneas incluidas en su composición se procesan de forma recursiva. Esto significa que al formar el numerador y el denominador, también se pueden usar caracteres de control. Este enfoque se demuestra en el siguiente ejemplo.

 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 siguiente figura muestra el resultado de este programa.



Para insertar letras del alfabeto griego, usamos los caracteres de control @ y ^ (para la letra  pi). El grado en el primer término se deriva utilizando desviaciones. La subcadena $ s2 $ lo muestra. La letra s indica el pequeño tamaño de la desviación, pero debido a la ausencia de un separador " ; »Solo se muestra la desviación superior.

Para formar una fracción, se usa la combinación $ d; $ . Además, el numerador y el denominador incluyen caracteres de control que proporcionan la salida de las letras del alfabeto griego.

El último sustraído (π pi) se muestra como el símbolo de la fuente Symbol usando los caracteres de control ^ y ~ .

Desafortunadamente, las posibilidades de tal "recursión" son muy limitadas. No podemos invertir fracciones y desviaciones entre sí. El problema es que ambos se forman usando el carácter $ control. Debido a esto, COMPASS no puede analizar correctamente qué $ pertenece a qué elemento.

Controlar caracteres en el párrafo

Puede omitir parcialmente la restricción con caracteres de control anidados mediante párrafos. El uso de caracteres de control y párrafos juntos le permite construir estructuras aún más complejas. El siguiente ejemplo demuestra la construcción de una fracción de 4 niveles.


En este ejemplo, los caracteres de control se utilizan para construir fracciones en el numerador y el denominador de la fracción principal, así como para insertar letras del alfabeto griego. La siguiente figura muestra el resultado de este programa.

Conclusión

En esta lección, nos encontramos con caracteres de control y aprendimos cómo usarlos para mostrar caracteres especiales y caracteres de fuente. Como puede ver, proporcionan una sintaxis simple para crear cadenas que incluyen caracteres especiales, fracciones y desviaciones. Desafortunadamente, no son adecuados para insertar caracteres especiales que contienen cadenas. Pero esos personajes especiales son extremadamente raros. Esta es una de las limitaciones de los caracteres de control. Además, no se pueden usar para crear subcadenas y subcadenas, y existen limitaciones cuando se trabaja con caracteres especiales que incluyen cadenas. Pero esto no resta valor a sus méritos. Esto concluye nuestra discusión sobre los personajes de control.

Para continuar, sigue las noticias del blog.

Sergey Norseev, Ph.D., autor del libro "Desarrollo de aplicaciones para COMPAS en Delphi".