Curso VB19

CURSO DE VB
CAPÍTULO 191
Índice de contenido
PERSONALIZAR LA CINTA DE OPCIONES .................................................................................2
INTRODUCCIÓN...........................................................................................................................2
CREANDO LA ESTRUCTURA DE NUESTRA BD.....................................................................3
LA CINTA DE OPCIONES. IDEAS GENERALES.......................................................................4
CÓDIGO XML...........................................................................................................................5
NUESTRA TABLA USysRibbons..............................................................................................5
LOS NOMBRES DE LA CINTA DE OPCIONES.....................................................................6
PLANIFICANDO NUESTRA CINTA DE OPCIONES.................................................................6
EL CÓDIGO XML INICIAL......................................................................................................7
PROGRAMACIÓN DE NUESTRA CINTA COMÚN..............................................................9
¿CÓMO ACTIVAR NUESTRA CINTA COMÚN?.............................................................12
PROGRAMACIÓN DE NUESTRA CINTA DE FORMULARIO..........................................13
¿CÓMO ACTIVAR NUESTRA CINTA DE FORMULARIO?...........................................14
PROGRAMANDO NUESTROS BOTONES CON VBA............................................................15
PREPARATIVOS PREVIOS....................................................................................................15
AHORA SÍ, A POR EL CÓDIGO VBA...................................................................................15
UNAS ÚLTIMAS LÍNEAS SOBRE LA CINTA DE OPCIONES...............................................17
PARA FINALIZAR EL CAPÍTULO.............................................................................................18
1 La BD donde están los ejemplos de este capítulo os la podéis bajar aquí.
1
Visítame en http://bit.ly/NckAccess
PERSONALIZAR LA CINTA DE OPCIONES
INTRODUCCIÓN
Este capítulo será de aplicación para usuarios de Access
2007 y 2010. Microsoft, a partir de Access 2007, ha
cambiado el sistema de menús que era típico de Access
2003, y lo ha sustituido por la llamada “cinta de opciones”.
Es por ello por lo que si alguno de vosotros aún utilizáis 2003 el

presente capítulo sólo os será de utilidad si pensáis migrar a una
versión superior de Access.
Así como la configuración de menús era extremadamente versátil en Access 2003, en sus
siguientes versiones este tema se ha vuelto un poco más complejo.
Tenemos algunas soluciones accesorias, como la creación de menús a través de macros. Si

estáis interesados en husmear por este tema os recomiendo que analizéis este ejemplo de la
web (aquí).
Más cosas: para poder programar una cinta de opciones personalizada vamos a requerir de
unos mínimos conocimientos de XML (¡no os asustéis: son realmente mínimos! ). Lo que
haremos (entre otras cosas) en general, en este capítulo, será:
1.- Aprenderemos cómo podemos programar nuestra cinta de opciones personalizada.

2.- Aprenderemos cómo “modificar” la cinta de opciones de Access
Dentro del punto 1, veremos:
a.- cómo crear una cinta de opciones para toda la aplicación

b.- cómo crear otra cinta de opciones “especial”, que sólo nos aparecerá cuando abramos un
formulario (ya que la ligaremos a dicho formulario).
Y dentro de los puntos a y b anteriores, veremos cómo:
i.- Aprovechar las funciones de los botones de los que ya dispone Access
ii.- Crearnos nuestros propios botones para que realicen las acciones que nosotros queramos
(y ahí es donde entra en juego nuestra programación en VBA).
Al final del capítulo os indicaré algunos enlaces que he considerado interesantes para que
podáis profundizar en diferentes aspectos del ribbon de Access.
Visto el esquema genérico del capítulo creo que la metodología más efectiva es seguir un
ejemplo y aprovecharlo para ir explicando las características de cada paso.
Por eso, si os parece bien, vamos a crearnos una BD muy simple (para no hacer este capítulo
interminable) desde cero. Esta BD nos servirá para gestionar las entradas/salidas en préstamo
de libros de una biblioteca.
Pongámonos pues manos a la obra:
2
CREANDO LA ESTRUCTURA DE NUESTRA BD2
Crearemos una tabla, a la que llamaremos TPrestamos, con
la siguiente estructura:
Con esto nos bastará.
Ahora nos creamos un formulario que nos hará de menú, y que llamaremos FMenu.
A continuación creamos los siguientes objetos:
El formulario FPrestamos, basado en la tabla TPrestamos.

