Creación de un gestor de macros (I)

Objetivo

Al finalizar este tutorial, habremos creado un gestor de macros, que pueda ser lanzado desde cualquier módulo para

acceder a todas aquellas utilidades que hayamos programado (o conseguido que nos programen) de una forma rápida y

fácil.

El aspecto final debe ser algo similar a esto:

Este gestor se lanzaría a través de un acceso directo y, seleccionando la macro a ejecutar en el mismo, solo tendríamos

que hace click en el botón Ejecutar macro. Además, al seleccionar cada macro, abajo aparecerá un mensaje descriptivo

de su función.

No deja de ser algo similar a lo que obtenemos desde CATIA en Tools macros, pero:

- Lo habremos hecho nosotros

- Habremos visto la técnica básica para crear UserForms y gestionar sus eventos más sencillos

- El formulario no desaparecerá cada vez que ejecutemos una macro (cosa que si pasa con el de CATIA)

- Podremos tenerlo abierto y seguir diseñando

Aunque intentaré ser lo más claro posible, doy por sentado que se tienen unos mínimos conocimientos de

programación.

Introducción

En primer lugar, vamos a introducir brevemente los distintos tipos de lenguajes que se pueden emplear para crear

macros en CATIA.

CATIA admite tres tipos de lenguajes de macros:

- CATScript

- VBScript

- VBA

- VB.net

Los dos primeros son lenguajes de scripts, derivados de VB. CATScript es una versión de VBScript de Dassault, mientas

que VBScript es un lenguaje de script genérico derivado de Visual Basic. Estos lenguajes disponen de una parte de las

opciones disponibles en sus hermanos mayores VBA y VB.net. Con respecto a estos dos últimos, VBA es un derivado de

Visual Basic, especialmente orientado a aplicaciones de tipo Office (Visual Basic para Aplicaciones), pero dispone de

suficientes elementos como para, no solo hacer todo lo que se puede hacer con scripts, sino para además, “hacerlo

bonito”.

Como seguro ya habréis adivinado los más avispados, este manual se va a centrar en VBA que, entre otras cosas, es lo

que más domino.

Es importante decir que, probablemente, cualquier script básico diseñado en cualquiera de los lenguajes mencionados,

puede ser “copiado” a una macro en cualquiera de los otros lenguajes y, con mínimas adaptaciones, funcionará. Eso sí,

mientras VBA y VB.net permiten el uso de formularios, que es lo que les da su atractivo, no ocurre lo mismo con los

otros dos.

Las opciones de macros en CATIA. Creación de nuestro proyecto

Cuando se abre la ventana de CATIA bajo Tools Macros, aparece la siguiente ventana:

Lo primero que debemos fijarnos es en la librería de macros a la que estamos apuntando (Current macro library or

document). Esto nos indica donde están guardadas las macros de las que vamos a disponer de forma directa, así como

donde se guardarán aquellas que grabemos con el grabador de CATIA.

Para trabajar en VBA deberemos hacer click en el botón de Macro libraries… y en la ventana que se abre, desplegar el

ComboBox (esto es un cuadro desplegable, para el que no lo sepa) y seleccionar la opción VBA Projects. Si no hemos

trabajado previamente con este lenguaje, deberemos crear una nueva librería, en la ruta que elijamos, y darle un

nombre con extensión catvba al archivo donde queramos almacenar nuestras macros. Cerramos la ventana de Macro

libraries y nos debe quedar algo como esto:

Vemos que tenemos el archivo MisMacrosVBA.catvba en el directorio D:\CursoCatia\Macros\ParaElBlog.

Creación de un gestor de macros (II)

Creación de la rutina principal

Ahora que ya hemos creado nuestra librería de macros, vamos a empezar a crear el gestor. Para ello, lo primero será

crear la rutina principal que servirá para lanzarlo.

Para ello, vamos a abrir el editor de VBA. Podemos hacerlo a través de Tools Macro Macros y allí, estando

nuestra librería seleccionada, clicar en el botón Create… o bien en Tools Macro Visual Basic Editor. Hecho esto, se

nos abre el editor que, si no tienes nada previo, no tiene nada más que el proyecto MisMacros visible en la ventana de

exploración de proyectos (derecha del editor).

Sobre el proyecto MisMacros, pulsamos el botón derecho y seleccionamos Insertar Modulo. Se nos abre la ventana

