Manual Ribbon 11

MANUAL RIBBON
CAPÍTULO 111
Índice de contenido
INTRO 11: UN POCO SOBRE LAS COMMANDBARS..................................................................2
UNA BREVÍSIMA SEGUNDA INTRODUCCIÓN............................................................................2
OPERATIVA EN ABSTRACTO..........................................................................................................2
OPERATIVA MÁS ESPECÍFICA, PERO AÚN EN ABSTRACTO..............................................3
ELEMENTOS QUE VAMOS A NECESITAR....................................................................................3
CREANDO POCO A POCO NUESTRA COMMANDBAR..............................................................4
BOTÓN DE COMANDO................................................................................................................4
DROPDOWN..................................................................................................................................5
COMBOBOX..................................................................................................................................7
MENÚ EMERGENTE..................................................................................................................10
LO QUE FALTA PARA QUE “EL INVENTO FUNCIONE”...........................................................12
SI QUEREMOS QUE NUESTRA COMMANDBAR SE CARGUE AL INICIO.......................12
SI QUEREMOS QUE NUESTRA COMMANDBAR SE CARGUE CON UN BOTÓN............12
PARA FINALIZAR ESTE CAPÍTULO.............................................................................................12
1 La BD de ejemplo os la podéis bajar aquí
1
Visítame en http://neckkito.siliconproject.com.ar
INTRO 11: UN POCO SOBRE LAS
COMMANDBARS
Aunque alguien pueda pensar: ¿y qué tiene esto que ver
con el ribbon? me he decidido a escribir este capítulo
porque le veo cierta similitud al tema. El ribbon nos permite
construirnos un conjunto de menús con opciones varias
para realizar acciones que queremos; las commandbars nos
permiten hacer algo similar, (con sus más y sus menos)
sólo que a través de código VBA.
Y dado que, como comentábamos en el capítulo anterior, hemos aprendido algo de las
commandbars para poder construir nuestros menús contextuales, me he dicho a mí mismo:
¿por qué no explicar también la construcción de un complemento (ya veréis más adelante
porque digo esto)?
Así que, camina caminarás, aquí tenéis un par de pinceladas de cómo manejar las
commandbars.
UNA BREVÍSIMA SEGUNDA INTRODUCCIÓN

Debido a esa “cierta similitud” que comentábamos en la Intro con las commandbars podemos
construirnos diferentes elementos: botones, cuadros combinados, menús emergentes...
No voy a entrar “hasta en el último detalle” en este capítulo. Simplemente, lo que intentaré es
explicaros algunas cosas básicas de cómo construirnos estos diferentes elementos para que
“se os abra el apetito”. Si consideráis que pueden ser útiles para vosotros al menos ya tendréis
una base para poder buscar información en otras fuentes y que, como mínimo (espero), podáis
entender “mejor” las diferentes explicaciones o ejemplos que encontréis “por el mundo de
Matrix” 
OPERATIVA EN ABSTRACTO
La operativa, genérica y en abstracto, sería la siguiente:
• Creamos un módulo estándar donde programamos nuestras commandbars.
• Creamos una macro “Autoexec” que nos cargue las commandbars que hemos definido
en ese módulo que os comentaba.
• Al abrir Access nos aparecerá un nuevo “menú”, llamado “COMPLEMENTOS”, donde

encontraremos los comandos que hayamos definido en las commandbars.
Como veis, algo muy sencillo... je, je...
Como nota a lo anterior comentaros que no debemos confundir la mecánica del ribbon con XML
con la mecánica de las commandbars con VBA. ¿Qué significa esto? Pues que, como sabréis (si
habéis seguido el curso entero hasta aquí), con el ribbon necesitábamos reiniciar la aplicación
cada vez que modificábamos el código XML. Con las commandbars eso no es necesario.
Por ejemplo, yo os he expuesto que utilizaríamos una macro “Autoexec” para cargar nuestras
commandbars, dado que lo “lógico” (o no) es que nuestra barra de comandos esté disponible
para el usuario (que no tiene ni idea sobre Access) desde el momento en que se inicia la
2
aplicación.
Ahora bien, ¿y si queremos que la commandbar no

