Trabajando con eventos

Esta página está en estado borrador.

Hemos llegado a un tema medular en la programación con OOo, la que responde a la importante pregunta, ¿cuando queremos que se ejecuten nuestras macros?

En este capítulo trataremos de dar respuesta a esta pregunta, para ello, saber que en estos dos últimos temas pondremos en practica la mayoría conocimientos vistos hasta ahora, los repasaremos y confirmaremos, por eso, recomiendo fehacientemente que si tienes alguna duda en algún tema, lo repases con calma y si aun hay dudas, usa las listas de correo o el foro para resolverlas, pero es importante, que no tengas dudas hasta aquí.

A los eventos, también se les conoce como sucesos, nosotros usaremos el nombre de evento, por ser el que se usa en OOo. Los primeros eventos que aprenderemos, son los relacionados con la aplicación, es decir, con el programa completo.

Eventos de la aplicación

Agrega la siguiente macro al archivo especial Mis Macros, es importante que quede en este archivo para que trabaje correctamente.

 Sub IniciarAplicacion()
 
     MsgBox "Hola, bienvenido a OOo"
 
 End Sub

Ahora, ve al menú Ver > Barra de herramientas > Personalizar... En el cuadro de diálogo Personalizar, selecciona la ficha Eventos (1), selecciona el evento Comenzar Aplicación (2), da un clic en el botón de comando Macro... (3).

En el cuadro de diálogo Selector de macros, selecciona Mis Macros (1), después la librería (2) donde hayas creado el modulo (3) con la macro (4), selecciona la macro y por ultimo da un clic en el botón de comando Aceptar (5).

El cuadro de diálogo Selector de macros se cerrará y veras de nuevo, el de Personalizar, en donde puedes ver la como hemos asignado la macro seleccionada al evento deseado (1). Asegúrate de que, esta asignación, quede guardada en OpenOffice.org (2). En este cuadro de diálogo, también puedes eliminar cualquier asignación establecida, con el botón de comando Eliminar (3). Para finalizar, da clic en el botón de comando Aceptar (4).

Guarda y cierra todos los archivos abiertos que tengas de OpenOffice.org, incluyendo el entorno de desarrollo (IDE) si es que lo tienes abierto, inmediatamente después, abre cualquier aplicación del mismo. Tienes que ver.

Nota que el mensaje solo aparece una vez cuando abres la primer aplicación, esto es, por que OpenOffice.org, es un contenedor de las demás aplicaciones. Cuando trabajes con eventos, es muy importante que tengas muy claro que puedes y que no puedes hacer, para ir aclarando este concepto tan importante, modifica la macro para que quede de la siguiente manera.

 Sub IniciarAplicacion()
 
     MsgBox "Hola, bienvenido a OOo"
 
     MsgBox ThisComponent.dbg_properties
 
 End Sub

De nuevo, cierra todo (recuerda que todo incluye al IDE), y vuelve a abrir Calc o cualquier aplicación de OpenOffice.org. Después de ver el primer mensaje de bienvenida, tienes que ver el siguiente mensaje.

Como ya hemos aprendido en estas notas, ThisComponent apunta al archivo desde donde se llama a la macro, pero en este caso, nos dice desconocido (Unknown), por que aun no tenemos ningún archivo en memoria. Prueba a ejecutar la macro, ya estando abierta cualquier aplicación o archivo para que veas la diferencia de mensaje que te muestra.

Vuelve a modificar la macro para que quede de la siguiente manera.

 Sub IniciarAplicacion()
 
     MsgBox "Hola, bienvenido a OOo"
 
     MsgBox ThisComponent.dbg_properties
 
     MsgBox StarDesktop.dbg_properties
 
 End Sub

Una vez más, cierra todo y abre tu aplicación favorita. Ahora, en el tercer mensaje, tienes que ver las propiedades del objeto StarDesktop. ¿Y para que podría servir ejecutar una macro al inicio de la aplicación?, esta pregunta podría tener muchas respuestas, todo dependerá de tus necesidades, como por ejemplo, abrir algún archivo (o archivos) necesarios para tu trabajo.

 Sub IniciarAplicacion()
 Dim sRuta As String
 Dim oDoc As Object
 Dim mArg()
 
     'Reemplaza esta ruta por la de tu archivo
     sRuta = ConvertToUrl( "/home/mau/Utilerias.ods" )
     oDoc = StarDesktop.loadComponentFromURL( sRuta, "_blank", 0, mArg() )    
 
 End Sub

O llevar un registro de uso en un simple archivo de texto.

 Sub IniciarAplicacion()
 Dim sRuta As String
 Dim sInfo As String
 Dim iLibre As Integer
 
     sInfo = "OpenOffice.org se ejecutó el día " & Format(Date, "ddd, dd-mmm-yy") & " a las " & Format(Now, "HH:mm:ss") 
     sRuta = ConvertToUrl("/home/mau/registro.log")
     'Si el archivo no existe se crea
     iLibre = FreeFile
     Open sRuta For Append As #iLibre
     Print #iLibre, sInfo
     Close #iLibre
 
 End Sub

Recuperar datos de tu Internet o de Internet, asegurarte de que existan archivos indispensables, pueden ser otras útiles formas de asignar una macro al inicio de la aplicación, de nuevo, tus necesidades serán tus rectoras al respecto.

Ahora, veamos el segundo evento de la lista; Cerrar aplicación, para ello, asigna la siguiente macro a este evento, asegurándote de guardar esta asignación en OpenOffice.org.

 Sub CerrarAplicacion()
 
     MsgBox "Cerrando aplicación"
 
 End Sub

Para ver el mensaje, cierra todo, incluyendo el IDE, al cerrar el ultimo archivo o aplicación abierta, tienes que ver dicho mensaje. Este evento lo puedes usar para cerrar conexiones a recursos externos, o para complementar el registro de actividad, solo como ejemplos de muchas posibilidades.

 Sub CerrarAplicacion()
 Dim sRuta As String
 Dim sInfo As String
 Dim iLibre As Integer
 
     sInfo = "OpenOffice.org se cerró el día " & Format(Date, "ddd, dd-mmm-yy") & " a las " & Format(Now, "HH:mm:ss") 
     sRuta = ConvertToUrl("/home/mau/registro.log")
     'Si el archivo no existe sé crea
     iLibre = FreeFile
     Open sRuta For Append As #iLibre
     Print #iLibre, sInfo
     Close #iLibre    
 
 End Sub

Al siguiente evento Crear documento, asígnale la siguiente macro, de nuevo, cuidando de que quede guardada la asignación en OpenOffice.org.

 Sub CrearDocumento()
 
     MsgBox "Se ha creado un nuevo documento"
 
 End Sub

Prueba a crear nuevos documentos de la aplicación que quieras, en todos tienes que ver el mensaje de la macro, incluso, en los nuevos documentos que se crean por código. Ahora, prueba la siguiente variante de la macro.

 Sub CrearDocumento()
 
     'MsgBox "Se ha creado un nuevo documento"
     MsgBox ThisComponent.getTitle
 
 End Sub

Nota que hemos deshabilitado la primer línea y agregado otra. Esta vez, tienes que ver correctamente el nombre del nuevo documento creado. Con lo que estamos seguros de que la variable ThisComponent, realmente apunta al nuevo documento creado, con lo cual, podemos controlar lo que queramos hacer con él.

Nuestro siguiente evento se llama Abrir documento, aquí la macro para asociar.

 Sub AbrirDocumento()
 
     MsgBox "Se ha abierto un documento"
 
 End Sub

Con estos dos últimos eventos vistos, ya no es necesario cerrar todo, así que es fácil probarlos. Creo que la diferencia entre ellos es clara, uno solo se desencadena, cuando se crean documentos nuevos y el otro, solo al abrir documentos existentes, incluso, cuando se crean o abren por código. Modifica la macro anterior para que quede así.

 Sub AbrirDocumento()
 
     'MsgBox "Se ha abierto un documento"
     MsgBox ThisComponent.getTitle
 
 End Sub