El formulario FHistorial, basado en la tabla TPrestamos, pero en forma de formularios
continuos.
El formulario FPrestamos me ha quedado así:
El código del botón cerrar (cmdCerrar) es
…
Private Sub cmdCerrar_Click()
DoCmd.Close acForm, Me.Name
DoCmd.OpenForm "FMenu"
End Sub
…
El formulario FHistorial me ha quedado así
2 La estructura de nuestra BD será mínima y no óptima, pues el objetivo del capítulo no es aprender a estructurar una BD. Por ello,
no toméis esta referencia como lo que debería ser una “BD bien estructurada” (porque no lo es).
3
El código del botón cerrar (cmdCerrar) será:
…
Private Sub cmdCerrar_Click()
End Sub
…
En el formulario FMenu vamos a insertar:
Un botón (cmdAbreFPrestamos), que nos abrirá FPrestamos preparado para la adición de un

nuevo registro
Un combo (cboDevolucion) que nos abrirá FPrestamos preparado para marcar la devolución del
libro.
El código de cmdAbreFPrestamos será:
…
Private Sub cmdAbreFPrestamos_Click()
DoCmd.OpenForm "FPrestamos", , , , acFormAdd
End Sub
…
En el combo, en sus propiedades, nos vamos a la pestaña Datos → Origen de la fila, y

escribimos la siguiente SQL:
SELECT DISTINCT TPrestamos.Titulo FROM TPrestamos;
Y en el evento “Después de actualizar” escribimos el siguiente código:
…
Private Sub cboDevolucion_AfterUpdate()
DoCmd.OpenForm "FPrestamos", , , "[Titulo]='" & Me.cboDevolucion.Value & "'" _
& " AND [Devolucion]=FALSE"
End Sub
…
Y, en principio, eso es todo. Veamos cómo podemos construirnos nuestra cinta de opciones
personalizada para nuestra aplicación.
LA CINTA DE OPCIONES. IDEAS GENERALES

Vamos a ver cuáles son los elementos que necesitamos para poder personalizar la cinta de
opciones con nuestros botones.
4
CÓDIGO XML
Para programar nuestra cinta de opciones deberemos
hacerlo utilizando código XML. Y para ello vamos a necesitar
un editor de XML. Aunque eso puede hacerse en cualquier
editor de textos (el mismo bloc de notas nos serviría) yo os
recomiento otros editores un poco más “especializados” en
xml. Por ejemplo, el que utilizo yo es el “notepad++”, que
podréis encontrar en la web portableapps (efectivamente,
como habéis intuido, es un programa portable, por lo que
no requiere instalación en nuestro disco duro).
De todas maneras insisto en que hay otros programas “por esos mundos de Dios” que os
pueden servir igualmente bien.
NUESTRA TABLA USysRibbons

El código que escribamos, junto con diferentes identificadores (ya los veremos en su
momento) se guardan en una tabla que crearemos, y que denominaremos USysRibbons.
La tabla USysRibbons es detectada por Access como una tabla de sistema, aunque no de
Access (las tablas de sistema de Access llevan el prefijo MSys), sino de usuario. ¿Cómo
podemos verlas? Pues de la siguiente manera:
• Nos situamos sobre el panel de exploración, en cualquier espacio en blanco, y hacemos

click derecho del ratón. Seleccionamos la opción “Opciones de exploración...” y, en la
ventana que nos aparece, marcamos el check de “Mostrar objetos del sistema”. Si
hecho esto aceptamos veremos cómo nos aparecen todas las tablas de sistema.
¿Y por qué no construirnos nuestra tabla USysRibbons ahora? Pues creamos una tabla nueva, a
la cual, lógicamente, llamaremos USysRibbons, con la siguiente estructura:
5
LOS NOMBRES DE LA CINTA DE OPCIONES
Veremos que existe una especie de jerarquía para llamar a
los diferentes elementos de una cinta de opciones.
Básicamente, nos encontraremos con:
La definición de la cinta (ribbon)