aparezca al inicio, sino cuando el usuario pulse un botón?
Pues ningún problema: no crearíamos ninguna macro
“Autoexec” y simplemente, en el código de ese botón,
indicaríamos que, al pulsarse, se cargara nuestra
commandbar (así como también podríamos hacer que
“desapareciese”). Esto lo veremos con un ejemplo un poco
más adelante.
En definitiva, que no quisiera que os quedarais con la idea de que

“hay que cargarlas al principio”. Podemos cargar las commandbars
cuando nosotros queramos.
OPERATIVA MÁS ESPECÍFICA, PERO AÚN EN ABSTRACTO

Visto lo anterior, y ya centrados en nuestro módulo estándar, la operativa sería la siguiente
(todo lo que sigue a través de código VBA, claro):
• Creamos, primero, la commandbar
• Creamos, a continuación, uno o varios objetos que representarán los diferentes tipos de
controles que queremos que tenga nuestra commandbar
• Añadimos, a cada objeto creado en el punto anterior, los diferentes comandos que
necesitemos y sus características, respetando lógicamente la tipología que hemos
asignado al objeto.
De nuevo quizá lo anterior os pueda sonar, en principio, a chino mandarín, pero no os

preocupéis porque a medida que vayamos avanzando en la explicación lo vais a ir asimilando
perfectamente (o al menos intentaré que sea así, claro).
ELEMENTOS QUE VAMOS A NECESITAR

Para no ser tan repetitivo vamos a crearnos una tabla que llamaremos TSocios, que tendrá la
siguiente estructura:
Nos crearemos un formulario sobre esa tabla que llamaremos FSocios.
Posteriormente vamos a crearnos un módulo estándar, que llamaremos mdlCommandBars.
 Recordad que debemos tener registrada la referencia “Microsoft Office x.y Object Library”