Al abrir documentos, veras el nombre de este, con lo cual, comprobamos que en este evento, también podemos tener control sobre los archivos abiertos.

Pero este evento puede tener una variante interesante, copia la siguiente macro.

 Sub AbrirEsteDocumento()
 
     MsgBox "Esta macro solo se ejecuta, cuando se abre este archivo: " & ThisComponent.getTitle
 
 End Sub

Y asóciala con el evento Abrir documento (1), pero, esta vez no guardes esta asignación en OpenOffice.org, si no en algún documento existente, en mi caso, la guardo en el archivo OooBasicEventos.ods (2), como te muestro a continuación.

Cierra y abre el archivo donde hayas hecho la asignación, tienes que ver dos mensajes en pantalla, el primero, es de la macro asociada al evento Abrir documento con la asignación guardada en OpenOffice.org.

El segundo, es el mensaje asociado al mismo evento; Abrir documento, pero de la asignación guardada en dicho archivo.

Abre más archivos para que notes la diferencia. Reescribe la macro asociada al documento para que quede de la siguiente manera.

 Sub AbrirEsteDocumento()
 Dim oCelda As Object
 
     'MsgBox "Esta macro solo se ejecuta, cuando se abre este archivo: " & ThisComponent.getTitle
     'Referencia a la celda A1 de la primer hoja del documento
     oCelda = ThisComponent.getSheets.getByIndex(0).getCellByPosition(0,0)
     'Aumentamos en uno el valor de dicha celda
     oCelda.setValue( oCelda.getValue() + 1 )
 
 End Sub

El ejemplo anterior, es una muestra sencilla de lo que podemos hacer asignando macros a los eventos. El criterio para guardar la asignación, en OpenOffice.org o dentro de un documento, estará, casi siempre, determinada por tus necesidades y dominio del lenguaje, pero sobre todo, por tu criterio, el cual, te recomiendo, debe estar enfocado, sustentado, guiado, por las necesidades de los usuarios finales de tu aplicación, no, de las del programador, así como por las posibilidades (y limitaciones) del lenguaje y entorno de desarrollo. Si guardas la asignación de la macro en un documento, también puedes tener la macro en dicho documento, pero, dependiendo de tus necesidades, a veces será conveniente y a veces no, lo cual tienes que evaluar y determinar en su momento.

Regresa a la macro del evento Abrir documento, la que su asignación la hemos guardado en OpenOffice.org y reescríbela de la siguiente forma.

 Sub AbrirDocumento( Event )
 
     'MsgBox "Se ha abierto un documento"
     'MsgBox ThisComponent.getTitle
     MsgBox Event.Source.getTitle
 
 End Sub

Pruébala y nota que obtenemos el mismo resultado de la línea inmediata anterior (comentada en esta versión de la macro), con la diferencia, de que hemos accedido al objeto de una nueva forma. Todas las macros que se asignan a eventos, cuentan con un argumento (Event), que, puede o no ir, pero si existe, a través este argumento puedes acceder al objeto (Source) que desencadeno el evento, esto, es una forma muy versátil de trabajar con macros y eventos, como lo iremos demostrando en las siguientes líneas. El nombre de este argumento, realmente puede ser cualquier palabra válida como nombre de variable, pero es un estándar de facto, usar el nombre de Event, aunque nada te impide llamarlo Evento si así es tu gusto.

Veamos el siguiente evento que se llama Guardar documento como. Asigna la siguiente macro a este evento y guarda esta asignación en OpenOffice.org.

 Sub GuardarDocumentoComo( Evento )
 
     MsgBox "Se desencadenó el evento Guardar Documento Como en el archivo: " & Evento.Source.getTitle
 
 End Sub

Observa como hemos usado la palabra Evento para el argumento y este sigue funcionando correctamente. El mensaje que tienes que ver, incluirá el nombre del archivo original antes de guardarse. Veamos inmediatamente el siguiente evento, que es muy ilustrativo del orden de los eventos. Asigna la siguiente macro al evento; El documento se ha guardado como y guarda la asignación en OpenOffice.org.

 Sub ElDocumentoSeHaGuardadoComo( Evento )
 
     MsgBox "Se desencadenó el evento El Documento Se Ha Guardado Como, el archivo se guardó con el nombre: " & Evento.Source.getTitle
 
 End Sub

Guarda cualquier archivo nuevo o existente, usando el menú Archivo > Guardar como..., las macros anteriores asignadas a sus respectivos eventos, te tienen que mostrar el nombre del archivo original y el nombre del archivo nuevo. El primer evento se desencadena antes de guardar definitivamente el archivo, y el segundo evento, cuando ya el archivo fue guardado correctamente. Si el usuario, en el cuadro de diálogo para seleccionar el nuevo nombre del archivo, selecciona cancelar la operación, ninguno de estos dos eventos se ejecutara. Estos dos eventos, también los puedes asignar y guardar en un documento, puedes incluso, asignar y guardar tanto en OpenOffice.org como en el documento, pero toma en cuenta que si haces esto, se ejecutarán dos veces cada evento, lo cual, puede o no ser correcto, de nuevo, dependiendo de tus necesidades.

Los dos eventos siguientes, son similares a estos últimos, con la diferencia, de que se desencadenan simplemente al guardar un archivo ya existente. Asigna la siguiente macro al evento; Guardar documento y guarda su asignación donde quieras.

 Sub GuardarDocumento( Evento ) 
 
     MsgBox "El documento " & Evento.Source.getTitle & " se va a guardar"
 
 End Sub

Y la siguiente macro, asígnala al evento; El documento se ha guardado

 Sub ElDocumentoSeHaGuardado( Evento ) 
 
     MsgBox "El documento " & Evento.Source.getTitle & " se guardó correctamente"
 
 End Sub

Si guardaste la asignación en OpenOffice.org, veras el nombre de cada archivo que guardes, y si la guardaste en un documento, siempre verás el nombre del mismo archivo. Nota que un evento se desencadena antes de guardar y el otro después de guardar.

Los dos siguiente eventos, se desencadenan al cerrar un documento. El evento Cerrar documento se ejecuta primero.

 Sub CerrarDocumento( Evento )
 
     MsgBox "El documento " & Evento.Source.getTitle & " se va a cerrar"
 
 End Sub

Y después el evento El documento se esta cerrando.

 Sub ElDocumentoSeEstaCerrando( Evento )
 
     MsgBox "El documento " & Evento.Source.getTitle & " se cerró correctamente"
 
 End Sub

Aunque por los nombres, parecería que se ejecuta primero el segundo, no es así. En el evento El documento se esta cerrando, no es recomendable hacer manipulaciones del documento, pues este, ya estará cerrado.

El siguiente evento se llama Activar documento, cuya macro de prueba para ver su funcionamiento es la siguiente, asígnala a este evento y guárdala en OpenOffice.org.

 Sub ActivarDocumento( Evento )
 
     MsgBox "Se activo el documento: " & Evento.Source.getTitle
 
 End Sub

Cambia entre documentos abiertos y te mostrará el mensaje, pero, si creas nuevos documentos o abres archivos existentes y no has desactivado las macros de los eventos Abrir documento o Crear documento, notarás que, aparentemente, ya no se ejecuta el evento, pues no te muestra el mensaje de estos, si no solo el del evento Activar documento, esto no significa que los demás eventos se desactiven, para probarlo, modifícalos de modo que queden así.

Para el evento Crear documento

 Sub CrearDocumento( Evento )
 
     Call GuardarInfo ( Evento )
 
 End Sub

Para el evento Abrir documento

 Sub AbrirDocumento( Evento )
 
     Call GuardarInfo ( Evento )
 
 End Sub

