MACROS

Índice de contenido
“MACROMÍZAME”............................................................................................................................2
TIPOS DE MACROS...........................................................................................................................2
INCRUSTEMOS UNA MACRO INCRUSTADA: FASE 1................................................................3
INCRUSTEMOS UNA MACRO INCRUSTADA: FASE 2................................................................4
DESNUDANDO LAS ACCIONES DE MACRO...............................................................................4
LAS MACROS “NORMALES”… LAS DE TODA LA VIDA, VAMOS...........................................5
A) SISTEMA TRADICIONAL.......................................................................................................5
B) SISTEMA A TRAVÉS DE MACRO INCRUSTADA................................................................6
TE “MACROMIZO” CON UNA CONDICIÓN….............................................................................6
Y TE CONTROLO Y AVISO CON UNA CONDICIÓN....................................................................8
CREEMOS UN GRUPO PARA UN “MACRO” CONCIERTO.........................................................9
DOS MACROS CURIOSAS..............................................................................................................11
1) AUTOEXEC..............................................................................................................................11
2) AUTOKEYS..............................................................................................................................11
¿MI MACRO EN VBA?....................................................................................................................11
¿MACROS O VBA?..........................................................................................................................12

1
Visítame en http://bit.ly/NckAccess
 “MACROMÍZAME”
Vamos a iniciar un nuevo artículo sobre este objeto tan
interesante como son las macros. La primera pregunta que
nos podemos plantear es: “¿Qué es una macro”. Y la
respuesta inicial podría ser “es un proceso asignado a un
evento de un control u objeto de Access que realiza una o
varias operaciones de carácter automático”. ¿A que ha
quedado bien esta definición? Je, je…

A mí me gusta pensar, utilizando un símil, que las macros son como “el servicio” de una casa
señorial de siglos atrás: tenemos el mayordomo, el asistente de cámara, la cocinera, la
limpiadora, el chófer (no es que quiera ser sexista, pero siglos atrás lo de la “igualdad de
género” no estaba de moda), etc.
Que quiero que preparen la comida, pues llamo a la cocinera. Que quiero que me lleven al
pueblo de al lado, pues llamo al chófer. Que quiero que se me abra un formulario, pues llamo a
la macro que abre un formulario…

Quizá los que sepáis ya qué es y que hace una macro podéis considerar este símil un poco
“tonto”, pero para quien no sepa qué es una macro creo que se ha podido formar una buena
idea de lo que representa una macro.
Pues lo dicho. Vamos a ver algunas cosillas a través de un poco de teoría y un ejemplo. La
base de datos que desarrolla este ejemplo os la podéis bajar aquí.
Todo lo explicado en este artículo está basado en el sistema de macros de Access 2007.
Exceptuando el tema de las macros incrustadas, el resto de explicación es de perfecta
aplicación para Access 2003. El diseño de macros en Access 2010 ha cambiado un poco
respecto del que se explicará aquí, pero, mutatis mutandi (y con un poco de imaginación por
nuestra parte) también se puede aplicar sin demasiados problemas.

Vamos a seguir entonces “macromizando” sobre el tema.

TIPOS DE MACROS
Hasta Access 2003 había un solo tipo de macro, a la que, para distinguirla del otro tipo,
llamaré “normal” a partir de ahora. Esta macro “normal” consistía en definir una serie de
operaciones (o una sola) para automatizar procesos. Hablaremos un poco más adelante con
detalle de estas macros. A estas macros les asignábamos un nombre descriptivo y quedaban
guardadas como objetos en nuestra BD. Con posterioridad íbamos a algún evento, por
ejemplo, de un botón, y “Al hacer click” seleccionábamos la macro que acabábamos de crear.

Desde Access 2007 existe otro tipo de macros, que se denominan “macros incrustadas”. El
proceso para crearlas, a grandes rasgos, es muy simple: creamos el control, por ejemplo, un
botón de comando; seleccionamos un evento y generamos una macro; definimos la operación
u operaciones que debe realizar la macro y… listo.

La macro incrustada queda “incorporada” al control u objeto. Nosotros no podemos “ver” la

macro a través del panel de exploración porque es “exclusiva” para ese control u objeto en el
cual la creamos.

2
Visítame en http://bit.ly/NckAccess
 ¿Qué sistema es mejor? Como siempre, “nada es verdad ni es