de edición y ahí, es donde vamos a crear nuestra macro principal.

El código es el siguiente:

Sub CATMain()

UF_MisMacros.Show

End Sub

Complicado, ¿no?.

Todas las macros de CATIA, estén en el lenguaje que estén, tienen un módulo principal que se debe llamar Sub

CATMain(). Desde este se podrá hacer llamadas a otras subrutinas o funciones, pero debe existir CATMain, sí o sí.

Esta rutina, lo único que hace es lanzar el formulario, que yo he llamado UF_MisMacros (UF de UserForm, para saber lo

que es) mediante el método show.

De momento, no tenemos nada, pero hemos hecho la primera rutina en VBA, que tampoco es poco. Ahora vamos a

dejarla bonita, creando el UserForm.

Creación de UserForm

El siguiente paso, será crear el UF, que vamos a llamar, como hemos visto más arriba, UF_MisMacros. Para ello,

seguimos el mismo procedimiento que para crear el módulo, pero esta vez insertando un UserForm: nos ponemos

sobre el proyecto, damos botón derecho y elegimos Insertar UserForm.

Debajo del explorador de proyectos, veremos la ventana de propiedades. En ella se pueden ver y modificar las

propiedades del objeto que seleccionemos en cada momento.

Con el UserForm seleccionado (si no lo tenemos, hacemos doble click en el árbol del proyecto, sobre él), en la primera

propiedad (Name) ponemos UF_MisMacros, que es como nos vamos a referir, a partir de ahora, a este UF.

En la propiedad Caption, ponemos el texto que queremos que nos muestre en la barra superior cuando esté visible y,

en ShowModal, elegimos False. Esta propiedad es importante en los UF ya que condiciona el funcionamiento de los

mismos. Un UF definido como modal, al mostrarse, bloqueará cualquier otro tipo de interacción con la aplicación de la

que procede, en este caso CATIA. En cambio, establecido como “no modal”, lo podemos tener visible en todo

momento, y seguir trabajando en CATIA. Está bien, eh?.

Yo, le he puesto el color de los usados por CATIA para mimetizarme con el entorno. Esto se hace en la propiedad del UF

BackColor.

Pues ahora vamos a darle forma insertando unos cuantos controles. Insertaremos:

- Un control tipo label para el título del cuadro de lista de macros

- Un control de tipo Cuadro de lista, donde podremos ver las macros disponibles para ser ejecutadas

- Un control de tipo label, donde veremos el texto explicativo de para qué sirve la macro que tengamos

seleccionada

- Un botón para lanzar la ejecución de la macro que seleccionemos

- Un botón para salir

Las propiedades asignadas a cada control son:

Label de título Macros disponibles:

- Name: Label1

- Caption: Macros disponibles

- Font: La que más os guste, negrita (que quepa en la pantalla)

Label de texto de ayuda:

- Name: LblTip

- Caption: Aquí se muestra la descripción de la macro seleccionada

- Font: La que más os guste, no excesivamente grande. Yo, además, le he dado altura como para que

me quepan dos líneas de texto

Lista de macros:

- Name: ListBoxMacros

- Multiselect: 0 – fmMultiSelectSingle (para poder seleccionar solo un macro cada vez)

Botón de ejecutar:

- Name: Ejecutar

- Caption: Ejecutar macro

- Enabled: False

Botón de salir:

- Name: Cerrar

- Caption: Salir

Ahora solo nos falta crear el codigo ligado a cada posible evento del formulario. Pero esta es tarea para el próximo

capítulo.

Creación de un gestor de macros (III)

Rutinas de ejemplo

Antes de pasar a programar el funcionamiento del UserForm que va a servir de “lanzadera” de nuestras macros, vamos

a crear un par de ellas sencillas para tener contenido que cargar.

Rutina1: Versión de CATIA

La primera es una rutina muy sencilla y, supongo, poco útil, ya que entiendo que sabes con que versión de CATIA

trabajas…

Lo primero que haremos será insertar un nuevo módulo y en su propiedad Name, escribir Mod_VersionCATIA. Suele ser

bueno dar nombre a los módulos, para luego saber que hay en ellos. Una vez creado el módulo, copiamos este código:

Sub VersionCatia()

MsgBox "Tu configuración de CATIA es: V" & CATIA.SystemConfiguration.Version & _