Para el evento Activar documento

 Sub ActivarDocumento( Evento )
 
     Call GuardarInfo ( Evento )
 
 End Sub

Y la macro para guardar la información.

 Sub GuardarInfo( Evento )
 Dim sRuta As String
 Dim sInfo As String
 Dim iLibre As Integer
 
     sInfo = "Documento: " & Evento.Source.getTitle & ", Evento: " & Evento.EventName & ", " & Format(Date, "ddd, dd-mmm-yy") & " - " & Format(Now, "HH:mm:ss") 
     sRuta = ConvertToUrl("/home/mau/registro.log")
     'Si el archivo no existe se crea
     iLibre = FreeFile
     Open sRuta For Append As #iLibre
     Print #iLibre, sInfo
     Close #iLibre
 End Sub

Crea un nuevo documento y abre un nuevo documento, después, abre el archivo de registro, donde tienes que ver algo similar a:

Documento: Sin título 3, Evento: OnFocus, mar, 13-oct-09 - 11:58:17 
Documento: Sin título 3, Evento: OnNew, mar, 13-oct-09 - 11:58:17 
Documento: Origen.ods, Evento: OnFocus, mar, 13-oct-09 - 11:58:24 
Documento: Origen.ods, Evento: OnLoad, mar, 13-oct-09 - 11:58:24

Nota como primero se llama al evento Activar documento (OnFocus) y después al evento Crear documento (OnNew) para el caso de documentos nuevos y para documentos existentes, también se llama primero al evento Activar documento (OnFocus) y después al evento Abrir documento (OnLoad), una diferencia entre estos eventos, es que los eventos Crear documento (OnNew) y Abrir documento (OnLoad), solo se ejecutan una vez y el evento Activar documento (OnFocus), se ejecuta cada vez que el usuario cambia de archivo.

Nuestro siguiente evento, nos servirá, también, para ilustrar el orden en que se llaman a los eventos, asigna la siguiente macro al evento Desactivar documento guardando esta asociación en OpenOffice.org.

 Sub DesActivarDocumento( Evento )
 
     Call GuardarInfo ( Evento )
 
 End Sub

Y modifica también los siguiente eventos; Cerrar documento y El documento se esta cerrando, de modo que queden así.

 Sub CerrarDocumento( Evento )
 
     Call GuardarInfo ( Evento )
 
 End Sub
 
 
 Sub ElDocumentoSeEstaCerrando( Evento )
 
     Call GuardarInfo ( Evento )
 
 End Sub

Dependiendo del orden en que actives o desactives tus archivos, en tu registro se verá algo así.

Documento: Sin título 3, Evento: OnUnfocus, mar, 13-oct-09 - 12:38:03 
Documento: Sin título 2, Evento: OnFocus, mar, 13-oct-09 - 12:38:03 
Documento: Sin título 2, Evento: OnUnfocus, mar, 13-oct-09 - 12:38:04 
Documento: Sin título 3, Evento: OnFocus, mar, 13-oct-09 – 12:38:04 

Observa como se alterna entre los eventos Activar documento (OnFocus) y Desactivar documento (OnUnfocus) de los archivos, para el caso de cerrar el archivo.

Documento: Origen.ods, Evento: OnPrepareUnload, mar, 13-oct-09 - 12:38:18 
Documento: Origen.ods, Evento: OnUnload, mar, 13-oct-09 – 12:38:18 
Documento: Sin título 2, Evento: OnFocus, mar, 13-oct-09 - 12:38:18

Observa que primero se ejecuta el evento Cerrar documento (OnPrepareUnload) y después el evento El documento se esta cerrando (OnUnload), aquí los nombres confunden un poco. Observa como, no se ejecuta el evento Desactivar documento (OnUnfocus) del archivo que se esta cerrando, si no que pasa directamente al evento activar (OnFocus) del siguiente archivo abierto.

Nuestro siguiente evento es Imprimir documento, este evento se ejecuta antes de enviar la impresión. Asigna la siguiente macro a este evento.

 Sub ImprimirDocumento( Evento )
 
     Call GuardarInfo( Evento )
 
 End Sub

Que mostrará en nuestro registro, así que no te podrán decir que no imprimieron el documento, ¿verdad?.

Documento: Sin título 2, Evento: OnPrint, mar, 13-oct-09 – 13:24:24

Por ultimo, el evento Se ha cambiado el estado 'Modificado', cuya macro de prueba es la siguiente, guárdala en OpenOffice.org.

 Sub DocumentoModificado( Evento )
 
     Call GuardarInfo( Evento )
 
 End Sub

Antes de ver el registro, al documento activo, hazle algunos cambios, puedes incluso cambiar de documento, vuelve de nuevo al documento y guárdalo, debes de ver algo similar en tu registro.

Documento: OOoBasicEventos.ods, Evento: OnModifyChanged, mar, 13-oct-09 - 14:02:19 
Documento: OOoBasicEventos.ods, Evento: OnUnfocus, mar, 13-oct-09 - 14:02:48 
Documento: OOoBasicEventos.ods, Evento: OnFocus, mar, 13-oct-09 - 14:02:49 
Documento: OOoBasicEventos.ods, Evento: OnModifyChanged, mar, 13-oct-09 - 14:03:02

Este evento (OnModifyChanged) solo se ejecuta cuando modificamos un documento, pero ojo, solo con la primer modificación, y vuelve a llamarse, cuando guardamos el documento.

Usar un archivo de registro, aparte de saber que fue lo que hizo el usuario, es muy útil para depurar una macro, cuando trabajes con eventos, es mejor usar un archivo de registro para saber que valores toman las variables en las macros, que usar el observador del IDE, o usar el método MsgBox.

Nota como tenemos una macro para casi todo los eventos, esto realmente no es muy usual, pero no descartes que un día lo necesites, también, considera que si guardas las asignaciones en OpenOffice.org, los eventos responderán a todos los documentos de todas las aplicaciones presentes en OpenOffice.org.

Asignando eventos en controles

Los formularios y sus controles, los puedes asociar a bases de datos, y automatizar muchas tareas sin una línea de código, pero para ilustrar el uso de eventos y macros asociadas a estos, por ahora, omitiremos esta capacidad de enlazarse con bases de datos y trataremos de asignar código para todas las tareas. Los controles tienen muchos eventos en común, compartidos, la mayoría, con los controles de cuadros de diálogo, veremos los más usuales de ellos, tratando de ir ilustrando su uso en unos y en otros, que reitero, es muy similar.

Lo primero que aprenderemos, es donde asociar los eventos de los controles a nuestras macros, ya que todos se asignan de la misma manera, solo veremos el primero, tanto en los formularios como en los cuadros de diálogo, después, solo indicaremos que macro va en cada evento.

Agrega un control de formulario a tu hoja de calculo, el que quieras. Para nuestro ejemplo, hemos agregado un botón de comando (CommandButton) (1), asegúrate de que este seleccionado (solo en tiempo de diseño) y da un clic en el icono Control (2) de la barra de herramientas Campos de control de formulario, como lo ilustramos en la siguiente imagen.

Otra forma de lograr lo mismo, es a través del menú contextual del control.

Cualquiera de las dos formas anteriores, te mostrará el cuadro de diálogo Propiedades del control, que ya hemos usado, pero ahora, tienes que seleccionar la ficha Acontecimientos (1), que te mostrará los eventos (2) que soporta el control seleccionado y el icono de asignación de macro (3) para cada uno.

Selecciona el icono de asignación de macro, que te mostrará el siguiente cuadro de diálogo. De forma predeterminada, estará seleccionado el evento que hayas seleccionado en el cuadro de diálogo anterior, pero aquí puedes cambiar a otro (1) si quieres, pero ojo, compara esta lista de eventos con la del cuadro de diálogo anterior, observa que los nombres son similares, no iguales, pero están en el mismo orden, trataré de mostrarte los dos nombres cuando haga referencia a ellos. Selecciona el evento que quieras y da un clic en el botón de comando Macro (2) como se ve en la siguiente imagen.