mentira: todo depende del color del cristal con que se mira”. Lo
que sí puedo hacer es resumiros un par de detalles que harán que
un sistema sea mejor o peor para vuestras BD’s:

- Si exportamos (o importamos) un objeto (v.gr., un

formulario) a otra BD (o de otra BD), las macros
incrustadas se nos exportarán (o importarán) con él. Si ese
objeto trabaja con macros “normales” deberemos exportar
(o importar) también las macros para que todo nos
funcione correctamente.

- Si tenemos una operación que sea “común” (por ejemplo, abrir siempre la misma consulta) y
que pueda ser ejecutada, por ejemplo, desde varios formularios, lógicamente sólo deberemos
crear una sola macro “normal” y asignarla a los eventos de los diferentes controles; si
queremos una macro incrustada deberemos crearla cada vez en cada control.

- Las macros “normales” pueden convertirse en código VBA, mientras que las incrustadas no.
Si queremos hacer nuestros “pinitos” con programación que una macro pueda convertirse en
código es algo muy útil (como mínimo, para ver cómo quedaría el código de una acción).
A lo largo de este artículo, con lo que expliquemos, podremos ver, por “intuición”, otros
pequeños detalles que nos ayudarán a elegir la mejor tipología de macro para nuestras
aplicaciones.

Ni que decir tiene que, en una misma BD, podemos utilizar simultáneamente ambos sistemas.
No sólo se puede sino que, según lo que queramos hacer, es altamente recomendable.

INCRUSTEMOS UNA MACRO INCRUSTADA: FASE 1

Vamos a crear una BD. En ella crearemos una tabla, a la que llamaremos TTrabajadores, con
los siguientes campos:
[Id] -> Autonumérico

[Nombre] -> Texto

[Apellidos] -> Texto

[NMatricula] -> Número (entero largo)

[FNacimiento] -> Fecha/Hora

Metemos algunos registros en esa tabla, para tener “material de trabajo”.

Creamos un formulario en blanco, al que llamaremos FMenu, que nos servirá como panel de
control.
Creamos un formulario basado en la tabla TTrabajadores, incluyendo todos los campos. A ese
formulario lo llamamos FTrabajadores
Con lo anterior ya podemos crear nuestra primera macro incrustada. Empezaremos por algo
muy simple, que es abrir el formulario FTrabajadores desde FMenu. Para ello debemos hacer lo
siguiente:

1.- Abrimos nuestro formulario FMenu en vista diseño e insertamos un botón de comando.
Sacamos sus propiedades y nos vamos a la pestaña Eventos->Al hacer click. Pulsamos sobre
el botón de puntos suspensivos y, en la pantalla que nos aparece, le decimos que queremos

3
Visítame en http://bit.ly/NckAccess
generar macros.
2.- Se nos abrirá la pantalla con las herramientas de macro.
Podemos observar, en dicha pantalla, dos zonas
diferenciadas: la mitad superior, donde podremos
especificar la acción o acciones a realizar por la macro, con
sus argumentos y comentarios, y la mitad inferior, donde
podremos manipular los argumentos de la acción.
3.- En nuestro caso, seleccionamos la acción: Abrir
formulario. Ahora debemos configurar los argumentos, de
manera que lo hacemos así:

Nombre del formulario: FTrabajadores

Y, en principio, con eso nos basta.

Cerramos la macro a través del botón “Cerrar” que podemos ver en la cinta de opciones, y
guardamos los cambios.

Ahora podemos, con FMenu en vista Formulario, probar nuestro botón, a ver qué pasa.

INCRUSTEMOS UNA MACRO INCRUSTADA: FASE 2

Después del durísimo ejemplo anterior (je, je…) vamos a complicar un poquitín las cosas (pero
no demasiado). Vamos a abrir el formulario FTrabajadores y lo vamos a dejar a punto para la
introducción de un nuevo registro. Esto lo hacemos así:
1.- Añadimos un nuevo botón, que llamaremos cmdAñadeTrabajadores, y, como ya sabemos,
le generaremos una macro.
2.- Hacemos lo mismo que en punto 3 del apartado anterior.

3.- Ahora añadimos una línea de Acción más. La acción que debemos seleccionar es:
IrARegistro. Los argumentos de la acción serán los siguientes:

- Tipo de objeto: Formulario

- Nombre del objeto: FTrabajadores
- Registro: Nuevo
4.- Guardamos y cerramos la macro… ¡y ya tenemos nuestra macro creada!