"R" & CATIA.SystemConfiguration.Release & _

"(SP" & CATIA.SystemConfiguration.ServicePack & ")"

End Sub

Como vemos, la rutina se llama VersionCatia, que es el nombre que tendremos que usar para después llamarla. Su

funionamiento es simple: toma del objeto CATIA.SystemConfiguration los valores de sus propiedades Version, Release y

ServicePack y los muestra en un cuadro de mensaje.

Rutina2: Saludos a todos!!!

Esta rutina es igual de sencilla, y mostrará un mensaje de saludo. Es aún más inútil que la primera, aunque siempre se

puede reprogramar para que nos lance un mensaje de ánimo cuando estemos atascados. El código es como sigue:

Sub Saludos()

Msgbox “Saludos a todos!!!”,vbOkOnly,”HOLA”

End sub

Podemos copiarla en el módulo anterior o, mejor, insertar un nuevo módulo, por separar rutinas independientes,

llamándolo de una forma que nos indique su contenido.

Programación de eventos del UserForm

Evento Initialize

Ya tenemos nuestro UserForm creado, solo que, de momento, no hace nada. Toca ahora decirle que hacer y usaremos

las dos rutinas sencillas de antes para cargarlas en el mismo y lanzar su ejecución.

El primer evento a programar es el de inicialización del UserForm. Este evento es el que se ejecuta para todo UF cuando

es llamado sin estar previamente cargado y su ejecución se produce antes de ser visualizado. Aquí es donde se pueden

inicializar valores para ser mostrados, el estado inicial de los controles, mensajes de texto, …

Para poder cargar el UF, hacemos doble click sobre el UF en el árbol de proyectos de forma que en la ventana de

edición veamos el diseño del mismo. Tendremos algo así:

Y para poder acceder a la programación del mismo, haremos doble click sobre una zona del mismo que no tenga ningún

control (si hacemos doble click sobre algún control, entraremos en la programación de los eventos de dicho control).

El evento de inicialización del UF tiene que:

- Limpiar el control ListBoxMacros. Debería estar limpio, pero no está de más asegurarse

- Cargar la lista de macros a las que tendremos acceso en el control ListBoxMacros

- Deshabilitar el funcionamiento del botón de ejecutar macro ya que inicializáremos el UF sin seleccionar

ninguna

El código necesario es el siguiente:

Private Sub UserForm_Initialize()

UF_MisMacros.ListBoxMacros.Clear

UF_MisMacros.Ejecutar.Enabled = False

UF_MisMacros.ListBoxMacros.AddItem ("Version CATIA")

UF_MisMacros.ListBoxMacros.AddItem ("Saludos")

End Sub

Si ahora lanzásemos la ejecución de lo que tenemos hasta el momento, cosa que se puede hacer desde el módulo

Mod_MisMacros, poniéndonos dentro del código y pulsando F5, veríamos lo siguiente (he movido el UF cerca del

compás para que veamos que se ha mostrado en la ventana de CATIA):

Creación de un gestor de macros (IV)

Siguiendo donde lo dejamos… vemos que en el cuadro de lista se han cargado las dos macros de que disponemos, que

en el cuadro inferior de ayuda, se muestra el valor de la propiedad Caption definida para dicho control, y que el botón

de Ejecutar macro, aparece deshabilitado, que es como lo queremos cuando no tenemos nada seleccionado. Parece

que vamos bien…

Podemos seguir con los eventos pendientes.

Evento al seleccionar una macro (click) de la lista

Cuando seleccionemos una macro de las disponibles en la lista queremos que:

- En la etiqueta inferior aparezca la ayuda relacionada con ella

- Se habilite la posibilidad de lanzar la ejecución de la macro seleccionada

Para programarla, de nuevo, hacemos que sea visible el UF haciendo doble click sobre él en el explorador de proyectos

y, cuando esté visible en el área de edición, hacemos doble click, esta vez sobre el cuadro de lista. Esto nos lleva a la

ventana de código y nos crea la subrutina Private Sub ListBoxMacros_Click() con la cabecera y el final. En medio

tendremos que decirle lo que queremos que haga. El ListBox, dispone de bastantes mas eventos, pero por defecto, nos

propone programar “que pasa al hacar click”. Si quereis investigar, encima de la ventana de codigo hay dos ventanitas.

