Cuando comenzamos a generar el Ribbon mucha gente prefiere hacerlo en Visual Estudio o Notepad++, pues nos marca los errores del xml al escribir el código, otros lo hacen en cualquier procesador de texto como el Word o el Block de notas, nosotros lo vamos a hacer en el mismo Access y dejar que nos indique si cometemos algún error y aparte podemos ir viendo visualmente lo que estamos haciendo.
La manera más fácil y común de agregar el Ribbon a nuestra base de datos, es guardando el XML del Ribbon en una tabla llamada UsysRibbons, la otra forma es cargar el Ribbon con el método LoadCustomUI ya sea con un archivo xml (usando msxml, DAO o ADO) o proveniente de una tabla y pasándolo a una cadena de texto.
Precisamente esto último es lo que vamos a hacer para poder ir haciendo en forma visual nuestro Ribbon solo necesitamos tener un formulario con un cuadro de texto para ir escribiendo el xml y un botón para cargarlo cada vez que hacemos cambios, mediante el método LoadCustomUI, del objeto Application que hace referencia a la aplicación activa.
Primero para usar un Ribbon personalizado necesitamos tener la librería Microsoft Office 14.0 Object Library así que lo tenemos que agregar en VBA (ALT + F11) => Herramientas => Referencias y vamos a crear nuestro formulario en Crear => Formularios => Formulario en Blanco y nos vamos a vista diseño y agregamos un cuadro de texto y lo nombramos txtRibbon y un botón cmdActualizar y en el evento al hacer click del botón ponemos:
Private Sub cmdActualizar_Click()
Dim nomForm
Randomize
nomForm = Int((1000 - 1 + 1) * Rnd + 1)
LoadCustomUI nomForm, txtRibbon
RibbonName = nomForm
End Sub
Yo agregué un botón más para salir del formulario y como soy muy original le llame salir y lo hice con el asistente de botones, ponemos el cuadro de texto lo más grande posible y nos queda algo como esto:
Solo nos resta probar a ver si funciona, primero vamos a usar algunos ribbon creados, pero antes de eso, para que Access nos avise si existe algún error tenemos que entrar en Archivo => Opciones => Configuración de cliente => General => y activar Mostrar errores de interfaz en el complemento => Aceptamos y salimos y volvemos a entrar (o compactamos y reparamos base).
Podemos probar nuestro formulario y que mejor usando una página de Microsoft sobre Ribbon:
https://msdn.microsoft.com/en-us/library/dd548010(v=office.12).aspx
Lo podemos probar pegando esto:
https://msdn.microsoft.com/en-us/library/dd548010(v=office.12).aspx
Lo podemos probar pegando esto:
<customUI
xmlns="http://schemas.microsoft.com/office/2006/01/customui">
<ribbon>
<tabs>
<tab id="tab1"
label="My Tab">
<group id="grp1"
label="My Group">
</group>
</tab>
</tabs>
</ribbon>
</customUI>
Le damos a Actualizar y debemos de ver esto:
Observemos que la línea es exactamente la que modificamos y si contamos cada carácter nos damos cuenta que es exactamente donde deben ir las comillas faltantes y para cerciorarse más que entendemos el error, nos dice se esperaba comillas. Hagan más pruebas, cambien el nombre de algún elemento o atributo y pongance a entender los mensajes tan directos que da Access.
Vamos entonces a ver para que sirve cada Elemento, y que significa, comenzando por el customUI, como su nombre lo indica custom = Personalizar y UI son las abreviaciones de Interfaz de Usuario, es el elemento raíz y debemos siempre de abrir y cerrar con él, si observamos en el elemento raíz customUI tenemos un xmlns seguido de una dirección de internet, el xmlns separamos xml ns = namespaces y en español y todo junto Espacio de Nombre del xml.
El espacio de nombre del xml por lo general es una dirección de internet, aunque esta no necesariamente existe, por ejemplo Microsoft tiene dos espacios de nombre uno para Access 2007 y otro para 2010/2013/2016 en Access 2007:
http://schemas.microsoft.com/office/2006/01/customui
Y en Access 2010/2013/2016
http://schemas.microsoft.com/office/2009/07/customui
En ambos casos no existe en internet la dirección, pero al instalar Office está integrado el esquema del xml dirigido al espacio de nombre que valida cada Elemento y Atributo para poder desplegar el Ribbon.
El elemento raíz customUI aparte del espacio de nombre dispone de dos atributos el onLoad es el que controla como reacción cada elemento de la cintas personalizadas e invalida la cinta personalizada cuando existe algún cambio y el loadImage sirve para cargar las imágenes personalizadas que tenemos en el ribbon y las almacena en cache, es la forma más rápida de cargar las imágenes pero no nos permite cambiarlas dinámicamente, en un futuro ya hablaremos de eso.
Si observamos Microsoft establece una convención de nombres para su esquema del Ribbon y consiste en que los elementos y atributos comienzan en minúsculas y si son palabras compuestas, ya sea una o varias van juntas pero cada palabra posterior a la primera su primer letra va con mayúsculas, ejemplo:
customUI
onLoad
loadImage
dialogBoxLauncher
Ya vimos en la primera parte que después del elemento raíz sigue los commands vamos a dejarlos a un lado y concentrarnos en el Ribbon, que como recordaremos el customUI tiene tres hijos que son: commands, ribbon y backstage, solo nos concentramos en el ribbon pues no necesitamos a los otros por el momento.
El elemento ribbon tiene un solo atributo startFromScratch que es un booleano, y debe ser true o false por default es falso si no lo ponemos estamos diciendo que es falso y startFromScratch significa iniciar desde el inico, así que podemos poner startFromScratch = ”true” y le decimos que nuestro Ribbon es único y startFromScratch = ”false” significa que nuestro ribbon aparece después del ribbon normal de Microsoft.
El elemento ribbon tiene tres hijos la cinta de acceso rápido (Qat), el botón office y las pestañas (tabs) por vamos a concentrarnos solo en el tabs. El elemento tabs es un elemento que sirve para contener cada una de las pestañas que se crean, es uno de los elementos más simples y no tiene ningún atributo, sus hijos son cada una de las pestañas (tab).
El elemento tabs (Pestañas) engloba a cada pestaña y no tiene atributos así que es muy fácil usarlo y finalmente ya podemos comenzar a ver algo que aparecerá en nuestro ribbon con el siguiente elemento.
El elemento tab es el que crea cada pestaña y pueden existir todos los tab que sean necesarios, este dispone de un identificador que puede ser cualquiera de los siguientes: id, idMso o idq, finalmente ya podemos comenzar a ver algo que aparecerá en nuestro ribbon.
Con la pestaña tab debemos poner ya sea un id que es un identificador único e irrepetible, o un idMso que son todos los identificadores que podemos reciclar de Microsoft o el idq es una pestaña compartida con espacio de nombre.
También tab debe llevar una etiqueta (label) para asignar el nombre de cada pestaña alfanumérico y es opcional si lleva otros atributos como visibles o getvisible, tag, keytip o getkeytip y podemos decidir la posición donde poner la pestaña dentro del ribbon con insertAfterMso, insertBeforeMso.
El elemento tab solo puede tener un elemento group ya sea personalizado o un grupo incorporado de Microsoft.
El elemento group al igual que tab debe de llevar un identificador (id, idMso, idq), una etiqueta (label) y si hay necesidad de esconder el grupo y hacerlo visible en forma dinámica se requiere getVisible.
El elemento Group tiene elementos hijos los cuales pueden ser: box, button, buttonGroup, checkBox, comboBox, dialogBoxLauncher, dropDown, editBox, gallery, labelControl, menú, separator, splitButton y el toggleButton.
Es aquí donde ya podemos comenzar a sacarle partida a los ribbons con los controles, vamos a comenzar con el control más tradicional que es el elemento button, y desde luego que tienen que llevar atributos estáticos: description, enabled, id, idMso, idQ, image, imageMso, insertAfterMso, insertAfterQ, insertBeforeMso, insertBeforeQ, keytip, label, screentip, showImage, showLabel, size, supertip, tag, visible, y los dinámicos getDescription, getEnabled, getImage getKeytip, getLabel, getScreentip, getShowImage, getShowLabel, getSize, getSupertip, getVisible, onAction.
Vamos a hacer un Ribbon con una pestaña, un grupo y dos botones, si usamos identificadores de Microsoft (idMso) o imágenes de Microsoft no necesitamos gran cosa y podemos hacer que funcione sin programar código en un Módulo.
Comenzamos con dos controles de Microsoft ExportExcel e ImportExcel todos los id o las imágenes de Microsoft las podemos obtener de un Excel en las diferentes versiones el cual se instala bajando un pequeño instalador solo tienes que buscar en internet: Office 2xxx: Developer References
Donde xxx es la versión de offices que requieres. Por ejemplo para la 2010 la página es :
https://www.microsoft.com/en-us/download/details.aspx?id=2451 y al instalarlo te crea una carpeta en C:\Office 2010 Developer Resources
O lo sacamos de Archivo => Opciones de Access => Personalizar cinta de opciones => Comandos Disponibles en => Todas.
Escribimos nuestro ribbon:
Escribimos nuestro ribbon:
<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui">
<ribbon startFromScratch="true">
<tabs>
<tab id="pestana01" label="MyPestaña">
<group id="grp1" label="My Grupo">
<button idMso="ExportExcel"/>
<button idMso="ImportExcel"/>
</group>
</tab>
</tabs>
</ribbon>
</customUI>
Y le damos a actualizar y nos aparece:
Pero por ejemplo yo quiero ver los botones grandes no pequeños, para eso tenemos un atributo llamado size, que como ya se dieron cuenta, tiene un estado por default que es precisamente “normal” y otro “large” vamos a poner el “large” para ver la diferencia y vamos a ponerle un nombre a la etiqueta para diferenciar uno de otro.
<button idMso="ExportExcel" label="Exportar a
Excel" size="large"/>
<button idMso="ImportExcel" label="Importar a
Excel" size="large"/>
En la próxima entrega vamos a continuar viendo más controles y nos centraremos con las devoluciones de llamadas (Callback), les dejo archivo.