DESNUDANDO LAS ACCIONES DE MACRO

Como estamos comprobando, trabajar con macros es, en general, un proceso muy intuitivo,
por lo que seguir poniendo ejemplos sería interesante, pero quizá un poco pesado. De todas
maneras hay algunas de las macros que vamos a citar cuyo nombre quizá no nos pueda decir
nada pero que sí tienen una utilidad práctica interesante. De estas sí plantearemos un ejemplo
un poco más adelante.

Vamos a hacer aquí una breve descripción de las acciones más usuales que pueden realizar las
macros, e intentaré poner la misma acción equivalente en código (es decir, cómo se iniciaría el
código VBA sin entrar en más detalles). Vamos allá:
- Abrir xxx: como ya hemos visto, con estas acciones podemos abrir formularios,
consultas, informes… En código esto sería DoCmd.Open…

4
Visítame en http://bit.ly/NckAccess
 - Buscar registro: el código sería DoCdm.FindRecord…
- Cerrar: nos permite cerrar objetos. El código sería DoCmd.Close…

- Cerrar base de datos: el código sería

DoCmd.CloseDatabase

- Cuadro Msj: para mostrar un MsgBox. Lógicamente el

código sería el correspondiente a MsgBox

- Ejecutar macro: nos permite ejecutar otra macro. El

código sería DoCmd.RunMacro… (veremos la utilidad de
esta acción más adelante)
- Encontrar registro: nos permite encontrar un registro que contenga el valor que
deseamos. El código correspondiente sería DoCmd.SearchForRecord…
- Ir a xxx: nos permite ir a un control, una página o registro. El código sería
DoCmd.GoTo…
- Maximizar / Minimizar: el código seria DoCmd.Maximize / DoCmd.Minimize

- Salida hacia: nos permite exportar diversos objetos de Access en el formato que
especifiquemos (y que sea posible, claro). El código sería DoCmd.OutputTo…
- Salir: salimos de la base de datos. El código sería DoCmd.Quit

LAS MACROS “NORMALES”… LAS DE TODA LA VIDA,

VAMOS.
Antes de iniciar la explicación de este breve apartado vamos a crear una consulta
parametrizada (para más información echad una ojeada al artículo sobre consultas) sobre la
tabla TTrabajadores. A la consulta la llamaremos CTrabajadorAñoNac. Para ello:

1.-Añadimos al grid de la consulta todos los campos de la tabla (arrastrando el asterisco que
hay sobre el campo [Id]).

2.- Ahora añadimos en una columna vacía la siguiente expresión (en la primera línea, la de
más arriba, que corresponde a “Campo”):

AñoNac: Year([FNacimiento])
3.- Le desmarcamos el check “Mostrar”

4.- En la línea de criterios añadimos el siguiente parámetro:

>=[“Nacidos después del año…”]

Y ya tenemos nuestra súper consulta preparada.

En Access 2003 tenemos el botoncillo correspondiente para crear una macro. A partir de
Access 2007 tenemos dos sistemas para crear macros “normales”. Vamos a verlo (para Access
2007 y posteriores):

A) SISTEMA TRADICIONAL
1.- Nos vamos al menú Crear->Grupo de opciones “Otros”->Botón Macro. Hacemos click sobre
él.

5
Visítame en http://bit.ly/NckAccess
2.- Nos aparece nuestra conocida ya pantalla para crear macros.
3.- En Acciones buscamos la acción “Abrir consulta”

4.- En los argumentos de la acción ponemos lo siguiente:

- Nombre de la consulta: CTrabajadorAñoNac

- Vista: Hoja de datos

5.- Cerramos la macro y la guardamos como
MTrabajadorAñoNac1
6.- Situamos nuestro formulario FMenu en vista diseño y
añadimos un botón de comando. Cancelamos el asistente.
7.- Nos situamos sobre ese botón de comando y sacamos sus propiedades. Nos vamos a la
pestaña Eventos->Al hacer click y pulsamos la flechita que indica hacia abajo, de manera que
se nos abran las distintas opciones que tenemos.

8.- Ahí veremos que nos aparece nuestra macro recién creada. La seleccionamos. Ahora ya
podemos probar el funcionamiento de nuestro botón.

B) SISTEMA A TRAVÉS DE MACRO INCRUSTADA

