Documentos de Académico
Documentos de Profesional
Documentos de Cultura
CAPÍTULO 31
Índice de contenido
MÓDULOS DE OBJETO, CONTROLES Y EVENTOS....................................................................2
MÓDULOS DE OBJETO...............................................................................................................2
EVENTOS.......................................................................................................................................2
CONTROLES..................................................................................................................................5
“MIX” DE LOS ANTERIORES CONCEPTOS.............................................................................5
LA FUNCIÓN MSGBOX....................................................................................................................7
LANZAR UN MENSAJE...............................................................................................................7
SALTOS DE LÍNEA EN MENSAJE..............................................................................................8
LANZAR MENSAJE Y ESPERAR RESPUESTA DE UN USUARIO.........................................9
LA FUNCIÓN INPUTBOX...............................................................................................................11
DETECTAR LA PULSACIÓN DEL BOTÓN <CANCELAR>...................................................13
OTROS “CONTROLES” PARA QUE NO NOS FALLE EL INPUTBOX..................................14
DETECTAR VALORES VACÍOS............................................................................................14
DETECTAR VALORES DE DIFERENTE TIPO....................................................................14
NORMALIZACIÓN..........................................................................................................................16
NOMBRES DE OBJETOS............................................................................................................16
NOMBRES DE CONTROLES.....................................................................................................17
NOMBRES DE VARIABLES.......................................................................................................17
¿Y POR QUÉ LOS PREFIJOS?....................................................................................................17
MÁS INFORMACIÓN SOBRE NORMALIZACIÓN.................................................................18
1 Los ejemplos propuestos en este capítulo están en una BD que os podéis bajar aquí
1
Visítame en http://bit.ly/NckAccess
MÓDULOS DE OBJETO, CONTROLES Y EVENTOS
MÓDULOS DE OBJETO
Quizá lo lógico en un curso de VBA sería empezar a explicar,
llegados a este punto, lo que se denominan “bloques de
decisión”. Sin embargo, nos vamos a separar de lo
“ortodoxo” para entrar en unas explicaciones que nos
proporcionaran una base “experimental” para posteriores
contenidos. De hecho, si este curso está enfocado a Access,
es entendible, creo yo, que lo hagamos así.
Como apuntamos en el capítulo en el que hablábamos de tipos de módulos, vamos a tratar
ahora esos módulos que se hallan asociados a un objeto de Access, en concreto módulos
asociados a formularios e informes.
Para poder ir entendiendo lo que se va a explicar vamos a ir “viéndolo” al mismo tiempo que lo
leemos. Lo que vamos a hacer es crear una base de datos. Una vez creada vamos a crear
(valga la redundancia) un objeto formulario. Es decir, creamos un nuevo formulario en blanco.
Guardamos ese formulario con el nombre de F01.
Una vez creado lo situamos en vista diseño.
Si ahora abrimos el editor de VB (a través de la combinación de teclas ALT+F11) podremos
comprobar que no existe ningún módulo de objeto. ¿Y cómo? Porque si nos fijamos en la
ventana proyecto sólo podremos ver ahí el nombre de nuestra BD, pero ningún otro elemento.
Volvamos a situarnos frente a F01 en vista diseño.
Antes de seguir necesitamos explicar alguna “cosita” más...
EVENTOS
Cojamos algo común que todo el mundo conozca (o al menos le suene), como podría ser el
mando de una Wii... Generalizando podemos decir que si pulsamos uno de los botones
confirmamos la opción que tenemos en pantalla; si movemos el mando a la izquierda se
produce un movimiento hacia la izquierda, y lo mismo para la derecha. Si agitamos el mando
de arriba a abajo pues obtenemos otro resultado...
Si lo “transformamos” en lo que nos interesa podemos hablar de “eventos”, que en caso de la
tele podríamos decir que...
– Evento al pulsar el botón
– Evento al mover el mando a la derecha
– Evento al mover el mando a la izquierda
– Evento al agitar el mando
Y, a cada uno de estos eventos, le corresponde la ejecución de una acción.
Asimilado lo anterior, nuestro formulario F01 es nuestro mando, que posee una serie de
eventos a los cuales les podemos asignar una acción, que vendría programada por nuestro
código VBA.
¿Y cuáles son esos eventos?
Pues si volvemos a nuestro F01, que teníamos situado en vista diseño, no tenemos más que
sacar sus propiedades y nos desplazamos a la pestaña Eventos. Ahí podremos ver una lista de
todas los eventos a los cuales podemos asignarles una acción a través de código. Algunos, al
leerlos, nos van a resultar más que evidentes; otros, sin embargo, no lo son tanto. No os
2
Visítame en http://bit.ly/NckAccess
preocupéis porque ya los iremos viendo con calma a través de este curso.
Nuestro espacio de trabajo para código será, pues, entre estas dos líneas.
3
Visítame en http://bit.ly/NckAccess
Private Sub Form_Open(Cancel As Integer)
MsgBox "¡Hola, mundo!"
End Sub
…
Lo que estamos haciendo es simplemente decirle al
formulario que cuando se abra nos lance un mensaje.
Si ahora cerramos (guardando los cambios) nuestro F01 y lo
abrimos en vista formulario veremos los “efectos” de nuestra
programación.
Vamos a ir un poco más allá. Con nuestro F01 en vista diseño vamos a a mostrar el
encabezado y el pie del formulario. Ahora, en teoría, deberíamos tener tres secciones:
– Encabezado
– Detalle
– Pie
Truco: por si no lo sabíamos podemos seleccionar lo que es el formulario en marcando el
pequeño cuadrado que hay en la esquina superior izquierda del mismo. Si después marcamos
otro elemento, y tenemos la ventana de propiedades abierta, esta irá cambiando las
propiedades en función del elemento que tengamos seleccionado.
La idea que os quiero transmitir es que el formulario tiene unos eventos asociados, pero la
sección encabezado, la sección detalle y la sección pie también tienen sus propios eventos.
4
Visítame en http://bit.ly/NckAccess
CONTROLES
Vamos a ver cómo se refleja una mezcla de los anteriores conceptos en nuestro editor de VB.
Operaremos sobre FPrueba.
Así pues, con FPrueba en vista diseño, sacamos las propiedades del formulario y nos vamos al
evento “Al activar registro”.
Este evento se produce cada vez que nos aparece un registro en pantalla; es decir, se
“activará” al abrir el formulario (porque nos aparece el primer registro o un registro nuevo,
dependiendo cómo tengamos configurado el formulario) y también se activará cada vez que
cambiemos de registro, ya sea porque nos desplacemos por los registros o porque vayamos a
añadir uno nuevo.
A este evento le generamos el siguiente código:
…
Private Sub Form_Current()
If IsNull(Me.Dato.Value) Then
MsgBox "El campo <dato> está vacío"
Else
MsgBox "El campo <dato> está lleno"
End If
End Sub
5
Visítame en http://bit.ly/NckAccess
…
Ahora sacamos las propiedades del campo [Dato] y programaremos el evento llamado “Al
recibir el enfoque”. Le generamos el siguiente código:
…
Private Sub Dato_GotFocus()
If IsNull(Me.Dato.Value) Then
Me.Dato.Value = "¡Estoy vacio!"
End If
End Sub
…
¿Qué hemos aprendido con estos dos simples códigos?
– Que para examinar SI hay valor o NO hay valor utilizamos el bloque IF... END IF (que
estudiaremos un poco más adelante)
– Que para saber si un dato no contiene ningún valor debemos utilizar ISNULL(valor)
– Hemos recordado que si queremos especificar un texto debemos situarlo entre comillas.
– Que para lanzar un mensaje al usuario utilizamos la función MsgBox (que también
veremos más adelante)
Como podréis intuir, lo que hace el código asociado al formulario es “mirar” si el campo [Dato]
tiene valor o no, y en función de ello nos lanza un mensaje de advertencia.
Lo que hace el código asociado al campo [Dato] es “mirar”, cada vez que este campo recibe el
foco, si tiene valor o no, y si no lo tiene nos escribe una cadena de texto dentro del mismo.
Vamos a probarlo. Situamos FPrueba en vista formulario y... ¡sorpresa! Y si ahora pulsamos
Enter o tabulación, para saltar al campo [Dato], automáticamente se nos escribe el texto que
habíamos especificado.
Añadamos dos registros más, de manera que acabemos en el registro número 3.
Ahora, a través de los botones de desplazamiento, volvamos al registro 2 (registro anterior).
Veremos que el código de formulario detecta que ya hay valor en [Dato] y nos da el mensaje
correcto, a la vez que en ese campo, al contener ya un valor, su código no permite que se
escriba nuestro valor por defecto.
6
Visítame en http://bit.ly/NckAccess
LA FUNCIÓN MSGBOX
LANZAR UN MENSAJE
Aunque lo hemos visto ya varias veces durante este curso ahora vamos a ver la sintaxis casi
completa de esta función. Esta sintaxis es la siguiente:
MsgBox [Texto a mostrar], [Botón/es a mostrar], [Título de la ventana de mensaje]
Hay dos argumentos más, pero no los vamos a ver. Simplemente comentar que corresponden
a la manipulación de un archivo de ayuda que hayamos podido crear.
7
Visítame en http://bit.ly/NckAccess
SALTOS DE LÍNEA EN MENSAJE
Aprovecho este espacio para comentaros que podemos crear una variable y pasarla como
mensaje. En este caso no deberíamos utilizar comillas, ya que no le pasamos el texto
directamente, sino el texto almacenado en la variable. Si queréis hacemos la prueba:
Añadimos un nuevo botón en F01 y lo llamamos cmdVariable, y le generamos el siguiente
código:
…
Private Sub cmdVariable_Click()
Dim miTexto As String
Dim miEdad As Integer
miTexto = "Yo soy Neckkito"
8
Visítame en http://bit.ly/NckAccess
miEdad = 125
MsgBox miTexto & miEdad, vbCritical, "MI MENSAJE"
End Sub
…
Si ejecutamos este código vemos que nos sale el mensaje,
pero muy “feo” ;)
Vamos a arreglar el mensaje combinando texto directo y
variables. Así pues modificamos la línea de MsgBox por la
siguiente:
MsgBox miTexto & " y tengo sólo " & miEdad & " años", vbCritical, "MI MENSAJE"
Como podremos comprobar ahora sí que nos sale un texto “guapo”. Fijaos simplemente,
además de cómo hemos ido concatenando el texto, que debemos ir con cuidado con los
espacios en blanco al principio y final de las cadenas de texto intermedias. ¡Los espacios
también cuentan!
Antes de meternos de lleno en el tema debemos saber una cosa: las constantes de VB
devuelven un valor entero (integer). Ese valor podemos utilizarlo para realizar acciones. De
hecho, podemos hacer referencia al valor devuelto a través de otra constante de VB. ¿A que
suena divertido?
Un ejemplo nos sacará de dudas. Podemos pedirle al usuario que nos responda Sí o No a
través de sendos botones. Para ello utilizaríamos los botones vbYesNo.
Si el usuario pulsa el botón YES el valor que se devuelve es el 6, mientras que si pulsa en NO
el valor devuelto es 7. Entonces aprovecharemos este espacio para introducir el bloque IF...
ELSE... END IF (lo veremos con más detalle en la próxima sección), con lo que podríamos
generar un código que dijera:
…
Si <el usuario pulsa YES> Msgbox = 6 Entonces
'Haz esto
End Si
…
En este caso operaríamos con el número. Pero también tenemos una constante VB que
equivaldría, en este caso, al 6 (ó al 7). Esa constante es vbYes (vbNo). Luego también
podríamos programar el código así:
…
Si <el usuario pulsa YES> Msgbox = vbYes Entonces
'Haz esto
End Si
…
Es decir, o es igual a 6 o es igual a vbYes (o es igual a 7 o igual a vbNo).
9
Visítame en http://bit.ly/NckAccess
Aunque veréis códigos que hacen la programación directa sobre todo el MsgBox a mí,
personalmente, me gusta almacenar el valor el código en una variable y operar sobre ella.
Desde mi punto de vista eso hace el código menos farragoso. Así pues os explicaré cómo lo
hago yo, aunque después os pondré lo mismo pero con programación “directa” para
que podáis ver la diferencia. A partir de ahí... a elegir lo que más guste ;)
10
Visítame en http://bit.ly/NckAccess
Hay otra serie de botones que operan, digamos, sobre el “comportamiento de la ventana en
sí”. Estos no los veremos (pero os diré dónde encontrarlos, un poco más abajo).
Escribir: <MsgBox (“Texto”, vbYesNo)> podría haber sido escrito de la siguiente manera:
<Msgbox (“Texto”, 4)>
Si queremos mostrar los dos botones (SiNo + Exclamación) a través de sus valores numéricos
simplemente tenemos que sumarlos: 4 + 48 = 52, y escribir <MsgBox (“Texto”,52)>
Evidentemente esto lo dejo para quien tenga una buena memoria y sea un fenómeno en
matemáticas... je, je...
Y como lo prometido es deuda, si en nuestro código (en el VBE) nos situamos sobre la palabra
MsgBox y pulsamos la tecla F1 podremos ver toda la lista de botones que acepta la función,
con sus valores representativos, y todos los valores de respuesta (constantes de VB o entero
correspondiente), con una explicación de cada uno de ellos.
LA FUNCIÓN INPUTBOX
Con la función MsgBox hemos visto que podemos lanzar un mensaje al usuario, e incluso
esperar una respuesta del mismo limitada a la pulsación de unas pocas opciones a través de
botones.
11
Visítame en http://bit.ly/NckAccess
La función InputBox nos permite solicitar información al usuario para que este la introduzca en
un cuadro de diálogo, información que no estará tan limitada como en el caso de MsgBox.
Vamos a plantear unj ejercicio sobre esta función. Imaginemos que queremos pedir el nombre
de usuario al usuario (nunca mejor dicho). Utilizaremos pues un InputBox. Para ello:
– Con F01 en vista diseño añadimos un botón de comando, al que llamaremos
cmdInputBox, y le generaremos el siguiente código en el evento “Al hacer click”:
…
Private Sub cmdInputBox_Click()
Dim miNombre As String
miNombre = InputBox("Introduzca su nombre", "NOMBRE", "XXX")
MsgBox "Su nombre es " & miNombre
End Sub
…
Fijaos que:
– Como pedimos la introducción de una cadena de texto hemos definido una variable
(miNombre) como String
– El valor de esa variable nos la proporciona la función InputBox
– Por si no lo habéis intuido, no es necesario utilizar todos los argumentos del InputBox.
Si hubiéramos escrito: <InputBox (“Nombre”)> hubiera bastado.
Vamos a realizar otro ejercicio práctico, pero en este caso realizaremos unos cálculos con los
datos que nos proporcione el usuario.
Añadimos otro botón de comando en F01 y le ponemos de nombre cmdInputBoxNum. Le
generamos el siguiente código en el evento “Al hacer click”:
…
Private Sub cmdInputBoxNum_Click()
Dim valor1 As Integer, valor2 As Integer
valor1 = InputBox("Introduzca el primer número", "#1", 0)
valor2 = InputBox("Introduzca el segundo número", "#2", 0)
MsgBox "La suma de " & valor1 & " y " & valor2 & " es " & valor1 + valor2
End Sub
…
12
Visítame en http://bit.ly/NckAccess
Como podemos ver en este ejemplo:
– Hemos definido las variables como Integer porque esperamos números
– Hemos practicado cómo concatenar el mensaje de MsgBox
– Hemos visto que podemos realizar cálculos
directamente sobre el mensaje devuelto por MsgBox.
Si hemos seguido los ejemplos hemos visto como el InputBox nos muestra dos botones:
aceptar y cancelar. Y si hemos intentado cancelar hemos visto que nos salta un error de
código.
Vamos a ver cómo programar el InputBox de manera que si el usuario cancela la acción
podamos salir del procedimiento. Para ello necesitamos utilizar la función StrPtr.
Cuando el usuario pulsa <Cancelar> la función StrPtr devuelve el valor 0 (cero). Eso nos
permite la detección de un valor para poder tomar una decisión.
Si la variable que recoge la respuesta del InputBox es miNombre, la sintaxis sería tan simple
como StrPtr(miNombre).
Vamos a modificar el primer código que nos solicitaba el nombre de usuario para añadir ese
control de pulsación de cancelar. Añadimos un nuevo botón de comando en F01 y lo
guardamos como cmdInputBoxCancelar. El nuevo código del evento “Al hacer click” debería
quedarnos así:
…
Private Sub cmdInputBoxCancelar_Click()
Dim miNombre As String
miNombre = InputBox("Introduzca su nombre", "NOMBRE", "XXX")
If StrPtr(miNombre) = 0 Then Exit Sub
MsgBox "Su nombre es " & miNombre
End Sub
13
Visítame en http://bit.ly/NckAccess
…
Y eso es todo. No hay más secreto.
Para detectar valores vacíos o cadenas de texto vacías podemos utilizar un bloque IF. El código
para ello sería:
Si <el valor es nulo> O <es una cadena vacía> entonces …
Por ejemplo, y siguiendo con el ejemplo anterior (yo he programado un nuevo botón de
comando en F01), podríamos escribir el código como sigue:
…
Private Sub cmdInputBoxVacios_Click()
Dim miNombre As String
miNombre = InputBox("Introduzca su nombre", "NOMBRE", "XXX")
If StrPtr(miNombre) = 0 Then Exit Sub
If IsNull(miNombre) Or miNombre = "" Then Exit Sub
MsgBox "Su nombre es " & miNombre
End Sub
…
Como vemos volvemos a encontrarnos que para saber si un valor es nulo debemos utilizar
<IsNull(variable)>. Y para ver si está vacío simplemente lo indicamos con dos comillas dobles
seguidas (“”)
También podemos ver que para unir condiciones hemos utilizado OR
En este ejemplo, si se produce la condición, se sale del proceso, pero podríamos haber hecho
que saltara un mensaje al usuario indicándole que el valor introducido no es correcto (si lo
queréis probar, os lo dejo como “deberes” ;) )
14
Visítame en http://bit.ly/NckAccess
Para “pillar” que el usuario está introduciendo un valor numérico en lugar de una cadena de
texto podemos utilizar la función IsNumeric. A partir del valor devuelto por esta función
(True/False) podremos tomar una decisión, como siempre, a través de nuestro amigo IF.
Veamos un ejemplo (que yo he programado en otro botón
de comando):
…
Private Sub cmdInputBoxIsNumeric_Click()
Dim miNombre As String
miNombre = InputBox("Introduzca su nombre", "NOMBRE",
"XXX")
If StrPtr(miNombre) = 0 Then Exit Sub
If IsNull(miNombre) Or miNombre = "" Then Exit Sub
If IsNumeric(miNombre) Then Exit Sub
MsgBox "Su nombre es " & miNombre
End Sub
…
Como podemos comprobar la sintaxis es <IsNumeric(variable)>. Si ahora el usuario introduce
un número nuestro código se dará cuenta y saldrá del proceso.
¿Y qué pasa si lo que queremos es precisamente que el dato sea numérico? Pues muy fácil:
negamos que sea numérico. Je, je... me encantan estas frases “ambiguas”...
Lo que quiero decir es que si situamos un NOT delante de IsNumeric podemos conseguir el
efecto deseado. Pongamos un ejemplo:
Creamos un nuevo botón de comando en F01, al que llamaremos cmdInputBoxEdad. En el
evento “Al hacer click” le generamos el siguiente código:
…
Private Sub cmdInputBoxEdad_Click()
Dim miEdad As Variant
miEdad = InputBox("Introduzca su edad", "AÑITOS")
If Not IsNumeric(miEdad) Then
MsgBox "El valor introducido no es válido", vbCritical, "MAL"
Exit Sub
Else
MsgBox "Vaya... ¡qué 'joven' eres!", vbExclamation, "CARAMBA!!!!!!!"
End If
End Sub
…
Un par de comentarios sobre el código:
– No nos ha quedado más remedio que definir la variable miEdad como Variant. Si la
hubiéramos definido como Integer, y el usuario hubiera introducido letras, se hubiera
15
Visítame en http://bit.ly/NckAccess
producido un conflicto de tipos y nuestro código nos hubiera dado un error (os animo a
probarlo para ver “lo listo que es Access”).
– Las decisiones de acción se han tomado dentro del
bloque IF. Esto lo veremos con más detalle en el próximo
capítulo.
NORMALIZACIÓN
Y como punto final a este capítulo vamos a hablar de normalización de nombres, para despejar
un poco nuestro cerebro.
No existe una norma “fija” para la nomenclatura de los elementos, tanto de Access. Por lo
tanto os voy a comentar lo que yo utilizo y lo que he visto que utilizan otras personas. Sólo
daré unas pinceladas porque la idea se va a coger muy rápido. Sí voy a dar un par de ideas
para aquellos que quieran profundizar en el tema.
NOMBRES DE OBJETOS
A los objetos de Access (tablas, formularios, etc.) yo tengo por costumbre añadir la inicial del
nombre genérico del objeto. Por ejemplo, si es una tabla añado una “T” al nombre de la tabla;
si es un formulario añado una “F”, informe una “R” (por Report), una “C” para consulta, una
macro “M”... La única excepción la hago en los subformularios, para lo que empleo “subFrm”, y
para los módulos, en los cuales sigo la nomenclatura que os explico en el siguiente párrafo.
Lo que otras personas hacen es utilizar tres letras identificativas del objeto. Así, tendríamos:
– tbl → Para tablas
– frm → Para formularios
– qry → Para consultas (de query)
– mcr → Para macros
– rpt → Para informes
– mdl → Para módulos estándar
– cls → Para módulos de clase
16
Visítame en http://bit.ly/NckAccess
NOMBRES DE CONTROLES
NOMBRES DE VARIABLES
Debo reconocer que yo no utilizo este sistema más que en ocasiones puntuales, en las cuales
pueden darse ambigüedades. Sin embargo os comento los prefijos más comunes para las
variables, que son:
– str → Para un String
– int → Para un Integer
– lng → Para un Long
– bln → Para un Boolean
– dtm → Para un Date
La idea de poner prefijos a los elementos de Access y VBA es simplemente para facilitar el
reconocimiento de los mismos. Evidentemente un prefijo aporta una información
complementaria extremadamente útil para una lectura rápida de código, o para un
reconocimiento inmediato del elemento de que estamos hablando.
Por ejemplo, y aún sin saberlo, si vemos esto:
---
Private Sub lstNombres_Click()
…
intMax = Dlookup(“[Edad]”, “TAlumnos”)
…
End Sub
---
17
Visítame en http://bit.ly/NckAccess
Con todo lo anterior ya sabemos que:
– Estamos en el evento “Al hacer click” de un cuadro de lista
– Que la variable intMax es de tipo Integer
– Que se busca en la tabla “TAlumnos”, y no en la
consulta “CAlumnos”, por ejemplo
El sistema que tiene una utilización mayoritaria es el que se denomina “sistema Leszynski”. Os
dejo un par de enlaces por si queréis profundizar sobre este tema:
● http://accessdemo.web.officelive.com/idiomas/esp/articulos/leszynski.htm
● http://en.wikipedia.org/wiki/Leszynski_naming_convention
18
Visítame en http://bit.ly/NckAccess