Tienes que ver el cuadro de diálogo Selector de macros que ya conoces. Tienes que seleccionar el archivo con el modulo (1), donde este la macro (2) que asignaremos al evento seleccionado, da un clic en el botón de comando Aceptar (3) para hacer la asignación.

La acción anterior te regresará al cuadro de diálogo Asignar acción, pero ahora tienes que ver la asociación respectiva de evento y macro (1). Solo te resta, dar clic en el botón de comando Aceptar (2).

Regresando al nuestro primero cuadro de diálogo, donde de nuevo, tienes que ver la asignación de la macro correcta en el evento correcto (1). Para terminar, solo cierra el cuadro de diálogo.

Recuerda que para que los controles respondan a las macros asignadas a sus eventos, tienes que pasar a modo ejecución, como aprendimos en el capítulo anterior.

Ahora veamos como se asigna macros a los eventos de los controles en cuadros de diálogo. Para ello, agrega un cuadro de diálogo a tu archivo desde el IDE, puedes agregar un control o seleccionar directamente el cuadro de diálogo. Después, selecciona el icono Propiedades (1) del cuadro de herramientas.

Si lo prefieres, puedes usar el menú contextual sobre el control seleccionado, donde te mostrará como primera opción Propiedades.

Esta acción te mostrará el cuadro de diálogo Propiedades, el mismo visto unas líneas atrás, donde también tienes que seleccionar la ficha Acontecimientos (eventos). Todos los subsiguientes pasos, son los mismos aprendidos en los formularios.

Principales eventos en controles

La mayoría de los controles implementan los mismos eventos. Lo importante es que sepas cuando sucede un evento, cuando es llamado para interceptarlo y codificar lo necesario para cumplir el propósito de tu aplicación.

También, aunque muchos eventos son soportados por un control, no es común escribir código en ellos, por ejemplo, las etiquetas (Label) implementan el evento Botón del ratón pulsado – Clic de ratón, pero no es común usarlo, casi siempre, este control es usado como un control estático o solo para mostrar información, pero claro, puedes usarlo, si así lo consideras. Otro ejemplo de este caso, son los controles cuadros de texto (TextBox), este control también implementa el evento Botón del ratón pulsado – Clic de ratón, pero no es muy común establecer código en el evento de este control, de nuevo, tu criterio y experiencia decidirá.

Vamos a trabajar sobre formularios y cuadros de diálogo, puedes usar el archivo que quieras, pero pon atención en los controles que vamos agregando, pues los vamos a ir usando conforme conozcamos los diferentes eventos.

Evento Botón del ratón pulsado – Clic de ratón

Este evento sucede cuando el usuario pulsa un botón del ratón, el botón que sea. Creo que es uno de los eventos más usados. Como curiosidad; ¿te imaginas cuantos clics, se han dado desde que se invento el primero ratón?. Agrega un etiqueta (Label) al formulario y asigna la siguiente macro a este evento.

 Sub Evento_Clic( Evento )
 Dim oControl As Object
 
     'Accedemos al modelo del control
     oControl = Evento.Source.getModel
     'Establecemos la fecha y hora actual, en la propiedad Titulo
     oControl.Label = Now
 
 End Sub

Nota que no necesitamos saber el nombre del control, pues accedemos a el, desde el mismo evento (Evento.Source). Una posibilidad muy interesante de la asignación de eventos en controles, es que podemos asignar la misma macro, a todos los controles que queramos, prueba a asignar esta misma macro a, por ejemplo, un botón de opción (OptionButton) y veras que también funciona, esto es posible, por que este control, también cuenta con la propiedad Titulo (Label), así que esta macro, funcionara con cualquier control que cuente con esta propiedad.

Para nuestro siguiente ejemplo, es necesario que agregues un cuadro de diálogo a tu archivo y un botón de comando (CommandButton) al formulario, a este ultimo, asigna la siguiente macro al evento que estamos estudiando.

 Sub MostrarDialogo()
 Dim oDialogo As Object
 
     DialogLibraries.LoadLibrary( "Standard" )
     oDialogo = CreateUnoDialog( DialogLibraries.Standard.getByName("Dialogo") )
     oDialogo.execute()
     oDialogo.dispose()
 
 End Sub

Ahora, agrega una etiqueta (Label) al cuadro de dialogo y asigna la misma macro asignada a nuestra etiqueta (Label) en el formulario. Pruébala y verifica que funcione como se espera, es decir, que te muestre la fecha y hora actual. Si todo va bien hasta ahora, debes de tener una etiqueta y un botón de comando en el formulario, con el que mostramos el cuadro de diálogo con su respectiva etiqueta.

Al principio, mencionamos que este evento es llamado cuando se presiona un botón del ratón, el que sea, pero podemos saber que botón presiono el usuario de la siguiente manera. Para este ejemplo, necesitamos un nuevo botón de comando (CommandButton) y un control de imagen (ImageControl) en el formulario, así como tres imágenes que te gusten, localizadas en una ruta accesible. Al botón de comando, asigna la siguiente macro al evento que estamos estudiando.

 Sub MostrarImagen( Evento )
 Dim sRuta(2) As String
 dim oFormulario As Object
 Dim oImagen As Object
 
     'Las rutas de ubicación de las imágenes
     sRuta(0) = ConvertToUrl("/home/mau/imagen1.jpg")
     sRuta(1) = ConvertToUrl("/home/mau/imagen2.jpg")
     sRuta(2) = ConvertToUrl("/home/mau/imagen3.jpg")
 
     'Accedemos al formulario
     oFormulario = Evento.Source.getModel.getParent()
     'El control de imagen
     oImagen = oFormulario.getByName("imgImagen")
 
     'Evaluamos que botón fue pulsado
     Select Case Evento.Buttons
         Case 1        'Botón izquierdo
             oImagen.ImageURL = sRuta(0)
         Case 2        'Botón derecho
             oImagen.ImageURL = sRuta(1)
         Case 4        'Botón central
             oImagen.ImageURL = sRuta(2)
     End Select
 
 End Sub

Observa como hemos hecho referencia al formulario, a través del control que llama al evento (Evento.Source.getModel.getParent), también observa que el nombre de la macro no tiene por que llevar la palabra evento, puedes llamarla como quieras, siempre que cumpla los requisitos del lenguaje. La forma de hacer referencia al formulario, es válida, si el control al que queremos hacer referencia esta en el mismo formulario, si no esta en el mismo formulario, tienes que usar la forma larga aprendida en capítulos anteriores.

oFormulario = ThisComponent.getCurrentController.getActiveSheet.getDrawPage.getForms.getByName( "Standard" ) 

Si quieres hacer lo mismo en controles de cuadros de diálogo, la forma de acceder a estos cambia, como se ve en el siguiente código.

Option Explicit
Dim oDialogo As Object

 Sub MostrarImagen( Evento )
 Dim sRuta(2) As String
 Dim oImagen As Object
 
     'Las rutas de ubicación de las imágenes
     sRuta(0) = ConvertToUrl("/home/mau/imagen1.jpg")
     sRuta(1) = ConvertToUrl("/home/mau/imagen2.jpg")
     sRuta(2) = ConvertToUrl("/home/mau/imagen3.jpg")
 
     'El control de imagen
     oImagen = oDialogo.getControl("imgImagen").getModel()    
 
     'Evaluamos que botón fue pulsado
     Select Case Evento.Buttons
         Case 1        'Botón izquierdo
             oImagen.ImageURL = sRuta(0)
         Case 2        'Botón derecho
             oImagen.ImageURL = sRuta(1)
         Case 4        'Botón central
             oImagen.ImageURL = sRuta(2)
     End Select
 
 End Sub
 
 
 Sub MostrarDialogo()
     DialogLibraries.LoadLibrary( "Standard" )
     oDialogo = CreateUnoDialog( DialogLibraries.Standard.getByName("Dialogo") )
     oDialogo.execute()
     oDialogo.dispose()
 End Sub