Como veremos, prácticamente la sistemática es la misma que en el caso anterior, sólo que
llegamos al resultado final por un camino ligeramente diferente. Arranquemos, pues:

1.- Creamos un botón de comando en nuestro formulario FMenu

2.- Nos situamos sobre el botón y hacemos click con el derecho del mouse. Seleccionamos
“Generar evento…”
3.- En la pantalla que nos aparece le decimos que queremos generar macro

4.- Se nos abre nuestra vieja amiga pantalla de macros. Como en el caso anterior,
seleccionamos la Acción “Abrir consulta” y en los argumentos le decimos que la consulta es
CTrabajadorAñoNac
5.- En la cinta de opciones de macro->Grupo Cerrar, pulsamos el botón “Guardar como…”.

6.- Se nos abre una ventana de diálogo. Ahí le decimos que queremos guardar con el nombre
MTrabajadorAñoNac2 como macro

7.- Cerramos la pantalla de macro y guardamos.

8.- Ahora veremos cómo en el panel de exploración nos aparece nuestra nueva macro.
Podemos probar el botón para ver su “maravilloso” comportamiento.
Cest tout! (no sé si está bien escrito porque no sé francés… je, je…)

TE “MACROMIZO” CON UNA CONDICIÓN…

Las macros aceptan condiciones para poderse ejecutar. Vamos a ver un ejemplo muy sencillo
de cómo podemos condicionar la ejecución de una macro. Lo haremos a través de macro
incrustada, pero el proceso para conseguir una macro “normal” sería exactamente el mismo
que el explicado en el punto B del apartado anterior.
Como siempre, vamos a preparar nuestro terreno:

6
Visítame en http://bit.ly/NckAccess
 1.- En el formulario FMenu en vista diseño añadimos un
cuadro combinado. Cuando nos salga el asistente le
decimos que queremos seleccionar de la tabla
TTrabajadores los campos [Nombre] y [Apellidos].
Acabamos de configurar el asistente a nuestro gusto.
2.- Sacamos las propiedades de ese combo y en la pestaña
Otras->Nombre, le ponemos de nombre cboNomTrab
OK. Ya tenemos nuestro precioso combo. Ahora sí vamos a
trabajar sobre la macro. La idea es que tras seleccionar el
nombre del trabajador nos abra su ficha en sólo lectura
(para no poder modificar los datos). Sin embargo, debemos
asegurarnos de que hay un valor en el combo para evitar
que si borramos el valor del combo, y este queda vacío no
nos presente cada vez un formulario en blanco.

Manos a la obra:
1.- Sacamos las propiedades del combo y nos vamos a la pestaña Eventos->Después de
actualizar…
2.- Como ya sabemos, le decimos que queremos generar macro.

3.- Ahora, en la cinta de opciones, nos vamos al botón “Condiciones” que está en el grupo
“Mostrar u ocultar”. Veremos que se nos añade una primera columna “Condición” a nuestro
generador de macros.
4.- En la primera línea de “Condición” vamos a escribir lo siguiente:

cboNomTrab.Value <> Null

Lo que le decimos en realidad es que la macro debe ejecutarse siempre y cuando el valor del
combo cboNomTrab sea distinto de Nulo, que traducido, lógicamente, significa que siempre
que no esté vacío.

5.- En “Acción” seleccionamos la acción “Abrir formulario”, y en sus argumentos le indicamos

que:

- Nombre del formulario: FTrabajadores

- Modo de datos: Sólo lectura

- Condición WHERE: aquí debemos especificarle lo siguiente:

[Id]=Forms!FMenu.cboNomTrab.Valor

Cerramos guardando y actualizando la macro.

Aunque ya lo he comentado en otros artículos de los objetos de Access, lo vuelvo a repetir
aquí: cuando una tabla contiene clave principal y creamos un combo, aunque no veamos la
clave principal, por defecto el valor que guarda el combo es la clave principal. ¿Por qué digo
eso?
Porque aunque el combo nos permita seleccionar nombre y apellidos del trabajador el valor
que guarda el combo es el valor del campo [Id]. Y eso nos implica que en lo que hemos escrito
en la condición WHERE debe buscar por Id, y no por nombre o apellidos.

Un poco más, teniendo en cuenta lo anterior. Si abrimos el formulario FTrabajadores en vista

diseño podemos ver los campos que tenemos en él. Vemos que el primero es [Id], y es el que