Finalmente yo utilizaré un formulario para “manejar la aplicación” que he llamado FMenu.
3
CREANDO POCO A POCO NUESTRA
COMMANDBAR
Vamos a ir creando poco a poco nuestra commandbar.
Empezaremos por la introducción de un botón de comando
y la iremos ampliando.
Ello significa que cada vez nuestra función irá creciendo “un
poquito” en cada uno de los subepígrafes que veremos a
continuación.
BOTÓN DE COMANDO
Vamos a crearnos un módulo estándar que llamaremos mdlCommandBars. Para empezar
veamos el código que vamos a necesitar, y que escribiremos en dicho módulo:
…
Public Function miBarraDeComandos()
'Declaramos las variables
'Primero, un objeto commandbar
Dim laCommandBar As CommandBar
'Segundo, un objeto botón de commandbar
Dim miComBarBoton As CommandBarButton
'Recorremos la colección de commandbars de la aplicación
'hasta encontrar la nuestra.
'Cuando la encontramos la eliminamos
'Esto es por si ya estuviera cargada. La cargaremos más adelante.
For Each laCommandBar In Application.CommandBars
If laCommandBar.Name = "Controles Neckkito" Then
laCommandBar.Delete
End If
Next laCommandBar
'Ahora sí, creamos nuestra commandbar
Set laCommandBar = Application.CommandBars.Add("Controles Neckkito")
'En los controles de nuestra commandbar...
With laCommandBar.Controls
'Creamos y añadimos nuestro botón
Set miComBarBoton = .Add(msoControlButton)
'Configuramos sus propiedades
With miComBarBoton
.Caption = "Cerrar formulario"
.FaceId = 11268
.Style = msoButtonIconAndCaption
.TooltipText = "Con esto cerramos el formulario activo"
.OnAction = "subCierraForm"
End With
End With
'Hacemos visible la commandbar
laCommandBar.Visible = True
End Function
…
Como vemos, la estructura es la que os indicaba en un epígrafe anterior (estructura en

abstracto). Ahora vemos esa estructura aplicada a un código.
Si os fijáis lo que hacemos es, con un bloque With... End With, configurar “de una tacada” las
propiedades de nuestro botón. En esas propiedades podéis ver que encontramos la propiedad
OnAction, y que a dicha propiedad le he asignado el nombre de un procedimiento.
También fijaos que NO he programado esta barra de comandos como elemento temporal. Eso
significa que una vez se cargue ya se “queda fija” en nuestra base de datos.
4
¿Qué pasaría si queremos que “desaparezca”? Pues,
evidentemente, lo primero que deberíamos hacer es
eliminar su carga en la macro Autoexec, y, después,
definirla como temporal (y ejecutar al menos una vez el
código para que Access “lea” que la barra es sólo temporal).
Para ello deberíamos modificar la línea de código:
Set laCommandBar = Application.CommandBars.Add("Controles

Neckkito")
por

Neckkito", , , True)
Pues bien, sólo nos quedaría programar lo que pasaría al pulsar el botón. Y este es el
procedimiento que he escrito a continuación de la anterior función:
…
Public Sub subCierraForm()
Dim nombreForm As String
nombreForm = Screen.ActiveForm.Name
If nombreForm = "FMenu" Then
'No hago nada
Else
'Cierro el form activo
DoCmd.Close acForm, nombreForm
End If
End Sub
…
El resultado “visible” de lo anterior sería el siguiente:
DROPDOWN
La estructura de este nuevo elemento sería, en abstracto:
• Declaro un objeto commandBar.Control
• Creo su instancia
• Defino sus propiedades
Nuestro código quedaría modificado así (os marco en negrita las nuevas líneas añadidas):
…
5
'Tercero, un objeto dropdown/combobox
Dim miComBarCbo As CommandBarComboBox de commandbar
laCommandBar.Delete
End If
Next laCommandBar
Neckkito")
With miComBarBoton
.FaceId = 11268
End With
'Creamos y añadimos nuestro dropdown
Set miComBarCbo = .Add(msoControlComboBox)
With miComBarCbo
.AddItem "VIP"
.AddItem "No VIP"
.AddItem "Todos"
.Style = msoComboLabel
.Caption = "VIP?"
.TooltipText = "Seleccione el tipo de socio a filtrar"
.OnAction = "subCboDDVip"
End With
End With
End Function
…
Como vemos, añadimos una instancia del objeto dropdown utilizando la constante
“msoControlCombobox”, y le configuramos algunas de las propiedades propias (valga la
“rebuznancia”) de ese control
Nos quedaría una cosa parecida a:
Como también podréis apreciar, hemos determinado que al seleccionar un valor se nos ejecute
el procedimiento “subCboDDVip” a través de la propiedad OnAction. Os indico a continuación
cómo podría ser el código para realizar el filtrado de datos:
…
Public Sub subCboDDVip()
Dim tipoSocio As String
Dim miFiltro As String
Dim hayFiltro As Boolean
6
'Inicializamos hayFiltro suponiendo que se va a filtrar
hayFiltro = True
'Cogemos el valor que se haya seleccionado en el dropdown
tipoSocio = CommandBars("Controles Neckkito").Controls(2).Text
'Comprobamos que el formulario activo sea FSocios
If Screen.ActiveForm.Name = "FSocios" Then
'Examinamos los casos posibles
Select Case tipoSocio
Case "VIP"
miFiltro = "[VIP]=True"
Case "No VIP"
miFiltro = "[VIP]=False"
Case "Todos"
'Significa que no hay filtro
hayFiltro = False
End Select
'Si no hay filtro quitamos el filtro del form (por si lo hubiera)
If hayFiltro = False Then
Screen.ActiveForm.FilterOn = False
Else
'Si lo hay lo construimos y lo aplicamos
With Screen.ActiveForm
.Filter = miFiltro
.FilterOn = True
End With
End If
End If
End Sub
…
Fijaos que para poder coger el valor que se haya seleccionado utilizo la línea:
tipoSocio = CommandBars("Controles Neckkito").Controls(2).Text
Esa línea es “una especie de” ruta: de la commandbar “Controles Neckkito”, de su control
identificado como 2, cógeme el texto seleccionado.
Ese número 2 aparece porque ese es el orden que hemos establecido en el código de la
función: 1-Botón de comando; 2-Dropdown
COMBOBOX
Al igual que comentábamos en capítulos anteriores cuando, a través de XML, creábamos un
dropdown y un combobox, ambos controles son “como hermanos”. Es por ello que las
diferencias son mínimas.
Veamos qué modificaciones debemos realizar en nuestro código para añadir un combobox en
nuestro menú.
La estructura de este nuevo elemento sería, al igual que os comentaba en el dropdown, en

abstracto:
• Declaro un objeto commandBar.Control (en este caso hay un pequeño matiz que
explicaré un poco más adelante)
Nuestro código quedaría modificado así (os marco en negrita las nuevas líneas añadidas):
7
…
'Tercero, un objeto dropdown/combobox de commandbar
Dim miComBarCbo As CommandBarComboBox
laCommandBar.Delete
End If
Next laCommandBar
With miComBarBoton
.FaceId = 11268
End With
With miComBarCbo
.AddItem "VIP"
.AddItem "No VIP"
.AddItem "Todos"
.Caption = "VIP?"
End With
'Creamos y añadimos nuestro combobox
With miComBarCbo
.AddItem "0-5"
.AddItem "0-10"
.AddItem "0-20"
.AddItem "Todos"
.Text = "Antigüedad:"
.Caption = "cboAntigüedad"
.Style = msoComboNormal
.TooltipText = "Seleccione la antigüedad a filtrar"
.OnAction = "subCboAntiguo"
End With
End With
End Function
…
Y aquí va el matiz sobre la declaración del objeto commandBar.Control que os comentaba

antes: dado que ya habíamos creado un dropdown, que nos sirve también para un combobox,
no es necesario declarar otro. Por ello veréis que os he puesto en negrita las líneas
'Tercero, un objeto dropdown/combobox

8
que también había marcado en negrita en el epígrafe de explicación del dropdown.
Resumiendo, que una vez declarado uno nos sirve para la

creación de varias instancias.
El resultado sería:
La programación del procedimiento “subCboAntiguo” que debe desencadenarse al seleccionar

una cota de antigüedad sería el siguiente (como podréis las similitudes con la “estructura
básica” del código “subCboDDVip” son más que evidentes):
…
Public Sub subCboAntiguo()
Dim antigElegida As String
Dim miFiltro As String
Dim fechaFiltro As Date
Dim hayFiltro As Boolean
'Inicializamos hayFiltro suponiendo que se va a filtrar
hayFiltro = True
'Cogemos el valor que se haya seleccionado en el combo
antigElegida = CommandBars("Controles Neckkito").Controls(3).Text
'Comprobamos que el formulario activo sea FSocios
'Examinamos los casos posibles
Select Case antigElegida
Case "0-5"
fechaFiltro = Date - (365 * 5)
Case "0-10"
Case "0-20"
Case "Todos"
'Significa que no hay filtro
hayFiltro = False
End Select
'Si no hay filtro quitamos el filtro del form (por si lo hubiera)
If hayFiltro = False Then
Screen.ActiveForm.FilterOn = False
Else
'Si lo hay lo construimos y lo aplicamos
miFiltro = "[FechAlta]>=#" & Format(fechaFiltro, "mm/dd/yy") & "#"
With Screen.ActiveForm
.Filter = miFiltro
.FilterOn = True
End With
End If
End If
End Sub
…
Poco queda que comentar sobre este código. Así que...
9
MENÚ EMERGENTE
Decir que he llamado a este epígrafe “Menú Emergente”
simplemente porque traduzco literalmente el tipo de menú
del inglés, que es “Popup”.
Para poder ver un ejemplo sobre este menú y ser un poco

más “original” vamos a añadir un elemento más a nuestra
base de datos. Así, vamos a crearnos un informe sobre
TSocios que llamaremos RSocios. Eso es todo.
Con el menú emergente lo que obtenemos es un “menú con

submenús”, para entendernos. Sin embargo, a pesar de su forma
la mecánica, como comprobaréis es muy parecida a la que ya
conocemos, además que hay que tener en cuenta que
necesitaremos varios elementos. Es decir:
• Declaro un objeto commandBar.Control
• Creo los objetos commandBar.Control que necesite para ir confeccionando el menú, con
la sistemática de crear sus instancias y definir sus propiedades.
Veamos cómo ha cambiado nuestro código (os marco en negrita los cambios):
…
'Tercero, un objeto dropdown/combobox de commandbar
'Cuarto, un objeto menú emergente de commandbar
Dim miComBarPopUp As CommandBarPopup
laCommandBar.Delete
End If
Next laCommandBar
With miComBarBoton
.FaceId = 11268
End With
10
With miComBarCbo
.AddItem "VIP"
.AddItem "No VIP"
.AddItem "Todos"
.Caption = "VIP?"
End With
'Creamos y añadimos nuestro combobox
With miComBarCbo
.AddItem "0-5"
.AddItem "0-10"
.AddItem "0-20"
.AddItem "Todos"
.Text = "Antigüedad:"
.Caption = "cboAntigüedad"
.Style = msoComboNormal
.TooltipText = "Seleccione la antigüedad a filtrar"
.OnAction = "subCboAntiguo"
End With
'Creamos y añadimos nuestro menú emergente
Set miComBarPopUp = .Add(msoControlPopup)
With miComBarPopUp
.Caption = "Informes:"
'Creamos un primer botón para obtener el informe global
Set miComBarBoton = .Controls.Add(msoControlButton)
'Configuramos las propiedades de este primer botón
With miComBarBoton
.Caption = "Global"
.FaceId = 12366
.OnAction = "subAbreRSocios"
End With
'Creamos un segundo botón para obtener el informe filtrado
Set miComBarBoton = .Controls.Add(msoControlButton)
'Configuramos las propiedades de este primer botón
With miComBarBoton
.Caption = "Filtrado"
.FaceId = 12364
.OnAction = "subAbreRSociosFiltrado"
End With
End With
End With
End Function
…
Como podréis observar he creado un menú emergente de dos botones. Nada impide crear un
menú emergente con combos, dropdowns, botones... Lógicamente no necesito declararlos
porque ya los tengo declarados en la parte inicial de declaraciones. Si no sí tendría que
acordarme de declararlos.
El resultado obtenido sería:
11
Los códigos para abrir los informes es muy sencillo. Os los dejo indicados aquí, sin más
comentarios:
…
Public Sub subAbreRSocios()
On Error Resume Next
'Comprobamos que se está operando sobre FSocios
'Abrimos el informe en vista previa
DoCmd.OpenReport "RSocios", acViewPreview
End If
End Sub
Public Sub subAbreRSociosFiltrado()

On Error Resume Next
Dim miId As Long
'Comprobamos que se está operando sobre FSocios
'Cogemos el identificador en pantalla
miId = Nz(Forms!FSocios.IdSoc.Value, 0)
'Si no hay identificador salimos
If miId = 0 Then Exit Sub
'Abrimos el informe filtrado por el registro en pantalla
DoCmd.OpenReport "RSocios", acViewPreview, , "IdSoc=" & miId
End If
End Sub
…
LO QUE FALTA PARA QUE “EL INVENTO FUNCIONE”

Todo lo que sigue, si habéis seguido el capítulo anterior, ya lo sabéis. Pero por si acaso, lo
repito rápidamente aquí:
SI QUEREMOS QUE NUESTRA COMMANDBAR SE CARGUE

AL INICIO...
Bastaría con crearnos una macro que llamaríamos “Autoexec” y que nos ejecutara la función.
Es decir:
SI QUEREMOS QUE NUESTRA COMMANDBAR SE CARGUE

CON UN BOTÓN...
Bastaría con asignar una macro a ese botón exactamente igual a la macro “Autoexec”.
Fácil, fácil... 
PARA FINALIZAR ESTE CAPÍTULO

Creo que tenemos las bases suficientes para podernos crear una “preciosa” barra
12
personalizada a través de código. Hay otras propiedades de las commandbars y sus controles
que no hemos visto aquí y que, si os interesa, os animo a examinar por vosotros mismos.
Espero que este capítulo os haya sido de utilidad. Un

saludo, y...
¡suerte!
13

Manual Ribbon 11

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Manual Ribbon 11

Hochgeladen von

Copyright:

Verfügbare Formate

MANUAL RIBBON

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

UNA BREVÍSIMA SEGUNDA INTRODUCCIÓN

• Creamos un módulo estándar donde programamos nuestras commandbars.

• Al abrir Access nos aparecerá un nuevo “menú”, llamado “COMPLEMENTOS”, donde

Como veis, algo muy sencillo... je, je...

Ahora bien, ¿y si queremos que la commandbar no

En definitiva, que no quisiera que os quedarais con la idea de que

OPERATIVA MÁS ESPECÍFICA, PERO AÚN EN ABSTRACTO

• Creamos, primero, la commandbar

De nuevo quizá lo anterior os pueda sonar, en principio, a chino mandarín, pero no os

ELEMENTOS QUE VAMOS A NECESITAR

Nos crearemos un formulario sobre esa tabla que llamaremos FSocios.

Posteriormente vamos a crearnos un módulo estándar, que llamaremos mdlCommandBars.

Finalmente yo utilizaré un formulario para “manejar la aplicación” que he llamado FMenu.

Como vemos, la estructura es la que os indicaba en un epígrafe anterior (estructura en

Set laCommandBar = Application.CommandBars.Add("Controles

Set laCommandBar = Application.CommandBars.Add("Controles

El resultado “visible” de lo anterior sería el siguiente:

• Declaro un objeto commandBar.Control

• Defino sus propiedades

Nos quedaría una cosa parecida a:

tipoSocio = CommandBars("Controles Neckkito").Controls(2).Text

La estructura de este nuevo elemento sería, al igual que os comentaba en el dropdown, en

• Defino sus propiedades

Y aquí va el matiz sobre la declaración del objeto commandBar.Control que os comentaba

'Tercero, un objeto dropdown/combobox

Resumiendo, que una vez declarado uno nos sirve para la

La programación del procedimiento “subCboAntiguo” que debe desencadenarse al seleccionar

Poco queda que comentar sobre este código. Así que...

Para poder ver un ejemplo sobre este menú y ser un poco

Con el menú emergente lo que obtenemos es un “menú con

• Declaro un objeto commandBar.Control

• Defino sus propiedades

El resultado obtenido sería:

Public Sub subAbreRSociosFiltrado()

LO QUE FALTA PARA QUE “EL INVENTO FUNCIONE”

SI QUEREMOS QUE NUESTRA COMMANDBAR SE CARGUE

SI QUEREMOS QUE NUESTRA COMMANDBAR SE CARGUE

PARA FINALIZAR ESTE CAPÍTULO

Espero que este capítulo os haya sido de utilidad. Un

Das könnte Ihnen auch gefallen