Observa que la variable para hacer referencia al cuadro de diálogo (oDialogo), la hemos quitado de la macro MostrarDialogo y la hemos puesto a nivel modulo, esto nos permite hacer referencia a esta variable, desde otras macros, como ya lo hemos aprendido. Cuidado, la macro MostrarImagen asignada al formulario y al cuadro de diálogo, ya no son la misma, las he escrito en módulos diferentes, por ello pueden tener el mismo nombre.

Evento Botón del ratón soltado

Este evento es casi igual al anterior, excepto por que es llamado, cuando el usuario suelta el botón del ratón. Para este ejemplo usaremos el control de imagen que ya tenemos y dos de las misma imágenes usadas en el ejemplo anterior. Asigna al evento Botón del ratón pulsado (Clic de ratón) la macro Imagen_Clic y al evento Botón del ratón soltado (Al soltar el botón del ratón) la macro Imagen_Soltar_Clic, que te muestro aquí.

 Sub Imagen_Clic( Evento )
 Dim sRuta(0) As String
 dim oFormulario As Object
 Dim oImagen As Object
 
     'Las rutas de ubicación de las imágenes
     sRuta(0) = ConvertToUrl("/home/mau/imagen2.jpg")
 
     'Accedemos al formulario
     oFormulario = Evento.Source.getModel.getParent()        
     'El control de imagen
     oImagen = oFormulario.getByName("imgImagen")
     'Cambiamos la imagen
     oImagen.ImageURL = sRuta(0)
 
 End Sub
 
 
 Sub Imagen_Soltar_Clic( Evento )
 Dim sRuta(0) As String
 dim oFormulario As Object
 Dim oImagen As Object
 
     'Las rutas de ubicación de las imágenes
     sRuta(0) = ConvertToUrl("/home/mau/imagen1.jpg")
 
     'Accedemos al formulario
     oFormulario = Evento.Source.getModel.getParent()        
     'El control de imagen
     oImagen = oFormulario.getByName("imgImagen")
     'Cambiamos la imagen
     oImagen.ImageURL = sRuta(0)
 
 End Sub

Presiona cualquier botón del ratón sobre el control de imagen, la imagen tiene que cambiar, pero ojo, mantén presionado el botón unos segundos, después suéltalo, la imagen debe de cambiar. Trata de hacer esto mismo con controles de cuadro de diálogo.

En este evento, también puedes saber que botón presionó el usuario, usando la misma técnica del ejemplo anterior.

OOo Basic no implementa el evento Doble_Clic, pero puedes emularlo con una propiedad de este evento, de la siguiente manera.

 Sub Emular_Doble_Clic( Evento )
 
     'Evaluamos el número de clics
     If Evento.ClickCount = 2 Then
         MsgBox "Doble clic"
     End If
 
 End Sub

Esta técnica la puedes usar en cualquiera de los dos eventos vistos hasta ahora. Es importante, a la hora de asignar una macro a un evento, que consideres las propiedades de este, es decir, si asocias esta macro a otro evento, por ejemplo, alguno del teclado, los cuales no implementa esta propiedad, el código te producirá un error.

El siguiente ejemplo combina el uso del clic y del doble clic, para esto, agrega un nuevo botón de comando (CommandButton), dos cuadros de lista (ListBox) y usaremos la etiqueta ya agregada. La asociación de eventos y macros en los controles es el siguiente.

Control	Nombre	Eventos	Macros
Botón de comando	cmdDatos	Botón del ratón pulsado	cmdDatos_Clic
Cuadro de lista	lstCuadroLista1	Botón del ratón pulsado Botón del ratón soltado	Lista_Clic Lista_Doble_Clic
Cuadro de lista	lstCuadroLista2	Botón del ratón pulsado Botón del ratón soltado	Lista_Clic Lista_Doble_Clic

Y las macros respectivas.

 Sub cmdDatos_Clic( Evento )
 Dim oFormulario As Object
 Dim oLista1 As Object
 Dim oLista2 As Object
 Dim mDatos()
 
     oFormulario = Evento.Source.getModel.getParent()        
     oLista1 = oFormulario.getByName("lstCuadroLista1")
     oLista2 = oFormulario.getByName("lstCuadroLista2")
     'Vaciamos el segundo cuadro de lista
     oLista2.StringItemList = mDatos()
     mDatos = Array("Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre")
     'Llenamos con datos el primero
     oLista1.StringItemList = mDatos()
 
 End Sub
 
 
 Sub Lista_Clic( Evento )
 Dim oFormulario As Object
 Dim oEtiqueta As Object
 
     oFormulario = Evento.Source.getModel.getParent()        
     oEtiqueta = oFormulario.getByName("lblInfo")
     'Mostramos en la etiqueta el elemento seleccionado
     oEtiqueta.Label = Evento.Source.getSelectedItem
 
 End Sub
 
 
 Sub Lista_Doble_Clic( Evento )
 Dim oFormulario As Object
 Dim oDestino As Object
 Dim oDestinoVista As Object
 
     'Si hay dos clic y hay elemento seleccionado
     If Evento.ClickCount = 2 And ( Evento.Source.getSelectedItemPos > -1 ) Then
         oFormulario = Evento.Source.getModel.getParent()
         'El destino será el control que NO este llamando al evento
         If Evento.Source.getModel.Name = "lstCuadroLista1" Then
             oDestino = oFormulario.getByName("lstCuadroLista2")
         Else
             oDestino = oFormulario.getByName("lstCuadroLista1")
         End If
         'Accedemos a la vista del control destino
         oDestinoVista = ThisComponent.getCurrentController.getControl( oDestino )
         'Agregamos el elemento seleccionado del origen al destino
         oDestinoVista.addItem( Evento.Source.getSelectedItem, oDestinoVista.getItemCount )
         'Quitamos el elemento seleccionado del origen
         Evento.Source.removeItems( Evento.Source.getSelectedItemPos, 1 )
     End If
 
 End Sub

Observa que en la macro Lista_Doble_Clic, tenemos que acceder a la vista del control destino a través del controlador (getCurrentController) del documento, pero para el control que llamo al evento no es necesario, pues de forma predeterminada, esta en su modo vista. En la primer macro (cmdDatos_Clic), solo iniciamos los valores de los cuadros de lista, el primero lo llenamos con los meses del año y el segundo solo lo vaciamos. En la segunda macro (Lista_Clic), cada vez que el usuario selecciona un elemento de cualquiera de los dos cuadros de lista, el elemento seleccionado se muestra en la etiqueta (Label) lblInfo, y la tercer macro (Lista_Doble_Clic), mueve el valor seleccionado de un cuadro de lista al otro. Tus controles tienes que verse más o menos así.

La propiedad que cuenta los clics (ClickCount) del ratón en este evento, puede ir aumentando a mucho más que dos, mientras otro evento no lo detenga o hasta que se te canse el dedo de dar clic. Para lograr lo mismo en un cuadro de diálogo, solo tienes que considerar el modo diferente en que se hace referencia a los controles, que es a través de la variable a nivel de modulo que apunta al cuadro de diálogo, las propiedades y el algoritmo deben de funcionar igual.

Evento Ratón dentro – Puntero encima

Este evento se ejecuta, cuando el ratón entra, se posiciona dentro del cualquier área del control que lo llama. Asigna la siguiente macro a este evento de una nueva etiqueta.

 Sub Raton_Entra( Evento )
 
     'Cambiamos de color el fondo del control
     Evento.Source.getModel.BackgroundColor = RGB(Rnd*255,Rnd*255,Rnd*255)
     'Quitamos la leyenda del control
     Evento.Source.getModel.Label = ""
 
 End Sub

Este evento solo se ejecuta una vez al entrar el ratón en el control.