7
Visítame en http://bit.ly/NckAccess
nos interesa porque es el valor que contiene nuestro combo. Cogemos pues ese campo:
[Id] =

¿Dónde está el valor que nos hará de filtro? En

cboNomTrab. ¿Y dónde está el combo cboNomTrab? Pues
en el formulario FMenu. Debemos escribir entonces la
secuencia de ubicaciones, lo que se hace de la siguiente
manera:
Forms!FMenu ->Para decirle que busque en FMenu

cboNomTrab.Value -> Para decirle que busque el valor del combo

cboNomTrab.

Si unimos todo eso ya tenemos la expresión WHERE

[Id] = Forms!FMenu.cboNomTrab.Value

Nota: si nuestros nombres contienen espacios, por ejemplo, si el formulario se llamara “Menu
Principal” y si el combo se llamara “Combo NomTrab”, deberíamos escribir ese nombre entre
corchetes, por lo que la expresión WHERE nos debería quedar así:
[Id] = Forms![Menu Principal].[Combo NomTrab].Value
(por eso suelo escribir los nombres sin espacios, para escribir menos… je, je…)

Y TE CONTROLO Y AVISO CON UNA CONDICIÓN

Vamos a ver cómo podemos controlar las acciones de un usuario a través de la macro. Lo
haremos a través de un ejemplo. Aprovecharemos lo que acabamos de aprender sobre WHERE
para aplicarlo a una consulta, y así podréis comprobar que hay muchas cosas que sirven para
diversos objetos en Access.

Vamos a controlar que el usuario introduzca un valor correcto para seleccionar un año de
nacimiento. Para ello debemos hacer un par de “gestiones” antes de machacar la macro.

1.- En nuestro FMenu insertamos un cuadro de texto, para introducir el año de nacimiento que
queremos filtrar. Una vez tengamos ese cuadro de texto sacamos sus propiedades->Pestaña
Otras->Nombre, y le llamamos txtFNac. Como etiqueta a ese cuadro de texto podemos escribir
“Nacidos después del año:”

2.- Copiamos la consulta CTrabajadorAñoNac y la guardamos con el nombre de

CTrabTxtAñoNac

3.- Abrimos CTrabTxtAñoNac en vista diseño y en el campo parametrizado borramos lo que

tenemos en criterios y ponemos lo siguiente:

>=Forms!FMenu.txtFNac.Value
Y, como veis, acabamos de aplicar lo que hemos aprendido en el apartado anterior, pero a una
consulta. ¿Fácil, no?
4.- De nuevo en nuestro FMenu, al lado de nuestro nuevo cuadro de texto, añadimos un botón
de comando, que nos permitirá ejecutar la consulta.
Bueno, bueno… Vamos a por la macro:

1.- A ese botón de comando le generamos una nueva macro

8
Visítame en http://bit.ly/NckAccess
2.- Mostramos la columna de condiciones
3.- Primero, vamos a comprobar que el usuario haya escrito
un valor en el cuadro de texto. Pero como queremos lanzar
un mensaje de advertencia, escribimos lo siguiente en
“Condición”:
EsNulo([txtFNac].[Valor])

4.- En “Acción” seleccionamos “CuadroMsj”, y configuramos

sus argumentos así:

- Mensaje: No ha escrito ningún año de nacimiento para filtrar

- Tipo: Aviso: ?

- Título: SIN DATOS

Ahora debemos detener la macro si no hay valor. Para ello:

5.- En una segunda línea situamos la misma condición (EsNulo([txtFNac].[Valor]) en

“Condición”, y en Acciones elegimos la acción “DetenerMacro”.

Ahora vamos a controlar las salvajadas que pueda hacer el usuario (que no son pocas).
Evitaremos que el usuario “graciosito” meta una fecha ilógica. Vamos a añadir una tercera
línea y haremos lo siguiente:
6.- En condiciones escribimos lo siguiente:

[txtFNac].[Valor]<1900 O [txtFNac].[Valor]>2000
7.- En Acciones elegimos la acción “CancelarEvento”

8.- Añadimos una cuarta línea y escribimos, en condiciones, puntos suspensivos (es decir,
escribimos tres puntos: …)

9.- En acciones seleccionamos la acción “CuadroMsj” y configuramos sus argumentos asi:

- Mensaje: El año introducido no es correcto

- Tipo: Aviso!
- Título: AÑO INCORRECTO

10.- Añadimos una línea más. En condiciones escribimos la misma condición que en el punto 6
y en Acciones seleccionamos “DetenerMacro”

Y ya tenemos nuestro fantástico control de usuario en la macro.

Ya sólo nos queda ejecutar la acción si todo es correcto. Para ello añadimos otra línea y:

11.- Dejamos el campo condición en blanco. En Acciones elegimos la acción “Abrir consulta”, y
configuramos sus argumentos así:

- Nombre de la consulta: CTrabTxtAñoNac

- Modo de datos: sólo lectura

That’s all, folks!

CREEMOS UN GRUPO PARA UN “MACRO” CONCIERTO

El grupo de macros se suele utilizar, principalmente, para crear un panel de control. Vamos a

9
Visítame en http://bit.ly/NckAccess
preparar el terreno para poder explicar este apartado.
1.- Creamos un formulario en blanco, y lo llamamos FPanel

2.- Creamos dos formularios más en blanco, y los llamamos

F01 y F02

3.- Abrimos FPanel en vista diseño y creamos dos botones

de comando. El primero abrirá, lógicamente, F01, y el
segundo F02
Por ahora ya tenemos la materia prima preparada. Vamos a
por la macro.
1.- Vamos a menú Crear->Grupo Otros->Macro

2.- Hacemos click en el botón de la cinta de opciones “Nombres de Macro”

3.- En la primera fila escribimos, como nombre de macro, F01

4.- En acción seleccionamos “Abrir formulario”, y configuramos el parámetro “Nombre del

formulario” indicándole F01.

Ahora vamos a dejar unas cuantas líneas en blanco. Por ejemplo, yo he dejado dos líneas en
blanco. Esto es por comodidad “visual”, para ver que estamos tratando una macro de grupo y
no una macro “normal” (aunque sea incrustada).
5.- Creamos una nueva línea (la que sería la cuarta contando desde arriba) y, en nombre de
macro, le escribimos F02.
6.- Como acción seleccionamos “Abrir formulario”, y en los argumentos abrimos el formulario
F02.
7.- Cerramos la macro y, al pedirnos un nombre, la llamamos MGrupoPanel

Ya tenemos nuestro grupo de macro configurado. Debemos saber pues que para llamar a una
acción de ese grupo lo debemos indicar con la siguiente sintaxis:

NombreGrupo.nombreMacro
Vamos a acabar de configurar los cambios:
8.- Abrimos FPanel en vista diseño y nos situamos sobre el primer botón. Sacamos sus
propiedades y nos vamos a la pestaña Eventos->Al hacer click.

9.- Si “desplegamos” para ver las posibilidades que tenemos veremos que nos han aparecido
tres nuevas macros, que son:

- MGrupoPanel
- MGrupoPanel.F01

- MGrupoPanel.F02
10.- Como la que nos interesa es MGrupoPanel.F01 esta es la que seleccionamos.

11.- Hacemos exactamente lo mismo con el segundo botón, pero seleccionando

MGrupoPanel.F02

Y ya tenemos nuestro “panel de control” configurado a través de grupos de macros.

10
Visítame en http://bit.ly/NckAccess
 DOS MACROS CURIOSAS
Vamos a explicar dos macros que, desde mi punto de vista,
pueden ser muy interesantes para nuestra aplicación.
Veamos:

1) AUTOEXEC
La palabra Autoexec es una palabra reservada en Access.
Eso significa que si creamos una macro y le ponemos de
nombre Autoexec Access entenderá que esa macro debe
ejecutarse en el momento en que abrimos la BD. Vamos a
ver cómo crear una a través de un ejemplo:
1.- Nos vamos a Menu->Crear->Macro

2.- En acción le seleccionamos la acción “CuadroMsj”, y lo configuramos así:

- Mensaje: Bienvenidos a mi BD

- Título: WELLCOME
3.- Guardamos la macro con el nombre de Autoexec

4.- Si ahora cerramos y volvemos a abrir la BD veremos los “efectos” de nuestros toqueteos.

2) AUTOKEYS
Puede ser que necesitemos que, al pulsar alguna tecla de función (las Fx de, normalmente, la
primera fila superior del teclado). Eso lo podemos conseguir a través de la macro Autokeys.
Veamos un ejemplo. Queremos conseguir que al pulsar F2 se abra el formulario FPanel, y que
al pulsar F3 se abra el formulario FTrabajadores:
1.- Nos vamos a Menu->Crear->Macro

