PDF de programación - Manual de Ribbon - Capítulo 10

MANUAL RIBBON

CAPÍTULO 101

Índice de contenido
INTRO 10: MENÚS CONTEXTUALES............................................................................................2
ELEMENTOS QUE VAMOS A NECESITAR....................................................................................2
MENÚ CONTEXTUAL UTILIZANDO LOS BOTONES DE ACCESS...........................................2
PROGRAMANDO NUESTRO MENÚ CONTEXTUAL..............................................................3
LO QUE QUEDA PARA QUE “EL INVENTO FUNCIONE”.......................................................6
PROGRAMAR UNA MACRO AUTOEXEC............................................................................6
INDICAR EN EL FORMULARIO QUE QUEREMOS ESE MENÚ CONTEXTUAL............6
MENÚ CONTEXTUAL UTILIZANDO NUESTROS PROPIOS BOTONES...................................7
PROGRAMANDO NUESTRO MENÚ CONTEXTUAL PERSONALIZADO............................7
LO QUE QUEDA PARA QUE “EL INVENTO FUNCIONE”.......................................................9
UN PEQUEÑO APUNTE: LAS FACEID’s.......................................................................................10
¿Y CÓMO LO HACEMOS FUNCIONAR?.................................................................................11
¿QUÉ OCURRE DESPUÉS DE EJECUTAR EL CÓDIGO?.......................................................11
MENÚS CONTEXTUALES EN SUBFORMULARIOS..................................................................11
PARA FINALIZAR EL CAPÍTULO.................................................................................................12
ADDENDA TRABAJO CON SUBFORMULARIOS.......................................................................13

1

La BD de ejemplo os la podéis bajar aquí

Visítame en http://neckkito.siliconproject.com.ar

1

INTRO 10: MENÚS CONTEXTUALES

En Access 2003 teníamos la opción de construirnos menús
contextuales a través de las herramientas que el propio
Access ponía a nuestra disposición.

En versiones posteriores de Access, al haber cambiado la
sistemática de la barra de menús por el ribbon, esta opción
nos ha “desaparecido”.

En este capítulo vamos a ver cómo podemos construirnos nuestros
propios menús contextuales, ya sea reutilizando los botones que
ya posee Access, ya sea creando nuestros propios botones.

Finalmente veremos también cómo sería la sistemática si esos menús contextuales los
queremos utilizar en un subformulario, ya que es este caso hay que recurrir a un pequeño
truco dado que la “operativa normal” para un formulario no funciona.

ELEMENTOS QUE VAMOS A NECESITAR
Vamos a necesitar una tabla que llamaremos TDatos, sobre la que crearemos un formulario
llamado FDatos. También utilizaremos una tabla llamada TTrabajos, sobre la que crearemos un
formulario en vista de formularios continuos (varios elementos) que llamaremos subFrmTrab, y
que a su vez nos servirá para crear un subformulario.

No os apuréis por lo anterior porque lo iré explicando poco a poco a lo largo del capítulo.

La estructura de la tabla TDatos (muy simple) sería la siguiente:

Y la estructura de la tabla TTrabajos sería:

Sobre TDatos nos crearemos el formulario FDatos. Y por ahora lo dejamos aquí.

MENÚ CONTEXTUAL UTILIZANDO LOS BOTONES DE

ACCESS

Vamos a crearnos un menú contextual utilizando tres botones que ya tenemos en Access. Por
ejemplo, podríamos utilizar el botón copiar, el botón pegar y el botón para filtrar.

La creación de un menú contextual para formulario pasa por utilizar código VBA. Así que, en

Visítame en http://neckkito.siliconproject.com.ar

2

este caso, no utilizaremos código XML.

Veamos cómo sería el proceso, pero tened en cuenta que
debemos registrar la referencia “Microsoft Office x.y Object
Library”, donde x.y es la versión que tengamos instalada de
Office, para que se nos reconozcan los tipos del código VBA
que escribamos.

PROGRAMANDO NUESTRO MENÚ

CONTEXTUAL

Para manipular las barras de menús debemos utilizar el objeto CommandBar, el cual pertenece
a la propiedad CommanBars del objeto Application.

El proceso en abstracto sería:

•

Eliminamos nuestro menú contextual (que se halla en la colección de CommandBars).
Esto lo hacemos para evitar posibles errores por si ya la tuviéramos cargada. De esta
manera nos aseguramos que la instancia que crearemos es única.

• Declaramos y definimos nuestros menú contextuales

•

Añadimos los botones que necesitemos

No os preocupéis si lo anterior os suena un poco a chino. A continuación veremos el código y lo
explicaré sobre el mismo.

Lo que haremos será crearnos un nuevo módulo estándar, que guardaremos con el nombre de
mdlBarrasMenu. En él escribiremos el siguiente código:

…
Public Function miMenuContextual()
On Error Resume Next
'Eliminamos la barra de menú por si ya estuviera cargada
CommandBars("miMenuContext").Delete
'Declaramos las variables
Dim cmb As CommandBar
'Creamos la barra de menú contextual
Set cmb = CommandBars.Add("miMenuContext", _
msoBarPopup, False, False)
'Añadimos los controles a la barra de menú
With cmb
.Controls.Add msoControlButton, _
19, , , True 'Copiar
.Controls.Add msoControlButton, _
22, , , True 'Pegar
.Controls.Add msoControlButton, _
11761, , , True 'Filtro
End With
End Function
…

Para que os hagáis una idea, lo que conseguimos con lo anterior es esto:

Visítame en http://neckkito.siliconproject.com.ar

3

Y al darle sobre la opción de “Autofiltro”...

Detengámonos un momento en el código. Como veis, empiezo con un control de errores donde
le digo que si se produce un error “no haga caso” y siga con la ejecución de la siguiente línea
del código a la que produjo el error.

A continuación elimino mi menú contextual “miMenuContext” por lo que os comentaba un poco
más arriba.

Declaro las variables y creo la barra de menú contextual. Para ello utilizo el método Add, al
cual paso una serie de argumentos. Estos argumentos “al completo” serían los siguientes
(utilizo la misma nomenclatura que le da Access):

CommandBars.Add([Nombre], [Posición], [BarraMenu], [Temporal])

Fijaos en que todos estos argumentos son opcionales. Veamos qué quieren decir:

✔ Nombre: sería el nombre que queremos dar a nuestro menú contextual.

✔ Posición: es el tipo de barra de comandos. Podemos utilizar alguna de las constantes de
MsoBarPosition. Y antes de que me digáis qué es esto de MsoBarPosition ahí tenéis las
diferentes constantes:

Visítame en http://neckkito.siliconproject.com.ar

4

En este caso, al ser un menú contextual que nos aparece
con el clic derecho del ratón, utilizamos msoBarPopup.

✔ BarraMenu: admite los valores “True” y “False” (este último es el valor por defecto).
Significa si queremos que reemplace la barra de menús “normal” y activa por la
nuestra.

✔ Temporal: admite los valores “True” y “False” (este último es el valor por defecto). Si la
situamos en “True” nuestra barra será temporal y se elimina cuando se cierra la
aplicación.

Y la última fase es ir añadiendo los botones de Access que queramos a través de
.Controls.Add, que tiene una serie de argumentos.

.Controls.Add([Tipo], [Id], [Parámetro], [Antes], [Temporal])

✔ Tipo: tipo de control. Como utilizamos los botones que ya existen en Access en el

código escribimos msoControlButton.

✔ Id: Identificador del botón.

✔ Parámetro: se utiliza para ejecutar el comando. No entraremos en más detalles para
este argumento. Sólo comentar que si el control fuera personalizado podríamos utilizar
este argumento para pasar información a alguna función o procedimiento propios.

✔ Antes: para realizar una ordenación de comandos. Si no ponemos nada se van

añadiendo al final.

✔ Temporal: tiene el mismo sentido que hemos visto unas líneas antes, pero aplicado a un

control.

Pero tranquilos, no os dejaré con la incógnita del Id... je, je... ¿Qué es este Id? Uhmmm...

¿Recordamos que en el capítulo 3, al hablar de las imágenes, os comentaba que Microsoft
ponía a nuestra disposición un Excel con información sobre los controles de Access? Pues ese
Id es el correspondiente al control que queremos utilizar. Por ejemplo, para los comandos
“Copiar” (19) y “Pegar” (22) tendríamos que (las columnas intermedias las he ocultado en la
ilustración para poder ver las columnas que me interesa mostrar):

Visítame en http://neckkito.siliconproject.com.ar

5

LO QUE QUEDA PARA QUE “EL INVENTO FUNCIONE”
Bueno... Pues para que nuestro invento funcione nos queda realizar un par de “gestiones” muy
sencillas.

PROGRAMAR UNA MACRO AUTOEXEC
Vamos a crear una macro-objeto, que guardaremos con el nombre “Autoexec” (sin las
comillas). En ella simplemente haremos que se realice la acción “EjecutarCódigo” y le
indicaremos el nombre de la función que acabamos de programar. Nos debería quedar una
cosa así:

Deberemos reiniciar la aplicación para que pueda ejecutarse esta macro y se cree nuestro
menú antes de pasar al paso siguiente.

INDICAR EN EL FORMULARIO QUE QUEREMOS ESE MENÚ

CONTEXTUAL

Vamos a sacar las propiedades del formulario FDatos y en Otras
contextuales, elegiremos nuestra barra.

→

Barra de menús

Y con esto ya tenemos nuestro menú contextual programado.

Visítame en http://neckkito.siliconproject.com.ar

6

MENÚ CONTEXTUAL UTILIZANDO
NUESTROS PROPIOS BOTONES
Para probar esta opción vamos a copiar FDatos y pegarlo
como FDatos2. La mecánica es prácticamente la misma que
hemos visto en los epígrafes anteriores, sólo que esta vez
necesitamos programar un poco más dado que para los
botones que van a ser las opciones de nuestro menú
contextual, al ser personalizados, necesitamos explicitar por
código qué es lo que van a hacer.

Veamos cómo procede