Evento Ratón fuera – Puntero fuera

Este evento es el contrario del anterior, se ejecuta al salir el ratón del control. Asigna la siguiente macro a la misma etiqueta usada en el evento anterior.

 Sub Raton_Sale( Evento )
 
     'Cambiamos el color y el texto de la etiqueta
     Evento.Source.getModel.BackgroundColor = RGB(255,255,255)
     Evento.Source.getModel.Label = "Mueve el ratón sobre mi"
 
 End Sub

Este evento también se ejecuta solo una vez.

Evento Movimiento del ratón

Este evento es llamado mientras el cursor del ratón este dentro del control y este en movimiento. Puedes usar la misma etiqueta o agregar una nueva para la siguiente macro, que tienes que asignar a este evento. También usaremos la primer etiqueta que agregamos (lblInfo) para mostrar información de este evento.

 Sub Raton_En_Movimiento( Evento )
 Dim oFormulario As Object
 Dim oEtiqueta As Object
 
     'Cambiamos de color el fondo del control
     Evento.Source.getModel.BackgroundColor = RGB(Rnd*255,Rnd*255,Rnd*255)
     oFormulario = Evento.Source.getModel.getParent()        
     oEtiqueta = oFormulario.getByName("lblInfo")
     'Mostramos la posición del ratón dentro del control
     oEtiqueta.Label = "X = " & Evento.X & " : " & "Y = " & Evento.Y
 
 End Sub

Mira que interesante (y divertido), podemos mostrar la ubicación del cursor del ratón a través de sus coordenadas X-Y, dentro del control que llama a este evento.

El siguiente ejemplo, toma el ancho, el alto y la diagonal del control y de acuerdo a estos valores, establece proporcionalmente el valor para el rojo, el verde y el azul del color de fondo del control.

 Sub Color_RGB( Evento )
 Dim oFormulario As Object
 Dim oEtiqueta As Object
 Dim Ancho As Integer
 Dim Alto As Integer
 Dim Rojo As Integer
 Dim Verde As Integer
 Dim Azul As Integer
 
     'Obtenemos el ancho y alto del control
     Ancho = Evento.Source.getSize.Width
     Alto = Evento.Source.getSize.Height
 
     'Obtenemos la proporción de cada color
     Rojo = Evento.X / (Ancho / 255)
     Verde = Evento.Y / (Alto / 255)
     Azul = Sqr( Evento.Y ^ 2 + Evento.X ^ 2 ) / ( Sqr( Alto ^ 2 + Ancho ^ 2 ) / 255)
 
     'Establecemos los colores
     Evento.Source.getModel.BackgroundColor = RGB( Rojo, Verde, Azul)
     oFormulario = Evento.Source.getModel.getParent()        
     oEtiqueta = oFormulario.getByName("lblInfo")
 
     'Mostramos la información
     oEtiqueta.Label = "Rojo = " & Rojo & " : Verde = " & Verde & " : Azul = " & Azul
 
 End Sub

Con esta macro, logramos cambiar el color de fondo del control, de acuerdo a la posición del cursor del ratón dentro de él. Para el valor del color azul, proporcional a la diagonal del control, viene en nuestra ayuda Don Pitágoras y su famoso teorema.

Prueba a realizar este ejercicio, pero usando botones de selección, también puedes usar barras de desplazamiento o un control numérico para establecer el valor de los colores.

Evento Mover ratón por medio del teclado - Movimiento de ratón con tecla pulsada

Este evento es similar al anterior, pero solo es llamado cuando alguna de las siguientes teclas esta presionada: MAYÚSCULAS, CTRL o ALT. Agrega una nueva etiqueta y asigna la siguiente macro a este evento.

 Sub Mover_Con_TeclaPulsada( Evento )
 Dim oFormulario As Object
 Dim oEtiqueta As Object
 Dim Ancho As Integer
 Dim Color As Long
 Dim Rojo As Integer
 Dim Verde As Integer
 Dim Azul As Integer
 
     'Obtenemos el ancho y alto del control
     Ancho = Evento.Source.getSize.Width
 
     'Obtenemos la proporción actual de cada color
     Color = Evento.Source.getModel.BackgroundColor
     Rojo = Int( Color / 65536 ) And 255 
     Verde = Int( Color / 256 ) And 255
     Azul = Color And 255 
 
     'Establecemos los colores, solo modificamos el color de acuerdo a la tecla especial seleccionada
     Select Case Evento.Modifiers
         Case 1
             Rojo = Evento.X / (Ancho / 255)
             Evento.Source.getModel.BackgroundColor = RGB( Rojo, Verde, Azul)
         Case 2
             Verde = Evento.X / (Ancho / 255)
             Evento.Source.getModel.BackgroundColor = RGB( Rojo, Verde, Azul)
         Case 4
             Azul = Evento.X / (Ancho / 255)
             Evento.Source.getModel.BackgroundColor = RGB( Rojo, Verde, Azul)
     End Select
     oFormulario = Evento.Source.getModel.getParent()        
     oEtiqueta = oFormulario.getByName("lblInfo")
     oEtiqueta.Label = "Rojo = " & Rojo & " : Verde = " & Verde & " : Azul = " & Azul 
 
 End Sub

Tomamos el ancho del control como unidad de medida, que va desde 0 en el extremo izquierdo a 255 al extremo derecho. Tomamos el valor actual de cada color y solo cambiamos el color de acuerdo a la tecla pulsada, MAYÚSCULAS para el rojo, CTRL para el verde y ALT para el azul. Los valores de las teclas (Modifiers) están determinados por las siguientes constantes.

com.sun.star.awt.KeyModifier	Valor	Valor en Interfaz
com.sun.star.awt.KeyModifier.SHIFT	1	Tecla MAYÚSCULAS
com.sun.star.awt.KeyModifier.MOD1	2	Tecla CTRL
com.sun.star.awt.KeyModifier.MOD2	4	Tecla ALT

Puedes sumar estos valores para saber si hay más de una tecla pulsada.

Evento Recepción de foco - Al activar área

Este evento es llamado cuando el control recibe el foco, es decir, cuando el cursor pasa a el por medio de teclado o ratón o incluso por medio de código. Para nuestro ejemplo agrega un nuevo control de cuadro de texto (TextBox) y establece un texto predeterminado en el, después, asigna la siguiente macro a este evento.

 Sub PonerColor( Evento )
 
     'Cambiamos el color de fondo y de fuente
     With Evento.Source.getModel
         .BackgroundColor = RGB( 255, 255, 153)
         .TextColor = RGB( 0, 0, 200)
     End With
 
 End Sub

Cuando el cursor entre en este control, el color de fondo y fuente cambiara, esto es útil para indicarle visualmente al usuario en que control esta el foco, por supuesto, hay que cambiar estos colores cuando el foco cambie de control, como lo demostramos en el siguiente evento.

Evento Al perder el foco - Al desactivar área

Este evento es el inverso del anterior, es llamado cuando el cursor sale del control. Al mismo control cuadro de texto (TextBox) agregado en nuestro evento anterior, asigna la siguiente macro.

 Sub QuitarColor( Evento )
 
     'Cambiamos el color de fondo y de fuente
     With Evento.Source.getModel
         .BackgroundColor = RGB( 255, 255, 255)
         .TextColor = RGB( 0, 0, 0)
     End With
 
 End Sub

Cuando el foco sale del control, establecemos los colores predeterminados, blanco para el fondo del control y negro para la fuente, estas macros las puedes asignar a los eventos de cualquier control que pueda recibir el foco y que implemente estas propiedades. Agrega unos cuantos cuadro de texto (TextBox) y asigna las mismas macros para que veas su uso.