La primera nos dice en que control estamos programando, la segunda nos dice que evento estamos programando. Si

teneis curiosidad, podeis desplegar la segunda para ver que eventos se pueden programar para el control seleccionado.

No todos los controles reaccionan a los mismos eventos.

Seguimos. Lo primero que haremos es verificar que hay algo seleccionado y, en tal caso, habilitar el botón de ejecutar;

en caso contrario, deshabilitarlo.

If UF_MisMacros.ListBoxMacros.ListCount = 0 Then

UF_MisMacros.Ejecutar.Enabled = False

Else

UF_MisMacros.Ejecutar.Enabled = True

End If

Leeremos también el índice de la línea seleccionada para actuar después en consecuencia. La primera tiene el índice 0 y

la última el número de elementos menos 1 (la numeración no va de 1 a n, sino de 0 a n-1). Con una orden Select,

determinaremos que hacer en función de este índice:

Seleccionada = UF_MisMacros.ListBoxMacros.ListIndex

Select Case Seleccionada

Case 0

UF_MisMacros.LblTip.Caption = "Muestra la versión de CATIA"

Case 1

UF_MisMacros.LblTip.Caption = "Saluda amablemente "

End Select

Y todo junto:

Private Sub ListBoxMacros_Click()

Dim Seleccionada As Integer

If UF_MisMacros.ListBoxMacros.ListCount = 0 Then

UF_MisMacros.Ejecutar.Enabled = False

Else

UF_MisMacros.Ejecutar.Enabled = True

End If

Seleccionada = UF_MisMacros.ListBoxMacros.ListIndex

Select Case Seleccionada

Case 0

UF_MisMacros.LblTip.Caption = "Muestra la versión de CATIA"

Case 1

UF_MisMacros.LblTip.Caption = "Saluda amablemente…”

End Select

End Sub

Si volvemos a ejecutar la macro, podremos comprobar que al seleccionar cada una de las macros, el texto de ayuda

mostrado es el indicado para cada caso en la orden Select Case y que el botón de ejecución se habilita (aún no hace

nada, porque no le hemos explicado que hacer).

Evento de Ejecución de macro seleccionada

Tenemos que decirle ahora a nuestro gestor que es lo que debe hacer cuando hagamos click sobre él. Ya sabemos cómo

programar su evento click:

- Doble click en explorador proyectos sobre UF

- Doble click sobre el control tipo button de ejecutar macro

Aquí vamos a volver a tirar de la propiedad ListIndex del cuadro de lista, que contiene el índice de la selección que

tengamos activada. También utilizaremos una orden Select – Case para, en función de la selección realizada, lanzar una

u otra macro. Para lanzar la macro correspondiente, usaremos la sentencia Call mas el nombre que antes dimos a cada

subrutina (recordemos: VersionCatia y Saludos).

Nos debe quedar algo así:

Private Sub Ejecutar_Click()

Dim EjecutarMacro As Integer

EjecutarMacro = UF_MisMacros.ListBoxMacros.ListIndex

Select Case EjecutarMacro

Case 0

Call VersionCatia

Case 1

Call Saludos

End Select

End Sub

Evento de cierre del formulario

Y solo nos queda gestionar otro evento, que es el de cerrar el gestor al hacer click en el botón Salir. Vamos a editar su

código, de la forma ya sabida. El código será como sigue:

Private Sub Cerrar_Click()

Unload Me

End Sub

El comando Unload, necesita un parámetro que es el nombre del UF a cerrar, pero cuando se cierra a sí mismo, es más

cómodo usar Me. También podríamos haber optado por ocultarlo en vez de descargarlo, pero:

- Seguiría en memoria

- No controlaríamos su inicialización (deberíamos controlar su comportamiento al abrirlo de nuevo mediante el

método actívate)

Pues ya tenemos todo. Solo nos falta probarlo. Lo ejecutamos de nuevo yendo al módulo Mod_MisMacros y,

situándonos en el código de la rutina CATMain (que solo tiene 3 líneas), pulsamos F5. Vamos a ver qué hace si

seleccionamos la primera macro y pulsamos ejecutar:

Vemos que nos dice que versión, reléase y SP tenemos en ejecución en un cuadro de mensaje de texto. Aceptamos y

vamos a probar nuestra segunda macro.

Nos saluda!!!

Probamos ahora el botón de Salir… Y completado.