La pestaña de la cinta (tab)
El grupo de una pestaña (group)
El nombre de un control personalizado (id) o el nombre de un control estándar (idMso).
Y ahora es cuando aparece la gran pregunta: ¿cómo se llaman los nombres de las cintas, de
los grupos y de los controles estándar? Es decir, a la cinta de opciones que ya existe, ¿qué
nombres les ha puesto Microsoft?
Por ejemplo, la primera pestaña de inicio tiene el curioso nombre de <TabHomeAccess>; el

grupo “Buscar” tiene el nombre <GroupFindAccess>; el control para aplicar filtro se llama
<ApplyFilter>...
Para ver todos estos nombres podéis bajaros estos documentos, con los nombres
exclusivamente para Access3:
– Nombres en Access 2007 (aquí) + Actualización 2007 (aquí)

– Nombres en Access 2010 (aquí).
Si queréis ver los nombres para todas las aplicaciones de Office podéis visitar los siguientes
enlances:
– Nombres Office 2007:

– (http://www.microsoft.com/en-us/download/details.aspx?id=3582)
– Nombres Office 2010:
– (http://www.microsoft.com/en-us/download/details.aspx?id=6627)
PLANIFICANDO NUESTRA CINTA DE OPCIONES

Es un buen ejercicio, antes de empezar a rellenar código XML, plantear cuidadosamente cómo
va a ser nuestra cinta de opciones: qué agrupaciones tendrá, que controles tendrá cada
grupo... Una cinta de opciones pierde parte de su utilidad si el usuario tiene que empezar a
buscar qué botón debe pulsar para realizar una acción si las disposiciones no siguen un poco
de lógica. Sirva esto simplemente como recomendación.
Respecto de nuestra BD de ejemplo vamos a hacer lo siguiente:
• Vamos a crearnos una cinta de opciones común para todos los formularios
• Vamos a crear una cinta específica para el formulario FPrestamos
• Vamos a crear una cinta específica para el formulario FHistorial
3 Los archivos de este ejemplo y que os propongo para su descarga han sido bajados por mí en junio 2012. Es decir, que,
teóricamente (si Microsoft no nos engaña) están actualizados a esa fecha.
6
EL CÓDIGO XML INICIAL
Nuestro código va a tener siempre unos elementos
comunes, que van a ser:
La cabecera del código (el namespace): se corresponde con

el CUSTOM UI, con una referencia a Microsoft, y será:
<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui">
A continuación debemos operar con el atributo startFromScratch, que puede adoptar los
valores “true” o “false” (nótense las comillas, pues hay que utilizarlas). Si utilizamos “false”
estaremos indicando que estamos modificando la barra de herramientas estándar; si usamos
“true” es que creamos una desde cero.
Y para ello escribiríamos:
<ribbon startFromScratch="false">
Aprovecho para haceros notar un detalle: cuando escribimos en XML utilizamos la notación
“camello”: es decir, las pablabras se escriben juntas, empezando por minúscula, pero la
primera letra de cada palabra entera (a partir de la segunda) se comienza en mayúscula. Así,
la letra “U” de la palabra “customUI”, por ejemplo, se escribe en mayúscula, dando la
sensación de que es la joroba de un camello. Si son más palabras, como por ejemplo
“startFromScratch”, ya vemos claramente (espero) cómo funciona esta sistemática.
Finalmente, escribimos la estructura jerárquica que comentábamos en el apartado anterior,

siguiendo una sistemática “anidada”. Para indicar que empieza un elemento lo que hacemos es
escribir el nombre del elemento entre <>; para indicar que finaliza dicho elemento lo que
hacemos es escribir de nuevo el nombre del elemento, precedido de una barra inclinada, todo
ello siempre entre <>4.
Más o menos nos debería quedar una cosa así:
<customUI...>
<tabs>
<(elementos del tab y valores)>
<group (elementos del group y valores)>
<button (elementos del button y valores)/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
Si nos fijamos en el esquema anterior, los interdentados nos muestran el nivel jerárquico. Es
importantísimo cerrar siempre los elementos por orden inverso a su creación. Es decir, que sí
es correcto escribir:
<amo>
<esclavo>
</esclavo>
4 No puedo aquí explicar cómo funciona el lenguaje XML, lamentablemente. Por ello sólo indicaré las características que necesitemos
para nuestro ribbon.
7
</amo>
Pero no sería correcto escribir:
<amo>
<esclavo>
</amo>
</esclavo>
Si analizáis la línea del button veréis que parece que no lo

cerramos, pero en realidad sí lo cerramos: podemos utilizar un
cierre en la misma línea de creación. Por ejemplo, podríamos
escribir
<amo/>
Evidentemente, eso lo podemos hacer si no tenemos un nivel inferior de jerarquía, porque si

no, como acabamos de comentar, estaríamos cerrando el “principal” antes que el “secundario”.
Veréis que he puesto (elementos del tab y valores). A continuación os indico en una tabla lo
más común de estos “elementos y valores” para operar con la cinta:
ELEMENTO SUBELEMENTO ¿QUÉ ES? COMENTARIOS

tabs tab id Nombre único de la pestaña
label Nombre que se muestra en la pestaña
visible Muestra u oculta la pestaña “true” o “false”
group id Nombre único del grupo
label Nombre que se muestra en el grupo
control idMso Nombre del control existente de Access
label Nombre que se muestra en el control
enabled Activa o desactiva el control
button id Nombre único del botón “btnNombreBoton”
label Nombre que se muestra en el botón
enabled Activa o desactiva el botón “true” o “false”
imageMso Imagen del botón
size Tamaño del botón “normal” o “large”
onAction Función que se va a ejecutar al hacer “nombreDeLaFuncion”
click sobre el botón
OTROS ELEMENTOS QUE PODEMOS UTILIZAR
dropDown Lista desplegable
comboBox Lista desplegable que admite entradas
manuales
screenTip Texto de ayuda contextual que
aparecerá al pasar el puntero del ratón
sobre el botón
Vamos a incidir sobre algunos puntos:
8
• No se pueden ni añadir ni eliminar elementos de la cinta
estándar de Access. Lo máximo que podemos hacer es
llamar a algún elemento de esa cinta predeterminada y
situarlo como no visible.
• El subelemento imageMso hace una llamada a la imagen

predeterminada de los botones de Access que existen. Para
hacer esa llamada necesitamos conocer el nombre exacto
del botón. Podemos recurrir al archivo de nombres cuyo
enlace os indicaba un poco más arriba o podemos recurrir a
otro sistema, que es el siguiente:
◦ Pulsamos el botón de Office (o el menú “Archivo” en 2010)
◦ Opciones de Access
◦ Opción “Personalizar”
◦ En la ventana de la derecha tenemos una lista de controles. Si situamos el puntero
del ratón sobre alguno de ellos y dejamos que nos aparezca la ayuda contextual
veremos que, al final del texto de ayuda y entre paréntesis, nos aparece el nombre
del control: ese es el que debemos utilizar.
• El subelemento imageMso también puede hacer una llamada a una imagen que
hayamos diseñado nosotros mismos para el botón.
PROGRAMACIÓN DE NUESTRA CINTA COMÚN

Si nos fijamos en la parte superior de Access veremos lo siguiente:
Pronto vamos a ver un elemento más (el nuestro), que llamaremos <Mis opciones>.
9
Abrimos la tabla USysRibbons y escribimos, en el primer registro, lo siguiente:
Y en el campo [RibbonXML] escribimos el siguiente código:
…
<tabs>
<tab idMso="TabHomeAccess"
visible="false">
</tab>
<tab id="cintaComun"
label="Mis Opciones"
visible="true">
<group id="cintaComunGrupoAccess"
label="Opciones generales Access">
<control idMso="Copy"
label="Copiar datos"
enabled="true"/>
<control idMso="Paste"
label="Pegar datos"
enabled="true"/>
</group>
<group id="cintaComunGrupoMio"
label="Mis opciones personalizadas">
<button id="btnAbreFPrestamos"
imageMso = "FileServerTransferDatabase"
label="Prestar libro"
size="large"
enabled="true"
onAction="subAbreFPrestamos"/>
<button id="btnAbreHistorial"
imageMso = "DataRefreshAll"
label = "Ver historial"
size="large"
enabled = "true"
onAction="subAbreFHistorial"/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
…
Analicemos el código:
• La cabecera está compuesta por las líneas comunes que ya conocemos:
…
<tabs>
…
• La siguiente etiqueta <tab> lo que hace es convertir en no visible la cinta “Inicio”
…
<tab idMso="TabHomeAccess"
visible="false">
</tab>
…
10
Como vemos, aquí debemos saber que la cinta “Inicio” se
llama “TabHomeAccess” (y para eso podemos recurrir al
fichero para el cual os apuntaba los enlaces más arriba).
Si quisiéramos ocultar no toda la cinta, sino algunos

elementos, deberíamos llegar hasta el nivel que
quisiéramos ocultar. Por ejemplo, si quisiéramos llegar a
ocultar un grupo deberíamos seguir la siguiente estructura:
…
<tab idMso=”NombreDeLaTab”
visible = “true”>
<group idMso=”NombreDelGrupoAOcultar”
visible = “false”>
</group>
</tab>
…
Y lo mismo si, más allá del grupo, queremos llegar a un control en concreto.
• La segunda etiqueta tab ya es la definición de nuestra cinta de opciones
…
<tab id="cintaComun"
label="Mis Opciones"
visible="true">
…
• A partir de ahí creamos los grupos. Como veis yo he creado dos grupos diferentes, para
que veais cómo manejar los controles de Access y los botones personalizados. Así:
◦ El primer grupo corresponde a los controles de Access
…
<group id="cintaComunGrupoAccess"
label="Opciones generales Access">
<control idMso="Copy"
label="Copiar datos"
enabled="true"/>
<control idMso="Paste"
label="Pegar datos"
enabled="true"/>
</group>
…
Como véis, llamo al control a través de <control idMso=”NombreControl”> y manipulo sus

propiedades. Acabado con uno (Copy), empiezo con otro (Paste).
El segundo grupo corresponde a nuestros botones personalizados
…
<group id="cintaComunGrupoMio"
label="Mis opciones personalizadas">
<button id="btnAbreFPrestamos"
imageMso = "FileServerTransferDatabase"
label="Prestar libro"
size="large"
enabled="true"
onAction="subAbreFPrestamos"/>
11
size="large"
enabled = "true"
onAction="subAbreFHistorial"/>
</group>
…
La mecánica es muy parecida al manejo de los controles de Access, sólo que utilizando botones
(control versus button). A los botones les he asignado una imagen (la que me ha gustado
más), recurriendo para ello al nombre que me mostraba el propio Access (tal y como os
explicaba más arriba con el tema buscar los nombres en las opciones de Access). Los
mostraremos como botones grandes (en contraposición a los controles) para que
podáis ver el efecto en la aplicación.
Finalmente, he asignado dos procedimientos (subAbreFPrestamos y subAbreFHistorial). Esos

procedimientos deberemos programarlos, pero esto os lo explicaré un poco más abajo.
• Para acabar completamos el código con todas las etiquetas necesarias de cierre
…
</tab>
</tabs>
</ribbon>
</customUI>
…
¿CÓMO ACTIVAR NUESTRA CINTA COMÚN?

La activación de la cinta común es un proceso muy sencillo, lo que algo reiterativo (esas
“cosas” que tiene Access a veces).
El proceso es el siguiente:
1.- Ya tenemos nuestro código en la tabla USysRibbons, pero Access aún no sabe que hemos
creado una cinta personalizada. ¿Qué hacemos?
Salimos completamente de Access y volvemos a entrar.
2.- Una vez reiniciado ahora Access sí ya sabe que existe una cinta de opciones nueva. Vamos
a configurarla:
Hacemos click en el botón de Office (Archivo en Access 2010) → Opciones de Access

→ Base de datos actual, y en el apartado “Opciones de la barra de herramientas y de
la cinta de Opciones” seleccionamos nuestra cinta.
12
3.- Ahora Access ya sabe que tiene que mostrar nuestra cinta de opciones, pero aún no ha
“refrescado” esa información. Pues...
Salimos totalmente de Access y volvemos a entrar
4.- Y ahora sí, ya nos aparece nuestra maravillosa cinta personalizada
Nota: si hay algún error de código XML no aparecerá nuestra cinta. Si os pasa eso “no
queda otra” que repasar bien el código de la cinta hasta dar con el error. El “rollo” está en que
para cada modificación tendremos que salir de Access y volver a entrar para ver si lo hemos
corregido correctamente.
PROGRAMACIÓN DE NUESTRA CINTA DE FORMULARIO

El proceso para programar la cinta ligada a un formulario es prácticamente idéntico al que
hemos desarrollado para lo que hemos denominado “cinta común”.
Para la cinta que ligaremos al formulario FPrestamos vamos a realizar lo siguiente:
.- En la tabla USysRibbons escribiremos:
13
Siendo el código XML
…
<tabs>
<tab id="cintaFPrestamos"
label="Menú Préstamos"
visible="true">
<group id="toqueteoRegistros"
label="Trabajo con registros">
<control idMso="GoToNewRecord"
label="Nuevo préstamo"
enabled="true"/>
<control idMso="RecordsDeleteRecord"
label="Borrar entrada"
enabled="true"/>
</group>
<group id="operoConFormulario"
label="Opciones de formulario">
<button id="btnCierraFPrestamos"
imageMso = "CloseDocument"
label="Volver a Menú"
size="large"
enabled="true"
onAction="subCierraFPrestamos"/>
size="large"
enabled = "true"
onAction="subAbreFHistorialFiltrado"/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
…
Os dejo el análisis del código para vosotros, aunque no deberíais tener problemas para
entenderlo. Sólo hay que recordar que debemos programar dos funciones:
subCierraFPrestamos y subAbreFHistorialFiltrado.
¿CÓMO ACTIVAR NUESTRA CINTA DE FORMULARIO?

Como ya habréis intuido, una vez creado el código XML en USysRibbons habrá que salir de
Access para que, al reinicializarlo, cargue la nueva cinta. Una vez hecho esto:
.- Abrimos el formulario FPrestamos en vista Diseño

.- Sacamos sus propiedades → Pestaña Otras → Nombre de banda de opciones, y ahí
seleccionamos “OpcionesFPrestamos”
14
Y eso debería ser todo. Si situamos FPrestamos en vista Formulario nos debería aparecer
nuestra cinta. Al cerrar FPrestamos esa cinta debería desaparecer.
Añadir que podemos hacer lo mismo con un informe; es decir, programar una cinta
personalizada para un informe: sólo deberíamos ligarle la cinta correspondiente.
PROGRAMANDO NUESTROS BOTONES CON VBA
PREPARATIVOS PREVIOS
Debemos preparar nuestra BD para que nuestro código VBA pueda interactuar con la cinta de
opciones. Ello implica realizar un paso previos a la programación.
Ese paso consiste en registrar una referencia, dado que nuestro código debe reconocer algunos
códigos que llaman a la cinta de opciones. Para conseguir esto abrimos el VBE (ALT+F11) y
nos vamos a Menú → Herramientas → Referencias..., y buscamos y marcamos el check de la
librería “Microsoft Office 12.0 Object Library” (la versión 14.0 para Access 2010).
Preparativo listo.
AHORA SÍ, A POR EL CÓDIGO VBA

Bueno... nos toca programar un poco con VBA.
Vamos a crear pues una serie de procedimientos, pero debemos tener en cuenta que en todos
los procedimientos que programemos vamos a tener que seguir la siguiente estructura:
Public sub nombreProcedimiento (ByVal control As IRibbonControl)
15
De esta manera enlazamos la cinta con el código que escribiremos.
Recapitulemos: de la cinta común tenemos dos

procedimientos:
• subAbreFPrestamos
• subAbreFHistorial
y de la cinta de formulario tenemos dos procedimientos:
• subCierraFPrestamos
• subAbreFHistorialFiltrado
Lo que vamos a hacer es crearnos un módulo estándar, que llamaremos mdlRibbons. Para la
primera función programaremos lo siguiente:
…
Public Sub subAbreFPrestamos(ByVal control As IRibbonControl)
On Error GoTo sol_err
'Comprobamos que FPrestamos no está ya cargado
If CurrentProject.AllForms("FPrestamos").IsLoaded Then
'Si está cargado avisamos y salimos
MsgBox "El formulario ya está abierto", vbExclamation, "FORMULARIO ABIERTO"
Else
'Si no está cargado cerramos FMenu y lo abrimos para añadir un registro nuevo
DoCmd.Close acForm, "FMenu"
DoCmd.OpenForm "FPrestamos", , , , acFormAdd
End If
Salida:
Exit Sub
sol_err:
MsgBox "Se ha producido el error " & Err.Number _
& " - " & Err.Description
Resume Salida
End Sub
…
Como veis el código no tiene mayor complicación, salvo por la particularidad que
comprobamos, antes de realizar la acción, si FPrestamos está cargado o no, y actuamos en
consecuencia.
El código para subAbreFHistorial sería:
…
Public Sub subAbreFHistorial(ByVal control As IRibbonControl)
On Error GoTo sol_err
'Comprobamos que FPrestamos no está ya cargado
If CurrentProject.AllForms("FHistorial").IsLoaded Then
'Si está cargado avisamos y salimos
MsgBox "El formulario ya está abierto", vbExclamation, "FORMULARIO ABIERTO"
Else
'Si no está cargado cerramos FMenu y lo abrimos para añadir un registro nuevo
DoCmd.OpenForm "FHistorial", , , , acFormReadOnly
End If
Salida:
16
Exit Sub
sol_err:
MsgBox "Se ha producido el error " & Err.Number _
& " - " & Err.Description
Resume Salida
End Sub
…
El código de subCierraFPrestamos sería, simplemente:
…
Public Sub subCierraFPrestamos(ByVal control As IRibbonControl)
DoCmd.Close acForm, "FPrestamos"
DoCmd.OpenForm "FMenu"
End Sub
…
Y finalmente, el código de subAbreFHistorialFiltrado sería:
…
Public Sub subAbreFHistorialFiltrado(ByVal control As IRibbonControl)
Dim vLector As String
vLector = Nz(Forms!FPrestamos.Lector.Value, "")
If vLector = "" Then
MsgBox "Debe indicar el nombre de un lector para filtrar su historial"
Else
DoCmd.OpenForm "FHistorial", , , "[Lector]='" & vLector & "'", acFormReadOnly
End If
End Sub
…
Sólo me queda añadir que, aunque yo no lo he hecho más que en los códigos de la cinta
común (porque los códigos programados son muy simples), es buena costumbre añadir un
control de errores en los códigos (sobre todo si la cinta de opcines es común y no está ligada a
ningún formulario). Si los usuarios “manazas” ya dan problemas con un objeto “normal” de
Access, si le añadimos un menú las consecuencias pueden ser insospechadas... je, je...
UNAS ÚLTIMAS LÍNEAS SOBRE LA CINTA DE OPCIONES

Si hay alguien que se haya entusiasmado con esto de “tener mi propia cinta de opciones”
puede complementar o profundizar sobre la programación de la cinta de opciones en las
siguientes direcciones:
http://office.microsoft.com/es-es/access-help/personalizar-la-cinta-de-opciones-
HA010211415.aspx (cómo crear un ribbon)
http://76areal.wordpress.com/2011/05/10/menus-y-botones-para-access-2007-y-2010/
(ofrece varias opciones adicionales de cómo configurar el menú de las aquí explicadas)
http://www.microsoft.com/en-us/download/details.aspx?id=8640 (ejemplo de Microsoft, donde

podréis ver cómo combinar el ribbon con macros)
http://geeks.ms/blogs/access/archive/2008/04/06/access-2007-cambiar-de-banda-de-
opciones-ribbon-usando-vba.aspx (con cosas curiosas sobre el ribbon que pueden sernos útiles
para nuestra aplicación)
17
http://geeks.ms/blogs/access/archive/2009/01/14/el-uso-de-las-cintas-de-opciones-ribbon-y-
xml-lenguaje-de-marcado-extensible-ribbonandxml-01.aspx (para ocultar iconos del menú del
botón de Office)
PARA FINALIZAR EL CAPÍTULO

Si habéis echado un vistazo a los enlaces que os propongo
habréis podido comprobar que el tema de la cinta de
opciones puede “complicarse” bastante, si uno quiere. El
objetivo de este capítulo era simplemente encaminaros y
mostraros el “recibidor” de la casa Ribbon... El resto de
habitaciones deberéis recorrerlas vosotros solos, si queréis
profundizar en el tema.
Espero que lo explicado hasta aquí os sea de utilidad.
Un saludo, y...
¡suerte!
18

Curso VB19

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso VB19

Cargado por

Copyright:

Formatos disponibles

CURSO DE VB

1 La BD donde están los ejemplos de este capítulo os la podéis bajar aquí.

Es por ello por lo que si alguno de vosotros aún utilizáis 2003 el

Tenemos algunas soluciones accesorias, como la creación de menús a través de macros. Si

1.- Aprenderemos cómo podemos programar nuestra cinta de opciones personalizada.

Dentro del punto 1, veremos:

a.- cómo crear una cinta de opciones para toda la aplicación

Y dentro de los puntos a y b anteriores, veremos cómo:

Pongámonos pues manos a la obra:

Con esto nos bastará.

A continuación creamos los siguientes objetos:

El formulario FPrestamos, basado en la tabla TPrestamos.

El formulario FPrestamos me ha quedado así:

El código del botón cerrar (cmdCerrar) es

El formulario FHistorial me ha quedado así

En el formulario FMenu vamos a insertar:

Un botón (cmdAbreFPrestamos), que nos abrirá FPrestamos preparado para la adición de un

El código de cmdAbreFPrestamos será:

En el combo, en sus propiedades, nos vamos a la pestaña Datos → Origen de la fila, y

SELECT DISTINCT TPrestamos.Titulo FROM TPrestamos;

Y en el evento “Después de actualizar” escribimos el siguiente código:

LA CINTA DE OPCIONES. IDEAS GENERALES

NUESTRA TABLA USysRibbons

• Nos situamos sobre el panel de exploración, en cualquier espacio en blanco, y hacemos

La definición de la cinta (ribbon)

Por ejemplo, la primera pestaña de inicio tiene el curioso nombre de <TabHomeAccess>; el

– Nombres en Access 2007 (aquí) + Actualización 2007 (aquí)

– Nombres Office 2007:

PLANIFICANDO NUESTRA CINTA DE OPCIONES

Respecto de nuestra BD de ejemplo vamos a hacer lo siguiente:

La cabecera del código (el namespace): se corresponde con

Y para ello escribiríamos:

Finalmente, escribimos la estructura jerárquica que comentábamos en el apartado anterior,

Más o menos nos debería quedar una cosa así:

Pero no sería correcto escribir:

Si analizáis la línea del button veréis que parece que no lo

Evidentemente, eso lo podemos hacer si no tenemos un nivel inferior de jerarquía, porque si

ELEMENTO SUBELEMENTO ¿QUÉ ES? COMENTARIOS

Vamos a incidir sobre algunos puntos:

• El subelemento imageMso hace una llamada a la imagen

PROGRAMACIÓN DE NUESTRA CINTA COMÚN

Y en el campo [RibbonXML] escribimos el siguiente código:

• La cabecera está compuesta por las líneas comunes que ya conocemos:

• La siguiente etiqueta <tab> lo que hace es convertir en no visible la cinta “Inicio”

Si quisiéramos ocultar no toda la cinta, sino algunos

• La segunda etiqueta tab ya es la definición de nuestra cinta de opciones

◦ El primer grupo corresponde a los controles de Access

Como véis, llamo al control a través de <control idMso=”NombreControl”> y manipulo sus

El segundo grupo corresponde a nuestros botones personalizados

Finalmente, he asignado dos procedimientos (subAbreFPrestamos y subAbreFHistorial). Esos

¿CÓMO ACTIVAR NUESTRA CINTA COMÚN?

Salimos completamente de Access y volvemos a entrar.

Hacemos click en el botón de Office (Archivo en Access 2010) → Opciones de Access

Salimos totalmente de Access y volvemos a entrar

4.- Y ahora sí, ya nos aparece nuestra maravillosa cinta personalizada

PROGRAMACIÓN DE NUESTRA CINTA DE FORMULARIO

Para la cinta que ligaremos al formulario FPrestamos vamos a realizar lo siguiente:

.- En la tabla USysRibbons escribiremos:

¿CÓMO ACTIVAR NUESTRA CINTA DE FORMULARIO?

.- Abrimos el formulario FPrestamos en vista Diseño

PROGRAMANDO NUESTROS BOTONES CON VBA

AHORA SÍ, A POR EL CÓDIGO VBA

Public sub nombreProcedimiento (ByVal control As IRibbonControl)