Ten cuidado cuando manejes eventos de foco, la primer precaución es usar las propiedades correctas cuando estés codificando, un error te puede provocar un ciclo infinito, por que el IDE trata de mostrarte el mensaje de error, pero al mostrarlo, el control sigue respondiendo a estos eventos lo que provoca que no puedas corregirlo sin forzar la salida de OpenOffice.org. Un error similar lo puede provocar una lógica errónea cuando mueves el foco por código.

El control que tiene el foco, resalta de los demás. Te aseguro que más de un usuario te lo agradecerá. Algunos programadores usan este evento para hacer la validación del contenido, bien estructurado, no deberías tener problemas, por ejemplo.

    'Evaluamos si es un número
    If Not IsNumeric( Evento.Source.getModel.Text ) Then
        MsgBox "El contenido no es un número"
        'Si no es, regresamos el foco al control
        Evento.Source.setFocus()
    End If

Solo debes de tener precaución de no cruzar eventos que provoquen ciclos infinitos, esto suele pasar mucho cuando uno es novel y se agregan demasiados controladores de eventos a un mismo control sin una técnica depurada.

Otros programadores prefieren hacer una sola validación global de todos los datos introducidos por el usuario, no importa que técnica uses, lo que si es muy importante, es que nunca, reitero, nunca dejes de validar los datos que introduce el usuario y notificarle de un modo suficientemente visible que es lo que esta mal y por que, he visto, no pocos grandes proyectos, obviar tan elemental tarea.

Evento Tecla pulsada

Este evento es llamado cuando el usuario pulsa una tecla del teclado. A un control cuadro de texto (TextBox), asigna la siguiente macro a este evento.

 Sub Tecla_Pulsada( Evento )
 Dim oFormulario As Object
 Dim oEtiqueta As Object
 
     oFormulario = Evento.Source.getModel.getParent()        
     oEtiqueta = oFormulario.getByName("lblInfo")
     'Mostramos el ultimo caracter introducido y su código
     oEtiqueta.Label = Evento.KeyChar & " = " & Evento.KeyCode
 
 End Sub

Si algún carácter, requiere una combinación de teclas, este evento solo es llamado una vez, por ejemplo, para las letras acentuadas, si mantienes presionada una tecla, este evento será llamado una y otra vez hasta que sueltes la tecla y de acuerdo a la configuración de velocidad de repetición de tu teclado. La primero propiedad (KeyChar) te muestra el carácter tal cual se ve en la interfaz del usuario, si vez solo un símbolo como este: □ es que se presionó una tecla que no tiene representación visual, la segunda propiedad (KeyCode), es el código de la tecla pulsada, de acuerdo a las siguientes constantes.

com.sun.star.awt.Key	Valor	Tecla
com.sun.star.awt.Key.NUM0	256	0
com.sun.star.awt.Key.NUM1	257	1
com.sun.star.awt.Key.NUM2	258	2
com.sun.star.awt.Key.NUM3	259	3
com.sun.star.awt.Key.NUM4	260	4
com.sun.star.awt.Key.NUM5	261	5
com.sun.star.awt.Key.NUM6	262	6
com.sun.star.awt.Key.NUM7	263	7
com.sun.star.awt.Key.NUM8	264	8
com.sun.star.awt.Key.NUM9	265	9
com.sun.star.awt.Key.A	512	A
com.sun.star.awt.Key.B	513	B
com.sun.star.awt.Key.C	514	C
com.sun.star.awt.Key.D	515	D
com.sun.star.awt.Key.E	516	E
com.sun.star.awt.Key.F	517	F
com.sun.star.awt.Key.G	518	G
com.sun.star.awt.Key.H	519	H
com.sun.star.awt.Key.I	520	I
com.sun.star.awt.Key.J	521	J
com.sun.star.awt.Key.K	522	K
com.sun.star.awt.Key.L	523	L
com.sun.star.awt.Key.M	524	M
com.sun.star.awt.Key.N	525	N
com.sun.star.awt.Key.O	526	O
com.sun.star.awt.Key.P	527	P
com.sun.star.awt.Key.Q	528	Q
com.sun.star.awt.Key.R	529	R
com.sun.star.awt.Key.S	530	S
com.sun.star.awt.Key.T	531	T
com.sun.star.awt.Key.U	532	U
com.sun.star.awt.Key.V	533	V
com.sun.star.awt.Key.W	534	W
com.sun.star.awt.Key.X	535	X
com.sun.star.awt.Key.Y	536	Y
com.sun.star.awt.Key.Z	537	Z
com.sun.star.awt.Key.F1	768	F1
com.sun.star.awt.Key.F2	769	F2
com.sun.star.awt.Key.F3	770	F3
com.sun.star.awt.Key.F4	771	F4
com.sun.star.awt.Key.F5	772	F5
com.sun.star.awt.Key.F6	773	F6
com.sun.star.awt.Key.F7	774	F7
com.sun.star.awt.Key.F8	775	F8
com.sun.star.awt.Key.F9	776	F9
com.sun.star.awt.Key.F10	777	F10
com.sun.star.awt.Key.F11	778	F11
com.sun.star.awt.Key.F12	779	F12
com.sun.star.awt.Key.F13	780
com.sun.star.awt.Key.F14	781
com.sun.star.awt.Key.F15	782
com.sun.star.awt.Key.F16	783
com.sun.star.awt.Key.F17	784
com.sun.star.awt.Key.F18	785
com.sun.star.awt.Key.F19	786
com.sun.star.awt.Key.F20	787
com.sun.star.awt.Key.F21	788
com.sun.star.awt.Key.F22	789
com.sun.star.awt.Key.F23	790
com.sun.star.awt.Key.F24	791
com.sun.star.awt.Key.F25	792
com.sun.star.awt.Key.F26	793
com.sun.star.awt.Key.DOWN	1024	↓
com.sun.star.awt.Key.UP	1025	↑
com.sun.star.awt.Key.LEFT	1026	←
com.sun.star.awt.Key.RIGHT	1027	→
com.sun.star.awt.Key.HOME	1028	Inicio
com.sun.star.awt.Key.END	1029	Fin
com.sun.star.awt.Key.PAGEUP	1030	RePag
com.sun.star.awt.Key.PAGEDOWN	1031	AvPag
com.sun.star.awt.Key.RETURN	1280	↵ Enter
com.sun.star.awt.Key.ESCAPE	1281	Esc
com.sun.star.awt.Key.TAB	1282	Tab ⇆
com.sun.star.awt.Key.BACKSPACE	1283	← Backspace  (Retroceso)
com.sun.star.awt.Key.SPACE	1284	SPACE  (Barra espaciadora)
com.sun.star.awt.Key.INSERT	1285	Insert
com.sun.star.awt.Key.DELETE	1286	Supr
com.sun.star.awt.Key.ADD	1287	+
com.sun.star.awt.Key.SUBTRACT	1288	-
com.sun.star.awt.Key.MULTIPLY	1289	*
com.sun.star.awt.Key.DIVIDE	1290	/
com.sun.star.awt.Key.POINT	1291	.  (Punto)
com.sun.star.awt.Key.COMMA	1292	,
com.sun.star.awt.Key.LESS	1293	<
com.sun.star.awt.Key.GREATER	1294	>
com.sun.star.awt.Key.EQUAL	1295	=
com.sun.star.awt.Key.OPEN	1296
com.sun.star.awt.Key.CUT	1297
com.sun.star.awt.Key.COPY	1298
com.sun.star.awt.Key.PASTE	1299
com.sun.star.awt.Key.UNDO	1300
com.sun.star.awt.Key.REPEAT	1301
com.sun.star.awt.Key.FIND	1302
com.sun.star.awt.Key.PROPERTIES	1303
com.sun.star.awt.Key.FRONT	1304
com.sun.star.awt.Key.CONTEXTMENU	1305
com.sun.star.awt.Key.HELP	1306
com.sun.star.awt.Key.MENU	1307
com.sun.star.awt.Key.HANGUL_HANJA	1308
com.sun.star.awt.Key.DECIMAL	1309	.  (Punto decimal)
com.sun.star.awt.Key.TILDE	1310
com.sun.star.awt.Key.QUOTELEFT	1311
com.sun.star.awt.Key.DELETE_TO_BEGIN_OF_LINE	1536
com.sun.star.awt.Key.DELETE_TO_END_OF_LINE	1537
com.sun.star.awt.Key.DELETE_TO_BEGIN_OF_PARAGRAPH	1538
com.sun.star.awt.Key.DELETE_TO_END_OF_PARAGRAPH	1539
com.sun.star.awt.Key.DELETE_WORD_BACKWARD	1540
com.sun.star.awt.Key.DELETE_WORD_FORWARD	1541
com.sun.star.awt.Key.INSERT_LINEBREAK	1542
com.sun.star.awt.Key.INSERT_PARAGRAPH	1543
com.sun.star.awt.Key.MOVE_WORD_BACKWARD	1544
com.sun.star.awt.Key.MOVE_WORD_FORWARD	1545
com.sun.star.awt.Key.MOVE_TO_BEGIN_OF_LINE	1546
com.sun.star.awt.Key.MOVE_TO_END_OF_LINE	1547
com.sun.star.awt.Key.MOVE_TO_BEGIN_OF_PARAGRAPH	1548
com.sun.star.awt.Key.MOVE_TO_END_OF_PARAGRAPH	1549
com.sun.star.awt.Key.SELECT_BACKWARD	1550
com.sun.star.awt.Key.SELECT_FORWARD	1551
com.sun.star.awt.Key.SELECT_WORD_BACKWARD	1552
com.sun.star.awt.Key.SELECT_WORD_FORWARD	1553
com.sun.star.awt.Key.SELECT_WORD	1554
com.sun.star.awt.Key.SELECT_LINE	1555
com.sun.star.awt.Key.SELECT_PARAGRAPH	1556
com.sun.star.awt.Key.SELECT_ALL	1557
com.sun.star.awt.Key.SELECT_TO_BEGIN_OF_LINE	1558
com.sun.star.awt.Key.SELECT_TO_END_OF_LINE	1559
com.sun.star.awt.Key.MOVE_TO_BEGIN_OF_DOCUMENT	1560
com.sun.star.awt.Key.MOVE_TO_END_OF_DOCUMENT	1561
com.sun.star.awt.Key.SELECT_TO_BEGIN_OF_DOCUMENT	1562
com.sun.star.awt.Key.SELECT_TO_END_OF_DOCUMENT	1563
com.sun.star.awt.Key.SELECT_TO_BEGIN_OF_PARAGRAPH	1564
com.sun.star.awt.Key.SELECT_TO_END_OF_PARAGRAPH	1565