2.- Convertimos esa macro en un grupo de macros a través del botón “Nombres de macro.
3.- Como primer nombre de macro escribimos lo siguiente:
{F2}
4.- Como acción seleccionamos la acción “AbrirFormulario” y, en argumentos, seleccionamos el
formulario FPanel
5.- Añadimos una segunda línea (inmediatamente debajo de la primera) y escribimos, como
nombre de macro:
{F3}

6.- Y seleccionamos la acción que nos abre el formulario FTrabajadores.

7.- Cerramos la macro y la guardamos como Autokeys

Si ahora pulsamos F2 ó F3 veremos los maravillosos efectos de nuestra nueva macro.

¿MI MACRO EN VBA?

Con las macros incrustadas no podemos hacer lo que explicaremos a continuación, pero sí con

11
Visítame en http://bit.ly/NckAccess
las macros “normales”. Es decir, que lo que vamos a hacer ahora es “pasar” las acciones de la
macro a Visual Basic.

Truco: este es un recurso muy útil si estamos

programando en VBA y no tenemos muy claro cómo se
programa una acción. Simplemente creamos una macro, la
convertimos a VB y copiamos-pegamos ese código donde
nos interese. Así, podemos dejar el código como está o
podemos realizar nuestras siempre afortunadas
“manipulaciones” de código… je, je…
Vamos a ver cómo hacemos eso:

1.- Utilizaremos la macro que ya tenemos y que hemos llamado MTrabajadorAñoNac1. Para
pasarla a VBA la seleccionamos con un click esa macro en el panel de exploración, de manera
que nos quede resaltada.
2.- Nos vamos a menú->Herramientas de la Base de Datos. El primer botón de la izquierda, de
la cinta de opciones, es “Visual Basic”. A su derecha hay tres pequeños botones. Debemos
seleccionar el botoncillo de más abajo (si dejamos el puntero del mouse sobre él nos saldrá un
mensaje emergente que nos indica “Convertir macros a Visual Basic”).
3.- Nos sale una ventana que nos indica dos opciones. Estas opciones, con su descripción,
están bastante claras. Dejamos los dos check marcados y pulsamos “Convertir”
4.- Se nos abrirá el editor de VB (VBE). En la ventana proyecto veremos, dentro de la carpeta
Módulos, un nuevo módulo que pone “Macro convertida-...”.
5.- Si hacemos doble click sobre ese módulo veremos cómo es nuestra macro en código VBA.

Y se acabó con el proceso.

¿MACROS O VBA?
Si me permitís voy a filosofar (muy brevemente) sobre qué es mejor, si utilizar macros o
utilizar código.

Evidentemente, si no sabemos VBA, la pregunta no tiene sentido.

Las macros son herramientas altamente útiles para conseguir muchísimas acciones para
nuestra BD, y su funcionamiento, una vez se le ha cogido “el tranquillo”, es bastante intuitivo,
por lo que son una vía muy útil para gestionar nuestra BD. Ahora bien, si lo que tenemos que
realizar acciones muy complicadas, cálculos “extremos”, etc., definitivamente las macros se
quedan algo “cortas”.

Quizá para alguien que aprenda VBA lo ideal sería utilizar una mezcla de ambos sistemas, de
manera que programar las macros le sirva de base para aprender cosas nuevas de código (tal
y como comentábamos en el truco del apartado anterior).
Cuando ya se controla medianamente bien VBA la verdad es que las macros suelen quedar en
el olvido.
Personalmente yo siempre utilizo código, a no ser que deba programar alguna aplicación muy
muy simple, en cuyo caso, para no “complicarme” la existencia, utilizo las macros.
En definitiva, que parece que la respuesta viene dada por la “evolución” de nuestros
conocimientos en relación a VBA.

12
Visítame en http://bit.ly/NckAccess
Finalmente, si queréis saber lo que opina el gran “profesional” Microsoft, podéis echarle un
vistazo a esta página:

http://office.microsoft.com/es-mx/access-
help/introduccion-a-la-programacion-en-access-
HA001214213.aspx?CTT=1#BMwhenusewhat
Espero que hayáis podido sacar alguna cosa útil de este
artículo.
¡Suerte!

---FIN DEL ARTÍCULO---

13
Visítame en http://bit.ly/NckAccess