Creación de un gestor de macros (V)

Ya está creado nuestro gestor de macros. Vamos a ver cuál sería el procedimiento para que vaya “creciendo”.

Como habéis visto, es bastante sencilla la manera de controlarlo. Si quisiéramos añadir una nueva macro solo

tendríamos que:

1. Insertar una nueva línea en la rutina UserForm_Initialize() del tipo:

UF_MisMacros.ListBoxMacros.AddItem ("Título nueva macro”)

Poniendo el título que le quisiéramos dar.

Ojito con donde la ponemos, porque si la insertamos “por ahí en medio”, tendremos que reordenar todos los Select-

Case. Lo mejor es insertarla al final, así el Case de los Select será , el que había al final, mas 1. Si algún día crecen en

exceso las macros, será el momento de plantearse modificar el lanzador para agruparlas por tipo, y seleccionar en una

lista el tipo y en otra lista cargar solo las pertenecientes a ese tipo. También sería conveniente entonces replantearse la

forma de localizar las macros a lanzar con un sistema mejor que “fiarnos” de que hemos puesto todo en orden: carga

del listado, texto de ayuda, rutina a llamar. Se puede complicar bastante su gestión y, sobre todo, cualquier

modificación.

2. En la rutina ListBoxMacros_Click(), deberíamos añadir el nuevo “caso” a la orden Select – Case

3. En la rutina Ejecutar_Click(), tendríamos que añadir la llamada al código de la macro, tal como hayamos

definido su nombre de rutina

Agregar el lanzador a una barra de herramientas

Para evitar tener que ir a Tools Macro cada vez que necesitemos lanzar el programilla, vamos a crear una barra

personalizada y vamos a hacer que esté siempre visible, independientemente del Workbrench en que estemos. El que

sepa hacer esto, se lo tengo que agradecer a Rufus, que me explicó en el foro como lo hizo él.

Lo primero que tenemos que hacer es cerrar todos los documentos que tengamos abiertos en CATIA, hasta que solo

nos quede la pantalla con “las estrellitas”:

Ahora vamos a crear una nueva barra de herramientas. Para ello nos vamos a Tools Customize y seleccionamos la

pestaña Toolbars. Aquí, damos en el botón New…. Y se nos abre una ventanita pidiéndonos el nombre que le queremos

dar a nuestra barra. Yo la he llamado MisMacros. Lo escribimos y aceptamos. Nos crea la nueva barra:

Nuestro siguiente paso, será asignar a la macro principal que hemos creado un icono para visualizarlo en la barra de

MisMacros. Dentro de la ventana de Customize, esta vez nos vamos a la pestaña Commands y en la parte izquierda,

seleccionamos Macros, de forma que a la derecha se nos muestre los nombres de los módulos que tenemos. Haciendo

click en el botón de Show Properties…, nos aparece un campo para poner un Títle (por defecto el nombre del módulo),

y podemos también seleccionar que icono queremos asociar a la macro haciendo click sobre el botón con puntos

suspensivos. Aquí te puedes aburrir buscando cual es el más bonito para tus macros… Yo, dejaré el que ya tiene (la

flecha tipo casette, aunque algunos igual no sabeis lo que eran los casettes…).

Ya podemos cerrar.

El último paso será insertar este comando en nuestra barra de herramientas. Vamos a ello.

Volvemos a la pestaña Toolbars, seleccionamos nuestra barra de herramientas MisMacros y hacemos click en Add

commands… Se nos abre una ventana con todos los posibles comandos, ordenados alfabéticamente, por lo que solo

tenemos que buscar el comando Mod_MisMacros y dar a OK.

Con esto ya hemos configurado el botón de comando de acceso directo a la rutina CATMain del Modulo MIsMacros y lo

hemos incluido en la barra de herramientas MisMacros, por tanto, podemos cerrar la ventana de Customize.

Si ahora nos situamos sobre la zona de barra de herramientas y pulsamos botón derecho, nos debería aparecer entre

las barras disponibles la de MisMacros:

Para dejarla bonita, la podemos poner fija en una zona de barra de herramientas, para que no nos flote en medio de la

zona gráfica.

Solo falta probar el acceso directo… y ver que funciona.

Y con esto, hemos terminado el trabajo. Ahora solo falta llenar de utilidades el gestor para hacernos la vida un poquito

mas cómoda.