Una tecla tendrá el mismo código (KeyCode), no importa si esta en minúsculas, mayúsculas o acentuadas pues el código se refiere a la tecla física del teclado, pero en la propiedad KeyChar, tendrás el carácter tal cual en pantalla. Si la tecla no es reconocida, KeyCode siempre será cero. Si presionas una tecla o una combinación de teclas que use OpenOffice.org, generalmente este responderá a ella, por ejemplo  F1 , que te mostrará la ayuda. Puedes saber si el usuario presiono una combinación de teclas, consultando la propiedad Modifiers, como lo demostramos en el siguiente evento en donde se comparten las mismas propiedades.

Evento Después de haber pulsado la tecla - Tecla soltada

Este evento es llamado cuando el usuario suelta la tecla, pero cuidado, podríamos pensar que este evento se ejecuta solo una vez al soltar la tecla, pero no es así, si mantienes presionada la tecla, este evento será llamado, también, una y otra vez, esto es, por que OOo Basic, reconoce cada carácter que se introduce con la repetición como si fuera una pulsación de tecla independiente. Por ello, cuando mantienes presionada una tecla, estos eventos son llamados alternativamente, considéralo al escribir tu código. Asigna la siguiente macro a este evento de un nuevo cuadro de texto.

 Sub Tecla_Soltada( Evento )
 Dim oFormulario As Object
 Dim oEtiqueta As Object
 Dim sInfo As String
 
     oFormulario = Evento.Source.getModel.getParent()        
     oEtiqueta = oFormulario.getByName("lblInfo")
 
     Select Case Evento.KeyCode
         'Teclas sin representación visual
         Case 768 : sinfo = "F1"
         Case 769 : sinfo = "F2" 
         Case 770 : sinfo = "F3" 
         Case 771 : sinfo = "F4" 
         Case 772 : sinfo = "F5" 
         Case 773 : sinfo = "F6" 
         Case 774 : sinfo = "F7" 
         Case 775 : sinfo = "F8" 
         Case 776 : sinfo = "F9" 
         Case 777 : sinfo = "F10" 
         Case 778 : sinfo = "F11" 
         Case 779 : sinfo = "F12" 
         Case 1024 : sinfo = "Flecha abajo"
         Case 1025 : sinfo = "Flecha arriba" 
         Case 1026 : sinfo = "Flecha izquierda" 
         Case 1027 : sinfo = "Flecha derecha"
         Case 1028 : sinfo = "Inicio"
         Case 1029 : sinfo = "Fin"
         Case 1030 : sinfo = "RePag"
         Case 1031 : sinfo = "AvPag"
         Case 1280 : sinfo = "Enter"
         Case 1281 : sinfo = "Esc"
         Case 1282 : sinfo = "Tab"
         Case 1283 : sinfo = "Retroceso"
         Case 1284 : sinfo = "Espacio"
         Case 1285 : sinfo = "Insertar"
         Case 1286 : sinfo = "Suprimir"
         'Todas las demás
         Case Else : sInfo = Evento.KeyChar
     End Select
 
     'Si presiono alguna tecla especial
     Select Case Evento.Modifiers
         Case 1 : sInfo = "Shift + " & sInfo
         Case 2 : sInfo = "Ctrl + " & sInfo
         Case 4 : sInfo = "Alt + " & sInfo
     End Select    
 
     sInfo = sInfo & " : " & Evento.KeyCode
     oEtiqueta.Label = sInfo
 
 End Sub

Recuerda que las teclas especiales (Modifiers), son susceptibles de sumarse, es decir, el usuario puede pulsar más de una y esta propiedad nos lo informará, modifica la macro anterior para considerar esto.

Otros eventos

Todos los eventos vistos hasta ahora, son compartidos por todos los controles, pero hay algunos que solo están disponibles para algunos controles.

El evento Al ejecutar - Al iniciar, responde de manera similar al evento Botón de ratón pulsado, pero tiene la particularidad de que no cuenta con propiedades para saber si se presionó alguna tecla (Modifiers) o botón del ratón (Buttons), por lo que solo es llamado con el botón primario del ratón. Si no usaras estos argumentos, este evento puede ser una buena opción para los botones de comando.

El evento Modificado, es llamado cuando el contenido de un control cambia, dependiendo del control se puede desencadenar de diferentes formas, por ejemplo, si es un cuadro de lista, con solo cambiar de selección entre su contenido, este evento es llamado, pero si es un cuadro de texto, este evento solo es llamado al perder el foco el control y solo si el contenido de este cambio.

El evento Estado modificado - Estado de elemento modificado, es llamado cuando en un control cuadro de lista, cambia el elemento seleccionado.

El evento Texto modificado, responde a cualquier control que tenga área de edición de texto, con cualquier cambio en su contenido y cada vez que se cambie, este evento es llamado.

Hay que tener cuidado con el uso de estos tres últimos eventos. Un error frecuente es modificar el contenido del control en estos eventos, con lo que corremos el riesgo de caer en un ciclo infinito, úsalos con precaución y moderación.

Si tienes dudas acerca de lo aquí explicado, tienes algún problema con AOO, o quieres ampliar la información, no dudes en dirigirte al Foro Oficial en español de Apache OpenOffice para Macros y API UNO